repo_name
stringlengths 6
130
| hexsha
list | file_path
list | code
list | apis
list |
|---|---|---|---|---|
ProfFan/gtsam
|
[
"67ce22c039cc0d04b0085203651dd859bbc44934"
] |
[
"cython/gtsam/tests/test_JacobianFactor.py"
] |
[
"\"\"\"\nGTSAM Copyright 2010-2019, Georgia Tech Research Corporation,\nAtlanta, Georgia 30332-0415\nAll Rights Reserved\n\nSee LICENSE for the license information\n\nJacobianFactor unit tests.\nAuthor: Frank Dellaert & Duy Nguyen Ta (Python)\n\"\"\"\nimport unittest\n\nimport numpy as np\n\nfrom gtsam_py import gtsam\n\nclass GtsamTestCase(unittest.TestCase):\n \"\"\"TestCase class with GTSAM assert utils.\"\"\"\n\n def gtsamAssertEquals(self, actual, expected, tol=1e-9):\n \"\"\" AssertEqual function that prints out actual and expected if not equal.\n Usage:\n self.gtsamAssertEqual(actual,expected)\n Keyword Arguments:\n tol {float} -- tolerance passed to 'equals', default 1e-9\n \"\"\"\n equal = actual.equals(expected, tol)\n if not equal:\n raise self.failureException(\n \"Values are not equal:\\n{}!={}\".format(actual, expected))\n\nclass TestJacobianFactor(GtsamTestCase):\n\n def test_eliminate(self):\n # Recommended way to specify a matrix (see cython/README)\n Ax2 = np.array(\n [[-5., 0.],\n [+0., -5.],\n [10., 0.],\n [+0., 10.]], order='F')\n\n # This is good too\n Al1 = np.array(\n [[5, 0],\n [0, 5],\n [0, 0],\n [0, 0]], dtype=float, order = 'F')\n\n # Not recommended for performance reasons, but should still work\n # as the wrapper should convert it to the correct type and storage order\n Ax1 = np.array(\n [[0, 0], # f4\n [0, 0], # f4\n [-10, 0], # f2\n [0, -10]]) # f2\n\n x2 = 1\n l1 = 2\n x1 = 3\n\n # the RHS\n b2 = np.array([-1., 1.5, 2., -1.])\n sigmas = np.array([1., 1., 1., 1.])\n model4 = gtsam.noiseModel.Diagonal.Sigmas(sigmas)\n combined = gtsam.JacobianFactor(x2, Ax2, l1, Al1, x1, Ax1, b2, model4)\n\n # eliminate the first variable (x2) in the combined factor, destructive\n # !\n ord = gtsam.Ordering()\n ord.push_back(x2)\n actualCG, lf = combined.eliminate(ord)\n\n # create expected Conditional Gaussian\n R11 = np.array([[11.1803, 0.00],\n [0.00, 11.1803]])\n S12 = np.array([[-2.23607, 0.00],\n [+0.00, -2.23607]])\n S13 = np.array([[-8.94427, 0.00],\n [+0.00, -8.94427]])\n d = np.array([2.23607, -1.56525])\n expectedCG = gtsam.GaussianConditional(\n x2, d, R11, l1, S12, x1, S13, gtsam.noiseModel.Unit.Create(2))\n # check if the result matches\n self.gtsamAssertEquals(actualCG, expectedCG, 1e-4)\n\n # the expected linear factor\n Bl1 = np.array([[4.47214, 0.00],\n [0.00, 4.47214]])\n\n Bx1 = np.array(\n # x1\n [[-4.47214, 0.00],\n [+0.00, -4.47214]])\n\n # the RHS\n b1 = np.array([0.0, 0.894427])\n\n model2 = gtsam.noiseModel.Diagonal.Sigmas(np.array([1., 1.]))\n expectedLF = gtsam.JacobianFactor(l1, Bl1, x1, Bx1, b1, model2)\n\n # check if the result matches the combined (reduced) factor\n self.gtsamAssertEquals(lf, expectedLF, 1e-4)\n\nif __name__ == \"__main__\":\n unittest.main()\n"
] |
[
[
"numpy.array"
]
] |
mayankiitg/cs224n
|
[
"c67b7904101c8f19a5a231e4fe521e764470d41b"
] |
[
"test_ensemble.py"
] |
[
"\"\"\"Test a model and generate submission CSV.\n\nUsage:\n > python test_ensemble.py --split SPLIT --load_path PATH --name NAME\n where\n > SPLIT is either \"dev\" or \"test\"\n > PATH is a path to a checkpoint (e.g., save/train/model-01/best.pth.tar)\n > NAME is a name to identify the test run\n\nAuthor:\n Chris Chute (chute@stanford.edu)\n\"\"\"\n\nimport csv\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.utils.data as data\nimport util\n\nfrom args import get_test_args\nfrom collections import OrderedDict\nfrom json import dumps\nfrom models import BiDAF\nfrom os.path import join\nfrom tensorboardX import SummaryWriter\nfrom tqdm import tqdm\nfrom ujson import load as json_load\nfrom util import collate_fn, SQuAD\nfrom collections import Counter\nfrom itertools import groupby\nimport random\n\ndef getModel(word_vectors,\n char_vectors,\n hidden_size,\n use_char_emb,\n use_attention,\n use_dynamic_decoder,\n log,\n use_multihead,\n multihead_count,\n fuse_att_mod_iter_dec,\n use_2_conv_filters=True,\n ):\n log.info('Building model...')\n model = BiDAF(word_vectors=word_vectors,\n char_vectors = char_vectors,\n hidden_size=hidden_size,\n use_char_emb=use_char_emb,\n use_dynamic_coattention = False,\n use_self_attention = False,\n use_attention = use_attention,\n use_dynamic_decoder=use_dynamic_decoder,\n use_multihead=use_multihead,\n use_2_conv_filters=use_2_conv_filters,\n use_hwy_encoder=True,\n multihead_count=multihead_count,\n fuse_att_mod_iter_dec = fuse_att_mod_iter_dec)\n return model\n\ndef weighted_avg(log_p1_models, log_p2_models, weights, args):\n # print('using weighted avg ensemble')\n\n n_models = log_p1_models.shape[0]\n\n w = weights.view(1, len(weights))\n p1, p2 = log_p1_models.exp(), log_p2_models.exp()\n\n p1_avg = 0\n p2_avg = 0\n for i in range(n_models):\n p1_avg = p1_avg + (weights[i] * p1[i])\n p2_avg = p2_avg + (weights[i] * p2[i])\n\n p1 = p1_avg / torch.sum(w)\n p2 = p2_avg / torch.sum(w)\n\n p1 = p1/(torch.sum(p1, dim=1).view(-1,1))\n p2 = p2/(torch.sum(p2, dim=1).view(-1,1))\n\n starts, ends = util.discretize(p1, p2, args.max_ans_len, args.use_squad_v2)\n return starts, ends\n\ndef majority_voting(log_p1_models, log_p2_models, weights, args):\n # print('using majority voting ensemble')\n\n n_models = log_p1_models.shape[0]\n batch_size = log_p1_models.shape[1]\n\n w = weights.view(1, len(weights))\n p1, p2 = log_p1_models.exp(), log_p2_models.exp()\n\n preds = [] # (batch, n_models)\n for i in range(batch_size):\n starts, ends = util.discretize(p1[:,i], p2[:,i], args.max_ans_len, args.use_squad_v2)\n # print(starts.shape, ends.shape) # (n_models, )\n starts = starts.tolist()\n ends = ends.tolist()\n\n tuples = [(starts[i], ends[i]) for i in range(len(starts))] # (n_models) tuples\n\n preds.append(tuples)\n \n # print(preds)\n\n ans_starts = []\n ans_ends = []\n for i in range(batch_size):\n preds_i = preds[i] # (n_models, 2)\n # print(preds_i) \n \n sorted_ct_tuples = Counter(preds_i).most_common()\n # ans_starts.append(sorted_ct_tuples[0][0][0])\n # ans_ends.append(sorted_ct_tuples[0][0][1])\n\n max_freq = sorted_ct_tuples[0][1]\n ans_choices = [span for span,ct in sorted_ct_tuples if ct == max_freq]\n ans = random.choice(ans_choices)\n ans_starts.append(ans[0])\n ans_ends.append(ans[1])\n \n \n\n\n # print(\"answers computed\")\n # print(ans_starts, ans_ends)\n return torch.tensor(ans_starts), torch.tensor(ans_ends) # (batch, 2)\n\n\ndef ensemble(log_p1_models, log_p2_models, f1_scores, ensemble_method, args):\n # Perform ensemble and select starts and end indexes for whole batch, combinging probs from each model.\n # Discretize will be called in this method.\n # shape log_p1_models : (n_models, batch_size, seq_len)\n ans_starts = []\n ans_edns = []\n # print(log_p1_models.shape, log_p2_models.shape)\n n_models = len(log_p1_models)\n batch_size = len(log_p1_models[0])\n\n f1_scores = torch.tensor(f1_scores)\n\n\n\n # for i in range(batch_size):\n # # for ith data point, get probs for each model.\n # log_p1_model = log_p1_models[:, i]\n # log_p2_model = log_p2_models[:, i]\n\n # p1, p2 = log_p1_model.exp(), log_p2_model.exp()\n\n # starts, ends = util.discretize(p1, p2, args.max_ans_len, args.use_squad_v2)\n\n if ensemble_method == 'weighted_avg':\n return weighted_avg(log_p1_models, log_p2_models, weights=f1_scores, args=args)\n if ensemble_method == \"majority_voting\":\n return majority_voting(log_p1_models, log_p2_models, weights=f1_scores, args=args)\n\n\n # select 1st model for now.\n log_p1 = log_p1_models[0]\n log_p2 = log_p2_models[0]\n p1, p2 = log_p1.exp(), log_p2.exp()\n starts, ends = util.discretize(p1, p2, args.max_ans_len, args.use_squad_v2)\n\n return starts, ends\n\n\ndef main(args_list, f1_scores, ensemble_method='weighted_avg'):\n \n # common args, pull from first configuration.\n args = args_list[0]\n\n # Set up logging\n args.save_dir = util.get_save_dir(args.save_dir, args.name, training=False)\n log = util.get_logger(args.save_dir, args.name)\n log.info(f'Args: {dumps(vars(args), indent=4, sort_keys=True)}')\n device, gpu_ids = util.get_available_devices()\n args.batch_size *= max(1, len(gpu_ids))\n\n # Get embeddings\n log.info('Loading embeddings...')\n word_vectors = util.torch_from_json(args.word_emb_file)\n char_vectors = util.torch_from_json(args.char_emb_file)\n models = []\n\n for args_model in args_list:\n # Get model\n \n use_2_conv_filters = False if hasattr(args_model, \"use_2_conv_filters\") and args_model.use_2_conv_filters == False else True\n\n print(\"use 2 conv filters flag: {}\".format(use_2_conv_filters))\n model = getModel(word_vectors, char_vectors, args_model.hidden_size,\n args_model.use_char_emb,\n use_attention = args_model.use_attention,\n use_dynamic_decoder=args_model.use_dynamic_decoder,\n log=log,\n use_multihead=args_model.use_multihead,\n use_2_conv_filters=use_2_conv_filters,\n multihead_count = args_model.multihead_count,\n fuse_att_mod_iter_dec = args_model.fuse_att_mod_iter_dec)\n\n model = nn.DataParallel(model, gpu_ids)\n log.info(f'Loading checkpoint from {args_model.load_path}...')\n model = util.load_model(model, args_model.load_path, gpu_ids, return_step=False)\n model = model.to(device)\n model.eval()\n models.append(model)\n\n # Get data loader\n log.info('Building dataset...')\n record_file = vars(args)[f'{args.split}_record_file']\n dataset = SQuAD(record_file, args.use_squad_v2)\n data_loader = data.DataLoader(dataset,\n batch_size=args.batch_size,\n shuffle=False,\n num_workers=args.num_workers,\n collate_fn=collate_fn)\n\n # Evaluate\n log.info(f'Evaluating on {args.split} split...')\n nll_meter = util.AverageMeter()\n pred_dict = {} # Predictions for TensorBoard\n sub_dict = {} # Predictions for submission\n eval_file = vars(args)[f'{args.split}_eval_file']\n with open(eval_file, 'r') as fh:\n gold_dict = json_load(fh)\n with torch.no_grad(), \\\n tqdm(total=len(dataset)) as progress_bar:\n for cw_idxs, cc_idxs, qw_idxs, qc_idxs, y1, y2, ids in data_loader:\n # Setup for forward\n cw_idxs = cw_idxs.to(device)\n qw_idxs = qw_idxs.to(device)\n batch_size = cw_idxs.size(0)\n\n log_p1_models = torch.tensor([]).to(device)\n log_p2_models = torch.tensor([]).to(device)\n loss_models = []\n\n for model in models:\n # Forward\n log_p1, log_p2 = model(cw_idxs, qw_idxs, cc_idxs, qc_idxs)\n y1, y2 = y1.to(device), y2.to(device)\n\n st_idx_i_1 = None\n end_idx_i_1 = None\n curr_mask_1 = None\n curr_mask_2 = None\n\n if len(log_p1.shape) == 3:\n n_iter = log_p1.shape[1]\n aggregated_loss = 0\n for i in range(n_iter):\n log_p1_i = log_p1[:,i,:]\n log_p2_i = log_p2[:,i,:]\n\n step_loss1 = F.nll_loss(log_p1_i, y1, reduce=False) \n step_loss2 = F.nll_loss(log_p2_i, y2, reduce=False)\n \n _, st_idx_i = torch.max(log_p1_i, dim=1)\n _, end_idx_i = torch.max(log_p2_i, dim=1)\n \n if curr_mask_1 == None:\n curr_mask_1 = (st_idx_i == st_idx_i)\n curr_mask_2 = (end_idx_i == end_idx_i)\n else:\n curr_mask_1 = (st_idx_i != st_idx_i_1) * curr_mask_1\n curr_mask_2 = (end_idx_i != end_idx_i_1) * curr_mask_2\n \n # print('iteration {} mask1: {}, mask2: {}'.format(i, curr_mask_1, curr_mask_2))\n # print('st_idx: {}, end: {}'.format(st_idx_i, end_idx_i))\n # print(step_loss1, step_loss2)\n\n step_loss1 = step_loss1 * curr_mask_1.float()\n step_loss2 = step_loss2 * curr_mask_2.float()\n \n\n aggregated_loss += (step_loss1 + step_loss2)\n # print(aggregated_loss)\n\n st_idx_i_1 = st_idx_i\n end_idx_i_1 = end_idx_i\n \n loss = torch.mean(aggregated_loss)\n # print('aggregated loss: {}'.format(loss))\n log_p1 = log_p1[:,-1,:] # take prob of last iteration for EM, F1 scores and predictions.\n log_p2 = log_p2[:,-1,:]\n else:\n loss = F.nll_loss(log_p1, y1) + F.nll_loss(log_p2, y2)\n \n\n # Add the log probs and losses from each model to these lists.\n log_p1_models = torch.cat((log_p1_models, log_p1.unsqueeze(0)), dim=0)\n log_p2_models = torch.cat((log_p2_models, log_p2.unsqueeze(0)), dim=0)\n loss_models.append(loss)\n\n\n starts, ends = ensemble(log_p1_models, log_p2_models, f1_scores=f1_scores, ensemble_method=ensemble_method, args=args)\n\n nll_meter.update(loss.item(), batch_size)\n\n # Get F1 and EM scores\n # p1, p2 = log_p1.exp(), log_p2.exp()\n # starts, ends = util.discretize(p1, p2, args.max_ans_len, args.use_squad_v2)\n\n # Log info\n progress_bar.update(batch_size)\n if args.split != 'test':\n # No labels for the test set, so NLL would be invalid\n progress_bar.set_postfix(NLL=nll_meter.avg)\n \n # print(starts, ends)\n\n idx2pred, uuid2pred = util.convert_tokens(gold_dict,\n ids.tolist(),\n starts.tolist(),\n ends.tolist(),\n args.use_squad_v2)\n pred_dict.update(idx2pred)\n sub_dict.update(uuid2pred)\n\n # Log results (except for test set, since it does not come with labels)\n if args.split != 'test':\n results = util.eval_dicts(gold_dict, pred_dict, args.use_squad_v2)\n results_list = [('NLL', nll_meter.avg),\n ('F1', results['F1']),\n ('EM', results['EM'])]\n if args.use_squad_v2:\n results_list.append(('AvNA', results['AvNA']))\n results = OrderedDict(results_list)\n\n # Log to console\n results_str = ', '.join(f'{k}: {v:05.2f}' for k, v in results.items())\n log.info(f'{args.split.title()} {results_str}')\n\n # Log to TensorBoard\n tbx = SummaryWriter(args.save_dir)\n util.visualize(tbx,\n pred_dict=pred_dict,\n eval_path=eval_file,\n step=0,\n split=args.split,\n num_visuals=args.num_visuals)\n\n # Write submission file\n sub_path = join(args.save_dir, args.split + '_' + args.sub_file)\n log.info(f'Writing submission file to {sub_path}...')\n with open(sub_path, 'w', newline='', encoding='utf-8') as csv_fh:\n csv_writer = csv.writer(csv_fh, delimiter=',')\n csv_writer.writerow(['Id', 'Predicted'])\n for uuid in sorted(sub_dict):\n csv_writer.writerow([uuid, sub_dict[uuid]])\n\n\nif __name__ == '__main__':\n checkpoints = [\"save/train/bidaf-char-02/best.pth.tar\",\n \"save/train/bestModel-const-lr-01/best.pth.tar\",\n \"save/train/bidaf-baseline-03/best.pth.tar\", \n \"save/train/samidh-best-model-1/best.pth.tar\",\n \"save/train/samidh-multiheadCoAtt-04/best.pth.tar\",\n \"save/train/samidh-8head-self02/best.pth.tar\",\n \"save/train/bidaf-char-02-05/best.pth.tar\",\n \"save/train/samidh-CoAttMultih-05/best.pth.tar\",\n \"save/train/BestModelIterativeDecImproved-01/best.pth.tar\",\n ]\n\n f1_scores=[0.6737, 0.6774, 0.6129, 0.6827, 0.688, 0.6881, 0.6731, 0.6827, 0.6557]\n\n num_models = len(checkpoints)\n args_list = []\n # multihead_count, use_self_attention\n # \n for i in range(num_models):\n args = get_test_args()\n args.load_path = checkpoints[i]\n\n # Override some args for each model/\n if i == 0:\n args.use_char_emb = True\n args.use_attention = False\n args.use_dynamic_decoder = False\n elif i == 1:\n args.use_char_emb = True\n args.use_attention = True\n args.use_dynamic_decoder = False\n elif i == 2:\n args.use_char_emb = False\n args.use_attention = False\n args.use_dynamic_decoder = False\n elif i == 3:\n args.use_char_emb = True\n args.use_attention = True\n args.use_dynamic_decoder = False\n args.use_2_conv_filters = False\n elif i == 4:\n args.use_char_emb = True\n args.use_attention = True\n args.use_self_attention = True\n args.use_dynamic_decoder = False\n args.use_multihead = True\n args.multihead_count = 4\n elif i == 5:\n args.use_char_emb = True\n args.use_attention = True\n args.use_self_attention = True\n args.use_dynamic_decoder = False\n args.use_multihead = True\n args.multihead_count = 8\n elif i == 6:\n args.use_char_emb = True\n args.use_attention = False\n args.use_self_attention = False\n args.use_dynamic_decoder = False\n elif i == 7:\n args.use_char_emb = True\n args.use_attention = True\n elif i == 8:\n args.use_dynamic_decoder = True\n \n args_list.append(args)\n\n args_list = [args_list[i] for i in [0,1,2,3,4,5,6,7,8]]\n f1_scores = [f1_scores[i] for i in [0,1,2,3,4,5,6,7,8]]\n # ensemble_method = 'majority_voting'\n ensemble_method = 'weighted_avg'\n main(args_list, f1_scores=f1_scores, ensemble_method=ensemble_method) # majority_voting\n"
] |
[
[
"torch.mean",
"torch.max",
"torch.nn.functional.nll_loss",
"torch.sum",
"torch.utils.data.DataLoader",
"torch.tensor",
"torch.no_grad",
"torch.nn.DataParallel"
]
] |
YannickNoelStephanKuhn/PyBaMM
|
[
"d90636a755b7b77bbc75ae7bc2728c8ee2fa730a",
"a31e2095600bb92e913598ac4d02b2b6b77b31c1"
] |
[
"tests/integration/test_models/test_full_battery_models/test_lithium_ion/test_spm.py",
"pybamm/expression_tree/operations/evaluate.py"
] |
[
"#\n# Tests for the lithium-ion SPM model\n#\nimport pybamm\nimport tests\nimport numpy as np\nimport unittest\nfrom platform import system\n\n\nclass TestSPM(unittest.TestCase):\n def test_basic_processing(self):\n options = {\"thermal\": \"isothermal\"}\n model = pybamm.lithium_ion.SPM(options)\n modeltest = tests.StandardModelTest(model)\n modeltest.test_all()\n\n def test_basic_processing_1plus1D(self):\n options = {\"current collector\": \"potential pair\", \"dimensionality\": 1}\n\n model = pybamm.lithium_ion.SPM(options)\n var = pybamm.standard_spatial_vars\n var_pts = {\n var.x_n: 5,\n var.x_s: 5,\n var.x_p: 5,\n var.r_n: 5,\n var.r_p: 5,\n var.y: 5,\n var.z: 5,\n }\n modeltest = tests.StandardModelTest(model, var_pts=var_pts)\n modeltest.test_all(skip_output_tests=True)\n\n def test_basic_processing_2plus1D(self):\n options = {\"current collector\": \"potential pair\", \"dimensionality\": 2}\n model = pybamm.lithium_ion.SPM(options)\n var = pybamm.standard_spatial_vars\n var_pts = {\n var.x_n: 5,\n var.x_s: 5,\n var.x_p: 5,\n var.r_n: 5,\n var.r_p: 5,\n var.y: 5,\n var.z: 5,\n }\n modeltest = tests.StandardModelTest(model, var_pts=var_pts)\n modeltest.test_all(skip_output_tests=True)\n\n def test_optimisations(self):\n options = {\"thermal\": \"isothermal\"}\n model = pybamm.lithium_ion.SPM(options)\n optimtest = tests.OptimisationsTest(model)\n\n original = optimtest.evaluate_model()\n simplified = optimtest.evaluate_model(simplify=True)\n using_known_evals = optimtest.evaluate_model(use_known_evals=True)\n simp_and_known = optimtest.evaluate_model(simplify=True, use_known_evals=True)\n simp_and_python = optimtest.evaluate_model(simplify=True, to_python=True)\n np.testing.assert_array_almost_equal(original, simplified)\n np.testing.assert_array_almost_equal(original, using_known_evals)\n np.testing.assert_array_almost_equal(original, simp_and_known)\n np.testing.assert_array_almost_equal(original, simp_and_python)\n\n if system() != \"Windows\":\n simp_and_jax = optimtest.evaluate_model(simplify=True, to_jax=True)\n np.testing.assert_array_almost_equal(original, simp_and_jax)\n\n def test_set_up(self):\n model = pybamm.lithium_ion.SPM()\n optimtest = tests.OptimisationsTest(model)\n optimtest.set_up_model(simplify=False, to_python=True)\n optimtest.set_up_model(simplify=True, to_python=True)\n optimtest.set_up_model(simplify=False, to_python=False)\n optimtest.set_up_model(simplify=True, to_python=False)\n\n def test_charge(self):\n options = {\"thermal\": \"isothermal\"}\n model = pybamm.lithium_ion.SPM(options)\n parameter_values = model.default_parameter_values\n parameter_values.update({\"Current function [A]\": -1})\n modeltest = tests.StandardModelTest(model, parameter_values=parameter_values)\n modeltest.test_all()\n\n def test_zero_current(self):\n options = {\"thermal\": \"isothermal\"}\n model = pybamm.lithium_ion.SPM(options)\n parameter_values = model.default_parameter_values\n parameter_values.update({\"Current function [A]\": 0})\n modeltest = tests.StandardModelTest(model, parameter_values=parameter_values)\n modeltest.test_all()\n\n def test_thermal(self):\n options = {\"thermal\": \"lumped\"}\n model = pybamm.lithium_ion.SPM(options)\n modeltest = tests.StandardModelTest(model)\n modeltest.test_all()\n\n options = {\"thermal\": \"x-full\"}\n model = pybamm.lithium_ion.SPM(options)\n modeltest = tests.StandardModelTest(model)\n modeltest.test_all()\n\n def test_particle_uniform(self):\n options = {\"particle\": \"uniform profile\"}\n model = pybamm.lithium_ion.SPM(options)\n modeltest = tests.StandardModelTest(model)\n modeltest.test_all()\n\n def test_particle_quadratic(self):\n options = {\"particle\": \"quadratic profile\"}\n model = pybamm.lithium_ion.SPM(options)\n modeltest = tests.StandardModelTest(model)\n modeltest.test_all()\n\n def test_particle_quartic(self):\n options = {\"particle\": \"quartic profile\"}\n model = pybamm.lithium_ion.SPM(options)\n modeltest = tests.StandardModelTest(model)\n modeltest.test_all()\n\n def test_loss_active_material(self):\n options = {\n \"loss of active material\": \"none\",\n }\n model = pybamm.lithium_ion.SPM(options)\n chemistry = pybamm.parameter_sets.Ai2020\n parameter_values = pybamm.ParameterValues(chemistry=chemistry)\n modeltest = tests.StandardModelTest(model, parameter_values=parameter_values)\n modeltest.test_all()\n\n def test_loss_active_material_negative(self):\n options = {\n \"particle cracking\": \"no cracking\",\n \"loss of active material\": \"negative\",\n }\n model = pybamm.lithium_ion.SPM(options)\n chemistry = pybamm.parameter_sets.Ai2020\n parameter_values = pybamm.ParameterValues(chemistry=chemistry)\n modeltest = tests.StandardModelTest(model, parameter_values=parameter_values)\n modeltest.test_all()\n\n def test_loss_active_material_positive(self):\n options = {\n \"particle cracking\": \"no cracking\",\n \"loss of active material\": \"positive\",\n }\n model = pybamm.lithium_ion.SPM(options)\n chemistry = pybamm.parameter_sets.Ai2020\n parameter_values = pybamm.ParameterValues(chemistry=chemistry)\n modeltest = tests.StandardModelTest(model, parameter_values=parameter_values)\n modeltest.test_all()\n\n def test_loss_active_material_both(self):\n options = {\n \"particle cracking\": \"no cracking\",\n \"loss of active material\": \"both\",\n }\n model = pybamm.lithium_ion.SPM(options)\n chemistry = pybamm.parameter_sets.Ai2020\n parameter_values = pybamm.ParameterValues(chemistry=chemistry)\n modeltest = tests.StandardModelTest(model, parameter_values=parameter_values)\n modeltest.test_all()\n\n def test_surface_form_differential(self):\n options = {\"surface form\": \"differential\"}\n model = pybamm.lithium_ion.SPM(options)\n modeltest = tests.StandardModelTest(model)\n modeltest.test_all()\n\n def test_surface_form_algebraic(self):\n options = {\"surface form\": \"algebraic\"}\n model = pybamm.lithium_ion.SPM(options)\n modeltest = tests.StandardModelTest(model)\n modeltest.test_all()\n\n\nclass TestSPMWithSEI(unittest.TestCase):\n def test_well_posed_reaction_limited(self):\n options = {\"sei\": \"reaction limited\"}\n model = pybamm.lithium_ion.SPM(options)\n modeltest = tests.StandardModelTest(model)\n modeltest.test_all()\n\n def test_well_posed_solvent_diffusion_limited(self):\n options = {\"sei\": \"solvent-diffusion limited\"}\n model = pybamm.lithium_ion.SPM(options)\n modeltest = tests.StandardModelTest(model)\n modeltest.test_all()\n\n def test_well_posed_electron_migration_limited(self):\n options = {\"sei\": \"electron-migration limited\"}\n model = pybamm.lithium_ion.SPM(options)\n modeltest = tests.StandardModelTest(model)\n modeltest.test_all()\n\n def test_well_posed_interstitial_diffusion_limited(self):\n options = {\"sei\": \"interstitial-diffusion limited\"}\n model = pybamm.lithium_ion.SPM(options)\n modeltest = tests.StandardModelTest(model)\n modeltest.test_all()\n\n def test_well_posed_ec_reaction_limited(self):\n options = {\"sei\": \"ec reaction limited\", \"sei porosity change\": \"true\"}\n model = pybamm.lithium_ion.SPM(options)\n modeltest = tests.StandardModelTest(model)\n modeltest.test_all()\n\n\nclass TestSPMWithCrack(unittest.TestCase):\n def test_well_posed_none_crack(self):\n options = {\"particle\": \"Fickian diffusion\", \"particle cracking\": \"none\"}\n model = pybamm.lithium_ion.SPM(options)\n chemistry = pybamm.parameter_sets.Ai2020\n parameter_values = pybamm.ParameterValues(chemistry=chemistry)\n modeltest = tests.StandardModelTest(model, parameter_values=parameter_values)\n modeltest.test_all()\n\n def test_well_posed_no_cracking(self):\n options = {\"particle\": \"Fickian diffusion\", \"particle cracking\": \"no cracking\"}\n model = pybamm.lithium_ion.SPM(options)\n chemistry = pybamm.parameter_sets.Ai2020\n parameter_values = pybamm.ParameterValues(chemistry=chemistry)\n modeltest = tests.StandardModelTest(model, parameter_values=parameter_values)\n modeltest.test_all()\n\n def test_well_posed_negative_cracking(self):\n options = {\"particle\": \"Fickian diffusion\", \"particle cracking\": \"negative\"}\n model = pybamm.lithium_ion.SPM(options)\n chemistry = pybamm.parameter_sets.Ai2020\n parameter_values = pybamm.ParameterValues(chemistry=chemistry)\n modeltest = tests.StandardModelTest(model, parameter_values=parameter_values)\n modeltest.test_all()\n\n def test_well_posed_positive_cracking(self):\n options = {\"particle\": \"Fickian diffusion\", \"particle cracking\": \"positive\"}\n model = pybamm.lithium_ion.SPM(options)\n chemistry = pybamm.parameter_sets.Ai2020\n parameter_values = pybamm.ParameterValues(chemistry=chemistry)\n modeltest = tests.StandardModelTest(model, parameter_values=parameter_values)\n modeltest.test_all()\n\n def test_well_posed_both_cracking(self):\n options = {\"particle\": \"Fickian diffusion\", \"particle cracking\": \"both\"}\n model = pybamm.lithium_ion.SPM(options)\n chemistry = pybamm.parameter_sets.Ai2020\n parameter_values = pybamm.ParameterValues(chemistry=chemistry)\n modeltest = tests.StandardModelTest(model, parameter_values=parameter_values)\n modeltest.test_all()\n\n\nif __name__ == \"__main__\":\n print(\"Add -v for more debug output\")\n import sys\n\n sys.setrecursionlimit(10000)\n\n if \"-v\" in sys.argv:\n debug = True\n unittest.main()\n",
"#\n# Write a symbol to python\n#\nimport pybamm\n\nimport numpy as np\nimport scipy.sparse\nfrom collections import OrderedDict\n\nimport numbers\nfrom platform import system\n\nif system() != \"Windows\":\n import jax\n\n from jax.config import config\n\n config.update(\"jax_enable_x64\", True)\n\n class JaxCooMatrix:\n \"\"\"\n A sparse matrix in COO format, with internal arrays using jax device arrays\n\n This matrix only has two operations supported, a multiply with a scalar, and a\n dot product with a dense vector. It can also be converted to a dense 2D jax\n device array\n\n Parameters\n ----------\n\n row: arraylike\n 1D array holding row indices of non-zero entries\n col: arraylike\n 1D array holding col indices of non-zero entries\n data: arraylike\n 1D array holding non-zero entries\n shape: 2-element tuple (x, y)\n where x is the number of rows, and y the number of columns of the matrix\n \"\"\"\n\n def __init__(self, row, col, data, shape):\n self.row = jax.numpy.array(row)\n self.col = jax.numpy.array(col)\n self.data = jax.numpy.array(data)\n self.shape = shape\n self.nnz = len(self.data)\n\n def toarray(self):\n \"\"\"convert sparse matrix to a dense 2D array\"\"\"\n result = jax.numpy.zeros(self.shape, dtype=self.data.dtype)\n return result.at[self.row, self.col].add(self.data)\n\n def dot_product(self, b):\n \"\"\"\n dot product of matrix with a dense column vector b\n\n Parameters\n ----------\n b: jax device array\n must have shape (n, 1)\n \"\"\"\n # assume b is a column vector\n result = jax.numpy.zeros((self.shape[0], 1), dtype=b.dtype)\n return result.at[self.row].add(self.data.reshape(-1, 1) * b[self.col])\n\n def scalar_multiply(self, b):\n \"\"\"\n multiply of matrix with a scalar b\n\n Parameters\n ----------\n b: Number or 1 element jax device array\n scalar value to multiply\n \"\"\"\n # assume b is a scalar or ndarray with 1 element\n return JaxCooMatrix(\n self.row, self.col, (self.data * b).reshape(-1), self.shape\n )\n\n def multiply(self, b):\n \"\"\"\n general matrix multiply not supported\n \"\"\"\n raise NotImplementedError\n\n def __matmul__(self, b):\n \"\"\"see self.dot_product\"\"\"\n return self.dot_product(b)\n\n def create_jax_coo_matrix(value):\n \"\"\"\n Creates a JaxCooMatrix from a scipy.sparse matrix\n\n Parameters\n ----------\n\n value: scipy.sparse matrix\n the sparse matrix to be converted\n \"\"\"\n scipy_coo = value.tocoo()\n row = jax.numpy.asarray(scipy_coo.row)\n col = jax.numpy.asarray(scipy_coo.col)\n data = jax.numpy.asarray(scipy_coo.data)\n return JaxCooMatrix(row, col, data, value.shape)\n\n\nelse:\n\n def create_jax_coo_matrix(value): # pragma: no cover\n raise NotImplementedError(\"Jax is not available on Windows\")\n\n\ndef id_to_python_variable(symbol_id, constant=False):\n \"\"\"\n This function defines the format for the python variable names used in find_symbols\n and to_python. Variable names are based on a nodes' id to make them unique\n \"\"\"\n\n if constant:\n var_format = \"const_{:05d}\"\n else:\n var_format = \"var_{:05d}\"\n\n # Need to replace \"-\" character to make them valid python variable names\n return var_format.format(symbol_id).replace(\"-\", \"m\")\n\n\ndef is_scalar(arg):\n is_number = isinstance(arg, numbers.Number)\n if is_number:\n return True\n else:\n return np.all(np.array(arg.shape) == 1)\n\n\ndef find_symbols(symbol, constant_symbols, variable_symbols, output_jax=False):\n \"\"\"\n This function converts an expression tree to a dictionary of node id's and strings\n specifying valid python code to calculate that nodes value, given y and t.\n\n The function distinguishes between nodes that represent constant nodes in the tree\n (e.g. a pybamm.Matrix), and those that are variable (e.g. subtrees that contain\n pybamm.StateVector). The former are put in `constant_symbols`, the latter in\n `variable_symbols`\n\n Note that it is important that the arguments `constant_symbols` and\n `variable_symbols` be an *ordered* dict, since the final ordering of the code lines\n are important for the calculations. A dict is specified rather than a list so that\n identical subtrees (which give identical id's) are not recalculated in the code\n\n Parameters\n ----------\n symbol : :class:`pybamm.Symbol`\n The symbol or expression tree to convert\n\n constant_symbol: collections.OrderedDict\n The output dictionary of constant symbol ids to lines of code\n\n variable_symbol: collections.OrderedDict\n The output dictionary of variable (with y or t) symbol ids to lines of code\n\n output_jax: bool\n If True, only numpy and jax operations will be used in the generated code,\n raises NotImplNotImplementedError if any SparseStack or Mat-Mat multiply\n operations are used\n\n \"\"\"\n # constant symbols that are not numbers are stored in a list of constants, which are\n # passed into the generated function constant symbols that are numbers are written\n # directly into the code\n if symbol.is_constant():\n value = symbol.evaluate()\n if not isinstance(value, numbers.Number):\n if output_jax and scipy.sparse.issparse(value):\n # convert any remaining sparse matrices to our custom coo matrix\n constant_symbols[symbol.id] = create_jax_coo_matrix(value)\n\n else:\n constant_symbols[symbol.id] = value\n return\n\n # process children recursively\n for child in symbol.children:\n find_symbols(child, constant_symbols, variable_symbols, output_jax)\n\n # calculate the variable names that will hold the result of calculating the\n # children variables\n children_vars = []\n for child in symbol.children:\n if child.is_constant():\n child_eval = child.evaluate()\n if isinstance(child_eval, numbers.Number):\n children_vars.append(str(child_eval))\n else:\n children_vars.append(id_to_python_variable(child.id, True))\n else:\n children_vars.append(id_to_python_variable(child.id, False))\n\n if isinstance(symbol, pybamm.BinaryOperator):\n # Multiplication and Division need special handling for scipy sparse matrices\n # TODO: we can pass through a dummy y and t to get the type and then hardcode\n # the right line, avoiding these checks\n if isinstance(symbol, pybamm.Multiplication):\n dummy_eval_left = symbol.children[0].evaluate_for_shape()\n dummy_eval_right = symbol.children[1].evaluate_for_shape()\n if scipy.sparse.issparse(dummy_eval_left):\n if output_jax and is_scalar(dummy_eval_right):\n symbol_str = \"{0}.scalar_multiply({1})\".format(\n children_vars[0], children_vars[1]\n )\n else:\n symbol_str = \"{0}.multiply({1})\".format(\n children_vars[0], children_vars[1]\n )\n elif scipy.sparse.issparse(dummy_eval_right):\n if output_jax and is_scalar(dummy_eval_left):\n symbol_str = \"{1}.scalar_multiply({0})\".format(\n children_vars[0], children_vars[1]\n )\n else:\n symbol_str = \"{1}.multiply({0})\".format(\n children_vars[0], children_vars[1]\n )\n else:\n symbol_str = \"{0} * {1}\".format(children_vars[0], children_vars[1])\n elif isinstance(symbol, pybamm.Division):\n dummy_eval_left = symbol.children[0].evaluate_for_shape()\n dummy_eval_right = symbol.children[1].evaluate_for_shape()\n if scipy.sparse.issparse(dummy_eval_left):\n if output_jax and is_scalar(dummy_eval_right):\n symbol_str = \"{0}.scalar_multiply(1/{1})\".format(\n children_vars[0], children_vars[1]\n )\n else:\n symbol_str = \"{0}.multiply(1/{1})\".format(\n children_vars[0], children_vars[1]\n )\n else:\n symbol_str = \"{0} / {1}\".format(children_vars[0], children_vars[1])\n\n elif isinstance(symbol, pybamm.Inner):\n dummy_eval_left = symbol.children[0].evaluate_for_shape()\n dummy_eval_right = symbol.children[1].evaluate_for_shape()\n if scipy.sparse.issparse(dummy_eval_left):\n if output_jax and is_scalar(dummy_eval_right):\n symbol_str = \"{0}.scalar_multiply({1})\".format(\n children_vars[0], children_vars[1]\n )\n else:\n symbol_str = \"{0}.multiply({1})\".format(\n children_vars[0], children_vars[1]\n )\n elif scipy.sparse.issparse(dummy_eval_right):\n if output_jax and is_scalar(dummy_eval_left):\n symbol_str = \"{1}.scalar_multiply({0})\".format(\n children_vars[0], children_vars[1]\n )\n else:\n symbol_str = \"{1}.multiply({0})\".format(\n children_vars[0], children_vars[1]\n )\n else:\n symbol_str = \"{0} * {1}\".format(children_vars[0], children_vars[1])\n\n elif isinstance(symbol, pybamm.Minimum):\n symbol_str = \"np.minimum({},{})\".format(children_vars[0], children_vars[1])\n elif isinstance(symbol, pybamm.Maximum):\n symbol_str = \"np.maximum({},{})\".format(children_vars[0], children_vars[1])\n\n elif isinstance(symbol, pybamm.MatrixMultiplication):\n dummy_eval_left = symbol.children[0].evaluate_for_shape()\n dummy_eval_right = symbol.children[1].evaluate_for_shape()\n if output_jax and (\n scipy.sparse.issparse(dummy_eval_left)\n and scipy.sparse.issparse(dummy_eval_right)\n ):\n raise NotImplementedError(\n \"sparse mat-mat multiplication not supported \"\n \"for output_jax == True\"\n )\n else:\n symbol_str = (\n children_vars[0] + \" \" + symbol.name + \" \" + children_vars[1]\n )\n else:\n symbol_str = children_vars[0] + \" \" + symbol.name + \" \" + children_vars[1]\n\n elif isinstance(symbol, pybamm.UnaryOperator):\n # Index has a different syntax than other univariate operations\n if isinstance(symbol, pybamm.Index):\n symbol_str = \"{}[{}:{}]\".format(\n children_vars[0], symbol.slice.start, symbol.slice.stop\n )\n else:\n symbol_str = symbol.name + children_vars[0]\n\n elif isinstance(symbol, pybamm.Function):\n children_str = \"\"\n for child_var in children_vars:\n if children_str == \"\":\n children_str = child_var\n else:\n children_str += \", \" + child_var\n if isinstance(symbol.function, np.ufunc):\n # write any numpy functions directly\n symbol_str = \"np.{}({})\".format(symbol.function.__name__, children_str)\n else:\n # unknown function, store it as a constant and call this in the\n # generated code\n constant_symbols[symbol.id] = symbol.function\n funct_var = id_to_python_variable(symbol.id, True)\n symbol_str = \"{}({})\".format(funct_var, children_str)\n\n elif isinstance(symbol, pybamm.Concatenation):\n\n # don't bother to concatenate if there is only a single child\n if isinstance(symbol, pybamm.NumpyConcatenation):\n if len(children_vars) > 1:\n symbol_str = \"np.concatenate(({}))\".format(\",\".join(children_vars))\n else:\n symbol_str = \"{}\".format(\",\".join(children_vars))\n\n elif isinstance(symbol, pybamm.SparseStack):\n if len(children_vars) > 1:\n if output_jax:\n raise NotImplementedError\n else:\n symbol_str = \"scipy.sparse.vstack(({}))\".format(\n \",\".join(children_vars)\n )\n else:\n symbol_str = \"{}\".format(\",\".join(children_vars))\n\n # DomainConcatenation specifies a particular ordering for the concatenation,\n # which we must follow\n elif isinstance(symbol, pybamm.DomainConcatenation):\n slice_starts = []\n all_child_vectors = []\n for i in range(symbol.secondary_dimensions_npts):\n child_vectors = []\n for child_var, slices in zip(children_vars, symbol._children_slices):\n for child_dom, child_slice in slices.items():\n slice_starts.append(symbol._slices[child_dom][i].start)\n child_vectors.append(\n \"{}[{}:{}]\".format(\n child_var, child_slice[i].start, child_slice[i].stop\n )\n )\n all_child_vectors.extend(\n [v for _, v in sorted(zip(slice_starts, child_vectors))]\n )\n if len(children_vars) > 1 or symbol.secondary_dimensions_npts > 1:\n symbol_str = \"np.concatenate(({}))\".format(\",\".join(all_child_vectors))\n else:\n symbol_str = \"{}\".format(\",\".join(children_vars))\n else:\n raise NotImplementedError\n\n # Note: we assume that y is being passed as a column vector\n elif isinstance(symbol, pybamm.StateVector):\n indices = np.argwhere(symbol.evaluation_array).reshape(-1).astype(np.int32)\n consecutive = np.all(indices[1:] - indices[:-1] == 1)\n if len(indices) == 1 or consecutive:\n symbol_str = \"y[{}:{}]\".format(indices[0], indices[-1] + 1)\n else:\n indices_array = pybamm.Array(indices)\n constant_symbols[indices_array.id] = indices\n index_name = id_to_python_variable(indices_array.id, True)\n symbol_str = \"y[{}]\".format(index_name)\n\n elif isinstance(symbol, pybamm.Time):\n symbol_str = \"t\"\n\n elif isinstance(symbol, pybamm.InputParameter):\n symbol_str = \"inputs['{}']\".format(symbol.name)\n\n else:\n raise NotImplementedError(\n \"Not implemented for a symbol of type '{}'\".format(type(symbol))\n )\n\n variable_symbols[symbol.id] = symbol_str\n\n\ndef to_python(symbol, debug=False, output_jax=False):\n \"\"\"\n This function converts an expression tree into a dict of constant input values, and\n valid python code that acts like the tree's :func:`pybamm.Symbol.evaluate` function\n\n Parameters\n ----------\n symbol : :class:`pybamm.Symbol`\n The symbol to convert to python code\n\n debug : bool\n If set to True, the function also emits debug code\n\n Returns\n -------\n collections.OrderedDict:\n dict mapping node id to a constant value. Represents all the constant nodes in\n the expression tree\n str:\n valid python code that will evaluate all the variable nodes in the tree.\n output_jax: bool\n If True, only numpy and jax operations will be used in the generated code.\n Raises NotImplNotImplementedError if any SparseStack or Mat-Mat multiply\n operations are used\n\n \"\"\"\n constant_values = OrderedDict()\n variable_symbols = OrderedDict()\n find_symbols(symbol, constant_values, variable_symbols, output_jax)\n\n line_format = \"{} = {}\"\n\n if debug:\n variable_lines = [\n \"print('{}'); \".format(\n line_format.format(id_to_python_variable(symbol_id, False), symbol_line)\n )\n + line_format.format(id_to_python_variable(symbol_id, False), symbol_line)\n + \"; print(type({0}),np.shape({0}))\".format(\n id_to_python_variable(symbol_id, False)\n )\n for symbol_id, symbol_line in variable_symbols.items()\n ]\n else:\n variable_lines = [\n line_format.format(id_to_python_variable(symbol_id, False), symbol_line)\n for symbol_id, symbol_line in variable_symbols.items()\n ]\n\n return constant_values, \"\\n\".join(variable_lines)\n\n\nclass EvaluatorPython:\n \"\"\"\n Converts a pybamm expression tree into pure python code that will calculate the\n result of calling `evaluate(t, y)` on the given expression tree.\n\n Parameters\n ----------\n\n symbol : :class:`pybamm.Symbol`\n The symbol to convert to python code\n\n\n \"\"\"\n\n def __init__(self, symbol):\n constants, python_str = pybamm.to_python(symbol, debug=False)\n\n # extract constants in generated function\n for i, symbol_id in enumerate(constants.keys()):\n const_name = id_to_python_variable(symbol_id, True)\n python_str = \"{} = constants[{}]\\n\".format(const_name, i) + python_str\n\n # constants passed in as an ordered dict, convert to list\n self._constants = list(constants.values())\n\n # indent code\n python_str = \" \" + python_str\n python_str = python_str.replace(\"\\n\", \"\\n \")\n\n # add function def to first line\n python_str = (\n \"def evaluate(constants, t=None, y=None, \"\n \"y_dot=None, inputs=None, known_evals=None):\\n\" + python_str\n )\n\n # calculate the final variable that will output the result of calling `evaluate`\n # on `symbol`\n result_var = id_to_python_variable(symbol.id, symbol.is_constant())\n if symbol.is_constant():\n result_value = symbol.evaluate()\n\n # add return line\n if symbol.is_constant() and isinstance(result_value, numbers.Number):\n python_str = python_str + \"\\n return \" + str(result_value)\n else:\n python_str = python_str + \"\\n return \" + result_var\n\n # store a copy of examine_jaxpr\n python_str = python_str + \"\\nself._evaluate = evaluate\"\n\n self._python_str = python_str\n self._result_var = result_var\n self._symbol = symbol\n\n # compile and run the generated python code,\n compiled_function = compile(python_str, result_var, \"exec\")\n exec(compiled_function)\n\n def evaluate(self, t=None, y=None, y_dot=None, inputs=None, known_evals=None):\n \"\"\"\n Acts as a drop-in replacement for :func:`pybamm.Symbol.evaluate`\n \"\"\"\n # generated code assumes y is a column vector\n if y is not None and y.ndim == 1:\n y = y.reshape(-1, 1)\n\n result = self._evaluate(self._constants, t, y, y_dot, inputs, known_evals)\n\n # don't need known_evals, but need to reproduce Symbol.evaluate signature\n if known_evals is not None:\n return result, known_evals\n else:\n return result\n\n def __getstate__(self):\n # Control the state of instances of EvaluatorPython\n # before pickling. Method \"_evaluate\" cannot be pickled.\n # See https://github.com/pybamm-team/PyBaMM/issues/1283\n state = self.__dict__.copy()\n del state[\"_evaluate\"]\n return state\n\n def __setstate__(self, state):\n # Restore pickled attributes and\n # compile code from \"python_str\"\n # Execution of bytecode (re)adds attribute\n # \"_method\"\n self.__dict__.update(state)\n compiled_function = compile(self._python_str, self._result_var, \"exec\")\n exec(compiled_function)\n\n\nclass EvaluatorJax:\n \"\"\"\n Converts a pybamm expression tree into pure python code that will calculate the\n result of calling `evaluate(t, y)` on the given expression tree. The resultant code\n is compiled with JAX\n\n Limitations: JAX currently does not work on expressions involving sparse matrices,\n so any sparse matrices and operations involved sparse matrices are converted to\n their dense equivilents before compilation\n\n Parameters\n ----------\n\n symbol : :class:`pybamm.Symbol`\n The symbol to convert to python code\n\n\n \"\"\"\n\n def __init__(self, symbol):\n constants, python_str = pybamm.to_python(symbol, debug=False, output_jax=True)\n\n # replace numpy function calls to jax numpy calls\n python_str = python_str.replace(\"np.\", \"jax.numpy.\")\n\n # convert all numpy constants to device vectors\n for symbol_id in constants:\n if isinstance(constants[symbol_id], np.ndarray):\n constants[symbol_id] = jax.device_put(constants[symbol_id])\n\n # get a list of constant arguments to input to the function\n arg_list = [\n id_to_python_variable(symbol_id, True) for symbol_id in constants.keys()\n ]\n\n # get a list of hashable arguments to make static\n # a jax device array is not hashable\n static_argnums = (\n i\n for i, c in enumerate(constants.values())\n if not (isinstance(c, jax.interpreters.xla.DeviceArray))\n )\n\n # store constants\n self._constants = tuple(constants.values())\n\n # indent code\n python_str = \" \" + python_str\n python_str = python_str.replace(\"\\n\", \"\\n \")\n\n # add function def to first line\n args = \"t=None, y=None, y_dot=None, inputs=None, known_evals=None\"\n if arg_list:\n args = \",\".join(arg_list) + \", \" + args\n python_str = \"def evaluate_jax({}):\\n\".format(args) + python_str\n\n # calculate the final variable that will output the result of calling `evaluate`\n # on `symbol`\n result_var = id_to_python_variable(symbol.id, symbol.is_constant())\n if symbol.is_constant():\n result_value = symbol.evaluate()\n\n # add return line\n if symbol.is_constant() and isinstance(result_value, numbers.Number):\n python_str = python_str + \"\\n return \" + str(result_value)\n else:\n python_str = python_str + \"\\n return \" + result_var\n\n # store a copy of examine_jaxpr\n python_str = python_str + \"\\nself._evaluate_jax = evaluate_jax\"\n\n # store the final generated code\n self._python_str = python_str\n\n # compile and run the generated python code,\n compiled_function = compile(python_str, result_var, \"exec\")\n exec(compiled_function)\n\n n = len(arg_list)\n static_argnums = tuple(static_argnums)\n self._jit_evaluate = jax.jit(self._evaluate_jax, static_argnums=static_argnums)\n\n # store a jit version of evaluate_jax's jacobian\n jacobian_evaluate = jax.jacfwd(self._evaluate_jax, argnums=1 + n)\n self._jac_evaluate = jax.jit(jacobian_evaluate, static_argnums=static_argnums)\n\n def get_jacobian(self):\n return EvaluatorJaxJacobian(self._jac_evaluate, self._constants)\n\n def debug(self, t=None, y=None, y_dot=None, inputs=None, known_evals=None):\n # generated code assumes y is a column vector\n if y is not None and y.ndim == 1:\n y = y.reshape(-1, 1)\n\n # execute code\n jaxpr = jax.make_jaxpr(self._evaluate_jax)(\n *self._constants, t, y, y_dot, inputs, known_evals\n ).jaxpr\n print(\"invars:\", jaxpr.invars)\n print(\"outvars:\", jaxpr.outvars)\n print(\"constvars:\", jaxpr.constvars)\n for eqn in jaxpr.eqns:\n print(\"equation:\", eqn.invars, eqn.primitive, eqn.outvars, eqn.params)\n print()\n print(\"jaxpr:\", jaxpr)\n\n def evaluate(self, t=None, y=None, y_dot=None, inputs=None, known_evals=None):\n \"\"\"\n Acts as a drop-in replacement for :func:`pybamm.Symbol.evaluate`\n \"\"\"\n # generated code assumes y is a column vector\n if y is not None and y.ndim == 1:\n y = y.reshape(-1, 1)\n\n result = self._jit_evaluate(*self._constants, t, y, y_dot, inputs, known_evals)\n\n # don't need known_evals, but need to reproduce Symbol.evaluate signature\n if known_evals is not None:\n return result, known_evals\n else:\n return result\n\n\nclass EvaluatorJaxJacobian:\n def __init__(self, jac_evaluate, constants):\n self._jac_evaluate = jac_evaluate\n self._constants = constants\n\n def evaluate(self, t=None, y=None, y_dot=None, inputs=None, known_evals=None):\n \"\"\"\n Acts as a drop-in replacement for :func:`pybamm.Symbol.evaluate`\n \"\"\"\n # generated code assumes y is a column vector\n if y is not None and y.ndim == 1:\n y = y.reshape(-1, 1)\n\n # execute code\n result = self._jac_evaluate(*self._constants, t, y, y_dot, inputs, known_evals)\n result = result.reshape(result.shape[0], -1)\n\n # don't need known_evals, but need to reproduce Symbol.evaluate signature\n if known_evals is not None:\n return result, known_evals\n else:\n return result\n"
] |
[
[
"numpy.testing.assert_array_almost_equal"
],
[
"numpy.all",
"numpy.array",
"numpy.argwhere"
]
] |
GOLoDovkA-A/tardis
|
[
"847b562022ccda2db2486549f739188ba48f172c",
"847b562022ccda2db2486549f739188ba48f172c"
] |
[
"tardis/plasma/standard_plasmas.py",
"tardis/gui/datahandler.py"
] |
[
"import os\nimport logging\n\nimport numpy as np\nimport pandas as pd\n\nfrom tardis.io.atom_data import AtomData\nfrom tardis.io.config_reader import ConfigurationError\nfrom tardis.util.base import species_string_to_tuple\nfrom tardis.plasma import BasePlasma\nfrom tardis.plasma.properties.property_collections import (basic_inputs,\n basic_properties, lte_excitation_properties, lte_ionization_properties,\n macro_atom_properties, dilute_lte_excitation_properties,\n nebular_ionization_properties, non_nlte_properties,\n nlte_properties, helium_nlte_properties, helium_numerical_nlte_properties,\n helium_lte_properties, detailed_j_blues_properties,\n detailed_j_blues_inputs, continuum_interaction_properties)\nfrom tardis.plasma.exceptions import PlasmaConfigError\n\nfrom tardis.plasma.properties import (\n LevelBoltzmannFactorNLTE,\n JBluesBlackBody,\n JBluesDiluteBlackBody,\n JBluesDetailed,\n RadiationFieldCorrection,\n StimulatedEmissionFactor,\n HeliumNumericalNLTE,\n IonNumberDensity)\n\nlogger = logging.getLogger(__name__)\n\n\ndef assemble_plasma(config, model, atom_data=None):\n \"\"\"\n Create a BasePlasma instance from a Configuration object\n and a Radial1DModel.\n\n Parameters\n ----------\n config: ~io.config_reader.Configuration\n model: ~model.Radial1DModel\n atom_data: ~atomic.AtomData\n If None, an attempt will be made to read the atomic data\n from config.\n\n Returns\n -------\n : ~plasma.BasePlasma\n\n \"\"\"\n # Convert the nlte species list to a proper format.\n nlte_species = [species_string_to_tuple(s) for s in\n config.plasma.nlte.species]\n\n # Convert the continuum interaction species list to a proper format.\n continuum_interaction_species = [\n species_string_to_tuple(s) for s in\n config.plasma.continuum_interaction.species\n ]\n continuum_interaction_species = pd.MultiIndex.from_tuples(\n continuum_interaction_species, names=['atomic_number', 'ion_number']\n )\n\n if atom_data is None:\n if 'atom_data' in config:\n if os.path.isabs(config.atom_data):\n atom_data_fname = config.atom_data\n else:\n atom_data_fname = os.path.join(config.config_dirname,\n config.atom_data)\n else:\n raise ValueError('No atom_data option found in the configuration.')\n\n logger.info('Reading Atomic Data from %s', atom_data_fname)\n\n try:\n atom_data = AtomData.from_hdf(atom_data_fname)\n except TypeError as e:\n print(e, 'Error might be from the use of an old-format of the atomic database, \\n'\n 'please see https://github.com/tardis-sn/tardis-refdata/tree/master/atom_data'\n ',for the most recent version.')\n raise\n\n atom_data.prepare_atom_data(\n model.abundance.index,\n line_interaction_type=config.plasma.line_interaction_type,\n nlte_species=nlte_species)\n\n # Check if continuum interaction species are in selected_atoms\n continuum_atoms = continuum_interaction_species.get_level_values(\n 'atomic_number'\n )\n continuum_atoms_in_selected_atoms = np.all(\n continuum_atoms.isin(atom_data.selected_atomic_numbers)\n )\n if not continuum_atoms_in_selected_atoms:\n raise ConfigurationError('Not all continuum interaction species '\n 'belong to atoms that have been specified '\n 'in the configuration.')\n\n kwargs = dict(t_rad=model.t_radiative, abundance=model.abundance,\n density=model.density, atomic_data=atom_data,\n time_explosion=model.time_explosion,\n w=model.dilution_factor, link_t_rad_t_electron=0.9,\n continuum_interaction_species=continuum_interaction_species)\n\n plasma_modules = basic_inputs + basic_properties\n property_kwargs = {}\n if config.plasma.continuum_interaction.species:\n plasma_modules += continuum_interaction_properties\n if config.plasma.radiative_rates_type == 'blackbody':\n plasma_modules.append(JBluesBlackBody)\n elif config.plasma.radiative_rates_type == 'dilute-blackbody':\n plasma_modules.append(JBluesDiluteBlackBody)\n elif config.plasma.radiative_rates_type == 'detailed':\n plasma_modules += detailed_j_blues_properties + detailed_j_blues_inputs\n kwargs.update(r_inner=model.r_inner,\n t_inner=model.t_inner,\n volume=model.volume,\n j_blue_estimator=None)\n property_kwargs[JBluesDetailed] = {'w_epsilon': config.plasma.w_epsilon}\n else:\n raise ValueError('radiative_rates_type type unknown - %s',\n config.plasma.radiative_rates_type)\n\n if config.plasma.excitation == 'lte':\n plasma_modules += lte_excitation_properties\n elif config.plasma.excitation == 'dilute-lte':\n plasma_modules += dilute_lte_excitation_properties\n\n if config.plasma.ionization == 'lte':\n plasma_modules += lte_ionization_properties\n elif config.plasma.ionization == 'nebular':\n plasma_modules += nebular_ionization_properties\n\n if nlte_species:\n plasma_modules += nlte_properties\n nlte_conf = config.plasma.nlte\n plasma_modules.append(\n LevelBoltzmannFactorNLTE.from_config(nlte_conf)\n )\n property_kwargs[StimulatedEmissionFactor] = dict(\n nlte_species=nlte_species)\n else:\n plasma_modules += non_nlte_properties\n\n if config.plasma.line_interaction_type in ('downbranch', 'macroatom'):\n plasma_modules += macro_atom_properties\n\n if 'delta_treatment' in config.plasma:\n property_kwargs[RadiationFieldCorrection] = dict(\n delta_treatment=config.plasma.delta_treatment)\n\n if config.plasma.helium_treatment == 'recomb-nlte':\n plasma_modules += helium_nlte_properties\n elif config.plasma.helium_treatment == 'numerical-nlte':\n plasma_modules += helium_numerical_nlte_properties\n # TODO: See issue #633\n if config.plasma.heating_rate_data_file in ['none', None]:\n raise PlasmaConfigError('Heating rate data file not specified')\n else:\n property_kwargs[HeliumNumericalNLTE] = dict(\n heating_rate_data_file=config.plasma.heating_rate_data_file)\n else:\n plasma_modules += helium_lte_properties\n\n if model._electron_densities:\n electron_densities = pd.Series(model._electron_densities.cgs.value)\n if config.plasma.helium_treatment == 'numerical-nlte':\n property_kwargs[IonNumberDensityHeNLTE] = dict(\n electron_densities=electron_densities)\n else:\n property_kwargs[IonNumberDensity] = dict(\n electron_densities=electron_densities)\n\n kwargs['helium_treatment'] = config.plasma.helium_treatment\n\n plasma = BasePlasma(plasma_properties=plasma_modules,\n property_kwargs=property_kwargs, **kwargs)\n\n return plasma\n",
"import os\nfrom pkg_resources import parse_version\n\nimport numpy as np\nimport matplotlib\nimport matplotlib.pylab as plt\n\n\nif os.environ.get('QT_API', None)=='pyqt':\n from PyQt4 import QtGui, QtCore\nelif os.environ.get('QT_API', None)=='pyside':\n from PySide import QtGui, QtCore\nelse:\n raise ImportError('QT_API was not set! Please exit the IPython console\\n'\n ' and at the bash prompt use : \\n\\n export QT_API=pyside \\n or\\n'\n ' export QT_API=pyqt \\n\\n For more information refer to user guide.')\nimport yaml\n\nfrom tardis import run_tardis\nfrom tardis.gui.widgets import MatplotlibWidget, ModelViewer, ShellInfo\nfrom tardis.gui.widgets import LineInfo, LineInteractionTables\n\nif (parse_version(matplotlib.__version__) >= parse_version('1.4')):\n matplotlib.style.use('fivethirtyeight')\nelse:\n print(\"Please upgrade matplotlib to a version >=1.4 for best results!\")\nmatplotlib.rcParams['font.family'] = 'serif'\nmatplotlib.rcParams['font.size'] = 10.0\nmatplotlib.rcParams['lines.linewidth'] = 1.0 \nmatplotlib.rcParams['axes.formatter.use_mathtext'] = True\nmatplotlib.rcParams['axes.edgecolor'] = matplotlib.rcParams['grid.color']\nmatplotlib.rcParams['axes.linewidth'] = matplotlib.rcParams['grid.linewidth']\n\nclass Node(object):\n \"\"\"Object that serves as the nodes in the TreeModel.\n\n Attributes\n ----------\n parent: None/Node \n The parent of the node.\n children: list of Node\n The children of the node.\n data: list of string \n The data stored on the node. Can be a key or a value.\n siblings: dictionary \n A dictionary of nodes that are siblings of this node. The \n keys are the values of the nodes themselves. This is \n used to keep track of which value the user has selected\n if the parent of this node happens to be a key that can\n take values from a list.\n\n \"\"\"\n\n def __init__(self, data, parent=None):\n \"\"\"Create one node with the data and parent provided.\n\n Parameters\n ----------\n data: list of string\n The data that is intended to be stored on the node.\n parent: Node \n Another node which is the parent of this node. The \n root node has parent set to None.\n\n Note\n ----\n A leaf node is a node that is the only child of its parent. \n For this tree this will always be the case. This is because\n the tree stores the key at every node except the leaf node\n where it stores the value for the key. So if in the dictionary\n the value of a key is another dictionary, then it will \n be a node with no leafs. If the key has a value that is a \n value or a list then it will have one child that is a leaf.\n The leaf can have no children. For example-\n\n 'a':val1\n 'b':{'c':val2\n 'd':val3\n 'e':{'f':val4\n 'g':val5\n :val6\n :val7}} *In this case the key g can take values\n val7, val5 and val6 and is currently\n set to val5.\n\n In the tree shown above all quoted values are keys in the \n dictionary and are non-leaf nodes in the tree. All values \n of the form valx are leaf nodes and are not dictionaries \n themselves. If the keys have non-dictionary values then they\n have a leaf attached. And no leaf can have a child.\n \n \"\"\"\n self.parent = parent\n self.children = []\n self.data = data\n self.siblings = {} #For 'type' fields. Will store the nodes to \n #enable disable on selection\n\n def append_child(self, child):\n \"\"\"Add a child to this node.\"\"\"\n self.children.append(child)\n child.parent = self\n\n def get_child(self, i):\n \"\"\"Get the ith child of this node. \n\n No error is raised if the cild requested doesn't exist. A \n None is returned in such cases.\n\n \"\"\"\n if i < self.num_children():\n return self.children[i]\n else:\n return None\n\n def num_children(self):\n \"\"\"Number of children this node has.\"\"\"\n return len(self.children)\n\n def num_columns(self):\n \"\"\"Returns the number of strings stored in the data attribute.\"\"\"\n return len(self.data)\n\n def get_data(self, i):\n \"\"\"Returns the ith string from the data list.\n\n No error is raised if the data list index is exceeded. A None is\n returned in such cases.\n\n \"\"\"\n try:\n return self.data[i]\n except IndexError:\n return None\n\n def get_parent(self):\n \"\"\"Return the parent of this node.\"\"\"\n return self.parent\n\n def get_index_of_self(self):\n \"\"\"Returns the number at which it comes in the list of its \n parent's children. For root the index 0 is returned.\n\n \"\"\"\n if self.parent:\n return self.parent.children.index(self)\n else:\n return 0\n\n def set_data(self, column, value):\n \"\"\"Set the data for the ith index to the provided value. Returns\n true if the data was set successfully.\n\n \"\"\"\n if column < 0 or column >= self.num_columns():\n return False\n\n self.data[column] = value\n\n return True\n\nclass TreeModel(QtCore.QAbstractItemModel):\n \"\"\"The class that defines the tree for ConfigEditor.\n\n Parameters\n ----------\n root: Node\n Root node of the tree.\n disabledNodes: list of Node \n List of leaf nodes that are not editable currently.\n typenodes: list of Node \n List of nodes that correspond to keys that set container \n types. Look at tardis configuration template. These are the\n nodes that have values that can be set from a list.\n\n \"\"\"\n def __init__(self, dictionary, parent=None):\n \"\"\"Create a tree of tardis configuration dictionary.\n\n Parameters\n ----------\n dictionary: dictionary \n The dictionary that needs to be converted to the tree.\n parent: None \n Used to instantiate the QAbstractItemModel\n\n \"\"\"\n QtCore.QAbstractItemModel.__init__(self, parent)\n\n self.root = Node([\"column A\"])\n self.disabledNodes = []\n self.typenodes = []\n self.dict_to_tree(dictionary, self.root)\n\n #mandatory functions for subclasses\n def columnCount(self, index):\n \"\"\"Return the number of columns in the node pointed to by\n the given model index.\n\n \"\"\"\n if index.isValid():\n return index.internalPointer().num_columns()\n else:\n return self.root.num_columns()\n\n def data(self, index, role):\n \"\"\"Returns the asked data for the node specified by the modeLabel\n index.\"\"\"\n if not index.isValid():\n return None\n\n if role != QtCore.Qt.DisplayRole:\n return None\n\n item = index.internalPointer()\n\n return item.get_data(index.column())\n\n def flags(self, index):\n \"\"\"Return flags for the items whose model index is provided.\"\"\"\n if not index.isValid():\n return QtCore.Qt.NoItemFlags\n\n node = index.internalPointer()\n if ((node.get_parent() in self.disabledNodes) or \n (node in self.disabledNodes)):\n return QtCore.Qt.NoItemFlags\n\n if node.num_children()==0:\n return (QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsEnabled | \n QtCore.Qt.ItemIsSelectable)\n\n return QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable \n\n def getItem(self, index):\n \"\"\"Returns the node to which the model index is pointing. If the\n model index is invalid then the root node is returned.\n\n \"\"\"\n if index.isValid():\n item = index.internalPointer()\n if item:\n return item\n\n return self.root\n\n def headerData(self, section, orientation, role):\n \"\"\"Returns header data. This is not used in QColumnView. But will\n be needed for QTreeView.\n\n \"\"\"\n if (orientation == QtCore.Qt.Horizontal and \n role == QtCore.Qt.DisplayRole):\n return self.root.get_data(section)\n\n return None\n\n def index(self, row, column, parent=QtCore.QModelIndex()):\n \"\"\"Create a model index for the given row and column. For a \n tree model, the row is the set of nodes with the same parents and\n the column indexes the data in the node.\n\n \"\"\"\n if parent.isValid() and parent.column() != 0:\n return QtCore.QModelIndex()\n\n parentItem = self.getItem(parent)\n childItem = parentItem.get_child(row)\n if childItem:\n return self.createIndex(row, column, childItem)\n else:\n return QtCore.QModelIndex()\n\n def insertColumns(self, position, columns, parent=QtCore.QModelIndex()):\n \"\"\"Insert columns in the tree model.\"\"\"\n self.beginInsertColumns(parent, position, position + columns - 1)\n success = self.root.insertColumns(position, columns)\n self.endInsertColumns()\n\n return success\n\n def insertRows(self, position, rows, parent=QtCore.QModelIndex()):\n \"\"\"Insert rows in the tree model.\"\"\"\n parentItem = self.getItem(parent)\n self.beginInsertRows(parent, position, position + rows - 1)\n success = parentItem.insertChildren(position, rows,\n self.rootItem.columnCount())\n self.endInsertRows()\n\n return success\n\n def parent(self, index):\n \"\"\"Return the parent of the node to which the index points.\"\"\"\n if not index.isValid():\n return QtCore.QModelIndex()\n\n childItem = index.internalPointer()\n parentItem = childItem.get_parent()\n\n if parentItem == self.root:\n return QtCore.QModelIndex()\n\n return self.createIndex(parentItem.get_index_of_self(), 0, parentItem)\n\n def rowCount(self, parent=QtCore.QModelIndex()):\n \"\"\"The number of rows for a given node. \n \n (The number of rows is just the number of children for a node.)\n\n \"\"\"\n parentItem = self.getItem(parent)\n\n return parentItem.num_hildren()\n\n def setData(self, index, value, role=QtCore.Qt.EditRole):\n \"\"\"Set the value as the data at the location pointed by the \n index.\n\n \"\"\"\n if role != QtCore.Qt.EditRole:\n return False\n\n item = self.getItem(index)\n result = item.setData(index.column(), value)\n\n if result:\n self.dataChanged.emit(index, index)\n return result\n\n def setHeaderData(self, section, orientation, value, \n role=QtCore.Qt.EditRole):\n \"\"\"Change header data. Unused in columnview.\"\"\"\n if role != QtCore.Qt.EditRole or orientation != QtCore.Qt.Horizontal:\n return False\n\n result = self.root.setData(section, value)\n if result:\n self.headerDataChanged.emit(orientation, section, section)\n\n return result\n \n #Custom functions\n def dict_to_tree(self, dictionary, root):\n \"\"\"Create the tree and append siblings to nodes that need them.\n\n Parameters\n ----------\n dictionary: dictionary\n The dictionary that is to be converted to the tree.\n root: Node \n The root node of the tree.\n\n \"\"\"\n #Construct tree with all nodes\n self.tree_from_node(dictionary, root)\n\n #Append siblings to type nodes\n for node in self.typenodes: #For every type node\n parent = node.get_parent()\n sibsdict = {}\n for i in range(parent.num_children()):\n sibsdict[parent.get_child(i).get_data(0)] = parent.get_child(i)\n\n typesleaf = node.get_child(0)\n for i in range(typesleaf.num_columns()):\n sibstrings = typesleaf.get_data(i).split('|_:_|')\n \n typesleaf.set_data(i, sibstrings[0])\n sibslist = []\n for j in range(1, len(sibstrings)):\n if sibstrings[j] in sibsdict:\n sibslist.append(sibsdict[sibstrings[j]])\n\n typesleaf.siblings[sibstrings[0]] = sibslist\n \n #Then append siblings of current selection for all type nodes to\n #disabled nodes\n for i in range(1,typesleaf.num_columns()):\n key = typesleaf.get_data(i)\n for nd in typesleaf.siblings[key]:\n self.disabledNodes.append(nd)\n\n\n def tree_from_node(self, dictionary, root):\n \"\"\"Convert dictionary to tree. Called by dict_to_tree.\"\"\"\n for key in dictionary:\n child = Node([key])\n root.append_child(child)\n if isinstance(dictionary[key], dict):\n self.tree_from_node(dictionary[key], child)\n elif isinstance(dictionary[key], list):\n if isinstance(dictionary[key][1], list):\n leaf = Node(dictionary[key][1]) \n else:\n leaf = Node([dictionary[key][1]])\n\n child.append_child(leaf)\n if key == 'type':\n self.typenodes.append(child)\n\n def dict_from_node(self, node): \n \"\"\"Take a node and convert the whole subtree rooted at it into a \n dictionary.\n\n \"\"\"\n children = [node.get_child(i) for i in range(node.num_children())]\n if len(children) > 1:\n dictionary = {}\n for nd in children:\n if nd in self.disabledNodes:\n pass\n else:\n dictionary[nd.get_data(0)] = self.dict_from_node(nd)\n return dictionary\n elif len(children)==1:\n return children[0].get_data(0)\n\n\nclass TreeDelegate(QtGui.QStyledItemDelegate):\n \"\"\"Create a custom delegate to modify the columnview that displays the \n TreeModel.\n\n \"\"\"\n def __init__(self, parent=None):\n \"\"\"Call the constructor of the superclass.\"\"\"\n QtGui.QStyledItemDelegate.__init__(self, parent)\n \n #Mandatory methods for subclassing\n def createEditor(self, parent, option, index):\n \"\"\"Create a lineEdit or combobox depending on the type of node.\"\"\"\n node = index.internalPointer()\n if node.num_columns()>1:\n combobox = QtGui.QComboBox(parent)\n combobox.addItems([node.get_data(i) for i in range(node.num_columns())])\n combobox.setEditable(False)\n return combobox\n else:\n editor = QtGui.QLineEdit(parent)\n editor.setText(str(node.get_data(0)))\n editor.returnPressed.connect(self.close_and_commit)\n return editor\n\n def setModelData(self, editor, model, index):\n \"\"\"Called when new data id set in the model. This is where the\n siblings of type nodes are enabled or disabled according to the \n new choice made.\n\n \"\"\"\n node = index.internalPointer()\n\n if node.num_columns() > 1 and node.get_parent().get_data(0) != 'type':\n selectedIndex = editor.currentIndex()\n firstItem = node.get_data(0)\n node.setData(0, str(editor.currentText()))\n node.setData(selectedIndex, str(firstItem))\n\n elif node.num_columns() > 1 and node.get_parent().get_data(0) == 'type':\n selectedIndex = editor.currentIndex()\n firstItem = node.get_data(0)\n node.setData(0, str(editor.currentText()))\n node.setData(selectedIndex, str(firstItem))\n\n itemsToDisable = node.siblings[firstItem]\n itemsToEnable = node.siblings[str(editor.currentText())]\n\n for nd in itemsToDisable:\n model.disabledNodes.append(nd)\n\n for nd in itemsToEnable:\n if nd in model.disabledNodes:\n model.disabledNodes.remove(nd) \n\n elif isinstance(editor, QtGui.QLineEdit): \n node.setData(0, str(editor.text()))\n else:\n QtGui.QStyledItemDelegate.setModelData(self, editor, model, index)\n \n #Custom methods\n def close_and_commit(self):\n \"\"\"Saver for the line edits.\"\"\"\n editor = self.sender()\n if isinstance(editor, QtGui.QLineEdit):\n self.commitData.emit(editor)\n self.closeEditor.emit(editor, QtGui.QAbstractItemDelegate.NoHint)\n\nclass SimpleTableModel(QtCore.QAbstractTableModel):\n \"\"\"Create a table data structure for the table widgets.\"\"\"\n \n def __init__(self, headerdata=None, iterate_header=(0, 0), \n index_info=None, parent=None, *args):\n \"\"\"Call constructor of the QAbstractTableModel and set parameters\n given by user.\n \"\"\"\n super(SimpleTableModel, self).__init__(parent, *args)\n self.headerdata = headerdata\n self.arraydata = []\n self.iterate_header = iterate_header\n self.index_info = index_info\n \n #Implementing methods mandatory for subclassing QAbstractTableModel\n def rowCount(self, parent=QtCore.QModelIndex()):\n \"\"\"Return number of rows.\"\"\"\n return len(self.arraydata[0])\n\n def columnCount(self, parent=QtCore.QModelIndex()):\n \"\"\"Return number of columns.\"\"\"\n return len(self.arraydata)\n\n def headerData(self, section, orientation, role=QtCore.Qt.DisplayRole):\n \"\"\"Set the header data.\"\"\"\n if orientation == QtCore.Qt.Vertical and role == QtCore.Qt.DisplayRole:\n if self.iterate_header[0] == 1:\n return self.headerdata[0][0] + str(section + 1)\n elif self.iterate_header[0] == 2:\n if self.index_info:\n return self.headerdata[0][0] + str(self.index_info[section])\n else:\n return self.headerdata[0][0] + str(section + 1)\n else:\n return self.headerdata[0][section]\n elif orientation == QtCore.Qt.Horizontal and role == QtCore.Qt.DisplayRole:\n if self.iterate_header[1] == 1:\n return self.headerdata[1][0] + str(section + 1)\n elif self.iterate_header[1] == 2:\n if self.index_info:\n return self.headerdata[1][0] + str(self.index_info[section])\n else:\n return self.headerdata[1][section]\n return None\n\n def data(self, index, role=QtCore.Qt.DisplayRole):\n \"\"\"Return data of specified index and role.\"\"\"\n if not index.isValid():\n return None\n elif role != QtCore.Qt.DisplayRole:\n return None\n return (self.arraydata[index.column()][index.row()])\n\n def setData(self, index, value, role=QtCore.Qt.EditRole):\n \"\"\"Change the data in the model for specified index and role\n to specified value.\"\"\"\n if not index.isValid():\n return False\n elif role != QtCore.Qt.EditRole:\n return False\n self.arraydata[index.column()][index.row()] = value\n self.emit(QtCore.SIGNAL(\n 'dataChanged(const QModelIndex &, const QModelIndex &)'), \n index, index)\n return True\n\n #Methods used to inderact with the SimpleTableModel\n def update_table(self):\n \"\"\"Update table to set all the new data.\"\"\"\n for r in range(self.rowCount()):\n for c in range(self.columnCount()):\n index = self.createIndex(r, c)\n self.setData(index, self.arraydata[c][r])\n \n def add_data(self, datain):\n \"\"\"Add data to the model.\"\"\"\n self.arraydata.append(datain)\n"
] |
[
[
"pandas.MultiIndex.from_tuples",
"pandas.Series"
],
[
"matplotlib.style.use"
]
] |
MickaelRigault/snprop
|
[
"e2505b612240b41e984d79e18355926e0c0462f4"
] |
[
"snprop/age.py"
] |
[
"\"\"\" Prompt vs. Delayed model of the SN population \"\"\"\nimport pandas\nimport numpy as np\n\nfrom scipy import stats\nfrom .tools import asym_gaussian\n\n\nclass PrompDelayModel(object):\n\n def __init__(self):\n \"\"\" \"\"\"\n\n # ====================== #\n # Methods #\n # ====================== #\n @staticmethod\n def deltaz(z, k=0.87, phi=2.8):\n \"\"\" fraction of young SNeIa as a function of redshift.\n from Rigault et al. 2018 (LsSFR paper)\n\n Parameters:\n -----------\n z: [float array of]\n redshifts\n\n k: [float] -optional-\n normalisation. 0.87 means that 50% of SNeIa are prompt at z\\approx 0.05\n (anchored by SNfactory)\n\n phi: [float] -optional-\n power law redshift dependency.\n\n Returns:\n --------\n array\n \"\"\"\n return (k**(-1)*(1+z)**(-phi)+1)**(-1)\n\n # -------- #\n # SETTER #\n # -------- #\n # STRETCH\n def set_distprop_stretch(self, mu1=0.37, sigma1=0.61,\n mu2=-1.22, sigma2=0.56, a=0.51):\n \"\"\" Set the parameters of the SNe Ia stretch distribution.\n\n Following Nicolas, Rigault et al. 2020, the model is the following:\n - prompt SNeIa are single moded, \"Mode 1\"\n - delayed SNeIa are bimodal, a*\"Model 1\" + (1-a)*\"Mode 2\"\n\n Parameters\n ----------\n mu1, sigma1: [float, float]\n Mean and std of the mode 1\n\n mu2, sigma2: [float, float]\n Mean and std of the mode 2\n\n a: [float between 0 and 1]\n The relative weight of mode 1 over mode 2 (0.5 means equal weight)\n\n\n \"\"\"\n if a < 0 or a > 1:\n raise ValueError(f\"a must be between 0 and 1, {a} given\")\n\n self._distprop_stretch = \\\n {\"mode1\": {\"loc\": mu1, \"scale\": sigma1},\n \"mode2\": {\"loc\": mu2, \"scale\": sigma2},\n \"a\": a}\n\n # COLOR\n def set_distprop_color(self, mu=-0.030, sigmaup=0.086, sigmadown=0.052,\n mu_delayed=None, sigmaup_delayed=None,\n sigmadown_delayed=None):\n \"\"\"\n Set the parameters of the SNe Ia color distribution,\n modeled as asymetric gaussians.\n\n If *_delayed are not provided, prompt and delayed are assumed\n similar (tested on mu_delayed)\n \"\"\"\n if mu_delayed is None:\n mu_delayed = mu\n sigmaup_delayed = sigmaup\n sigmadown_delayed = sigmadown\n\n self._distprop_color = \\\n {\"prompt\":\n {\"mu\": mu, \"sigmaup\": sigmaup, \"sigmadown\": sigmadown},\n \"delayed\":\n {\"mu\": mu_delayed, \"sigmaup\": sigmaup_delayed,\n \"sigmadown\": sigmadown_delayed}}\n\n # HOST MASS\n def set_distprop_mass(self,\n mu_prompt=9.41, sigma_prompt=0.62,\n a=0.90,\n mu_delayed1=10.60, sigma_delayed1=0.38,\n mu_delayed2=8.74, sigma_delayed2=0.43):\n \"\"\"\n Set the parameters of the SNe Ia mass distribution,\n modeled as one Gaussian for the prompt,\n and a Gaussian mixture for the delayed.\n \"\"\"\n self._distprop_mass = \\\n {\"prompt\":\n {\"mu\": mu_prompt, \"sigma\": sigma_prompt},\n \"delayed\":\n {\"a\": a,\n \"mu_1\": mu_delayed1, \"sigma_1\": sigma_delayed1,\n \"mu_2\": mu_delayed2, \"sigma_2\": sigma_delayed2}}\n\n # HUBBLE RESIDUALS\n def set_distprop_hr(self, mean_prompt=0.075, sigma_prompt=0.1,\n mean_delayed=-0.075, sigma_delayed=0.1):\n \"\"\"\n Normal distribution for each age sample. (assuming 0.15 mag step).\n \"\"\"\n self._distprop_hr = \\\n {\"prompt\":\n {\"mean\": mean_prompt, \"sigma\": sigma_prompt},\n \"delayed\":\n {\"mean\": mean_delayed, \"sigma\": sigma_delayed}}\n\n # - Distortion of what is in Nature\n\n # -------- #\n # GETTER #\n # -------- #\n def get_frac_prompt(self, z):\n \"\"\"\n Get the expected fraction of prompt SNe Ia as the given redshift(s)\n \"\"\"\n if len(np.atleast_1d(z)) > 1:\n return self.deltaz(np.asarray(z)[:, None])\n return self.deltaz(z)\n\n # - Stretch\n def get_distpdf_stretch(self, x, fprompt, dx=None, **kwargs):\n \"\"\"\n Get the pdf of the stretch distribution at the given values.\n\n Parameters\n ----------\n x: [1d array]\n values where you want to estimate the pdf\n\n fprompt: [float between 0 and 1]\n Fraction of prompt. 0(1) means pure delayed(prompt)\n Could be a list.\n\n dx: [1d array] -optional-\n measurement error added in quadrature to the model's std.\n\n **kwargs goes to set_distprop_stretch()\n\n Returns\n -------\n pdf values (or list of)\n \"\"\"\n self.set_distprop_stretch(**kwargs)\n if dx is None:\n dx = 0\n\n mode1_pdf = stats.norm.pdf(x,\n loc=self.distprop_stretch[\"mode1\"][\"loc\"],\n scale=np.sqrt(self.distprop_stretch[\"mode1\"]\n [\"scale\"]**2 + dx**2))\n mode2_pdf = stats.norm.pdf(x,\n loc=self.distprop_stretch[\"mode2\"][\"loc\"],\n scale=np.sqrt(self.distprop_stretch[\"mode2\"]\n [\"scale\"]**2 + dx**2))\n\n return(fprompt * mode1_pdf +\n (1-fprompt) * (self.distprop_stretch[\"a\"]*mode1_pdf +\n (1-self.distprop_stretch[\"a\"])*mode2_pdf))\n\n # - Color\n def get_distpdf_color(self, x, fprompt, dx=None, **kwargs):\n \"\"\"\n Get the pdf of the color distribution at the given values.\n\n Parameters\n ----------\n x: [1d array]\n values where you want to estimate the pdf\n\n fprompt: [float between 0 and 1]\n Fraction of prompt. 0(1) means pure delayed(prompt)\n Could be a list.\n\n dx: [1d array] -optional-\n measurement error added in quadrature to the model's std.\n\n **kwargs goes to set_distprop_color()\n\n Returns\n -------\n pdf values (or list of)\n \"\"\"\n self.set_distprop_color(**kwargs)\n if dx is None:\n dx = 0\n\n prompt = asym_gaussian(\n x, *list(self.distprop_color[\"prompt\"].values()), dx=dx)\n delayed = asym_gaussian(\n x, *list(self.distprop_color[\"delayed\"].values()), dx=dx)\n return fprompt*prompt + (1-fprompt) * delayed\n\n # - Mass\n def get_distpdf_mass(self, x, fprompt, dx=None, z=None, **kwargs):\n \"\"\" get the pdf of the mass distribution at the given values.\n\n Parameters\n ----------\n x: [1d array]\n values where you want to estimate the pdf\n\n fprompt: [float between 0 and 1]\n Fraction of prompt. 0(1) means pure delayed(prompt)\n Could be a list.\n\n dx: [1d array] -optional-\n measurement error added in quadrature to the model's std.\n\n z: [float] -optional-\n NOT IMPLEMENTED YET\n the redshift at which the prompt/delayed - mass association is made\n\n **kwargs goes to set_distprop_mass()\n\n Returns\n -------\n pdf values (or list of)\n \"\"\"\n self.set_distprop_mass(**kwargs)\n if dx is None:\n dx = 0\n\n if z is not None:\n raise NotImplementedError(\n \"No redshift dependency implemented for get_distpdf_mass().\" +\n \"Set z=None\")\n\n prompt_pdf = stats.norm.pdf(x,\n loc=self.distprop_mass[\"prompt\"]\n [\"mu\"],\n scale=np.sqrt(\n self.distprop_mass[\"prompt\"]\n [\"sigma\"]**2 + dx**2))\n\n delay_pdf1 = stats.norm.pdf(x,\n loc=self.distprop_mass[\"delayed\"]\n [\"mu_1\"],\n scale=np.sqrt(\n self.distprop_mass[\"delayed\"]\n [\"sigma_1\"]**2 + dx**2))\n\n delay_pdf2 = stats.norm.pdf(x,\n loc=self.distprop_mass[\"delayed\"]\n [\"mu_2\"],\n scale=np.sqrt(\n self.distprop_mass[\"delayed\"]\n [\"sigma_2\"]**2 + dx**2))\n\n return(fprompt * prompt_pdf +\n (1-fprompt) * (self.distprop_mass[\"delayed\"][\"a\"]*delay_pdf1 +\n (1-self.distprop_mass[\"delayed\"][\"a\"]) *\n delay_pdf2))\n\n # - HR\n def get_distpdf_hr(self, x, fprompt, dx=None, **kwargs):\n \"\"\"\n Get the pdf of the standardised Hubble Residual distribution at the\n given values.\n\n Parameters\n ----------\n x: [1d array]\n values where you want to estimate the pdf\n\n fprompt: [float between 0 and 1]\n Fraction of prompt. 0(1) means pure delayed(prompt)\n Could be a list.\n\n dx: [1d array] -optional-\n measurement error added in quadrature to the model's std.\n\n **kwargs goes to set_distprop_hr()\n\n Returns\n -------\n pdf values (or list of)\n \"\"\"\n self.set_distprop_hr(**kwargs)\n if dx is None:\n dx = 0\n\n prompt = stats.norm.pdf(x,\n loc=self.distprop_hr[\"prompt\"][\"mean\"],\n scale=np.sqrt(self.distprop_hr[\"prompt\"]\n [\"sigma\"]**2+dx**2))\n delayed = stats.norm.pdf(x,\n loc=self.distprop_hr[\"delayed\"][\"mean\"],\n scale=np.sqrt(self.distprop_hr[\"delayed\"]\n [\"sigma\"]**2+dx**2))\n return fprompt*prompt + (1-fprompt) * delayed\n\n # ---------- #\n # Draw #\n # ---------- #\n def _draw_(self, a, pdf, size=None):\n \"\"\" \"\"\"\n if len(np.shape(pdf)) == 1:\n return np.random.choice(a, size=size, p=pdf)\n elif len(np.shape(pdf)) == 2:\n return(np.asarray([np.random.choice(mm, size=size, p=pdf_)\n for pdf_ in pdf]))\n raise ValueError(\"pdf shape must be 1 or 2.\")\n\n def draw_age(self, fprompt=None, z=None, size=1):\n \"\"\" \"\"\"\n fprompt = self._read_fprompt_z_(fprompt=fprompt, z=z)\n s = np.random.random(size=[len(np.atleast_1d(fprompt)), size])\n flag_p = s < fprompt\n young = np.zeros(s.shape)\n young[flag_p] = 1\n return young\n\n def draw_property(self, which, nprompt, ndelayed, concat=True):\n \"\"\" get a random realisation of the SN Ia property you want\n\n Parameters\n ----------\n which: [string]\n Property you want:\n - stretch\n - color\n - hr\n - mass\n - age\n\n nprompt, ndelayed: [ints]\n Number of prompt and delayed in the sample respectively.\n\n concat: [bool] -optional-\n do you want a unique list or first prompt then first delayed.\n\n Returns\n -------\n list of properties (see concat)\n \"\"\"\n if which in [\"age\"]:\n if len(np.atleast_1d(nprompt)) == 1:\n return np.concatenate([np.ones(int(nprompt)),\n np.zeros(int(ndelayed))], axis=0)\n else:\n return [np.concatenate([np.ones(int(p_)),\n np.zeros(int(d_))], axis=0)\n for p_, d_ in zip(nprompt, ndelayed)]\n\n xx_ = self.property_range[which]\n prompt_pdf = getattr(self, f\"get_distpdf_{which}\")(xx_, 1)\n delayed_pdf = getattr(self, f\"get_distpdf_{which}\")(xx_, 0)\n\n if len(np.atleast_1d(nprompt)) == 1:\n prompt_prop = self._draw_(\n xx_,\n prompt_pdf/np.sum(prompt_pdf, axis=0),\n size=int(nprompt))\n delayed_prop = self._draw_(\n xx_,\n delayed_pdf/np.sum(delayed_pdf, axis=0),\n size=int(ndelayed))\n return(np.concatenate([prompt_prop, delayed_prop], axis=0)\n if concat else [prompt_prop, delayed_prop])\n else:\n prompt_prop = [self._draw_(xx_,\n prompt_pdf/np.sum(prompt_pdf, axis=0),\n size=int(nprompt_))\n for nprompt_ in np.atleast_1d(nprompt)]\n delayed_prop = [self._draw_(xx_,\n delayed_pdf /\n np.sum(delayed_pdf, axis=0),\n size=int(ndelayed_))\n for ndelayed_ in np.atleast_1d(ndelayed)]\n return([np.concatenate([p_, d_], axis=0)\n if concat else [p_, d_] for p_, d_ in zip(prompt_prop,\n delayed_prop)])\n\n def draw_sample(self, fprompt=None, z=None, size=1):\n \"\"\" draw a random realisation of a sample.\n It will be stored as self.sample (pandas.DataFrame)\n\n Parameters\n ----------\n fprompt: [0<=float<=1 or list of] -optional-\n Fraction of prompt in the sample\n = requested if z is not given =\n\n z: [float or list of] -optional-\n Redshift(s) of the SNe Ia\n = requested if fprompt is not given =\n\n // z and fprompt cannot be given together //\n\n size: [int] -optional-\n size of the sample.\n If fprompt or z are list, this will be the size per element.\n\n Returns\n -------\n Void (sets self.sample)\n\n Usage:\n -----\n >self.draw_sample(z=[0.1,0.5,1], size=1000)\n >self.sample is in that case a dataframe with the length of 3000\n 1000 per redshift)\n \"\"\"\n z = np.atleast_1d(z)\n ages = self.draw_age(fprompt=fprompt, z=z, size=size)\n nprompt = np.sum(ages, axis=1)\n ndelayed = size - nprompt\n data = {k: (np.concatenate(self.draw_property(k, nprompt, ndelayed))\n if len(nprompt) > 1\n else self.draw_property(k,\n nprompt,\n ndelayed))\n for k in [\"color\", \"stretch\", \"age\", \"mass\", \"hr\"]}\n data[\"z\"] = np.concatenate((np.ones((len(z), size)).T*z).T)\\\n if z is not None else None\n # - Color\n self._sample = pandas.DataFrame(data)\n\n def get_subsample(self, size, index_pdf=None):\n \"\"\"Get the subsample (DataFrame) of the main self.sample given the pdf\n of each index.\n\n Parameters\n ----------\n size: [int]\n size of the new subsample\n\n index_pdf: [array/None] -optional-\n array of float of the same size if self.sample\n None means equal weight to all indexes.\n\n Returns\n -------\n DataFrame\n \"\"\"\n if index_pdf is not None:\n index_pdf = index_pdf/np.sum(index_pdf, axis=0)\n\n subsample_index = np.random.choice(\n self.sample.index, p=index_pdf, size=size, replace=False)\n return self.sample[self.sample.index.isin(subsample_index)]\n\n def show_pdf(self, which, fprompt=None, z=None, detailed=False, ax=None,\n cmap=\"coolwarm\", zmax=2, **kwargs):\n \"\"\" Show the figure of the PDF distribution of the given SN property\n\n Parameters\n ----------\n which: [string]\n Property you want:\n - stretch\n - color\n - hr\n - mass\n\n fprompt: [0<=float<=1 or list of] -optional-\n Fraction of prompt in the sample\n = requested if z is not given =\n\n z: [float or list of] -optional-\n Redshift(s) of the SNe Ia\n = requested if fprompt is not given =\n\n // z and fprompt cannot be given together //\n\n detailed: Not Implemented yet\n\n ax: [matplotlib Axes] -optional-\n ax where the figure will be displayed\n\n cmap: [string ; matplotlib colormap] -optional-\n colormap. The value will be the SN redshift.\n\n zmax: [float] -optional-\n upper limit of the colormap\n\n\n **kwargs goes to ax.plot()\n Returns\n -------\n matplotlib Figure\n \"\"\"\n import matplotlib.pyplot as mpl\n\n fprompt = self._read_fprompt_z_(fprompt=fprompt, z=z)\n\n # - Data\n xx = self.property_range[which]\n if detailed:\n print(\"detailed not implemented\")\n prompt_pdf = getattr(self, f\"get_distpdf_{which}\")(xx, 1)\n delayed_pdf = getattr(self, f\"get_distpdf_{which}\")(xx, 0)\n pdf = fprompt * prompt_pdf + (1-fprompt) * delayed_pdf\n else:\n pdf = getattr(self, f\"get_distpdf_{which}\")(xx, fprompt)\n\n # - Axes\n if ax is None:\n fig = mpl.figure(figsize=[6, 4])\n ax = fig.add_subplot(111)\n else:\n fig = ax.figure\n\n # - Plot\n z = np.atleast_1d(z)\n if len(z) == 1:\n pdf = [pdf]\n for pdf_, z_ in zip(pdf, z):\n ax.plot(xx, pdf_, color=mpl.cm.get_cmap(cmap)(\n z_/zmax) if z_ is not None else \"k\", **kwargs)\n\n ax.set_xlabel(which, fontsize=\"large\")\n return fig\n\n def show_scatter(self, xkey, ykey, colorkey=\"age\", ax=None, **kwargs):\n \"\"\" Show the scatter plot of the sample parameters\n\n Parameters\n ----------\n xkey, ykey, colorkey: [string]\n self.sample entries used as x, y and color values\n\n ax: [matplotlib Axes] -optional-\n ax where the figure will be displayed\n\n **kwargs goes to ax.scatter()\n\n Returns\n -------\n matplotlib Figure\n \"\"\"\n import matplotlib.pyplot as mpl\n # - Axes\n if ax is None:\n fig = mpl.figure(figsize=[6, 4])\n ax = fig.add_subplot(111)\n else:\n fig = ax.figure\n\n ax.scatter(self.sample[xkey], self.sample[ykey],\n c=self.sample[colorkey], **kwargs)\n\n ax.set_xlabel(xkey, fontsize=\"large\")\n ax.set_ylabel(ykey, fontsize=\"large\")\n return fig\n\n # ---------------- #\n # Internal #\n # ---------------- #\n def _read_fprompt_z_(self, fprompt=None, z=None):\n \"\"\" \"\"\"\n if fprompt is None and z is None:\n raise ValueError(\"z or fprompt must be given.\")\n\n elif fprompt is None:\n fprompt = self.get_frac_prompt(z)\n elif z is not None:\n raise ValueError(\"complict: either fprompt or z must be given.\")\n\n return fprompt\n # ====================== #\n # Properties #\n # ====================== #\n\n @property\n def distprop_stretch(self):\n \"\"\"dict of the stretch distribution parameters \"\"\"\n if not hasattr(self, \"_distprop_stretch\")\\\n or self._distprop_stretch is None:\n self.set_distprop_stretch()\n return self._distprop_stretch\n\n @property\n def distprop_color(self):\n \"\"\"dict of the color distribution parameters\"\"\"\n if not hasattr(self, \"_distprop_color\")\\\n or self._distprop_color is None:\n self.set_distprop_color()\n return self._distprop_color\n\n @property\n def distprop_mass(self):\n \"\"\"dict of the host mass distribution parameters\"\"\"\n if not hasattr(self, \"_distprop_mass\")\\\n or self._distprop_mass is None:\n self.set_distprop_mass()\n return self._distprop_mass\n\n @property\n def distprop_hr(self):\n \"\"\"dict of the standardized hubble residuals distribution parameters\"\"\"\n if not hasattr(self, \"_distprop_hr\")\\\n or self._distprop_hr is None:\n self.set_distprop_hr()\n return self._distprop_hr\n\n @property\n def sample(self):\n \"\"\"pandas.DataFrame of the randomly draw sample parameters\n (see self.draw_sample()) \"\"\"\n if not self.has_sample():\n raise AttributeError(\"No sample drawn. See self.draw_sample()\")\n return self._sample\n\n def has_sample(self):\n \"\"\"Test if you loaded a sample already (True means yes) \"\"\"\n return hasattr(self, \"_sample\") and self._sample is not None\n\n @property\n def property_range(self):\n \"\"\"Extent of the SN properties \"\"\"\n if not hasattr(self, \"_property_range\")\\\n or self._property_range is None:\n self._property_range = {\"color\": np.linspace(-0.4, 0.5, 1000),\n \"stretch\": np.linspace(-5, 5, 1000),\n \"mass\": np.linspace(6, 13, 1000),\n \"hr\": np.linspace(-1, +1, 1000)\n }\n return self._property_range\n"
] |
[
[
"numpy.sqrt",
"numpy.linspace",
"numpy.random.choice",
"numpy.asarray",
"matplotlib.pyplot.cm.get_cmap",
"pandas.DataFrame",
"numpy.atleast_1d",
"numpy.concatenate",
"numpy.shape",
"numpy.zeros",
"numpy.sum",
"matplotlib.pyplot.figure"
]
] |
Pawandeep-prog/hand-gestured-vlc
|
[
"8760ee6d1d17456ddc96248775031dc2cee30ca6"
] |
[
"vlc_main.py"
] |
[
"import cv2\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\nfrom tensorflow.keras.models import load_model\r\nfrom pynput.keyboard import Controller, Key\r\nimport time\r\ncont= Controller()\r\nflag = True\r\n\r\nmodel = load_model('finger.hdf')\r\n\r\ncap = cv2.VideoCapture(0)\r\n\r\nstart = time.time()\r\n\r\n\r\nwhile True:\r\n wind = np.zeros((200,200,3))\r\n _, frame = cap.read()\r\n frame = cv2.flip(frame, 1)\r\n show = frame[50:200, 400:550]\r\n frame = cv2.blur(frame, (2,2))\r\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\r\n \r\n gray = gray[50:200, 400:550]\r\n \r\n _, mask = cv2.threshold(gray,120 ,255 ,cv2.THRESH_BINARY_INV)\r\n mask = mask / 255.0\r\n mask = cv2.resize(mask, (128,128))\r\n mask = mask.reshape(-1,128,128,1) \r\n \r\n ############################\r\n \r\n result=model.predict(mask)\r\n res = np.argmax(result)\r\n #print(res)\r\n\r\n cv2.putText(wind, \"{}\".format(res),(50,125), cv2.FONT_HERSHEY_SIMPLEX,3,(0,255,0),2)\r\n\r\n \r\n if flag:\r\n if res == 0:\r\n cont.press(Key.space)\r\n cont.release(Key.space)\r\n flag = False\r\n elif res == 1:\r\n cont.press(Key.up)\r\n cont.release(Key.up)\r\n flag = False \r\n elif res == 2: \r\n cont.press(Key.down)\r\n cont.release(Key.down) \r\n flag = False\r\n elif res == 3:\r\n cont.press(Key.left)\r\n cont.release(Key.left) \r\n flag = False\r\n elif res == 4:\r\n cont.press(Key.right)\r\n cont.release(Key.right) \r\n flag = False\r\n ############################\r\n \r\n cv2.imshow(\"main\", show)\r\n cv2.imshow(\"result\", mask.reshape(128,128))\r\n cv2.imshow(\"\", wind)\r\n\r\n end = time.time()\r\n if (end - start) > 2:\r\n start = end\r\n flag = True\r\n \r\n if cv2.waitKey(1) == 27:\r\n break\r\n \r\ncap.release()\r\ncv2.destroyAllWindows()\r\n\r\n\r\n"
] |
[
[
"tensorflow.keras.models.load_model",
"numpy.argmax",
"numpy.zeros"
]
] |
lamto20132223/mealpy
|
[
"b25bd7548299d490cf2f40d3ecfc5dc87cf60994"
] |
[
"mealpy/swarm_based/SSA.py"
] |
[
"#!/usr/bin/env python\n# ------------------------------------------------------------------------------------------------------%\n# Created by \"Thieu Nguyen\" at 11:59, 17/03/2020 %\n# %\n# Email: nguyenthieu2102@gmail.com %\n# Homepage: https://www.researchgate.net/profile/Thieu_Nguyen6 %\n# Github: https://github.com/thieunguyen5991 %\n#-------------------------------------------------------------------------------------------------------%\n\nimport numpy as np\nfrom numpy.random import rand\nfrom copy import deepcopy\nfrom scipy.spatial.distance import cdist\nfrom mealpy.root import Root\n\n\nclass BaseSSA(Root):\n \"\"\"\n Original version of: Social Spider Algorithm - A social spider algorithm for global optimization\n \"\"\"\n\n def __init__(self, root_paras=None, epoch=750, pop_size=100, r_a=1, p_c=0.7, p_m=0.1):\n Root.__init__(self, root_paras)\n self.epoch = epoch\n self.pop_size = pop_size\n self.r_a = r_a # the rate of vibration attenuation when propagating over the spider web.\n self.p_c = p_c # controls the probability of the spiders changing their dimension mask in the random walk step.\n self.p_m = p_m # the probability of each value in a dimension mask to be one\n self.info = True\n\n def _train__(self):\n\n g_best = [np.Inf, np.zeros(self.problem_size)]\n self.position = np.random.uniform(self.domain_range[0], self.domain_range[1], (self.pop_size, self.problem_size))\n target_position = self.position.copy()\n target_intensity = np.zeros(self.pop_size)\n mask = np.zeros((self.pop_size, self.problem_size))\n movement = np.zeros((self.pop_size, self.problem_size))\n inactive = np.zeros(self.pop_size)\n\n epoch = 0\n while (epoch < self.epoch):\n epoch += 1\n spider_fitness = np.array([self._fitness_model__(self.position[i]) for i in range(self.pop_size)])\n base_distance = np.mean(np.std(self.position, 0))\n distance = cdist(self.position, self.position, 'euclidean')\n\n intensity_source = np.log(1. / (spider_fitness + 1E-100) + 1)\n intensity_attenuation = np.exp(-distance / (base_distance * self.r_a))\n intensity_receive = np.tile(intensity_source, self.pop_size).reshape(self.pop_size, self.pop_size) * intensity_attenuation\n\n max_index = np.argmax(intensity_receive, axis=1)\n keep_target = intensity_receive[np.arange(self.pop_size), max_index] <= target_intensity\n keep_target_matrix = np.repeat(keep_target, self.problem_size).reshape(self.pop_size, self.problem_size)\n inactive = inactive * keep_target + keep_target\n target_intensity = target_intensity * keep_target + intensity_receive[np.arange(self.pop_size), max_index] * (1 - keep_target)\n target_position = target_position * keep_target_matrix + self.position[max_index] * (1 - keep_target_matrix)\n\n rand_position = self.position[np.floor(rand(self.pop_size * self.problem_size) * self.pop_size).astype(int), \\\n np.tile(np.arange(self.problem_size), self.pop_size)].reshape(self.pop_size, self.problem_size)\n new_mask = np.ceil(rand(self.pop_size, self.problem_size) + rand() * self.p_m - 1)\n keep_mask = rand(self.pop_size) < self.p_c ** inactive\n inactive = inactive * keep_mask\n keep_mask_matrix = np.repeat(keep_mask, self.problem_size).reshape(self.pop_size, self.problem_size)\n mask = keep_mask_matrix * mask + (1 - keep_mask_matrix) * new_mask\n\n follow_position = mask * rand_position + (1 - mask) * target_position\n movement = np.repeat(rand(self.pop_size), self.problem_size).reshape(self.pop_size, self.problem_size) * movement + \\\n (follow_position - self.position) * rand(self.pop_size, self.problem_size)\n self.position = self.position + movement\n\n if np.min(spider_fitness) < g_best[0]:\n g_best = [np.min(spider_fitness), self.position[np.argmin(spider_fitness)].copy()]\n\n self.loss_train.append(g_best[0])\n if self.print_train:\n print(\"> Epoch: {}, Best fit: {}\".format(epoch + 1, g_best[0]))\n\n return g_best[1], g_best[0], self.loss_train\n\n\nclass MySSA(BaseSSA):\n \"\"\"\n My version: Social Spider Algorithm\n - A social spider algorithm for global optimization\n \"\"\"\n ID_POS = 0\n ID_FIT = 1\n ID_INT = 2\n ID_TARGET_POS = 3\n ID_PREV_MOVE_VEC = 4\n ID_MASK = 5\n\n def __init__(self, root_paras=None, epoch=750, pop_size=100, r_a=1, p_c=0.7, p_m=0.1):\n BaseSSA.__init__(self, root_paras, epoch, pop_size, r_a, p_c, p_m)\n\n def _create_solution__(self, minmax=0):\n \"\"\" This algorithm has different encoding mechanism, so we need to override this method\n x: The position of s on the web.\n fit: The fitness of the current position of s.\n target_vibration: The target vibration of s in the previous iteration.\n intensity_vibration: intensity of vibration\n movement_vector: The movement that s performed in the previous iteration.\n dimension_mask: The dimension mask 1 that s employed to guide movement in the previous iteration.\n The dimension mask is a 0-1 binary vector of length problem size.\n\n n_changed: The number of iterations since s has last changed its target vibration. (No need)\n\n \"\"\"\n x = np.random.uniform(self.domain_range[0], self.domain_range[1], self.problem_size)\n fit = self._fitness_model__(solution=x, minmax=minmax)\n intensity = np.log(1. /(fit - 1E-100) + 1)\n target_position = deepcopy(x)\n previous_movement_vector = np.zeros(self.problem_size)\n dimension_mask = np.zeros(self.problem_size)\n return [x, fit, intensity, target_position, previous_movement_vector, dimension_mask]\n\n def _amend_solution_and_return__(self, solution=None):\n for i in range(self.problem_size):\n if solution[i] < self.domain_range[0]:\n solution[i] = np.random.uniform() * (self.domain_range[0] - solution[i])\n if solution[i] > self.domain_range[1]:\n solution[i] = np.random.uniform() * (solution[i] - self.domain_range[1])\n return solution\n\n def _train__(self):\n pop = [self._create_solution__() for _ in range(self.pop_size)]\n g_best = self._get_global_best__(pop, self.ID_FIT, self.ID_MIN_PROB)\n\n # Epoch loop\n for epoch in range(self.epoch):\n all_pos = np.array([it[self.ID_POS] for it in pop]) ## Matrix (pop_size, problem_size)\n base_distance = np.mean(np.std(all_pos, axis=0)) ## Number\n dist = cdist(all_pos, all_pos, 'euclidean')\n\n intensity_source = np.array([it[self.ID_INT] for it in pop])\n intensity_attenuation = np.exp(-dist / (base_distance * self.r_a)) ## vector (pop_size)\n intensity_receive = np.reshape(intensity_source, (1, self.pop_size)) * intensity_attenuation ## vector (pop_size)\n index_best_pos = np.argmax(intensity_receive, axis=1)\n\n ## Each individual loop\n for i in range(self.pop_size):\n\n if pop[index_best_pos[i]][self.ID_INT] > pop[i][self.ID_INT]:\n pop[i][self.ID_TARGET_POS] = pop[index_best_pos[i]][self.ID_TARGET_POS]\n\n if np.random.uniform() > self.p_c: ## changing mask\n pop[i][self.ID_MASK] = np.array([ 0 if np.random.uniform() < self.p_m else 1 for _ in range(self.problem_size)])\n\n #p_fo = deepcopy(pop[i][self.ID_POS])\n # for j in range(self.problem_size):\n # if pop[i][self.ID_MASK][j] == 0:\n # p_fo[j] == pop[i][self.ID_TAR_VIB][j]\n # else:\n # p_fo[j] == pop[np.random.randint(0, self.pop_size)][self.ID_POS][j]\n\n p_fo = np.array([ pop[i][self.ID_TARGET_POS][j] if pop[i][self.ID_MASK][j] == 0\n else pop[np.random.randint(0, self.pop_size)][self.ID_POS][j]\n for j in range(self.problem_size)])\n ## Perform random walk\n temp = pop[i][self.ID_POS] + np.random.uniform() * (pop[i][self.ID_POS] - pop[i][self.ID_PREV_MOVE_VEC]) + \\\n (p_fo - pop[i][self.ID_POS]) * np.random.uniform(self.domain_range[0], self.domain_range[1], self.problem_size)\n\n temp = self._amend_solution_and_return__(temp)\n fit = self._fitness_model__(temp)\n pop[i][self.ID_PREV_MOVE_VEC] = temp - pop[i][self.ID_POS]\n pop[i][self.ID_INT] = np.log(1. /(fit + 1E-100) + 1)\n pop[i][self.ID_POS] = temp\n pop[i][self.ID_FIT] = fit\n\n g_best = self._update_global_best__(pop, self.ID_MIN_PROB, g_best)\n self.loss_train.append(g_best[self.ID_FIT])\n if self.print_train:\n print(\"> Epoch: {}, Best fit: {}\".format(epoch+1, g_best[self.ID_FIT]))\n\n return g_best[self.ID_POS], g_best[self.ID_FIT], self.loss_train\n"
] |
[
[
"numpy.log",
"numpy.min",
"numpy.reshape",
"numpy.arange",
"numpy.repeat",
"scipy.spatial.distance.cdist",
"numpy.tile",
"numpy.std",
"numpy.argmax",
"numpy.argmin",
"numpy.random.rand",
"numpy.random.uniform",
"numpy.array",
"numpy.exp",
"numpy.zeros",
"numpy.random.randint"
]
] |
Spiph/GTG
|
[
"4a45032290d0c1364e4398684582c51094b245f5"
] |
[
"torchbeast/monobeast.py"
] |
[
"import argparse\nimport logging\nimport os\nimport pprint\nimport threading\nimport time\nimport timeit\nimport traceback\nimport typing\nimport wandb\n\nos.environ[\"OMP_NUM_THREADS\"] = \"1\" # Necessary for multithreading.\n\nimport torch\nfrom torch import multiprocessing as mp\nfrom torch import nn\nfrom torch.nn import functional as F\nfrom agent.neural_logic.nlmagent import NLMAgent\nfrom agent.neural_logic.kbmlp import KnowledgeBaseMLP\nfrom agent.geometric.gnnagent import GNNAgent\nfrom agent.baselines.cnnagent import CNNAgent\nimport pandas as pd\n\nfrom torchbeast.core import environment\nfrom torchbeast.core import file_writer\nfrom torchbeast.core import prof\nfrom torchbeast.core import vtrace\n\nfrom environment.minigrid import *\nfrom gym_minigrid.wrappers import FullyObsWrapper, ReseedWrapper\nfrom typing import List\n\n\n# yapf: disable\nparser = argparse.ArgumentParser(description=\"PyTorch Scalable Agent\")\n\nparser.add_argument(\"--env\", type=str, help=\"Gym environment.\", choices=[\"breakout\", \"seaquest\", \"asterix\",\n \"freeway\", \"space_invaders\",\n \"boxworld\", \"rtfm\", \"rtfm-onehop\",\n \"MiniGrid-LavaCrossingS9N1-v0\",\n \"MiniGrid-LavaCrossingS9N2-v0\",\n \"MiniGrid-LavaCrossingS9N3-v0\",\n \"MiniGrid-LavaCrossingClosed-v0\",\n \"blockworld\", \"MiniHack-Corridor-R2-v0\"\n ])\nparser.add_argument(\"--agent\", type=str, default=\"CNN\",\n choices=[\"CNN\", \"NLM\", \"KBMLP\", \"GCN\"],\n help=\"agent type.\")\nparser.add_argument(\"--action\", type=str, default=\"move_dir\" , choices=[\"raw\", \"moveto\", \"move_dir\",\n \"relational\", \"propositional\"])\nparser.add_argument(\"--mode\", default=\"train\",\n choices=[\"train\", \"test\", \"test_render\"],\n help=\"Training or test mode.\")\nparser.add_argument(\"--xpid\", default=None,\n help=\"Experiment id (default: None).\")\nparser.add_argument(\"--actor_id\", default=None)\nparser.add_argument(\"--wandb\", action=\"store_true\",help=\"Log to wandb.\")\nparser.add_argument(\"--project\", type=str, default=\"NetHack\")\nparser.add_argument(\"--group\", type=str, default=\"default_group\")\nparser.add_argument(\"--entity\", type=str, default=None)\n\n# Training settings.\nparser.add_argument(\"--disable_checkpoint\", action=\"store_true\",\n help=\"Disable saving checkpoint.\")\nparser.add_argument(\"--savedir\", default=\"~/logs/torchbeast\",\n help=\"Root dir where experiment data will be saved.\")\nparser.add_argument(\"--num_actors\", default=4, type=int, metavar=\"N\",\n help=\"Number of actors (default: 4).\")\nparser.add_argument(\"--total_steps\", default=10000000, type=int, metavar=\"T\",\n help=\"Total environment steps to train for.\")\nparser.add_argument(\"--batch_size\", default=4, type=int, metavar=\"B\",\n help=\"Learner batch size.\")\nparser.add_argument(\"--unroll_length\", default=30, type=int, metavar=\"T\",\n help=\"The unroll length (time dimension).\")\nparser.add_argument(\"--num_buffers\", default=None, type=int,\n metavar=\"N\", help=\"Number of shared-memory buffers.\")\nparser.add_argument(\"--num_learner_threads\", \"--num_threads\", default=2, type=int,\n metavar=\"N\", help=\"Number learner threads.\")\nparser.add_argument(\"--disable_cuda\", action=\"store_true\",\n help=\"Disable CUDA.\")\n\n# Test settings.\nparser.add_argument(\"--episodes\", default=200, type=int)\nparser.add_argument(\"--store_stats\", action=\"store_true\")\n\n# Loss settings.\nparser.add_argument(\"--entropy_cost\", default=0.0006,\n type=float, help=\"Entropy cost/multiplier.\")\nparser.add_argument(\"--baseline_cost\", default=0.5,\n type=float, help=\"Baseline cost/multiplier.\")\nparser.add_argument(\"--discounting\", default=0.99,\n type=float, help=\"Discounting factor.\")\nparser.add_argument(\"--reward_clipping\", default=\"abs_one\",\n choices=[\"abs_one\", \"none\"],\n help=\"Reward clipping.\")\n\n# Optimizer settings.\nparser.add_argument(\"--learning_rate\", default=0.001,\n type=float, metavar=\"LR\", help=\"Learning rate.\")\nparser.add_argument(\"--alpha\", default=0.99, type=float,\n help=\"RMSProp smoothing constant.\")\nparser.add_argument(\"--momentum\", default=0, type=float,\n help=\"RMSProp momentum.\")\nparser.add_argument(\"--epsilon\", default=0.01, type=float,\n help=\"RMSProp epsilon.\")\nparser.add_argument(\"--grad_norm_clipping\", default=40.0, type=float,\n help=\"Global gradient norm clip.\")\n# yapf: enable\n\n# NLM Settings\nparser.add_argument('--depth', type=int, default=4, help='depth of the logic machine')\nparser.add_argument(\"--output_dims\", type=int, default=64)\nparser.add_argument(\"--breath\", type=int, default=2)\nparser.add_argument(\"--state\", type=str, default=\"absolute\")\nparser.add_argument(\"--binary_op\", type=str, default=\"diff\", choices=[\"square\", \"diff\"])\nparser.add_argument(\"--global_units\", type=int, default=0)\nparser.add_argument(\"--activation\", type=str, default=\"relu\")\nparser.add_argument(\"--bg_code\", type=str, default=\"b3\")\n\n# Env Setting\nparser.add_argument(\"--sticky_prob\", type=float, default=0.1)\nparser.add_argument(\"--rand_env\", action=\"store_true\")\nparser.add_argument(\"--nb_blocks\", default=4, type=int)\nparser.add_argument(\"--disable_wiki\", action=\"store_true\")\nparser.add_argument(\"--room_size\", default=6, type=int)\nparser.add_argument(\"--goal_length\", default=2, type=int)\nparser.add_argument(\"--nb_distractor\", default=1, type=int)\nparser.add_argument(\"--distractor_length\", default=1, type=int)\n\n# CNN GCN Setting\nparser.add_argument(\"--cnn_code\", type=str, default=\"2g2f\")\nparser.add_argument(\"--embedding_size\", type=int, default=64)\nparser.add_argument(\"--mp_rounds\", type=int, default=1)\n\nlogging.basicConfig(\n format=(\n \"[%(levelname)s:%(process)d %(module)s:%(lineno)d %(asctime)s] \" \"%(message)s\"\n ),\n level=0,\n)\n\nBuffers = typing.Dict[str, typing.List[torch.Tensor]]\n\n\ndef compute_baseline_loss(advantages):\n return 0.5 * torch.sum(advantages ** 2)\n\n\ndef compute_entropy_loss(logits):\n \"\"\"Return the entropy loss, i.e., the negative entropy of the policy.\"\"\"\n policy = F.softmax(logits, dim=-1)\n log_policy = F.log_softmax(logits, dim=-1)\n return torch.sum(policy * log_policy)\n\n\ndef compute_policy_gradient_loss(logits, actions, advantages):\n cross_entropy = F.nll_loss(\n F.log_softmax(torch.flatten(logits, 0, 1), dim=-1),\n target=torch.flatten(actions, 0, 1),\n reduction=\"none\",\n )\n cross_entropy = cross_entropy.view_as(advantages)\n return torch.sum(cross_entropy * advantages.detach())\n\n\ndef act(\n flags,\n gym_env,\n actor_index: int,\n free_queue: mp.SimpleQueue,\n full_queue: mp.SimpleQueue,\n buffers: Buffers,\n actor_buffers: Buffers,\n actor_model_queues: List[mp.SimpleQueue],\n actor_env_queues: List[mp.SimpleQueue]\n):\n try:\n logging.info(\"Actor %i started.\", actor_index)\n timings = prof.Timings() # Keep track of how fast things are.\n\n gym_env = gym_env\n #seed = actor_index ^ int.from_bytes(os.urandom(4), byteorder=\"little\")\n #gym_env.seed(seed)\n if flags.agent in [\"CNN\"]:\n env = environment.Environment(gym_env, \"image\")\n elif flags.agent in [\"NLM\", \"KBMLP\", \"GCN\"]:\n if flags.state in [\"relative\", \"integer\", \"block\"]:\n env = environment.Environment(gym_env, \"VKB\")\n elif flags.state == \"absolute\":\n env = environment.Environment(gym_env, \"absVKB\")\n env_output = env.initial()\n for key in env_output:\n actor_buffers[key][actor_index][0] = env_output[key]\n while True:\n index = free_queue.get()\n if index is None:\n break\n\n # Write old rollout end.\n for key in actor_buffers:\n buffers[key][index][0] = actor_buffers[key][actor_index][0]\n\n # Do new rollout.\n for t in range(flags.unroll_length):\n timings.reset()\n\n actor_model_queues[actor_index].put(actor_index)\n env_info = actor_env_queues[actor_index].get()\n if env_info==\"exit\":\n return\n\n timings.time(\"model\")\n\n env_output = env.step(actor_buffers[\"action\"][actor_index][0])\n\n timings.time(\"step\")\n\n for key in actor_buffers:\n buffers[key][index][t + 1] = actor_buffers[key][actor_index][0]\n for key in env_output:\n buffers[key][index][t + 1, ...] = env_output[key]\n for key in env_output:\n actor_buffers[key][actor_index][0] = env_output[key]\n\n timings.time(\"write\")\n\n\n full_queue.put(index)\n\n if actor_index == 0:\n logging.info(\"Actor %i: %s\", actor_index, timings.summary())\n\n except KeyboardInterrupt:\n pass # Return silently.\n except Exception as e:\n logging.error(\"Exception in worker process %i\", actor_index)\n traceback.print_exc()\n print()\n raise e\n\ndef get_inference_batch(flags, actor_buffers: Buffers):\n indices = list(range(flags.num_actors))\n batch = {\n key: torch.stack([actor_buffers[key][m] for m in indices], dim=1) for key in actor_buffers\n }\n batch = {k: t.to(device=flags.device, non_blocking=True) for k, t in batch.items()}\n return batch\n\ndef get_batch(\n flags,\n free_queue: mp.SimpleQueue,\n full_queue: mp.SimpleQueue,\n buffers: Buffers,\n timings,\n lock=threading.Lock(),\n):\n with lock:\n timings.time(\"lock\")\n indices = [full_queue.get() for _ in range(flags.batch_size)]\n timings.time(\"dequeue\")\n batch = {\n key: torch.stack([buffers[key][m] for m in indices], dim=1) for key in buffers\n }\n timings.time(\"batch\")\n for m in indices:\n free_queue.put(m)\n timings.time(\"enqueue\")\n batch = {k: t.to(device=flags.device, non_blocking=True) for k, t in batch.items()}\n timings.time(\"device\")\n return batch\n\n\ndef learn(\n flags,\n model,\n batch,\n optimizer,\n scheduler,\n lock=threading.Lock(), # noqa: B008\n):\n \"\"\"Performs a learning (optimization) step.\"\"\"\n with lock:\n learner_outputs = model(batch)\n\n # Take final value function slice for bootstrapping.\n bootstrap_value = learner_outputs[\"baseline\"][-1]\n\n # Move from obs[t] -> action[t] to action[t] -> obs[t].\n batch = {key: tensor[1:] for key, tensor in batch.items()}\n learner_outputs = {key: tensor[:-1] for key, tensor in learner_outputs.items()}\n\n rewards = batch[\"reward\"]\n if flags.reward_clipping == \"abs_one\":\n clipped_rewards = torch.clamp(rewards, -1, 1)\n elif flags.reward_clipping == \"none\":\n clipped_rewards = rewards\n\n discounts = (~batch[\"done\"]).float() * flags.discounting\n\n vtrace_returns = vtrace.from_logits(\n behavior_policy_logits=batch[\"policy_logits\"],\n target_policy_logits=learner_outputs[\"policy_logits\"],\n actions=batch[\"action\"],\n discounts=discounts,\n rewards=clipped_rewards,\n values=learner_outputs[\"baseline\"],\n bootstrap_value=bootstrap_value,\n )\n\n pg_loss = compute_policy_gradient_loss(\n learner_outputs[\"policy_logits\"],\n batch[\"action\"],\n vtrace_returns.pg_advantages,\n )\n baseline_loss = flags.baseline_cost * compute_baseline_loss(\n vtrace_returns.vs - learner_outputs[\"baseline\"]\n )\n entropy_loss = flags.entropy_cost * compute_entropy_loss(\n learner_outputs[\"policy_logits\"]\n )\n\n total_loss = pg_loss + baseline_loss + entropy_loss\n\n episode_returns = batch[\"episode_return\"][batch[\"done\"]]\n stats = {\n \"episode_returns\": tuple(episode_returns.cpu().numpy()),\n \"mean_episode_return\": torch.mean(episode_returns).item(),\n \"total_loss\": total_loss.item(),\n \"pg_loss\": pg_loss.item(),\n \"baseline_loss\": baseline_loss.item(),\n \"entropy_loss\": entropy_loss.item(),\n }\n\n optimizer.zero_grad()\n total_loss.backward()\n nn.utils.clip_grad_norm_(model.parameters(), flags.grad_norm_clipping)\n optimizer.step()\n scheduler.step()\n wandb.log(stats)\n return stats\n\n\ndef create_buffers(flags, obs_shape, num_actions, T, num_buffers, img_shape=None) -> Buffers:\n specs = dict(\n reward=dict(size=(T + 1,), dtype=torch.float32),\n done=dict(size=(T + 1,), dtype=torch.bool),\n episode_return=dict(size=(T + 1,), dtype=torch.float32),\n episode_step=dict(size=(T + 1,), dtype=torch.int32),\n policy_logits=dict(size=(T + 1, num_actions), dtype=torch.float32),\n baseline=dict(size=(T + 1,), dtype=torch.float32),\n last_action=dict(size=(T + 1,), dtype=torch.int64),\n action=dict(size=(T + 1,), dtype=torch.int64),\n )\n if flags.agent in [\"CNN\"]:\n specs[\"frame\"] = dict(size=(T + 1, *obs_shape), dtype=torch.uint8)\n if flags.agent in [\"NLM\", \"KBMLP\", \"GCN\"]:\n specs[\"frame\"] = dict(size=(T + 1, *img_shape), dtype=torch.uint8)\n specs[\"nullary_tensor\"] = dict(size=(T+1, obs_shape[0]), dtype=torch.uint8)\n specs[\"unary_tensor\"] = dict(size=(T+1, *obs_shape[1]), dtype=torch.uint8)\n specs[\"binary_tensor\"] = dict(size=(T+1, *obs_shape[2]), dtype=torch.uint8)\n elif flags.agent == \"SNLM\":\n specs[\"frame\"] = dict(size=(T + 1, *obs_shape), dtype=torch.uint8)\n if flags.agent in [\"NLM\", \"KBMLP\", \"SNLM\"] and \"MiniGrid\" in flags.env:\n specs[\"direction\"] = dict(size=(T+1, 4), dtype=torch.uint8)\n buffers: Buffers = {key: [] for key in specs}\n for _ in range(num_buffers):\n for key in buffers:\n buffers[key].append(torch.zeros(**specs[key]).share_memory_())\n return buffers\n\n\nclass AttributeDict(dict):\n __getattr__ = dict.__getitem__\n __setattr__ = dict.__setitem__\n\n\ndef load_actor(checkpointpath):\n import json\n with open(checkpointpath.replace(\"model.tar\", \"meta.json\"), 'r') as file:\n args = json.load(file)[\"args\"]\n if \"breath\" not in args:\n args[\"breath\"] = 2\n env = create_gymenv(AttributeDict(args))\n return env, create_model(AttributeDict(args), env), AttributeDict(args)\n\n\ndef train(flags): # pylint: disable=too-many-branches, too-many-statements\n terms = flags.xpid.split(\"-\")\n if len(terms) == 3:\n group = terms[0] + \"-\" + terms[1]\n if flags.xpid is None:\n flags.xpid = \"torchbeast-%s\" % time.strftime(\"%Y%m%d-%H%M%S\")\n plogger = file_writer.FileWriter(\n xpid=flags.xpid, xp_args=flags.__dict__, rootdir=flags.savedir\n )\n checkpointpath = os.path.expandvars(\n os.path.expanduser(\"%s/%s/%s\" % (flags.savedir, flags.xpid, \"model.tar\"))\n )\n\n if flags.num_buffers is None: # Set sensible default for num_buffers.\n flags.num_buffers = max(2 * flags.num_actors, flags.batch_size)\n if flags.num_actors >= flags.num_buffers:\n raise ValueError(\"num_buffers should be larger than num_actors\")\n if flags.num_buffers < flags.batch_size:\n raise ValueError(\"num_buffers should be larger than batch_size\")\n\n T = flags.unroll_length\n B = flags.batch_size\n\n flags.device = None\n if (not flags.disable_cuda) and torch.cuda.is_available():\n logging.info(\"Using CUDA.\")\n flags.device = torch.device(\"cuda:\"+str(torch.cuda.current_device()))\n else:\n logging.info(\"Not using CUDA.\")\n flags.device = torch.device(\"cpu\")\n\n step, stats = 0, {}\n\n env = create_gymenv(flags)\n actor_flags = flags\n try:\n checkpoint = torch.load(checkpointpath, map_location=flags.device)\n step = checkpoint[\"step\"]\n except Exception as e:\n print(e)\n\n model = create_model(flags, env).to(device=flags.device)\n try:\n model.load_state_dict(checkpoint[\"model_state_dict\"])\n except Exception as e:\n print(e)\n\n if flags.agent in [\"CNN\"]:\n buffers = create_buffers(flags, env.observation_space.spaces[\"image\"].shape, env.action_space.n,\n flags.unroll_length, flags.num_buffers,\n img_shape=env.observation_space.spaces[\"image\"].shape)\n actor_buffers = create_buffers(flags, env.observation_space.spaces[\"image\"].shape, env.action_space.n,\n 0, flags.num_actors,\n img_shape=env.observation_space.spaces[\"image\"].shape)\n elif flags.agent in [\"NLM\", \"KBMLP\", \"GCN\"]:\n buffers = create_buffers(flags, env.obs_shape, model.num_actions,\n flags.unroll_length, flags.num_buffers,\n img_shape=env.observation_space.spaces[\"image\"].shape)\n actor_buffers = create_buffers(flags, env.obs_shape, model.num_actions,\n 0, flags.num_actors,\n img_shape=env.observation_space.spaces[\"image\"].shape)\n else:\n raise ValueError()\n\n actor_processes = []\n ctx = mp.get_context(\"fork\")\n free_queue = ctx.SimpleQueue()\n full_queue = ctx.SimpleQueue()\n\n actor_model_queues = [ctx.SimpleQueue() for _ in range(flags.num_actors)]\n actor_env_queues = [ctx.SimpleQueue() for _ in range(flags.num_actors)]\n\n for i in range(flags.num_actors):\n actor = ctx.Process(\n target=act,\n args=(\n actor_flags,\n create_gymenv(flags),\n i,\n free_queue,\n full_queue,\n buffers,\n actor_buffers,\n actor_model_queues,\n actor_env_queues\n ),\n )\n actor.start()\n actor_processes.append(actor)\n\n\n optimizer = torch.optim.RMSprop(\n model.parameters(),\n lr=flags.learning_rate,\n momentum=flags.momentum,\n eps=flags.epsilon,\n alpha=flags.alpha,\n )\n\n def lr_lambda(epoch):\n return 1 - min(epoch * T * B, flags.total_steps) / flags.total_steps\n\n scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)\n\n logger = logging.getLogger(\"logfile\")\n if flags.mode == \"imitate\":\n stat_keys = [\n \"total_loss\",\n \"accuracy\",\n \"mean_episode_return\",\n ]\n else:\n stat_keys = [\n \"total_loss\",\n \"mean_episode_return\",\n \"pg_loss\",\n \"baseline_loss\",\n \"entropy_loss\",\n ]\n logger.info(\"# Step\\t%s\", \"\\t\".join(stat_keys))\n finish=False\n\n def batch_and_inference():\n nonlocal finish\n while not all(finish):\n indexes = []\n for i in range(flags.num_actors):\n indexes.append(actor_model_queues[i].get())\n batch = get_inference_batch(flags, actor_buffers)\n with torch.no_grad():\n agent_output = model(batch)\n\n for index in indexes:\n for key in agent_output:\n actor_buffers[key][index][0] = agent_output[key][0, index]\n for i in range(flags.num_actors):\n actor_env_queues[i].put(None)\n\n finish = [False for _ in range(flags.num_learner_threads)]\n\n def batch_and_learn(i, lock=threading.Lock()):\n \"\"\"Thread target for the learning process.\"\"\"\n nonlocal step, stats, finish\n timings = prof.Timings()\n while step < flags.total_steps:\n timings.reset()\n batch = get_batch(\n flags,\n free_queue,\n full_queue,\n buffers,\n timings,\n )\n stats = learn(flags, model, batch, optimizer, scheduler)\n timings.time(\"learn\")\n with lock:\n to_log = dict(step=step)\n to_log.update({k: stats[k] for k in stat_keys})\n plogger.log(to_log)\n step += T * B\n\n if i == 0:\n logging.info(\"Batch and learn: %s\", timings.summary())\n finish[i]=True\n\n for m in range(flags.num_buffers):\n free_queue.put(m)\n\n threads = []\n thread = threading.Thread(target=batch_and_inference, name=\"batch-and-inference\")\n thread.start()\n threads.append(thread)\n for i in range(flags.num_learner_threads):\n thread = threading.Thread(\n target=batch_and_learn, name=\"batch-and-learn-%d\" % i, args=(i,)\n )\n thread.start()\n threads.append(thread)\n\n def checkpoint():\n if flags.disable_checkpoint:\n return\n logging.info(\"Saving checkpoint to %s\", checkpointpath)\n torch.save(\n {\n \"model_state_dict\": model.state_dict(),\n \"optimizer_state_dict\": optimizer.state_dict(),\n \"scheduler_state_dict\": scheduler.state_dict(),\n \"flags\": vars(flags),\n \"step\": step\n },\n checkpointpath,\n )\n\n timer = timeit.default_timer\n try:\n last_checkpoint_time = timer()\n while step < flags.total_steps:\n start_step = step\n start_time = timer()\n time.sleep(5)\n\n if timer() - last_checkpoint_time > 10 * 60: # Save every 10 min.\n checkpoint()\n last_checkpoint_time = timer()\n\n sps = (step - start_step) / (timer() - start_time)\n total_loss = stats.get(\"total_loss\", float(\"inf\"))\n if stats.get(\"episode_returns\", None):\n mean_return = (\n \"Return per episode: %.1f. \" % stats[\"mean_episode_return\"]\n )\n else:\n mean_return = \"\"\n logging.info(\n \"Steps %i @ %.1f SPS. Loss %f. %sStats:\\n%s\",\n step,\n sps,\n total_loss,\n mean_return,\n pprint.pformat(stats),\n )\n except KeyboardInterrupt:\n return # Try joining actors then quit.\n else:\n for thread in threads:\n thread.join()\n logging.info(\"Learning finished after %d steps.\", step)\n finally:\n for i in range(flags.num_actors):\n free_queue.put(None)\n actor_env_queues[i].put(\"exit\")\n\n for actor in actor_processes:\n actor.join(timeout=1)\n\n checkpoint()\n plogger.close()\n\n\ndef create_model(flags, env):\n if flags.activation == \"relu\":\n activation = nn.ReLU()\n elif flags.activation == \"sigmoid\":\n activation = nn.Sigmoid()\n else:\n raise ValueError()\n\n if flags.agent == \"CNN\":\n model = CNNAgent(env.observation_space.spaces[\"image\"].shape, env.action_space.n,\n flags.cnn_code, use_lstm=False, embedding_size=flags.embedding_size)\n elif flags.agent == \"NLM\":\n obs_shape = env.observation_space.spaces[\"image\"].shape\n action = flags.action\n if action == \"relational\" and flags.state == \"integer\":\n action = \"move_xy\"\n model = NLMAgent(env.obj_n, flags.depth, flags.breath,\n [env.obs_shape[0],env.obs_shape[1][-1], env.obs_shape[2][-1]], env.action_space.n,\n observation_shape=obs_shape, nn_units=flags.global_units,\n output_dims=flags.output_dims, residual=False,\n activation=activation, action_type=action)\n elif flags.agent == \"KBMLP\":\n model = KnowledgeBaseMLP(env.obj_n, [env.obs_shape[0],env.obs_shape[1][-1], env.obs_shape[2][-1]],\n env.action_space.n)\n elif flags.agent in [\"GCN\"]:\n model = GNNAgent(env.nb_all_entities, env.action_space.n, [env.obs_shape[0],env.obs_shape[1][-1], env.obs_shape[2][-1]],\n type=flags.agent, net_code=flags.cnn_code, embedding_size=flags.embedding_size, mp_rounds=flags.mp_rounds)\n return model\n\n\ndef test(flags):\n num_episodes = flags.episodes\n if flags.xpid is None:\n checkpointpath = \"./latest/model.tar\"\n else:\n log_path = os.path.expandvars(\n os.path.expanduser(\"%s/%s/%s\" % (flags.savedir, flags.xpid, flags.env))\n )\n if not os.path.exists(log_path):\n os.mkdir(log_path)\n checkpointpath = os.path.expandvars(\n os.path.expanduser(\"%s/%s/%s\" % (flags.savedir, flags.xpid, \"model.tar\"))\n )\n\n gym_env = create_gymenv(flags)\n if flags.agent in [\"CNN\", \"SNLM\", \"MHA\"]:\n env = environment.Environment(gym_env, \"image\")\n elif flags.agent in [\"NLM\", \"KBMLP\", \"GCN\"]:\n env = environment.Environment(gym_env, \"absVKB\")\n model = create_model(flags, gym_env)\n model.eval()\n checkpoint = torch.load(checkpointpath, map_location=\"cpu\")\n model.load_state_dict(checkpoint[\"model_state_dict\"])\n\n observation = env.initial()\n returns = []\n\n total_steps = 0\n obs_index = 0\n if flags.store_stats:\n stats = dict(episode=[], total_steps=[], reward=[], action=[], obs_index=[])\n evals = [[] for _ in range(3)]\n obs = []\n while len(returns) < num_episodes:\n if flags.mode == \"test_render\":\n env.gym_env.render()\n agent_outputs = model(observation)\n policy_outputs = agent_outputs\n observation = env.step(policy_outputs[\"action\"])\n\n if flags.store_stats:\n frame = observation[\"frame\"].numpy()[0,0]\n if not obs or np.any(obs[-1] != frame):\n if \"evaluation\" in policy_outputs:\n evaluation = policy_outputs[\"evaluation\"]\n for i, eval in enumerate(evals):\n eval.append(evaluation[i].detach().numpy()[0])\n obs.append(frame)\n else:\n obs_index -= 1\n stats[\"episode\"].append(len(returns))\n stats[\"total_steps\"].append(total_steps)\n stats[\"obs_index\"].append(obs_index)\n stats[\"reward\"].append(observation[\"reward\"].numpy()[0,0])\n stats[\"action\"].append(policy_outputs[\"action\"].numpy()[0,0])\n if observation[\"done\"].item():\n returns.append(observation[\"episode_return\"].item())\n logging.info(\n \"Episode ended after %d steps. Return: %.2f\",\n observation[\"episode_step\"].item(),\n observation[\"episode_return\"].item(),\n )\n #index_img = vector2index_img(observation[\"frame\"])\n #render_index_img(gym_env.get_index_img())\n #print(str(env.gym_env))\n #print(\"-\"*15)\n #time.sleep(0.1)\n total_steps+=1\n obs_index+=1\n env.close()\n if flags.store_stats:\n if \"evaluation\" in policy_outputs:\n for i, eval in enumerate(evals):\n np.save(log_path+f\"/eval-{i}-arity.npy\", np.stack(eval))\n np.save(log_path+\"/obs.npy\", np.stack(obs))\n pd.DataFrame(stats).to_csv(log_path+\"/stats.csv\")\n mean = sum(returns) / len(returns)\n std = np.std(returns)\n logging.info(\n \"Average returns over %i steps: %.2f ± %.2f\", num_episodes, mean, std\n )\n env_name = flags.env.replace(\"MiniGrid-\",\"\").replace(\"-v0\",\"\")\n\n if flags.env in [\"rtfm\", \"rtfm-onehop\"]:\n wins = np.array(returns)>-1.0\n win_rate = np.mean(wins)*100\n win_std = np.std(wins)*100\n print(f\"{mean:.2f} ± {std:.2f}, {win_rate:.2f} ± {win_std:.2f}\")\n else:\n print(f\"{mean:.2f} ± {std:.2f}\")\n return mean, std\n\n\ndef create_gymenv(flags):\n if flags.env in [\"seaquest\", \"breakout\", \"asterix\", \"freeway\", \"space_invaders\"]:\n env_type = \"minatar\"\n elif flags.env == \"random\":\n env_type = \"random\"\n elif \"block-\" in flags.env:\n env_type = \"blockworld\"\n elif flags.env in [\"rtfm\", \"rtfm-onehop\"]:\n env_type = \"rtfm\"\n elif flags.env == \"boxworld\":\n env_type = \"boxworld\"\n elif flags.env in [\"MiniHack-Corridor-R2-v0\"]:\n env_type = \"minihack\"\n else:\n env_type = \"minigrid\"\n\n portal_pairs = []\n if env_type == \"minigrid\":\n env = gym.make(flags.env)\n #env = ReseedWrapper(env)\n env = FullyObsWrapper(env)\n env = PaddingWrapper(env)\n if flags.action == \"moveto\":\n env = MoveToActionWrapper(env)\n elif flags.action == \"move_dir\":\n env = MoveDirActionWrapper(env)\n if flags.env == \"MiniGrid-LavaCrossingClosed-v0\":\n env = ProtalWrapper(env, portal_pairs)\n elif env_type == \"minatar\":\n from environment.minatarwarpper import MinAtarEnv\n env = MinAtarEnv(flags.env, flags.sticky_prob)\n elif env_type == \"random\":\n from environment.random import RandomEnv\n env = RandomEnv()\n elif env_type == \"blockworld\":\n from environment.blockworld import BlockEnv, GridActionWrapper, BlockActionWrapper\n state_block_spec = False if flags.state != \"block\" and flags.action == \"propositional\" else True\n env = BlockEnv(flags.env, nb_blocks=flags.nb_blocks, variation=flags.variation,\n rand_env=flags.rand_env, state_block_spec=state_block_spec)\n if flags.state != \"block\" and flags.action == \"relational\":\n env = GridActionWrapper(env)\n if flags.state == \"block\" and flags.action == \"relational\":\n env = BlockActionWrapper(env)\n elif env_type in [\"rtfm\"]:\n from environment.rtfmkbenv import RTFMEnv, RTFMAbstractEnv, RTFMOneHopEnv\n with_vkb = False if flags.agent in [\"CNN\", \"MHA\"] or flags.disable_wiki else True\n if with_vkb:\n if flags.env == \"rtfm\":\n env = RTFMAbstractEnv(flags.room_size)\n elif flags.env == \"rtfm-onehop\":\n env = RTFMOneHopEnv(flags.room_size)\n else:\n raise ValueError()\n else:\n env = RTFMEnv()\n elif env_type in [\"minihack\"]:\n import minihack\n env = gym.make(\"MiniHack-Corridor-R2-v0\", observation_keys=[\"glyphs\", \"glyphs_crop\", \"screen_descriptions_crop\", \"chars_crop\", \"colors_crop\", \"screen_descriptions\"])\n env.observation_space.spaces[\"image\"] = env.observation_space[\"glyphs_crop\"] # TODO is this right?\n if flags.agent in [\"NLM\", \"KBMLP\", \"GCN\"]:\n if env_type == \"minigrid\":\n env = DirectionWrapper(env)\n if flags.state == \"absolute\":\n env = AbsoluteVKBWrapper(env, flags.bg_code, portal_pairs)\n elif flags.state == \"block\":\n from environment.blockworld import BlockVKBWarpper\n env = BlockVKBWarpper(env)\n else:\n raise ValueError(f\"state encoding cannot be {flags.state}\")\n elif flags.agent in [\"SNLM\"]:\n if env_type == \"minigrid\":\n env = DirectionWrapper(env, type=\"onehot\")\n env = OneHotFullyObsWrapper(env)\n\n return env\n\n\ndef main(flags):\n if flags.wandb:\n wandb.init(\n project=flags.project,\n config=vars(flags),\n group=flags.group,\n entity=flags.entity,\n )\n if flags.mode == \"train\":\n train(flags)\n else:\n test(flags)\n\nif __name__ == \"__main__\":\n flags = parser.parse_args()\n main(flags)\n"
] |
[
[
"torch.mean",
"torch.nn.functional.softmax",
"torch.optim.lr_scheduler.LambdaLR",
"torch.clamp",
"torch.nn.functional.log_softmax",
"torch.load",
"torch.cuda.current_device",
"torch.zeros",
"torch.sum",
"pandas.DataFrame",
"torch.nn.Sigmoid",
"torch.multiprocessing.get_context",
"torch.no_grad",
"torch.cuda.is_available",
"torch.flatten",
"torch.stack",
"torch.device",
"torch.nn.ReLU"
]
] |
Kou-kun42/Fire-Detection-API
|
[
"8f69c2c4b1ac30b4dbf0b230f3229e9ff779742b"
] |
[
"app/main_test.py"
] |
[
"import unittest\nfrom fastapi import FastAPI\nfrom fastapi.testclient import TestClient\nimport tensorflow as tf\n\nfrom app.main import app\n\nclient = TestClient(app)\n\n\nclass ClassifierAPITest(unittest.TestCase):\n\n TEST_COLOR_IMG_URL = \"https://storage.googleapis.com/download.tensorflow.org/example_images/592px-Red_sunflower.jpg\"\n\n def test_make_prediction_normal(self):\n \"\"\"Client submits a RGB image and gets a valid response.\"\"\"\n # A: get image\n image_path = tf.keras.utils.get_file(\n origin=self.TEST_COLOR_IMG_URL, cache_dir=\".\", cache_subdir=\"./test-assets\"\n )\n with open(image_path, \"rb\") as f:\n # B: format a mock request\n files = {\"file\": (f.name, f, \"multipart/form-data\")}\n # C: make a request, and verify a valid prediction is returned\n response = client.post(\"/detect-fire\", files=files)\n assert response.status_code == 307\n"
] |
[
[
"tensorflow.keras.utils.get_file"
]
] |
astrolabsoftware/fink-filters
|
[
"1542b68e7c1bfff6b3747e60d5f2e1eec5b7c9ae"
] |
[
"fink_filters/filter_sn_candidates/filter.py"
] |
[
"# Copyright 2019-2022 AstroLab Software\n# Author: Julien Peloton\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\nfrom pyspark.sql.functions import pandas_udf, PandasUDFType\nfrom pyspark.sql.types import BooleanType\n\nimport pandas as pd\n\ndef sn_candidates_(\n cdsxmatch, snn_snia_vs_nonia, snn_sn_vs_all,\n drb, classtar, jd, jdstarthist, roid, ndethist) -> pd.Series:\n \"\"\" Return alerts considered as SN-Ia candidates\n\n Parameters\n ----------\n cdsxmatch: Pandas series\n Column containing the cross-match values\n snn_snia_vs_nonia: Pandas series\n Column containing the probability to be a SN Ia from SuperNNova.\n snn_sn_vs_all: Pandas series\n Column containing the probability to be a SNe from SuperNNova.\n drb: Pandas series\n Column containing the Deep-Learning Real Bogus score\n classtar: Pandas series\n Column containing the sextractor score\n jd: Pandas series\n Column containing the JD of the _alert_\n jdstarthist: Pandas series\n Column containing the starting JD of the _object_\n roid: Pandas series\n Column containing the SSO label\n ndethist: Pandas series\n Column containing the number of detection at 3 sigma since the\n beginning of the survey\n\n Returns\n ----------\n out: pandas.Series of bool\n Return a Pandas DataFrame with the appropriate flag:\n false for bad alert, and true for good alert.\n\n Examples\n ----------\n >>> pdf = pd.read_parquet('datatest')\n >>> classification = sn_candidates_(\n ... pdf['cdsxmatch'],\n ... pdf['snn_snia_vs_nonia'],\n ... pdf['snn_sn_vs_all'],\n ... pdf['candidate'].apply(lambda x: x['drb']),\n ... pdf['candidate'].apply(lambda x: x['classtar']),\n ... pdf['candidate'].apply(lambda x: x['jd']),\n ... pdf['candidate'].apply(lambda x: x['jdstarthist']),\n ... pdf['roid'],\n ... pdf['candidate'].apply(lambda x: x['ndethist']))\n >>> print(len(pdf[classification]['objectId'].values))\n 9\n\n >>> assert 'ZTF21acoqgmy' in pdf[classification]['objectId'].values\n \"\"\"\n snn1 = snn_snia_vs_nonia.astype(float) > 0.5\n snn2 = snn_sn_vs_all.astype(float) > 0.5\n sn_history = jd.astype(float) - jdstarthist.astype(float) <= 90\n high_drb = drb.astype(float) > 0.5\n high_classtar = classtar.astype(float) > 0.4\n no_mpc = roid.astype(int) != 3\n no_first_det = ndethist.astype(int) > 1\n\n list_simbad_galaxies = [\n \"galaxy\",\n \"Galaxy\",\n \"EmG\",\n \"Seyfert\",\n \"Seyfert_1\",\n \"Seyfert_2\",\n \"BlueCompG\",\n \"StarburstG\",\n \"LSB_G\",\n \"HII_G\",\n \"High_z_G\",\n \"GinPair\",\n \"GinGroup\",\n \"BClG\",\n \"GinCl\",\n \"PartofG\",\n ]\n keep_cds = \\\n [\"Unknown\", \"Candidate_SN*\", \"SN\", \"Transient\", \"Fail\"] + list_simbad_galaxies\n\n f_sn = (snn1 | snn2) & cdsxmatch.isin(keep_cds) & sn_history & high_drb & high_classtar & no_first_det & no_mpc\n\n return f_sn\n\n@pandas_udf(BooleanType(), PandasUDFType.SCALAR)\ndef sn_candidates(\n cdsxmatch, snn_snia_vs_nonia, snn_sn_vs_all,\n drb, classtar, jd, jdstarthist, roid, ndethist) -> pd.Series:\n \"\"\" Pandas UDF for sn_candidates_ \"\"\"\n series = sn_candidates_(\n cdsxmatch, snn_snia_vs_nonia, snn_sn_vs_all,\n drb, classtar, jd, jdstarthist, roid, ndethist\n )\n return series\n\n\nif __name__ == \"__main__\":\n \"\"\" Execute the test suite \"\"\"\n import sys\n import doctest\n import numpy as np\n\n # Numpy introduced non-backward compatible change from v1.14.\n if np.__version__ >= \"1.14.0\":\n np.set_printoptions(legacy=\"1.13\")\n\n sys.exit(doctest.testmod()[0])\n"
] |
[
[
"numpy.set_printoptions"
]
] |
iliesidaniel/image-classification
|
[
"138c7fa83e084ccb8f5c2ad8827f1fbb2527c00c"
] |
[
"session/test_session.py"
] |
[
"from controllers.data_set_controller import DataSetController\nfrom controllers.session_controller import SessionController\n\nfrom utils.train.session_details import SessionDetails\n\n\nimport constants.cnn_constants as cnn_const\nimport neural_networks.cnn as cnn\n\nimport tensorflow as tf\nimport threading\nimport math\n\n\nclass TestSession(threading.Thread):\n\n def __init__(self,\n\n session_details: SessionDetails,\n test_data_set_path: str,\n automated_test_session,\n testing_finished):\n\n super(TestSession, self).__init__()\n\n self._test_data_set_path = test_data_set_path\n self._testing_finished = testing_finished\n self._session_details = session_details\n self._GUI = automated_test_session\n\n self._confusion_matrix = [\n [\n 0\n for _ in range(self._session_details.number_of_classes)\n ]\n for _ in range(self._session_details.number_of_classes)\n ]\n\n self._cnn = cnn.CNN(\n session_details=session_details\n )\n\n self.stop_testing = False\n\n #########################################################################\n # Auxiliary methods\n\n def _test(self):\n\n with tf.Graph().as_default() as graph:\n\n self._test_data_set_details = DataSetController.read_main_data_set_file(\n file_path=self._test_data_set_path\n )\n\n labels, images = SessionController.get_examples_for_test_session(\n test_data_set_details=self._test_data_set_details,\n session_details=self._session_details\n )\n\n logits = self._cnn.create_cnn_model(images)\n\n top_k_op = tf.nn.top_k(logits, 1)\n\n summary_op = tf.summary.merge_all()\n\n summary_writer = tf.summary.FileWriter(\n logdir=self._session_details.checkpoints_directory,\n graph=graph\n )\n\n variable_averages = tf.train.ExponentialMovingAverage(\n cnn_const.CNN_MOVING_AVERAGE_DECAY\n\n )\n variables_to_restore = variable_averages.variables_to_restore()\n\n saver = tf.train.Saver(variables_to_restore)\n\n writer = tf.summary.FileWriter(\n logdir=self._session_details.checkpoints_directory\n )\n\n with tf.Session() as sess:\n checkpoint = tf.train.get_checkpoint_state(\n checkpoint_dir=self._session_details.checkpoints_directory\n )\n\n if checkpoint and checkpoint.model_checkpoint_path:\n saver.restore(sess, checkpoint.model_checkpoint_path)\n global_step = checkpoint.model_checkpoint_path.split('/')[-1].split('-')[-1]\n else:\n print('No checkpoint file found')\n return\n\n coord = tf.train.Coordinator()\n threads = []\n try:\n for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS):\n threads.extend(\n qr.create_threads(\n sess,\n coord=coord,\n daemon=True,\n start=True\n )\n )\n\n num_iter = int(\n math.ceil(\n self._test_data_set_details.number_of_examples\n / self._session_details.examples_per_batch\n )\n )\n\n left_to_check = \\\n self._test_data_set_details.number_of_examples\n\n step = 0\n\n while step < num_iter and not coord.should_stop():\n\n predictions, label, img = sess.run(\n [\n top_k_op,\n labels,\n images\n ]\n )\n\n for index in range(len(label)):\n\n b = predictions.indices[index][0]\n a = label[index]\n\n self._confusion_matrix[a][b] \\\n = self._confusion_matrix[a][b] \\\n + 1\n\n left_to_check -= 1\n\n if left_to_check == 0:\n break\n\n step += 1\n percent = int(step / num_iter * 100)\n\n self._GUI.update_test_progress(\n progress=percent\n )\n\n if not self.stop_testing:\n summary = tf.Summary()\n summary.ParseFromString(sess.run(summary_op))\n summary_writer.add_summary(summary, global_step)\n\n except Exception as e:\n coord.request_stop(e)\n\n writer.close()\n\n coord.request_stop()\n coord.join(threads, stop_grace_period_secs=10)\n\n writer.close()\n\n #########################################################################\n # Public methods\n\n def run(self):\n\n self._test()\n\n self._GUI.confusion_matrix_update_method(\n confusion_matrix=self._confusion_matrix\n )\n\n self._testing_finished()\n\n def start_test(self):\n\n self.start()\n\n #########################################################################\n"
] |
[
[
"tensorflow.train.get_checkpoint_state",
"tensorflow.Graph",
"tensorflow.summary.FileWriter",
"tensorflow.get_collection",
"tensorflow.train.Coordinator",
"tensorflow.nn.top_k",
"tensorflow.train.ExponentialMovingAverage",
"tensorflow.summary.merge_all",
"tensorflow.Session",
"tensorflow.train.Saver",
"tensorflow.Summary"
]
] |
gdikov/adversarial-variational-bayes
|
[
"c23da9cc1c914d10646a0c0bc1a2497fe2cbaaca"
] |
[
"third_party/ite/cost/meta_i.py"
] |
[
"\"\"\" Meta mutual information estimators. \"\"\"\n\nfrom numpy.random import rand\nfrom numpy import ones\n\nfrom ite.cost.x_initialization import InitX, InitAlpha\nfrom ite.cost.x_verification import VerCompSubspaceDims, VerOneDSubspaces,\\\n VerSubspaceNumberIsK\nfrom ite.cost.x_factory import co_factory\nfrom ite.shared import joint_and_product_of_the_marginals_split,\\\n copula_transformation\n\n\nclass MIShannon_DKL(InitX, VerCompSubspaceDims):\n \"\"\" Shannon mutual information estimator based on KL divergence.\n \n The estimation is based on the relation I(y^1,...,y^M) = \n D(f_y,\\prod_{m=1}^M f_{y^m}), where I is the Shannon mutual\n information, D is the Kullback-Leibler divergence.\n \n Partial initialization comes from 'InitX', verification is from \n 'VerCompSubspaceDims' (see 'ite.cost.x_initialization.py',\n 'ite.cost.x_verification.py').\n \n \"\"\"\n \n def __init__(self, mult=True, kl_co_name='BDKL_KnnK', kl_co_pars=None):\n \"\"\" Initialize the estimator. \n \n Parameters\n ----------\n mult : bool, optional\n 'True': multiplicative constant relevant (needed) in the \n estimation. 'False': estimation up to 'proportionality'. \n (default is True)\n kl_co_name : str, optional \n You can change it to any Kullback-Leibler divergence \n estimator (default is 'BDKL_KnnK').\n kl_co_pars : dictionary, optional\n Parameters for the KL divergence estimator (default\n is None (=> {}); in this case the default parameter\n values of the KL divergence estimator are used).\n \n Examples\n --------\n >>> import ite\n >>> co1 = ite.cost.MIShannon_DKL()\n >>> co2 = ite.cost.MIShannon_DKL(kl_co_name='BDKL_KnnK')\n >>> dict_ch = {'knn_method': 'cKDTree', 'k': 4, 'eps': 0.1}\n >>> co3 = ite.cost.MIShannon_DKL(kl_co_name='BDKL_KnnK',\\\n kl_co_pars=dict_ch)\n \n \"\"\"\n\n # initialize with 'InitX':\n super().__init__(mult=mult)\n \n # initialize the KL divergence estimator:\n kl_co_pars = kl_co_pars or {}\n kl_co_pars['mult'] = mult # guarantee this property\n self.kl_co = co_factory(kl_co_name, **kl_co_pars) \n \n def estimation(self, y, ds):\n \"\"\" Estimate Shannon mutual information.\n \n Parameters\n ----------\n y : (number of samples, dimension)-ndarray\n One row of y corresponds to one sample.\n ds : int vector\n Dimensions of the individual subspaces in y; ds[i] = i^th\n subspace dimension.\n \n Returns\n -------\n i : float\n Estimated Shannon mutual information.\n \n Examples\n --------\n i = co.estimation(y,ds) \n \n \"\"\" \n \n # verification:\n self.verification_compatible_subspace_dimensions(y, ds)\n \n y1, y2 = joint_and_product_of_the_marginals_split(y, ds)\n i = self.kl_co.estimation(y1, y2)\n \n return i\n\n\nclass MIChi2_DChi2(InitX, VerCompSubspaceDims):\n \"\"\" Chi-square mutual information estimator based on chi^2 distance.\n \n The estimation is based on the relation I(y^1,...,y^M) = \n D(f_y,\\prod_{m=1}^M f_{y^m}), where I is the chi-square mutual \n information, D is the chi^2 distance.\n \n Partial initialization comes from 'InitX', verification is from \n 'VerCompSubspaceDims' (see 'ite.cost.x_initialization.py',\n 'ite.cost.x_verification.py').\n \n \"\"\"\n \n def __init__(self, mult=True, chi2_co_name='BDChi2_KnnK',\n chi2_co_pars=None):\n \"\"\" Initialize the estimator. \n \n Parameters\n ----------\n mult : bool, optional\n 'True': multiplicative constant relevant (needed) in the \n estimation. 'False': estimation up to 'proportionality'. \n (default is True)\n chi2_co_name : str, optional \n You can change it to any Pearson chi-square\n divergence estimator (default is 'BDChi2_KnnK').\n chi2_co_pars : dictionary, optional\n Parameters for the Pearson chi-square divergence \n estimator (default is None (=> {}); in this case the\n default parameter values of the Pearson chi-square\n divergence estimator are used).\n \n Examples\n --------\n >>> import ite\n >>> co1 = ite.cost.MIChi2_DChi2()\n >>> co2 = ite.cost.MIChi2_DChi2(chi2_co_name='BDChi2_KnnK')\n >>> dict_ch = {'knn_method': 'cKDTree', 'k': 4, 'eps': 0.1}\n >>> co3 = ite.cost.MIChi2_DChi2(chi2_co_name='BDChi2_KnnK', \\\n chi2_co_pars=dict_ch)\n \n \"\"\"\n\n # initialize with 'InitX':\n super().__init__(mult=mult)\n \n # initialize the chi-square divergence estimator:\n chi2_co_pars = chi2_co_pars or {}\n chi2_co_pars['mult'] = mult # guarantee this property\n self.chi2_co = co_factory(chi2_co_name, **chi2_co_pars) \n \n def estimation(self, y, ds):\n \"\"\" Estimate chi-square mutual information.\n \n Parameters\n ----------\n y : (number of samples, dimension)-ndarray\n One row of y corresponds to one sample.\n ds : int vector\n Dimensions of the individual subspaces in y; ds[i] = i^th\n subspace dimension.\n \n Returns\n -------\n i : float\n Estimated chi-square mutual information.\n \n Examples\n --------\n i = co.estimation(y,ds) \n \n \"\"\" \n \n # verification:\n self.verification_compatible_subspace_dimensions(y, ds)\n \n y1, y2 = joint_and_product_of_the_marginals_split(y, ds)\n i = self.chi2_co.estimation(y1, y2)\n \n return i\n\n\nclass MIL2_DL2(InitX, VerCompSubspaceDims):\n \"\"\" L2 mutual information estimator based on L2 divergence. \n \n The estimation is based on the relation I(y^1,...,y^M) = \n D(f_y,\\prod_{m=1}^M f_{y^m}), where I is the L2 mutual \n information, D is the L2 divergence.\n \n Partial initialization comes from 'InitX', verification is from \n 'VerCompSubspaceDims' (see 'ite.cost.x_initialization.py',\n 'ite.cost.x_verification.py').\n \n \"\"\"\n \n def __init__(self, mult=True, l2_co_name='BDL2_KnnK', l2_co_pars=None):\n \"\"\" Initialize the estimator. \n \n Parameters\n ----------\n mult : bool, optional\n 'True': multiplicative constant relevant (needed) in the \n estimation. 'False': estimation up to 'proportionality'. \n (default is True)\n l2_co_name : str, optional \n You can change it to any L2 divergence estimator\n (default is 'BDL2_KnnK').\n l2_co_pars : dictionary, optional\n Parameters for the L2 divergence estimator (default\n is None (=> {}); in this case the default parameter\n values of the L2 divergence estimator are used).\n \n Examples\n --------\n >>> import ite\n >>> co1 = ite.cost.MIL2_DL2()\n >>> co2 = ite.cost.MIL2_DL2(l2_co_name='BDL2_KnnK')\n >>> dict_ch = {'knn_method': 'cKDTree', 'k': 2, 'eps': 0.1}\n >>> co3 = ite.cost.MIL2_DL2(l2_co_name='BDL2_KnnK',\\\n l2_co_pars=dict_ch)\n \n \"\"\"\n\n # initialize with 'InitX':\n super().__init__(mult=mult)\n \n # initialize the L2 divergence estimator:\n l2_co_pars = l2_co_pars or {}\n l2_co_pars['mult'] = mult # guarantee this property\n self.l2_co = co_factory(l2_co_name, **l2_co_pars)\n \n def estimation(self, y, ds):\n \"\"\" Estimate L2 mutual information.\n \n Parameters\n ----------\n y : (number of samples, dimension)-ndarray\n One row of y corresponds to one sample.\n ds : int vector\n Dimensions of the individual subspaces in y; ds[i] = i^th\n subspace dimension.\n \n Returns\n -------\n i : float\n Estimated L2 mutual information.\n \n References\n ----------\n Barnabas Poczos, Zoltan Szabo, Jeff Schneider: Nonparametric \n divergence estimators for Independent Subspace Analysis. European \n Signal Processing Conference (EUSIPCO), pages 1849-1853, 2011.\n \n Examples\n --------\n i = co.estimation(y,ds) \n \n \"\"\" \n \n # verification:\n self.verification_compatible_subspace_dimensions(y, ds)\n \n y1, y2 = joint_and_product_of_the_marginals_split(y, ds)\n i = self.l2_co.estimation(y1, y2)\n \n return i \n\n\nclass MIRenyi_DR(InitAlpha, VerCompSubspaceDims):\n \"\"\" Renyi mutual information estimator based on Renyi divergence. \n \n The estimation is based on the relation I(y^1,...,y^M) = \n D(f_y,\\prod_{m=1}^M f_{y^m}), where I is the Renyi mutual \n information, D is the Renyi divergence.\n \n Partial initialization comes from 'InitAlpha', verification is from \n 'VerCompSubspaceDims' (see 'ite.cost.x_initialization.py',\n 'ite.cost.x_verification.py').\n \n \"\"\"\n \n def __init__(self, mult=True, alpha=0.99, renyi_co_name='BDRenyi_KnnK',\n renyi_co_pars=None):\n \"\"\" Initialize the estimator. \n \n Parameters\n ----------\n mult : bool, optional\n 'True': multiplicative constant relevant (needed) in the \n estimation. 'False': estimation up to 'proportionality'. \n (default is True)\n alpha : float, optional\n Parameter of the Renyi mutual information (default is\n 0.99).\n renyi_co_name : str, optional \n You can change it to any Renyi divergence\n estimator (default is 'BDRenyi_KnnK').\n renyi_co_pars : dictionary, optional\n Parameters for the Renyi divergence estimator \n (default is None (=> {}); in this case the default\n parameter values of the Renyi divergence estimator\n are used).\n \n Examples\n --------\n >>> import ite\n >>> co1 = ite.cost.MIRenyi_DR()\n >>> co2 = ite.cost.MIRenyi_DR(renyi_co_name='BDRenyi_KnnK')\n >>> co3 = ite.cost.MIRenyi_DR(renyi_co_name='BDRenyi_KnnK',\\\n alpha=0.4)\n >>> dict_ch = {'knn_method': 'cKDTree', 'k': 2, 'eps': 0.1}\n >>> co4 = ite.cost.MIRenyi_DR(mult=True,alpha=0.9,\\\n renyi_co_name='BDRenyi_KnnK',\\\n renyi_co_pars=dict_ch)\n \n \"\"\"\n\n # initialize with 'InitAlpha':\n super().__init__(mult=mult, alpha=alpha)\n \n # initialize the Renyi divergence estimator:\n renyi_co_pars = renyi_co_pars or {}\n renyi_co_pars['mult'] = mult # guarantee this property\n renyi_co_pars['alpha'] = alpha # -||-\n self.renyi_co = co_factory(renyi_co_name, **renyi_co_pars)\n \n def estimation(self, y, ds):\n \"\"\" Estimate Renyi mutual information.\n \n Parameters\n ----------\n y : (number of samples, dimension)-ndarray\n One row of y corresponds to one sample.\n ds : int vector\n Dimensions of the individual subspaces in y; ds[i] = i^th\n subspace dimension.\n \n Returns\n -------\n i : float\n Estimated Renyi mutual information.\n \n References\n ----------\n Barnabas Poczos, Zoltan Szabo, Jeff Schneider. Nonparametric \n divergence estimators for Independent Subspace Analysis. European \n Signal Processing Conference (EUSIPCO), pages 1849-1853, 2011.\n \n Barnabas Poczos, Jeff Schneider. On the Estimation of \n alpha-Divergences. International Conference on Artificial\n Intelligence and Statistics (AISTATS), pages 609-617, 2011.\n \n Examples\n --------\n i = co.estimation(y,ds) \n \n \"\"\" \n \n # verification:\n self.verification_compatible_subspace_dimensions(y, ds)\n \n y1, y2 = joint_and_product_of_the_marginals_split(y, ds)\n i = self.renyi_co.estimation(y1, y2)\n \n return i \n\n\nclass MITsallis_DT(InitAlpha, VerCompSubspaceDims):\n \"\"\" Tsallis mutual information estimator based on Tsallis divergence. \n \n The estimation is based on the relation I(y^1,...,y^M) = \n D(f_y,\\prod_{m=1}^M f_{y^m}), where I is the Tsallis mutual \n information, D is the Tsallis divergence.\n \n Partial initialization comes from 'InitAlpha', verification is from \n 'VerCompSubspaceDims' (see 'ite.cost.x_initialization.py',\n 'ite.cost.x_verification.py').\n \n \"\"\"\n \n def __init__(self, mult=True, alpha=0.99,\n tsallis_co_name='BDTsallis_KnnK', tsallis_co_pars=None):\n \"\"\" Initialize the estimator. \n \n Parameters\n ----------\n mult : bool, optional\n 'True': multiplicative constant relevant (needed) in the \n estimation. 'False': estimation up to 'proportionality'. \n (default is True)\n alpha : float, optional\n Parameter of the Renyi mutual information (default is\n 0.99).\n tsallis_co_name : str, optional \n You can change it to any Tsallis divergence \n estimator (default is 'BDTsallis_KnnK').\n tsallis_co_pars : dictionary, optional\n Parameters for the Tsallis divergence estimator \n (default is None (=> {}); in this case the\n default parameter values of the Tsallis\n divergence estimator are used).\n \n Examples\n --------\n >>> import ite\n >>> co1 = ite.cost.MITsallis_DT()\n >>> co2 = ite.cost.MITsallis_DT(tsallis_co_name='BDTsallis_KnnK')\n >>> co3 = ite.cost.MITsallis_DT(tsallis_co_name='BDTsallis_KnnK',\\\n alpha=0.4)\n >>> dict_ch = {'knn_method': 'cKDTree', 'k': 2, 'eps': 0.1}\n >>> co4 = ite.cost.MITsallis_DT(mult=True,alpha=0.9,\\\n tsallis_co_name='BDTsallis_KnnK',\\\n tsallis_co_pars=dict_ch)\n \n \"\"\"\n\n # initialize with 'InitAlpha':\n super().__init__(mult=mult, alpha=alpha)\n \n # initialize the Tsallis divergence estimator:\n tsallis_co_pars = tsallis_co_pars or {}\n tsallis_co_pars['mult'] = mult # guarantee this property\n tsallis_co_pars['alpha'] = alpha # -||-\n self.tsallis_co = co_factory(tsallis_co_name, **tsallis_co_pars)\n \n def estimation(self, y, ds):\n \"\"\" Estimate Tsallis mutual information.\n \n Parameters\n ----------\n y : (number of samples, dimension)-ndarray\n One row of y corresponds to one sample.\n ds : int vector\n Dimensions of the individual subspaces in y; ds[i] = i^th\n subspace dimension.\n \n Returns\n -------\n i : float\n Estimated Tsallis mutual information.\n \n References\n ----------\n Barnabas Poczos, Zoltan Szabo, Jeff Schneider. Nonparametric \n divergence estimators for Independent Subspace Analysis. European \n Signal Processing Conference (EUSIPCO), pages 1849-1853, 2011.\n \n Barnabas Poczos, Jeff Schneider. On the Estimation of \n alpha-Divergences. International Conference on Artificial\n Intelligence and Statistics (AISTATS), pages 609-617, 2011.\n \n Examples\n --------\n i = co.estimation(y,ds) \n \n \"\"\" \n \n # verification:\n self.verification_compatible_subspace_dimensions(y, ds)\n \n y1, y2 = joint_and_product_of_the_marginals_split(y, ds)\n i = self.tsallis_co.estimation(y1, y2)\n \n return i \n\n\nclass MIMMD_CopulaDMMD(InitX, VerCompSubspaceDims, VerOneDSubspaces):\n \"\"\" Copula and MMD based kernel dependency estimator.\n\n MMD stands for maximum mean discrepancy.\n \n The estimation is based on the relation I(Y_1,...,Y_d) = MMD(P_Z,P_U), \n where (i) Z =[F_1(Y_1);...;F_d(Y_d)] is the copula transformation of\n Y; F_i is the cdf of Y_i, (ii) P_U is the uniform distribution on\n [0,1]^d, (iii) dim(Y_1) = ... = dim(Y_d) = 1.\n \n Partial initialization comes from 'InitX', verification is from \n 'VerCompSubspaceDims' and 'VerOneDSubspaces' (see\n 'ite.cost.x_initialization.py', 'ite.cost.x_verification.py').\n \n \"\"\"\n \n def __init__(self, mult=True, mmd_co_name='BDMMD_UStat',\n mmd_co_pars=None):\n \"\"\" Initialize the estimator. \n \n Parameters\n ----------\n mult : bool, optional\n 'True': multiplicative constant relevant (needed) in the \n estimation. 'False': estimation up to 'proportionality'. \n (default is True)\n mmd_co_name : str, optional \n You can change it to any MMD estimator (default is \n 'BDMMD_UStat').\n mmd_co_pars : dictionary, optional\n Parameters for the MMD estimator (default is None\n (=> {}); in this case the default parameter values\n of the MMD estimator are used).\n \n Examples\n --------\n >>> import ite\n >>> from ite.cost.x_kernel import Kernel\n >>> co1 = ite.cost.MIMMD_CopulaDMMD()\n >>> co2 = ite.cost.MIMMD_CopulaDMMD(mmd_co_name='BDMMD_UStat')\n >>> dict_ch = {'kernel': Kernel({'name': 'RBF','sigma': 0.1})}\n >>> co3 = ite.cost.MIMMD_CopulaDMMD(mmd_co_name='BDMMD_UStat',\\\n mmd_co_pars=dict_ch)\n \n \"\"\"\n\n # initialize with 'InitX':\n super().__init__(mult=mult)\n \n # initialize the MMD estimator:\n mmd_co_pars = mmd_co_pars or {}\n mmd_co_pars['mult'] = mult # guarantee this property\n self.mmd_co = co_factory(mmd_co_name, **mmd_co_pars) \n \n def estimation(self, y, ds=None):\n \"\"\" Estimate copula and MMD based kernel dependency.\n \n Parameters\n ----------\n y : (number of samples, dimension)-ndarray\n One row of y corresponds to one sample.\n ds : int vector, vector of ones\n If ds is not given (ds=None), the vector of ones [ds =\n ones(y.shape[1],dtype='int')] is emulated inside the function.\n\n Returns\n -------\n i : float\n Estimated copula and MMD based kernel dependency.\n \n References\n ----------\n Barnabas Poczos, Zoubin Ghahramani, Jeff Schneider. Copula-based \n Kernel Dependency Measures. International Conference on Machine \n Learning (ICML), 2012. \n \n Examples\n --------\n i = co.estimation(y,ds) \n \n \"\"\" \n\n if ds is None: # emulate 'ds = vector of ones'\n ds = ones(y.shape[1], dtype='int')\n\n # verification:\n self.verification_compatible_subspace_dimensions(y, ds)\n self.verification_one_dimensional_subspaces(ds)\n \n z = copula_transformation(y)\n u = rand(z.shape[0], z.shape[1])\n \n i = self.mmd_co.estimation(z, u)\n\n return i\n\n\nclass MIRenyi_HR(InitAlpha, VerCompSubspaceDims, VerOneDSubspaces):\n \"\"\" Renyi mutual information estimator based on Renyi entropy.\n \n The estimation is based on the relation I_{alpha}(X) = -H_{alpha}(Z), \n where Z =[F_1(X_1);...;F_d(X_d)] is the copula transformation of X, \n F_i is the cdf of X_i; I_{alpha} is the Renyi mutual information, \n H_{alpha} is the Renyi entropy.\n \n Partial initialization comes from 'InitAlpha', verification is from \n 'VerCompSubspaceDims' and 'VerOneDSubspaces' (see\n 'ite.cost.x_initialization.py', 'ite.cost.x_verification.py').\n \n \"\"\"\n \n def __init__(self, mult=True, alpha=0.99, renyi_co_name='BHRenyi_KnnK',\n renyi_co_pars=None):\n \"\"\" Initialize the estimator. \n \n Parameters\n ----------\n mult : bool, optional\n 'True': multiplicative constant relevant (needed) in the \n estimation. 'False': estimation up to 'proportionality'. \n (default is True)\n alpha : float, \\ne 1\n Parameter of the Renyi mutual information.\n renyi_co_name : str, optional \n You can change it to any Renyi entropy estimator \n (default is 'BHRenyi_KnnK').\n renyi_co_pars : dictionary, optional\n Parameters for the Renyi entropy estimator\n (default is None (=> {}); in this case the default\n parameter values of the Renyi entropy estimator\n are used).\n \n Examples\n --------\n >>> import ite\n >>> co1 = ite.cost.MIRenyi_HR()\n >>> co2 = ite.cost.MIRenyi_HR(renyi_co_name='BHRenyi_KnnK')\n >>> dict_ch = {'k': 2, 'eps': 0.4}\n >>> co3 = ite.cost.MIRenyi_HR(renyi_co_name='BHRenyi_KnnK',\\\n renyi_co_pars=dict_ch)\n \n \"\"\"\n\n # initialize with 'InitAlpha':\n super().__init__(mult=mult, alpha=alpha)\n \n # initialize the Renyi entropy estimator:\n renyi_co_pars = renyi_co_pars or {}\n renyi_co_pars['mult'] = mult # guarantee this property\n renyi_co_pars['alpha'] = alpha # -||-\n self.renyi_co = co_factory(renyi_co_name, **renyi_co_pars) \n \n def estimation(self, y, ds=None):\n \"\"\" Estimate Renyi mutual information.\n \n Parameters\n ----------\n y : (number of samples, dimension)-ndarray\n One row of y corresponds to one sample.\n ds : int vector, vector of ones\n If ds is not given (ds=None), the vector of ones [ds = \n ones(y.shape[1],dtype='int')] is emulated inside the function.\n \n Returns\n -------\n i : float\n Estimated Renyi mutual information.\n \n References\n ----------\n David Pal, Barnabas Poczos, Csaba Szepesvari. Estimation of Renyi \n Entropy and Mutual Information Based on Generalized\n Nearest-Neighbor Graphs. Advances in Neural Information Processing\n Systems (NIPS), pages 1849-1857, 2010.\n \n Barnabas Poczos, Sergey Krishner, Csaba Szepesvari. REGO:\n Rank-based Estimation of Renyi Information using Euclidean Graph\n Optimization. International Conference on Artificial Intelligence\n and Statistics (AISTATS), pages 605-612, 2010.\n \n Examples\n --------\n i = co.estimation(y,ds) \n \n \"\"\" \n \n if ds is None: # emulate 'ds = vector of ones'\n ds = ones(y.shape[1], dtype='int')\n \n # verification:\n self.verification_compatible_subspace_dimensions(y, ds)\n self.verification_one_dimensional_subspaces(ds)\n \n z = copula_transformation(y)\n i = -self.renyi_co.estimation(z)\n \n return i\n\n\nclass MIShannon_HS(InitX, VerCompSubspaceDims):\n \"\"\" Shannon mutual information estimator based on Shannon entropy.\n \n The estimation is based on the relation I(y^1,...,y^M) = \\sum_{m=1}^M\n H(y^m) - H([y^1,...,y^M]), where I is the Shannon mutual information,\n H is the Shannon entropy.\n \n Partial initialization comes from 'InitX', verification is from \n 'VerCompSubspaceDims' (see 'ite.cost.x_initialization.py',\n 'ite.cost.x_verification.py').\n \n \"\"\"\n \n def __init__(self, mult=True, shannon_co_name='BHShannon_KnnK',\n shannon_co_pars=None):\n \"\"\" Initialize the estimator. \n \n Parameters\n ----------\n mult : bool, optional\n 'True': multiplicative constant relevant (needed) in the \n estimation. 'False': estimation up to 'proportionality'. \n (default is True)\n shannon_co_name : str, optional \n You can change it to any Shannon differential \n entropy estimator (default is 'BHShannon_KnnK').\n shannon_co_pars : dictionary, optional\n Parameters for the Shannon differential entropy \n estimator (default is None (=> {}); in this case\n the default parameter values of the Shannon\n differential entropy estimator are used).\n \n Examples\n --------\n >>> import ite\n >>> co1 = ite.cost.MIShannon_HS()\n >>> co2 = ite.cost.MIShannon_HS(shannon_co_name='BHShannon_KnnK')\n >>> dict_ch = {'knn_method': 'cKDTree', 'k': 4, 'eps': 0.1}\n >>> co3 = ite.cost.MIShannon_HS(shannon_co_name='BHShannon_KnnK',\\\n shannon_co_pars=dict_ch)\n \n \"\"\"\n\n # initialize with 'InitX':\n super().__init__(mult=mult)\n \n # initialize the Shannon differential entropy estimator:\n shannon_co_pars = shannon_co_pars or {}\n shannon_co_pars['mult'] = True # guarantee this property\n self.shannon_co = co_factory(shannon_co_name, **shannon_co_pars) \n \n def estimation(self, y, ds):\n \"\"\" Estimate Shannon mutual information.\n \n Parameters\n ----------\n y : (number of samples, dimension)-ndarray\n One row of y corresponds to one sample.\n ds : int vector\n Dimensions of the individual subspaces in y; ds[i] = i^th\n subspace dimension.\n \n Returns\n -------\n i : float\n Estimated Shannon mutual information.\n \n References\n ----------\n Thomas M. Cover, Joy A. Thomas. Elements of Information Theory,\n John Wiley and Sons, New York, USA (1991).\n \n Examples\n --------\n i = co.estimation(y,ds) \n \n \"\"\" \n \n # verification:\n self.verification_compatible_subspace_dimensions(y, ds)\n\n # I = - H([y^1,...,y^M]):\n i = -self.shannon_co.estimation(y)\n\n # I = I + \\sum_{m=1}^M H(y^m):\n idx_start = 0 \n for k in range(len(ds)):\n dim_k = ds[k]\n idx_stop = idx_start + dim_k\n # print(\"{0}:{1}\".format(idx_start,idx_stop))\n i += self.shannon_co.estimation(y[:, idx_start:idx_stop])\n idx_start = idx_stop \n\n return i\n\n\nclass MIDistCov_HSIC(InitX, VerCompSubspaceDims, VerSubspaceNumberIsK):\n \"\"\" Estimate distance covariance from HSIC.\n\n The estimation is based on the relation I(y^1,y^2;rho_1,rho_2) =\n 2 HSIC(y^1,y^2;k), where HSIC stands for the Hilbert-Schmidt\n independence criterion, y = [y^1; y^2] and k = k_1 x k_2, where k_i-s\n generates rho_i-s, semimetrics of negative type used in distance\n covariance.\n\n Partial initialization comes from 'InitX', verification is from\n 'VerCompSubspaceDims' and 'VerSubspaceNumberIsK' (see\n 'ite.cost.x_initialization.py', 'ite.cost.x_verification.py').\n\n\n \"\"\"\n\n def __init__(self, mult=True, hsic_co_name='BIHSIC_IChol',\n hsic_co_pars=None):\n\n \"\"\" Initialize the estimator.\n\n Parameters\n ----------\n mult : bool, optional\n 'True': multiplicative constant relevant (needed) in the\n estimation. 'False': estimation up to 'proportionality'.\n (default is True)\n hsic_co_name : str, optional\n You can change it to any HSIC estimator\n (default is 'BIHSIC_IChol').\n hsic_co_pars : dictionary, optional\n Parameters for the HSIC estimator (default is\n None (=> {}); in this case the default parameter\n values of the HSIC estimator are used.\n\n Examples\n --------\n >>> import ite\n >>> from ite.cost.x_kernel import Kernel\n >>> co1 = ite.cost.MIDistCov_HSIC()\n >>> co2 = ite.cost.MIDistCov_HSIC(hsic_co_name='BIHSIC_IChol')\n >>> k = Kernel({'name': 'RBF','sigma': 0.3})\n >>> dict_ch = {'kernel': k, 'eta': 1e-3}\n >>> co3 = ite.cost.MIDistCov_HSIC(hsic_co_name='BIHSIC_IChol',\\\n hsic_co_pars=dict_ch)\n\n \"\"\"\n\n # initialize with 'InitX':\n super().__init__(mult=mult)\n\n # initialize the HSIC estimator:\n hsic_co_pars = hsic_co_pars or {}\n hsic_co_pars['mult'] = mult # guarantee this property\n self.hsic_co = co_factory(hsic_co_name, **hsic_co_pars)\n\n def estimation(self, y, ds):\n \"\"\" Estimate distance covariance.\n\n Parameters\n ----------\n y : (number of samples, dimension)-ndarray\n One row of y corresponds to one sample.\n ds : int vector\n Dimensions of the individual subspaces in y; ds[i] = i^th\n subspace dimension. Length(ds) = 2.\n\n Returns\n -------\n i : float\n Estimated distance covariance.\n\n References\n ----------\n\n Examples\n --------\n i = co.estimation(y,ds)\n\n \"\"\"\n\n # verification:\n self.verification_compatible_subspace_dimensions(y, ds)\n self.verification_subspace_number_is_k(ds, 2)\n\n i = 2 * self.hsic_co.estimation(y, ds)\n\n return i\n"
] |
[
[
"numpy.random.rand",
"numpy.ones"
]
] |
hiroyasuakada/CycleGAN-PyTorch
|
[
"9ad0762b9ed13f3ef9a342ba5b4585fa6a507927"
] |
[
"test.py"
] |
[
"import os\r\nimport random\r\nimport argparse\r\nimport itertools\r\nimport numpy as np\r\nimport torch\r\nimport torch.nn as nn\r\nfrom torchvision import utils \r\nfrom tensorboardX import SummaryWriter\r\nimport time\r\n\r\nfrom dataset import UnalignedDataset\r\nfrom model_base import ResNetBlock, Generator, Discriminator\r\nfrom model_cyclegan import CycleGAN\r\n\r\n\r\ndef save_imgs(imgs, name_imgs, epoch_label):\r\n img_table_name = '{}_'.format(epoch_label) + name_imgs + '.png'\r\n save_path = os.path.join('generated_imgs', img_table_name)\r\n\r\n utils.save_image(\r\n imgs,\r\n save_path,\r\n nrow=1,\r\n normalize=True,\r\n range=(-1, 1)\r\n )\r\n \r\ndef test(device, log_dir, gpu_ids, batch_size, lr, beta1, lambda_idt, lambda_A, lambda_B, load_epoch, test_loader):\r\n model = CycleGAN(device=device, log_dir=log_dir, gpu_ids=gpu_ids)\r\n model.log_dir = log_dir\r\n print('load model {}'.format(load_epoch))\r\n model.load('epoch_' + str(load_epoch))\r\n\r\n if not os.path.exists('generated_imgs'):\r\n os.makedirs('generated_imgs')\r\n\r\n time_list = []\r\n with torch.no_grad():\r\n for batch_idx, data in enumerate(test_loader):\r\n t1 = time.perf_counter()\r\n\r\n real_A = data['A'].to(device)\r\n real_B = data['B'].to(device)\r\n fake_B = model.netG_A(real_A)\r\n fake_A = model.netG_B(real_B)\r\n\r\n save_imgs(real_A, 'real_A', 'epoch_' + str(load_epoch))\r\n save_imgs(real_B, 'real_B', 'epoch_' + str(load_epoch))\r\n save_imgs(fake_B, 'fake_B', 'epoch_' + str(load_epoch))\r\n save_imgs(fake_A, 'fake_A', 'epoch_' + str(load_epoch))\r\n\r\n t2 = time.perf_counter()\r\n get_processing_time = t2 - t1\r\n time_list.append(get_processing_time)\r\n\r\n if batch_idx % 10 == 0:\r\n print('batch: {} / elapsed_time: {} sec'.format(batch_idx, sum(time_list)))\r\n time_list = []\r\n\r\n print('done!')\r\n\r\n\r\nif __name__ == '__main__':\r\n\r\n parser = argparse.ArgumentParser(description='CycleGAN trainer')\r\n\r\n parser.add_argument(\r\n 'name_dataset', type=str, help='name of your testing image dataset'\r\n )\r\n parser.add_argument(\r\n 'load_epoch', type=int, default=0, help='epochs for testing '\r\n )\r\n parser.add_argument(\r\n '--path_log', type=str, default='logs', help='path to dict where log of training details was saved'\r\n )\r\n parser.add_argument(\r\n '--gpu_ids', type=int, nargs='+', default=[0], help='gpu ids'\r\n )\r\n parser.add_argument(\r\n '--num_epoch', type=int, default=400, help='total training epochs'\r\n )\r\n parser.add_argument(\r\n '--save_freq', type=int, default=1, help='frequency of saving log'\r\n )\r\n parser.add_argument(\r\n '--load_size', type=int, default=256, help='original image sizes to be loaded'\r\n ) \r\n parser.add_argument(\r\n '--crop_size', type=int, default=256, help='image sizes to be cropped'\r\n )\r\n parser.add_argument(\r\n '--batch_size', type=int, default=1, help='batch_size for each gpu'\r\n )\r\n parser.add_argument(\r\n '--lr', type=int, default=0.0002, help='learning rate'\r\n )\r\n parser.add_argument(\r\n '--beta1', type=int, default=0.5, help='learning rate'\r\n )\r\n parser.add_argument(\r\n '--lambda_idt', type=int, default=5, help='weights of identity loss'\r\n ) \r\n parser.add_argument(\r\n '--lambda_A', type=int, default=10, help='weights of identity loss'\r\n ) \r\n parser.add_argument(\r\n '--lambda_B', type=int, default=10, help='weights of identity loss'\r\n )\r\n\r\n args = parser.parse_args()\r\n\r\n # random seeds\r\n torch.manual_seed(1234)\r\n np.random.seed(1234)\r\n random.seed(1234)\r\n\r\n # gpu\r\n device = torch.device(\"cuda\" if torch.cuda.is_available else \"cpu\")\r\n print('device {}'.format(device))\r\n\r\n # dataset\r\n test_dataset = UnalignedDataset(\r\n name_dataset=args.name_dataset, \r\n load_size=args.load_size, \r\n crop_size=args.crop_size, \r\n is_train=False\r\n )\r\n test_loader = torch.utils.data.DataLoader(\r\n test_dataset, \r\n batch_size=1,\r\n shuffle=True\r\n )\r\n\r\n # train\r\n test(device, args.path_log, args.gpu_ids, 1, args.lr, args.beta1, args.lambda_idt, args.lambda_A, args.lambda_B,\r\n args.load_epoch, test_loader)\r\n"
] |
[
[
"numpy.random.seed",
"torch.manual_seed",
"torch.utils.data.DataLoader",
"torch.no_grad",
"torch.device"
]
] |
peendebak/PycQED_py3
|
[
"dcc19dbaedd226112a2f98a7985dcf2bab2c9734"
] |
[
"pycqed/tests/analysis_v2/test_simple_analysis.py"
] |
[
"import unittest\nimport pycqed as pq\nimport os\nimport matplotlib.pyplot as plt\nfrom pycqed.analysis_v2 import measurement_analysis as ma\n\n\nclass Test_SimpleAnalysis(unittest.TestCase):\n\n @classmethod\n def tearDownClass(self):\n plt.close('all')\n\n @classmethod\n def setUpClass(self):\n self.datadir = os.path.join(pq.__path__[0], 'tests', 'test_data')\n ma.a_tools.datadir = self.datadir\n\n def test_1D_analysis_multi_file(self):\n a = ma.Basic1DAnalysis(t_start='20170726_164507',\n t_stop='20170726_164845',\n options_dict={'scan_label': 'flipping'})\n self.assertTrue(len(a.timestamps) > 5)\n\n def test_1D_analysis_single_file(self):\n # giving only a single file\n a = ma.Basic1DAnalysis(t_start='20170726_164845',\n options_dict={'scan_label': 'flipping'})\n self.assertEqual(a.timestamps, ['20170726_164845'])\n\n def test_2D_analysis_multi_file(self):\n\n # N.B. by setting x2, x2_label and x2_unit in the options dict\n # the values can be plotted versus the varied parameter between\n # the linecuts\n a = ma.Basic2DAnalysis(t_start='20170726_164521',\n t_stop='20170726_164845',\n options_dict={'scan_label': 'flipping'})\n self.assertTrue(len(a.timestamps) > 5)\n\n def test_2D_interpolated(self):\n a=ma.Basic2DInterpolatedAnalysis(t_start='20180522_030206')\n fig_keys = list(a.figs.keys())\n exp_list_keys = ['Cost function value', 'Conditional phase',\n 'offset difference']\n self.assertEqual(fig_keys, exp_list_keys)\n\n def test_1D_binned_analysis(self):\n a=ma.Basic1DBinnedAnalysis(label='120543_Single_qubit_GST_QL')\n"
] |
[
[
"matplotlib.pyplot.close"
]
] |
batuozt/transformer-ls
|
[
"80961f8ad5aa43dda2e938526b1b7c0733a9d097"
] |
[
"lra/attention_transformer_ls_sketch.py"
] |
[
"# Copyright (c) 2021 NVIDIA CORPORATION. Licensed under the MIT license.\n# Written by Chen Zhu during an internship at NVIDIA, zhuchen.eric@gmail.com\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport math\n\n\nclass AttentionSketch(nn.Module):\n \"\"\"Sketching Attention adapted from transformer-ls\n \"\"\"\n\n def __init__(self, config):\n super().__init__()\n\n assert not (config.pooling_mode.lower() == 'cls' and config.cls_token)\n self.cls_from_seq = config.pooling_mode.lower() == 'cls'\n\n self.num_head = config.num_head\n self.head_dim = config.head_dim\n self.num_landmarks = config.num_landmarks\n self.seq_len = config.max_seq_len\n self.dim = config.transformer_dim\n\n self.drop_attn = torch.nn.Dropout(p=config.attention_dropout)\n\n self.window_size = config.window_size\n\n self.W_q = nn.Linear(self.dim, self.num_head * self.head_dim)\n self.W_k = nn.Linear(self.dim, self.num_head * self.head_dim)\n self.W_v = nn.Linear(self.dim, self.num_head * self.head_dim)\n self.W_o = nn.Linear(self.dim, self.num_head * self.head_dim)\n\n self.fp32 = config.fp32_attn\n\n self.dual_ln_s = nn.LayerNorm(self.num_head * self.head_dim)\n self.dual_ln_l = nn.LayerNorm(self.num_head * self.head_dim)\n\n self.dconv_fc = nn.Linear(self.dim, self.num_head * self.num_landmarks)\n\n self.use_conv = getattr(config, \"conv_kernel_size\", -1) > 0\n if self.use_conv:\n self.conv = nn.Conv1d(\n in_channels=self.num_head, out_channels=self.num_head,\n kernel_size=(config.conv_kernel_size, 1), padding=(config.conv_kernel_size // 2, 0),\n bias=False,\n groups=self.num_head)\n nn.init.zeros_(self.conv.weight)\n\n def get_tiles(self, x, transpose=False):\n # x: bsz x n_heads x seqlen x d_head\n bsz, n_heads, seqlen, d_h = x.shape\n out_shape = (bsz, n_heads, seqlen//self.window_size-1, 2 * self.window_size, d_h)\n in_strides = x.stride()\n out_strides = (in_strides[0], in_strides[1], in_strides[2]*self.window_size, in_strides[2], 1)\n\n x_main = x.as_strided(size=out_shape, stride=out_strides)\n x_last = x[:, :, None, -2*self.window_size:, :]\n x = torch.cat([x_main, x_last], dim=2)\n if transpose:\n return x.transpose(-1, -2)\n else:\n # bsz x n_heads x seqlen//wlen x 2*wlen x d_h\n return x\n\n def get_tiled_mask(self, mask):\n bsz, seqlen = mask.shape\n out_shape = (bsz, seqlen//self.window_size-1, 2*self.window_size)\n in_stride = mask.stride()\n out_stride = (in_stride[0], in_stride[1]*self.window_size, in_stride[1])\n mask_main = mask.as_strided(size=out_shape, stride=out_stride)[:, None, :, :]\n mask_last = mask[:, None, None, -2*self.window_size:]\n\n return torch.cat([mask_main, mask_last], dim=2)[:, :, :, None, :]\n\n def sliding_chunks_matmul_qk(self, Q, K, padding_mask):\n # Q, K: bsz x num_heads x seqlen x d_head\n # padding_mask: bsz x seqlen\n bsz, num_heads, seqlen, d_h = Q.shape\n mask_tiles = self.get_tiled_mask(padding_mask)\n K_tiles = self.get_tiles(K, transpose=True)\n Q_tiles = Q.view(bsz, num_heads, seqlen//self.window_size, self.window_size, d_h)\n # bsz x num_heads x seqlen//winsize x winsize x 2winsize\n qk_scores = Q_tiles.matmul(K_tiles)\n qk_scores.masked_fill_(mask_tiles, float('-inf'))\n return qk_scores.view(bsz, num_heads, seqlen, 2*self.window_size)\n\n def get_tiles_v2(self, x, transpose=False):\n if self.window_size <= 0:\n return x\n\n bsz, n_heads, seqlen, d_h = x.shape\n n_groups = seqlen // self.window_size\n ext_len = max(self.window_size//2, 1)\n x = F.pad(x, (0, 0, ext_len, ext_len), value=0)\n strides = x.stride()\n if transpose:\n out_shape = (bsz, n_heads, n_groups, d_h, 2 * ext_len + self.window_size)\n out_stride = (strides[0], strides[1], self.window_size * strides[2], strides[3], strides[2])\n else:\n out_shape = (bsz, n_heads, n_groups, 2 * ext_len + self.window_size, d_h)\n out_stride = (strides[0], strides[1], self.window_size * strides[2], strides[2], strides[3])\n return torch.as_strided(x, size=out_shape, stride=out_stride)\n\n def get_tiled_mask_v2(self, mask):\n # only mask along the key dimension\n bsz, seqlen = mask.shape\n ext_len = max(self.window_size//2, 1)\n mask = F.pad(mask, (ext_len, ext_len), value=True)\n out_shape = (bsz, seqlen//self.window_size, 2*ext_len + self.window_size)\n in_stride = mask.stride()\n out_stride = (in_stride[0], in_stride[1]*self.window_size, in_stride[1])\n return mask.as_strided(size=out_shape, stride=out_stride)[:, None, :, None, :]\n\n def sliding_chunks_matmul_qk_v2(self, Q, K, padding_mask):\n bsz, num_heads, seqlen, d_h = Q.shape\n if self.window_size > 0:\n # Q, K: bsz x num_heads x seqlen x d_head\n # padding_mask: bsz x seqlen\n\n mask_tiles = self.get_tiled_mask_v2(padding_mask)\n K_tiles = self.get_tiles_v2(K, transpose=True)\n Q_tiles = Q.view(bsz, num_heads, seqlen//self.window_size, self.window_size, d_h)\n # bsz x num_heads x seqlen//winsize x winsize x 2winsize\n qk_scores = Q_tiles.matmul(K_tiles)\n qk_scores = qk_scores.masked_fill(mask_tiles, float('-inf'))\n return qk_scores.view(bsz, num_heads, seqlen, -1)\n else:\n qk_scores = torch.sum(Q*K, dim=-1, keepdim=True)\n return qk_scores\n\n def forward(self, X, mask, cls_embed=None):\n assert not (self.num_landmarks <= 0 and cls_embed is None and self.window_size <= 0)\n if self.cls_from_seq:\n cls_embed = X[:,:1].contiguous()\n X = X[:,1:].contiguous()\n mask = mask[:,1:].contiguous()\n \n bsz, seqlen, d_model = X.shape\n # bsz x n_head x length x head_dim\n Q = self.split_heads(self.W_q(X)).mul(1./math.sqrt(self.head_dim))\n\n K = self.split_heads(self.dual_ln_l(self.W_k(X)))\n V = self.split_heads(self.dual_ln_l(self.W_v(X)))\n if self.fp32:\n Q, K, V = Q.float(), K.float(), V.float()\n\n # bsz x length x num_head*num_lms\n padding_mask = ~mask.bool()\n\n K_compress = V_compress = None\n if self.num_landmarks > 0:\n head_scores = self.dconv_fc(X).masked_fill(padding_mask[:, :, None], float('-inf'))\n head_scores = F.softmax(head_scores, dim=1, dtype=torch.float32) #.to(X)\n if not self.fp32:\n head_scores = head_scores.to(X)\n # bsz x num_head x num_lms x length\n head_scores = head_scores.view(bsz, seqlen, self.num_head, self.num_landmarks).permute(0, 2, 3, 1)\n K_compress = head_scores.matmul(K)\n V_compress = head_scores.matmul(V)\n\n if cls_embed is not None:\n Q_cls = self.split_heads(self.W_q(cls_embed)).mul(1. / math.sqrt(self.head_dim))\n K_cls = self.split_heads(self.W_k(cls_embed))\n V_cls = self.split_heads(self.W_v(cls_embed))\n if self.num_landmarks > 0:\n K_compress = torch.cat([K_cls, K_compress], dim=2)\n V_compress = torch.cat([V_cls, V_compress], dim=2)\n else:\n K_compress = K_cls\n V_compress = V_cls\n\n if self.dual_ln_s is not None and K_compress is not None:\n K_compress = self.dual_ln_s(K_compress.transpose(1, 2).contiguous().view(bsz, -1, d_model))\n K_compress = self.split_heads(K_compress)\n V_compress = self.dual_ln_s(V_compress.transpose(1, 2).contiguous().view(bsz, -1, d_model))\n V_compress = self.split_heads(V_compress)\n\n if self.num_landmarks > 0 or (cls_embed is not None):\n # bsz x num_head x length x num_lms\n attn_compress = Q.matmul(K_compress.transpose(-1, -2))\n else:\n attn_compress = None\n\n if self.window_size > 0 or self.num_landmarks == 0:\n # First, compute the compressed part, or the attentions on the landmarks\n # First use window attention to attend to the diagonals\n # V: bsize, self.seq_len, self.num_head, self.head_dim\n # win_attn_weights = self.sliding_chunks_matmul_qk(Q, K, padding_mask)\n win_attn_weights = self.sliding_chunks_matmul_qk_v2(Q, K, padding_mask)\n else:\n win_attn_weights = None\n\n if attn_compress is None:\n all_attn_ = win_attn_weights\n elif win_attn_weights is None:\n all_attn_ = attn_compress\n else:\n all_attn_ = torch.cat([attn_compress, win_attn_weights], dim=-1)\n\n all_attn = all_attn_.float().softmax(dim=-1).to(win_attn_weights)\n # If one of the rows are all -inf, then it will be NaN!\n all_attn = all_attn.masked_fill(padding_mask[:,None,:,None], 0)\n if not self.fp32:\n all_attn = all_attn.to(X)\n all_attn = self.drop_attn(all_attn)\n\n C = 0\n if attn_compress is not None:\n C += all_attn[:,:,:,:K_compress.shape[2]].matmul(V_compress)\n\n if win_attn_weights is not None:\n win_attn_probs = all_attn[:,:,:,-win_attn_weights.shape[-1]:]\n if self.window_size > 0:\n win_attn_probs = win_attn_probs.view(bsz, self.num_head, seqlen // self.window_size, self.window_size,-1)\n V_tiles = self.get_tiles_v2(V, transpose=False)\n C += win_attn_probs.matmul(V_tiles).view(bsz, self.num_head, seqlen, self.head_dim)\n else:\n C += win_attn_probs * V\n\n if cls_embed is not None:\n if self.fp32:\n Q_cls, K_cls, V_cls = Q_cls.float(), K_cls.float(), V_cls.float()\n # bsz x n_heads x 1 x (1+seqlen)\n cls_scores = torch.cat([Q_cls.matmul(K_cls.transpose(-1, -2)),\n Q_cls.matmul(C.transpose(-1, -2)).masked_fill(padding_mask[:,None,None,:], float('-inf'))],\n dim=-1)\n cls_probs = torch.softmax(cls_scores, dim=-1, dtype=torch.float32)#.to(X)\n if not self.fp32:\n cls_probs = cls_probs.to(X)\n out_cls_embed = V_cls * cls_probs[:,:,:,:1] + cls_probs[:,:,:,1:].matmul(C)\n\n if self.use_conv:\n V = V.masked_fill(padding_mask[:, None, :, None], 0)\n C = C + self.conv(V)\n\n if cls_embed is not None:\n C = torch.cat([out_cls_embed, C], dim=2)\n\n if self.fp32:\n # Finally convert it back, same as Nystromformer\n C = C.to(X)\n out = self.W_o(self.combine_heads(C))\n return out\n\n def extra_repr(self):\n return f'num_landmarks={self.num_landmarks}, window_size={self.window_size}'\n\n def combine_heads(self, X):\n X = X.transpose(1, 2)\n X = X.reshape(X.size(0), X.size(1), self.num_head * self.head_dim)\n return X\n\n def split_heads(self, X):\n X = X.reshape(X.size(0), X.size(1), self.num_head, self.head_dim)\n X = X.transpose(1, 2)\n return X\n"
] |
[
[
"torch.nn.Dropout",
"torch.nn.functional.softmax",
"torch.softmax",
"torch.cat",
"torch.sum",
"torch.nn.LayerNorm",
"torch.nn.Linear",
"torch.nn.Conv1d",
"torch.nn.init.zeros_",
"torch.as_strided",
"torch.nn.functional.pad"
]
] |
pepealza/Curso-ML-A-a-Z
|
[
"951229ea730e6975f3fa323f734a8310f6aed378"
] |
[
"datasets/Part 10 - Model Selection & Boosting/Section 48 - Model Selection/k_fold_cross_validation.py"
] |
[
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Thu May 2 16:47:17 2019\n\n@author: juangabriel\n\"\"\"\n\n# k - Fold Cross Validation\n\n\n# Cómo importar las librerías\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\n# Importar el data set\ndataset = pd.read_csv('Social_Network_Ads.csv')\n\nX = dataset.iloc[:, [2,3]].values\ny = dataset.iloc[:, 4].values\n\n\n# Dividir el data set en conjunto de entrenamiento y conjunto de testing\nfrom sklearn.model_selection import train_test_split\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)\n\n\n# Escalado de variables\nfrom sklearn.preprocessing import StandardScaler\nsc_X = StandardScaler()\nX_train = sc_X.fit_transform(X_train)\nX_test = sc_X.transform(X_test)\n\n\n# Ajustar el clasificador en el Conjunto de Entrenamiento\nfrom sklearn.svm import SVC\nclassifier = SVC(kernel = \"rbf\", random_state = 0)\nclassifier.fit(X_train, y_train)\n\n\n# Predicción de los resultados con el Conjunto de Testing\ny_pred = classifier.predict(X_test)\n\n# Elaborar una matriz de confusión\nfrom sklearn.metrics import confusion_matrix\ncm = confusion_matrix(y_test, y_pred)\n\n# Aplicar k-fold cross validation\nfrom sklearn.model_selection import cross_val_score\naccuracies = cross_val_score(estimator = classifier, X = X_train, y = y_train, cv = 10)\naccuracies_mean = accuracies.mean()\naccuracies_std = accuracies.std()\n\n# Representación gráfica de los resultados del algoritmo en el Conjunto de Entrenamiento\nfrom matplotlib.colors import ListedColormap\nX_set, y_set = X_train, y_train\nX1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),\n np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))\nplt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),\n alpha = 0.75, cmap = ListedColormap(('red', 'green')))\nplt.xlim(X1.min(), X1.max())\nplt.ylim(X2.min(), X2.max())\nfor i, j in enumerate(np.unique(y_set)):\n plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],\n c = ListedColormap(('red', 'green'))(i), label = j)\nplt.title('SVM Kernel (Conjunto de Entrenamiento)')\nplt.xlabel('Edad')\nplt.ylabel('Sueldo Estimado')\nplt.legend()\nplt.show()\n\n\n# Representación gráfica de los resultados del algoritmo en el Conjunto de Testing\nX_set, y_set = X_test, y_test\nX1, X2 = np.meshgrid(np.arange(start = X_set[:, 0].min() - 1, stop = X_set[:, 0].max() + 1, step = 0.01),\n np.arange(start = X_set[:, 1].min() - 1, stop = X_set[:, 1].max() + 1, step = 0.01))\nplt.contourf(X1, X2, classifier.predict(np.array([X1.ravel(), X2.ravel()]).T).reshape(X1.shape),\n alpha = 0.75, cmap = ListedColormap(('red', 'green')))\nplt.xlim(X1.min(), X1.max())\nplt.ylim(X2.min(), X2.max())\nfor i, j in enumerate(np.unique(y_set)):\n plt.scatter(X_set[y_set == j, 0], X_set[y_set == j, 1],\n c = ListedColormap(('red', 'green'))(i), label = j)\nplt.title('Clasificador (Conjunto de Test)')\nplt.xlabel('Edad')\nplt.ylabel('Sueldo Estimado')\nplt.legend()\nplt.show()\n"
] |
[
[
"matplotlib.pyplot.legend",
"pandas.read_csv",
"sklearn.model_selection.cross_val_score",
"matplotlib.pyplot.title",
"numpy.unique",
"sklearn.metrics.confusion_matrix",
"sklearn.model_selection.train_test_split",
"matplotlib.colors.ListedColormap",
"sklearn.svm.SVC",
"matplotlib.pyplot.xlabel",
"sklearn.preprocessing.StandardScaler",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel"
]
] |
egdaub/seistools
|
[
"9ec61de03c2231760dba6a42e7fa2018309a99f3"
] |
[
"seistools/stz.py"
] |
[
"import numpy as np\nimport seistools.stress as stress\nimport seistools.integration as integration\n\nclass stzparams:\n \"class holding parameters for STZ equations\"\n def __init__(self, epsilon = 10, t0 = 1.e-13, E0 = 2.424, T = 293., V = 1.98e-28, sy = 1.,\n c0 = 2.e4, R = 1.e6, beta = 0.9, E1 = 0.16, chiw = 1.5, chi0 = 0.07, chi1 = 1.e-1,\n q0 = 1.e-4, k = 0.00015, v0 = 1.e-3, mu = 32., cs = 3.464, poisson = 0., dx = 0.01,\n nload = 0, vf = False):\n self.epsilon = epsilon\n self.t0 = t0\n self.E0 = E0\n self.T = T\n self.V = V\n self.sy = sy\n self.c0 = c0\n self.R = R\n self.beta = beta\n self.E1 = E1\n self.chiw = chiw\n self.chi0 = chi0\n self.chi1 = chi1\n self.q0 = q0\n self.k = k\n self.v0 = v0\n self.mu = mu\n self.cs = cs\n self.coeff_v = 0.5*self.mu/self.cs\n self.poisson = poisson\n self.dx = dx\n self.nload = nload\n self.vf = vf\n\ndef chihat(v, params):\n \"calculate chihat for a given strain rate v\"\n if (v > params.q0/params.t0):\n raise ValueError(\"strain rate exceeds threshhold\")\n if (v == 0.):\n return params.chi0\n chihat1 = params.chiw/np.log(params.q0/params.t0/v)\n chihat2 = params.chi0+(params.chiw+params.chi1)/np.log(params.q0/params.t0/v)\n chihat3 = 4.*params.chiw*params.chi0/np.log(params.q0/params.t0/v)\n if params.vf:\n return 0.5*(chihat2+np.sqrt(chihat2**2-chihat3))\n else:\n return chihat1\n\ndef vpl(s, chi, params):\n \"calculates plastic strain rate given parameters\"\n if s < params.sy:\n return 0.\n else:\n return params.epsilon/params.t0*np.exp(-(params.E0/7.69e-5-s*params.V*8.13e31)/params.T-1./chi)*(1.-params.sy/s)\n\ndef dvplds(v, s, chi, params):\n \"derivative of plastic strain rate wrt s\"\n return vpl(s, chi, params)*params.V*8.13e31/params.T+params.sy/s/(s-params.sy)\n\ndef dvpldchi(v, s, chi, params):\n \"derivative of plastic strain rate wrt chi\"\n return vpl(s, chi, params)/chi/chi\n\ndef dchi(v, s, chi, params):\n \"calculates time derivative of effective temperature given v, s, chi, and parameter values\"\n return (v*s/params.c0/params.sy*(1.-chi/chihat(v, params))-params.R*np.exp(-params.beta/chi-params.E1/7.69e-5/params.T))\n\ndef dchidt(s, chi, params):\n \"calculates time derivative of effective temperature given s, chi, and parameters\"\n return dchi(vpl(s, chi, params), s, chi, params)\n\ndef dsdt_2d(s, chi, f, params):\n \"derivative of stress at a given point given stress, chi, stress change (from convolution), and parameters\"\n return ((f-params.coeff_v*dvpldchi(vpl(s, chi, params), s, chi, params)*dchidt(s, chi, params))/\n (1.+params.coeff_v*dvplds(vpl(s, chi, params), s, chi, params)))\n\ndef dsdt_1d(s, chi, params):\n \"derivative of stress given stress, chi, and parameters\"\n return params.k*(params.v0-vpl(s, chi, params))\n\ndef stz_2d_der(t, x, params):\n \"wrapper function for calculating derivatives for adaptive rk integration of 2d continuum stz model\"\n\n # calculate stressing term\n\n xsize = len(x)//2\n\n dx = np.empty(len(x))\n\n v = np.empty(xsize)\n s = x[:xsize]\n chi = x[xsize:]\n\n for i in range(xsize):\n v[i] = vpl(s[i], chi[i], params)\n\n # set loading points to have v0\n\n v[:params.nload] = params.v0\n v[-params.nload:] = params.v0\n\n f = stress.calc_ds_2d(v-params.v0, params.dx, params.mu, params.poisson)\n\n for i in range(xsize):\n dx[i] = dsdt_2d(s[i], chi[i], f[i], params)\n dx[xsize+i] = dchidt(s[i], chi[i], params)\n\n # set loading points appropriately\n\n dx[:params.nload] = f[:params.nload]\n dx[xsize-params.nload:xsize] = f[-params.nload:]\n\n return dx\n\ndef stz_1d_der(t, x, params):\n \"wrapper function for calculating derivatives for adaptive rk integration of 1d stz model\"\n\n dx = np.empty(2)\n\n dx[0] = dsdt_1d(x[0], x[1], params)\n dx[1] = dchidt(x[0], x[1], params)\n\n return dx\n\ndef calc_v_2d(s, chi, params):\n \"calculates strain rate given stress and effective temperature\"\n\n v = np.empty(s.shape)\n\n for i in range(s.shape[0]):\n for j in range(s.shape[1]):\n v[i,j] = vpl(s[i,j], chi[i,j], params)\n\n return v\n\ndef calc_v_1d(s, chi, params):\n \"calculates strain rate given stress and effective temperature\"\n\n v = np.empty(s.shape)\n\n for i in range(s.shape[0]):\n v[i] = vpl(s[i], chi[i], params)\n\n return v\n\ndef integrate_stz_2d(u0, chi0, params, ttot, tol = 1.e-6, errnorm = None, maxsteps = 1000000, outstride = 1000000):\n \"\"\"\n integrate STZ equations coupled to a 2d quasidynamic elastic continuum\n s0 (array) is initial slip\n chi0 (array) is initial effective temperature\n params is class holding STZ parameter values\n ttot is total integration time\n tol (optional) is tolerance level for adaptive RK method\n maxsteps (optional) is maximum number of steps\n returns number of time steps, time, stress, and effective temperature arrays\n \"\"\"\n\n # set up array with initial conditions\n\n x = np.empty(2*u0.size)\n\n x[:u0.size] = stress.calc_ds_2d(u0, params.dx, params.mu, params.poisson)+1.1\n x[u0.size:] = chi0\n\n nt, t, x = integration.rk54(x, stz_2d_der, params, ttot, tol, errnorm, maxsteps, outstride)\n\n return nt, t, x[:,:u0.size], x[:,u0.size:], calc_v_2d(x[:,:u0.size], x[:,u0.size:], params)\n \ndef integrate_stz_1d(s0, chi0, params, ttot, tol = 1.e-6, errnorm = None, maxsteps = 1000000, outstride = 1000000):\n \"integrates STZ equations using Cash-Karp method\"\n\n x = np.array([s0, chi0])\n\n nt, t, x = integration.rk54(x, stz_1d_der, params, ttot, tol, errnorm, maxsteps, outstride)\n\n return nt, t, x[:,0], x[:,1], calc_v_1d(x[:,0], x[:,1], params)\n"
] |
[
[
"numpy.log",
"numpy.sqrt",
"numpy.array",
"numpy.exp",
"numpy.empty"
]
] |
edlectrico/dissertation
|
[
"eec342383ef4f15968e6417020681a3eb095bf08"
] |
[
"graphics/sus_developers_pie.py"
] |
[
"from pylab import *\nimport matplotlib.pyplot as plt\n\n# make a square figure and axes\nfigure(1, figsize=(6,6))\nax = axes([0.1, 0.1, 0.8, 0.8])\n\n# The slices will be ordered and plotted counter-clockwise.\nlabels = ['SUS punctuation under 50 points', 'SUS punctuation between 50 and 70 points', 'SUS punctuation over or equal 70 points']\nfracs = [0, 16.66666667, 75]\nexplode=(0.05, 0.05, 0.05)\ncolors = ['yellowgreen', 'gold', 'lightskyblue']\n\npatches = pie(fracs, explode=explode, autopct='%1.1f%%', colors=colors, startangle=90)\n#, texts = \n#title('SUS reponses', bbox={'facecolor':'0.8', 'pad':5})\n#plt.legend(patches, labels, loc=\"best\")\n\n#plt.pie(sizes, colors=colors, shadow=True)\nplt.axis('equal')\nplt.legend(labels, loc=(-0.1, -0.1), shadow=False)\n#plt.savefig(name)\n\nplt.savefig('sus_developers.pdf')\n\nshow()\n\n"
] |
[
[
"matplotlib.pyplot.legend",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.axis"
]
] |
nicktien007/Nick.Udic.RNN
|
[
"e6ebabb880a61e8ca41bba4f079cae452197fa79"
] |
[
"service/train_service.py"
] |
[
"import logging as log\nimport os\n\nimport numpy as np\nimport torch\nfrom torchtext import data\n\nfrom model.RNN import RNN\nfrom service.tokenize_service import tokenize\n\n\ndef build_RNN_model(train_data_path, trained_model_path, device):\n if not os.path.isdir(trained_model_path):\n os.mkdir(trained_model_path)\n\n setup_manual_seed()\n\n TEXT, test_data, train_data = get_build_RNN_model_data(train_data_path, trained_model_path)\n\n batch_size = 30\n # # Iterator是torchtext到模型的輸出\n train_iterator, test_iterator = data.BucketIterator.splits(\n (train_data, test_data),\n batch_size=batch_size,\n sort_key=lambda x: len(x.review),\n device=device\n )\n vocab_size = len(TEXT.vocab) # 詞典大小\n # vocab_size = 10002 # 詞典大小\n embedding_dim = 100 # 詞向量維度\n hidden_dim = 100 # 隱藏層維度\n output_dim = 1 # 輸出層\n rnn = RNN(vocab_size, embedding_dim, hidden_dim, output_dim)\n print(rnn)\n # pretrained_embedding = TEXT.vocab.vectors\n # print('pretrained_embedding:', pretrained_embedding.shape)\n # rnn.embedding.weight.data.copy_(pretrained_embedding)\n # print('embedding layer inited.')\n # 優化器\n optimizer = torch.optim.Adam(rnn.parameters(), lr=1e-3)\n\n # 因為我們輸出只有1個，所以選用binary cross entropy\n loss_func = torch.nn.BCEWithLogitsLoss().to(device)\n\n # 用cpu\n rnn.to(device)\n # 開始訓練\n log.info('start train')\n for epoch in range(10):\n train(rnn, epoch, train_iterator, optimizer, loss_func, trained_model_path)\n eval(rnn, epoch, test_iterator, loss_func)\n log.info('end train')\n torch.save(rnn, trained_model_path + '/RNN-model.pt') # 存模型\n\n\ndef get_build_RNN_model_data(train_data_path, trained_model_path):\n log.info(\"start get_build_RNN_model_data\")\n CAT = data.Field(sequential=True, fix_length=20)\n LABEL = data.LabelField(dtype=torch.float)\n TEXT = data.Field(tokenize=tokenize, # 斷詞function\n lower=True, # 是否將數據轉小寫\n fix_length=100, # 每條數據的長度\n stop_words=None)\n\n train_data, valid_data, test_data = \\\n data.TabularDataset.splits(\n path=train_data_path + \"/\", # 數據所在文件夾\n train='dataset_train.csv',\n validation='dataset_valid.csv',\n test='test.csv',\n format='csv',\n skip_header=True,\n fields=[('cat', CAT), ('label', LABEL),\n ('review', TEXT)])\n print('len of train_data:', len(train_data))\n print('len of test data:', len(test_data))\n print('len of valid_data:', len(valid_data))\n print(train_data.examples[18].review)\n print(train_data.examples[18].label)\n # 建立詞典\n # TEXT.build_vocab(train_data, vectors=\"glove.6B.100d\")#可以使用預訓練word vector\n TEXT.build_vocab(train_data, max_size=10000)\n LABEL.build_vocab(train_data)\n CAT.build_vocab(train_data)\n print(TEXT.vocab.freqs.most_common(20)) # 資料集裡最常出現的20個詞\n print(TEXT.vocab.itos[:10]) # 列表 index to word\n print(TEXT.vocab.stoi) # 字典 word to index\n\n torch.save(TEXT.vocab, trained_model_path + \"/vocab\")\n log.info(\"end get_build_RNN_model_data\")\n\n return TEXT, test_data, train_data\n\n\ndef binary_acc(preds, y):\n \"\"\"\n 準確率\n \"\"\"\n preds = torch.round(torch.sigmoid(preds))\n correct = torch.eq(preds, y).float()\n acc = correct.sum() / len(correct)\n return acc\n\n\ndef train(rnn, epoch, iterator, optimizer, loss_func, trained_model_path):\n rnn.train() # 訓練模式\n\n avg_acc = []\n TrainAcc = 0.0\n TrainLoss = 0.0\n\n for step, batch in enumerate(iterator):\n optimizer.zero_grad() # 優化器優化之前須將梯度歸零\n\n # [seq, b] => [b, 1] => [b]\n pred = rnn(batch.review).squeeze(1)\n\n acc = binary_acc(pred, batch.label).item() # 取得正確率\n TrainAcc = TrainAcc + acc\n avg_acc.append(acc)\n\n loss = loss_func(pred, batch.label) # loss計算\n TrainLoss = TrainLoss + loss\n\n loss.backward() # 反向傳遞 => 把loss 傳遞有訂閱的角色\n optimizer.step() # 通過梯度做參數更新(更新權重)\n\n # if step%20 == 0:print('train loss: %.4f, train acc: %.2f' %(loss, acc))\n\n TrainLoss = TrainLoss / (step + 1) # epoch loss\n TrainAcc = TrainAcc / (step + 1) # epoch acc\n avg_acc = np.array(avg_acc).mean()\n log.info('epoch : %d ,TrainLoss: %f , TrainAcc acc: %f , avg TrainAcc acc: %f ' % (\n epoch + 1, round(TrainLoss.item(), 3), round(TrainAcc, 3), avg_acc))\n\n if avg_acc > 0.9:\n torch.save(rnn, trained_model_path + '/RNN-model.pt') # 存模型\n # torch.save(rnn.state_dict(), SYS_DIR+trained_Model_Path+'/'+trained_Model_Name) #只存權重\n log.info('save done')\n\n\ndef eval(rnn, epoch, iterator, loss_func):\n rnn.eval() # 評估模式\n\n avg_acc = []\n TestAcc = 0.0\n TestLoss = 0.0\n\n with torch.no_grad():\n for step, batch in enumerate(iterator):\n # [b, 1] => [b]\n pred = rnn(batch.review).squeeze(1)\n\n acc = binary_acc(pred, batch.label).item() # 取得正確率\n TestAcc = TestAcc + acc\n avg_acc.append(acc)\n\n loss = loss_func(pred, batch.label) # loss計算\n TestLoss = TestLoss + loss\n\n # if step%20 == 0:print('test loss: %.4f, test acc: %.2f' %(loss, acc))\n\n TestLoss = TestLoss / (step + 1)\n TestAcc = TestAcc / (step + 1)\n avg_acc = np.array(avg_acc).mean()\n log.info('epoch : %d ,TestLoss: %f , TestAcc acc: %f , avg TestAcc acc: %f ' % (\n epoch + 1, round(TestLoss.item(), 3), round(TestAcc, 3), avg_acc))\n\n\ndef setup_manual_seed():\n # 設置固定生成隨機數的種子，使得每次運行文件時生成的隨機數相同\n if torch.cuda.is_available():\n print(\"gpu cuda is available!\")\n torch.cuda.manual_seed(1000)\n else:\n print(\"cuda is not available! cpu is available!\")\n torch.manual_seed(1000)\n"
] |
[
[
"torch.sigmoid",
"torch.cuda.manual_seed",
"torch.eq",
"torch.manual_seed",
"torch.nn.BCEWithLogitsLoss",
"torch.no_grad",
"torch.cuda.is_available",
"numpy.array",
"torch.save"
]
] |
polossk/Peridynamics-Example-Using-HMSolver
|
[
"cc13a96db0257f9db19ec32131cc72ff43bda3b8"
] |
[
"Group-2020-11-17/test_of_correction_config_A5.py"
] |
[
"import numpy as np\nimport time\nimport sys\nimport argparse\nimport pickle\n\nimport hmsolver.geometry as geometry\nfrom hmsolver.app import Simulation2d\nfrom hmsolver.app import PdSimulation2d\nfrom hmsolver.basis import Quad4Node\nfrom hmsolver.meshgrid import Zone2d, HybridMesh2d\nfrom hmsolver.material import PdMaterial2d\nfrom hmsolver.femcore import point_criteria, segment_criteria\nfrom hmsolver.femcore import boundary_cond2d, BoundaryConds2d\nfrom hmsolver.femcore import read_mesh_to_MeshObject\nfrom hmsolver.utils import formatting_time\n\n\ndef mse(sth):\n return np.sqrt(np.dot(sth, sth) / max(sth.shape))\n\n\ndef mae(sth):\n return np.max(np.abs(sth))\n\n\ndef mse2l2e(sth, N, h):\n return np.sqrt(sth**2 * h**2 * N)\n\n\ndef output_error(u_err_0, u_err_1, runid, ratio, grid_size, export_filename):\n n_nodes = u_err_0.shape[0]\n # mean square error\n mse_ux_0, mse_uy_0, mse_ux_1, mse_uy_1 = [\n mse2l2e(mse(_), n_nodes, grid_size)\n for _ in [u_err_0[:, 0], u_err_0[:, 1], u_err_1[:, 0], u_err_1[:, 1]]\n ]\n # maximum absolute error\n mae_ux_0, mae_uy_0, mae_ux_1, mae_uy_1 = [\n mae(_)\n for _ in [u_err_0[:, 0], u_err_0[:, 1], u_err_1[:, 0], u_err_1[:, 1]]\n ]\n # output to file\n with open(export_filename, \"a\", encoding='utf-8') as fout:\n print(\"\\n## Runid\", runid, file=fout)\n print(\"ratio=\", ratio, file=fout)\n print(\"grid_size=\", grid_size, file=fout)\n print(\"before: mse_ux =\", mse_ux_0, file=fout)\n print(\"before: mse_uy =\", mse_uy_0, file=fout)\n print(\"after: mse_ux =\", mse_ux_1, file=fout)\n print(\"after: mse_uy =\", mse_uy_1, file=fout)\n print(\"before: mae_ux =\", mae_ux_0, file=fout)\n print(\"before: mae_uy =\", mae_uy_0, file=fout)\n print(\"after: mae_ux =\", mae_ux_1, file=fout)\n print(\"after: mae_uy =\", mae_uy_1, file=fout)\n\n\ndef output_kavg(kavg_old, kavg_new, export_filename):\n kavg_new = np.array(kavg_new)\n kavg_old = np.array(kavg_old)\n difference = kavg_new - kavg_old\n err_L2 = mse(difference)\n err_Linf = mae(difference)\n err_relative = np.max(np.abs(difference) / (kavg_new + 1e-8))\n # output to file\n with open(export_filename, \"a\", encoding='utf-8') as fout:\n print(\"kavg error(L2) :=\", err_L2, file=fout)\n print(\"kavg error(Linf) :=\", err_Linf, file=fout)\n print(\"relative error :=\", f\"{err_relative * 100:.5f}%\", file=fout)\n\n\ndef main(example_name, mesh_config, cname, export_filename):\n t0 = time.time()\n zone_xl, zone_xr = 0, 1\n zone_yl, zone_yr = 0, 2\n zone_xmid = 0.5 * (zone_xl + zone_xr)\n zone_ymid = 0.5 * (zone_yl + zone_yr)\n total_area = (zone_yr - zone_yl) * (zone_xr - zone_xl)\n zone = Zone2d(zone_xl, zone_xr, zone_yl, zone_yr)\n nx, ny, grid_size, ratio = mesh_config # 个数 大小 近场邻域比例\n # 网格配置\n mesh2d = zone.meshgrid_zone_safe_xy(HybridMesh2d, nx, ny)\n n_nodes, n_elements = mesh2d.n_nodes, mesh2d.n_elements\n grid_size = np.sqrt(total_area / n_elements)\n print(f\"Mesh contains {n_nodes} nodes and {n_elements} elements.\")\n print(f\"Average Grid Size= {grid_size:.8f}\")\n horizon_radius, inst_len = ratio * grid_size, grid_size / 3.0\n if cname == \"constant\":\n material2d = PdMaterial2d(192e9, 1.0 / 3)\n elif cname == \"attenuate\":\n material2d = PdMaterial2d(192e9, 1.0 / 3, attenuation=\"exp\")\n stretch = 0.1\n _bc_ = boundary_cond2d # abbreviate the word for type & read\n boundarys_ccm = BoundaryConds2d()\n boundarys_ccm.append(\n _bc_(\"point\", point_criteria(zone_xmid, zone_yl), \"set_ux\", \"constant\",\n 0))\n boundarys_ccm.append(\n _bc_(\"point\", point_criteria(zone_xmid, zone_yr), \"set_ux\", \"constant\",\n 0))\n boundarys_ccm.append(\n _bc_(\"segment\", segment_criteria(zone_xl, zone_yl, zone_xr, zone_yl),\n \"set_uy\", \"constant\", 0))\n boundarys_ccm.append(\n _bc_(\"segment\", segment_criteria(zone_xl, zone_yr, zone_xr, zone_yr),\n \"set_uy\", \"constant\", +stretch))\n boundarys_pd = BoundaryConds2d()\n for offset in range(1):\n real_yl = zone_yl - offset * grid_size\n real_yr = zone_yr + offset * grid_size\n dirichlet_yl = segment_criteria(zone_xl, real_yl, zone_xr, real_yl)\n dirichlet_yr = segment_criteria(zone_xl, real_yr, zone_xr, real_yr)\n center_yl = point_criteria(zone_xmid, real_yl)\n center_yr = point_criteria(zone_xmid, real_yr)\n boundarys_pd.append(_bc_(\"point\", center_yl, \"set_ux\", \"constant\", 0))\n boundarys_pd.append(_bc_(\"point\", center_yr, \"set_ux\", \"constant\", 0))\n boundarys_pd.append(\n _bc_(\"segment\", dirichlet_yl, \"set_uy\", \"constant\", 0))\n boundarys_pd.append(\n _bc_(\"segment\", dirichlet_yr, \"set_uy\", \"constant\", +stretch))\n del _bc_ # delete the abbreviation\n boundarys_ccm.manually_verify()\n boundarys_pd.manually_verify()\n app_ccm = Simulation2d(mesh2d, material2d, boundarys_ccm)\n app_ccm.parallelized = True\n app_ccm.app_name = example_name\n app_ccm.apply_basis(Quad4Node())\n app_ccm.check_engine()\n app_ccm.export_to_tecplot(\"elasticity\", *app_ccm.provied_solutions)\n app_pd = PdSimulation2d(mesh2d, material2d, boundarys_pd)\n app_pd.parallelized = True\n app_pd.app_name = example_name\n app_pd.material.setPeridynamic(horizon_radius, grid_size, inst_len)\n app_pd.mesh.peridynamic_construct(horizon_radius, 2 * horizon_radius,\n 4 * horizon_radius)\n app_pd.apply_basis(Quad4Node())\n app_pd.check_engine()\n app_pd.export_to_tecplot(\"peridynamic-without-correction\",\n *app_pd.provied_solutions)\n wpd_0 = app_pd.get_pd_elastic_energy_density()\n app_pd.export_custom_data_to_tecplot(\"peridynamic-energy-density\",\n ['\"wpd\"'], [wpd_0])\n u_err_0 = app_pd.u - app_ccm.u\n kavg_old = app_pd.k_avgs\n for runid in range(0, 1):\n print(f\"### Runid= {runid}\")\n app_pd.init_surface_correction()\n app_pd.clear()\n app_pd.export_to_tecplot(\n \"peridynamic-after-correction\" + f\"{runid:02d}\",\n *app_pd.provied_solutions)\n wpd_1 = app_pd.get_pd_elastic_energy_density()\n u_err_1 = app_pd.u - app_ccm.u\n app_pd.export_custom_data_to_tecplot(\n \"peridynamic-energy-density\" + f\"{runid:02d}\", ['\"wpd\"'], [wpd_1])\n app_pd.export_custom_data_to_tecplot(\n \"peridynamic-displacement-error\" + f\"{runid:02d}\",\n ['\"Ux Before\"', '\"Uy Before\"', '\"Ux After\"', '\"Uy After\"'],\n [u_err_0[:, 0], u_err_0[:, 1], u_err_1[:, 0], u_err_1[:, 1]])\n output_error(u_err_0, u_err_1, runid, ratio, grid_size,\n export_filename)\n output_kavg(kavg_old, app_pd.k_avgs, export_filename)\n kavg_old = app_pd.k_avgs\n print(f\"Total time cost: {formatting_time(time.time() - t0)}\")\n\n\nif __name__ == \"__main__\":\n # 基础配置\n # meshtype # 网格单元配置名 options: 0, 1, 2，这里的网格主要指 horizon 的大小配置\n # constitutive # 本构模型 options: \"const\", \"exp\"\n arg = argparse.ArgumentParser(f\"python {sys.argv[0]}\")\n arg.add_argument(\"-t\",\n \"--mtype\",\n metavar=\"int\",\n default=1,\n type=int,\n help=\"mesh type of simulation\")\n arg.add_argument(\"-c\",\n \"--ctype\",\n metavar=\"str\",\n default=\"const\",\n type=str,\n help=\"constitutive type\")\n args = arg.parse_args()\n configs = [(64, 128, 0.015625, 8), (64, 128, 0.015625, 4),\n (64, 128, 0.015625, 2)]\n constitutive_mapping = {\n \"const\": (\"A\", \"constant\"),\n \"exp\": (\"B\", \"attenuate\")\n }\n c, cname = constitutive_mapping[args.ctype]\n example_name = f\"example-A5{c}{args.mtype}-{cname}\"\n export_filename = example_name + \".out\"\n nx, ny, grid_size, ratio = configs[args.mtype]\n main(example_name, (nx, ny, grid_size, ratio), cname, export_filename)\n"
] |
[
[
"numpy.abs",
"numpy.dot",
"numpy.array",
"numpy.sqrt"
]
] |
haoNTT/logisticRegression
|
[
"4405e50c8320b8c777a1f4bb6453b4a2a9545768"
] |
[
"logisticRegression.py"
] |
[
"# Author: Haonan Tian \n# Date: 07/26/2018\n# All Rights Reserved\n\n################################# Description ########################################\n# This is a demo of applying logistic regression to sample data set. The description \n# the data set applied in this program can be found at the following link:\n# http://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.names\n######################################################################################\n\n################################# Initialization ########################################\nimport time\nimport math\nimport numpy as np\nimport sklearn\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.metrics import confusion_matrix\n\nworkclass = {\"Private\": 8, \n\t\t\t \"Self-emp-not-inc\": 7, \n\t\t\t 'Self-emp-inc': 6, \n\t\t\t 'Federal-gov': 5, \n\t\t\t \"State-gov\": 4,\n\t\t\t \"Local-gov\": 3, \n\t\t\t \"Without-pay\": 2, \n\t\t\t \"Never-worked\": 1, \n\t\t\t \"?\": 0}\nmarital_status = {\"Married-civ-spouse\": 1, \n\t\t\t\t \"Divorced\": 2, \n\t\t\t\t \"Never-married\": 3,\n\t\t\t\t \"Separated\": 4, \n\t\t\t\t \"Widowed\": 5, \n\t\t\t\t \"Married-spouse-absent\": 6, \n\t\t\t\t \"Married-AF-spouse\": 7, \n\t\t\t\t \"?\": 0}\noccupation = {\"Tech-support\": 1, \n \"Craft-repair\": 2, \n \"Other-service\": 3, \n \"Sales\": 4, \n \"Exec-managerial\": 5, \n \"Prof-specialty\": 6, \n \"Handlers-cleaners\": 7, \n \"Machine-op-inspct\": 8, \n \"Adm-clerical\": 9, \n \"Farming-fishing\": 10, \n \"Transport-moving\": 11, \n \"Priv-house-serv\": 12, \n \"Protective-serv\": 13, \n \"Armed-Forces\": 14, \n \"?\": 0}\nrelationship = {\"Wife\": 1, \n\t\t\t\t\"Own-child\": 2, \n\t\t\t\t\"Husband\": 3, \n\t\t\t\t\"Not-in-family\": 4, \n\t\t\t\t\"Other-relative\": 5, \n\t\t\t\t\"Unmarried\": 6, \n\t\t\t\t\"?\": 0}\nrace = {\"White\": 1, \n\t\t\"Asian-Pac-Islander\": 2, \n\t\t\"Amer-Indian-Eskimo\": 3, \n\t\t\"Other\": 4, \n\t\t\"Black\": 5, \n\t\t\"?\": 0}\nsex = {\"Female\": 1, \n \"Male\": 2, \n \"?\": 0}\nnative_country = {\"United-States\": 1, \n\t\t\t\t \"Cambodia\": 2, \n\t\t\t\t \"England\": 3, \n\t\t\t\t \"Puerto-Rico\": 4, \n\t\t\t\t \"Canada\": 5,\n\t\t\t\t \"Germany\": 6,\n\t\t\t\t \"Outlying-US(Guam-USVI-etc)\": 7,\n\t\t\t\t \"India\": 8,\n\t\t\t\t \"Japan\": 9,\n\t\t\t\t \"Greece\": 10,\n\t\t\t\t \"South\": 11,\n\t\t\t\t \"China\": 12,\n\t\t\t\t \"Cuba\": 13,\n\t\t\t\t \"Iran\": 14,\n\t\t\t\t \"Honduras\": 15,\n\t\t\t\t \"Philippines\": 16,\n\t\t\t\t \"Italy\": 17,\n\t\t\t\t \"Poland\": 18,\n\t\t\t\t \"Jamaica\": 19,\n\t\t\t\t \"Vietnam\": 20,\n\t\t\t\t \"Mexico\": 21,\n\t\t\t\t \"Portugal\": 22,\n\t\t\t\t \"Ireland\": 23,\n\t\t\t\t \"France\": 24,\n\t\t\t\t \"Dominican-Republic\": 25,\n\t\t\t\t \"Laos\": 26,\n\t\t\t\t \"Ecuador\": 27,\n\t\t\t\t \"Taiwan\": 28,\n\t\t\t\t \"Haiti\": 29,\n\t\t\t\t \"Columbia\": 30,\n\t\t\t\t \"Hungary\": 31,\n\t\t\t\t \"Guatemala\": 32,\n\t\t\t\t \"Nicaragua\": 33,\n\t\t\t\t \"Scotland\": 34,\n\t\t\t\t \"Thailand\": 35,\n\t\t\t\t \"Yugoslavia\": 36,\n\t\t\t\t \"El-Salvador\": 37,\n\t\t\t\t \"Trinadad&Tobago\": 38,\n\t\t\t\t \"Peru\": 39,\n\t\t\t\t \"Hong\": 40,\n\t\t\t\t \"Holand-Netherlands\": 41,\n\t\t\t\t \"?\": 0}\nincome = {\">50K\": 1, \n\t\t \"<=50K\": 0}\n######################################################################################\n\n################################# Load Data Set ########################################\n\ndef detectWidth(inputFile):\n\tfin = open(inputFile, 'r')\n\tline = fin.readline()\n\tline = line.strip().split(',')\n\tnum_x = len(line) - 1 # last column is the column of output y\n\tfin.close()\n\treturn num_x\n\ndef detectNum(inputFile):\n\tfin = open(inputFile, 'r')\n\tcounter = 0\n\tfor line in fin:\n\t\tif line is not \"\\n\":\n\t\t\tcounter = counter + 1\n\tfin.close()\n\treturn counter\n\ndef loadData(inputFile):\n\tfin = open(inputFile, 'r')\n\tnum_x = detectWidth(inputFile) - 1 # The education can be represented by edu-num\n\tm = detectNum(inputFile)\n\tx = np.zeros((m, num_x))\n\ty = np.zeros((m, 1))\n\tfor i in range(m):\n\t\tline = fin.readline()\n\t\ttempLine = line.strip().split(\",\")\n\t\tfor k in range(len(tempLine)):\n\t\t\ttempLine[k] = tempLine[k].strip()\n\t\t\ttempLine[k] = tempLine[k].strip(\".\")\n\t\tfor j in range(len(tempLine)):\n\t\t\tif j == 0:\n\t\t\t\tx[i, j] = tempLine[j]\n\t\t\telif j == 2:\n\t\t\t\tx[i, j] = tempLine[j]\n\t\t\telif j == 1:\n\t\t\t\tx[i, j] = workclass[tempLine[j]]\n\t\t\telif j == 4 or j ==10 or j == 11 or j ==12:\n\t\t\t\tx[i, j-1] = tempLine[j]\n\t\t\telif j == 5:\n\t\t\t\tx[i, j-1] = marital_status[tempLine[j]]\n\t\t\telif j == 6:\n\t\t\t\tx[i, j-1] = occupation[tempLine[j]]\n\t\t\telif j == 7:\n\t\t\t\tx[i, j-1] = relationship[tempLine[j]]\n\t\t\telif j == 8:\n\t\t\t\tx[i, j-1] = race[tempLine[j]]\n\t\t\telif j == 9:\n\t\t\t\tx[i, j-1] = sex[tempLine[j]]\n\t\t\telif j == 13:\n\t\t\t\tx[i, j-1] = native_country[tempLine[j]]\n\t\t\tif j == 14:\n\t\t\t\ty[i, 0] = income[tempLine[j]]\n\t\t'''if i % 5000 == 0:\n\t\t\tprint(\"Finished line \" + str(i))'''\n\tfin.close()\n\tprint(\"Shape of x = \" + str(x.shape) + \" Shape of y = \" + str(y.shape) + \"\\n\")\n\treturn x, y, num_x + 1, m\n######################################################################################\n\n################################# Logistic Module ########################################\ndef normalization(X):\n\tm = X.shape[0]\n\tnum_x = X.shape[1]\n\tmean = np.sum(X, axis = 0) / m\n\tvar = np.sum(np.square(X - mean), axis = 0) / m\n\toutput = (X - mean) / var\n\treturn output\n\ndef initialize_parameters(num_x): # Return grad and initial weights\n\treturn np.zeros((num_x, 1))\n\n\ndef sigmoid(Z): # input may be a scaler or an arrary\n\tg = 1 / (1 + np.exp(-Z))\n\treturn g\n\ndef compute_cost(X, W, y):\n\tm = X.shape[0]\n\tA = sigmoid(np.dot(X, W))\n\tJ = -(1 / m) * (np.dot(y.T, np.log(A) + np.dot((1 - y).T, np.log(1 - A))))\n\treturn J\n\ndef gradient_update(X, W, y, learning_rate):\n\tm = X.shape[0]\n\tresult = W - learning_rate/ m * np.dot(X.T, sigmoid(np.dot(X, W)) - y) \n\treturn result \n\ndef predict(X, W, y):\n\tA = sigmoid(np.dot(X, W))\n\tfor i in range(A.shape[0]):\n\t\tif A[i,0] <= 0.5:\n\t\t\tA[i,0] = 0\n\t\telse:\n\t\t\tA[i,0] = 1\n\tA = A - y\n\tA = A == 0\n\tunique, counts = np.unique(A, return_counts = True)\n\tdiction = dict(zip(unique, counts))\n\treturn diction[True] / X.shape[0]\n######################################################################################\n\n\ndef main():\n\tprint(\"Start running trainning set\\n\")\n\ttime_start = time.time()\n\tX_train, y_train, num_x_train, m_train = loadData(\"adult.data.txt\")\n\tX_train = normalization(X_train)\n\tX_train = np.append(X_train, np.ones((m_train,1)), 1)\n\tW_train = initialize_parameters(num_x_train)\n\tfor i in range(num_iterations):\n\t\tJ = compute_cost(X_train, W_train, y_train)\n\t\tif i % 40 == 0:\n\t\t\tprint(\"Cost for iteration \" + str(i) + \" is \" + str(J) + \"\\n\")\n\t\tW_train = gradient_update(X_train, W_train, y_train, learning_rate)\n\tprint(\"Accuracy for trainning set = \" + str(predict(X_train, W_train, y_train)) + \"\\n\\n\")\n\tprint(\"--------------------------------------------------------------------------\\n\")\n\tprint(\"Start running test set\\n\")\n\tX_test, y_test, num_x_test, m_test = loadData(\"adult.test.txt\")\n\tX_test = normalization(X_test)\n\tX_test = np.append(X_test, np.ones((m_test,1)), 1)\n\tW_test = initialize_parameters(num_x_test)\n\tfor i in range(num_iterations):\n\t\tJ = compute_cost(X_test, W_test, y_test)\n\t\tif i % 40 == 0:\n\t\t\tprint(\"Cost for iteration \" + str(i) + \" is \" + str(J) + \"\\n\")\n\t\tW_test = gradient_update(X_test, W_test, y_test, learning_rate)\n\tprint(\"Accuracy for test set = \" + str(predict(X_test, W_test, y_test)) + \"\\n\\n\")\n\tprint(\"--------------------------------------------------------------------------\\n\")\n\tprint(\"Start trainning by API\\n\") # running the same data set by API \n\tclassifier = LogisticRegression(random_state=0)\n\tclassifier.fit(X_train, y_train.ravel()) # ravel() convert the array to shape [n,]\n\ty_pred = classifier.predict(X_test)\n\tconfusion_matrix_1 = confusion_matrix(y_test, y_pred.ravel())\n\tprint(\"Start printing cofusion matrix:\\n\")\n\tprint(confusion_matrix_1)\n\tprint('\\nAccuracy of logistic regression classifier on test set: {:.2f}'.\n\t\tformat(classifier.score(X_test, y_test)) + \"\\n\")\n\ttime_end = time.time()\n\ttotal_time = time_end - time_start\n\tprint(\"Total time used = \" + str(total_time) + \"\\n\")\n\tprint(\"Done!\\n\")\n\treturn 0\n\nif __name__ == \"__main__\":\n\tlearning_rate = 1\n\tnum_iterations = 400\n\tmain()\n\n\n"
] |
[
[
"numpy.square",
"numpy.dot",
"numpy.log",
"sklearn.linear_model.LogisticRegression",
"numpy.unique",
"numpy.ones",
"numpy.exp",
"numpy.zeros",
"numpy.sum"
]
] |
mvsusp/sagemaker-mxnet-container
|
[
"90b3e096c1b27109926184780087d9d4192d1020"
] |
[
"test/integration/sagemaker/test_mnist_distributed.py"
] |
[
"# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\").\n# You may not use this file except in compliance with the License.\n# A copy of the License is located at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# or in the \"license\" file accompanying this file. This file is distributed\n# on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either\n# express or implied. See the License for the specific language governing\n# permissions and limitations under the License.\nfrom __future__ import absolute_import\n\nimport os\n\nimport numpy as np\nfrom sagemaker.mxnet.estimator import MXNet\nfrom sagemaker.utils import sagemaker_timestamp\n\nfrom test.integration import RESOURCE_PATH\nfrom timeout import timeout, timeout_and_delete_endpoint\n\n\ndef test_mxnet_distributed(sagemaker_session, ecr_image, instance_type, framework_version):\n data_path = os.path.join(RESOURCE_PATH, 'mnist')\n script_path = os.path.join(data_path, 'mnist.py')\n\n mx = MXNet(entry_point=script_path, role='SageMakerRole', train_instance_count=2,\n train_instance_type=instance_type, sagemaker_session=sagemaker_session,\n image_name=ecr_image, framework_version=framework_version,\n hyperparameters={'sagemaker_parameter_server_enabled': True})\n\n prefix = 'mxnet_mnist/{}'.format(sagemaker_timestamp())\n\n with timeout(minutes=15):\n train_input = mx.sagemaker_session.upload_data(path=os.path.join(data_path, 'train'),\n key_prefix=prefix + '/train')\n test_input = mx.sagemaker_session.upload_data(path=os.path.join(data_path, 'test'),\n key_prefix=prefix + '/test')\n\n mx.fit({'train': train_input, 'test': test_input})\n\n with timeout_and_delete_endpoint(estimator=mx, minutes=30):\n predictor = mx.deploy(initial_instance_count=1, instance_type=instance_type)\n\n data = np.zeros(shape=(1, 1, 28, 28))\n predictor.predict(data)\n"
] |
[
[
"numpy.zeros"
]
] |
KyreOn/web
|
[
"557bdfa0f5608a1f2f203349089adda405ef8a2f"
] |
[
"main.py"
] |
[
"from flask import Flask\nfrom flask import render_template\nfrom flask import Response\nimport sqlite3\nimport random\nimport io\n\nfrom matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas\nfrom matplotlib.figure import Figure\n\n\napp = Flask(__name__)\n\n\n@app.route(\"/\")\ndef cv_index():\n cvs = get_cv()\n res = \"\"\n for i, cv in enumerate(cvs):\n res += f\"<h1>{i + 1})</h1>\"\n res += f\"<p>Желаемая зарплата: {cv['salary']}.</p>\"\n res += f\"<p>Образование: {cv['educationType']}.</p>\"\n\n return res\n\n\n@app.route(\"/dashboard\")\ndef dashboard():\n con = sqlite3.connect('works.sqlite')\n res = con.execute('SELECT SUBSTR(dateModify, 1, 4), COUNT(*) FROM works WHERE dateModify NOT NULL GROUP BY '\n 'SUBSTR(dateModify, 1, 4)').fetchall()\n con.close()\n return render_template('d3.html',\n cvs=get_cv(),\n labels=[row[0] for row in res],\n data=[row[1] for row in res]\n )\n\n\n@app.route(\"/statistic\")\ndef statistic():\n job_titles = get_list_field('jobTitle')\n qualifications = get_list_field('qualification')\n res = \"\"\n count = get_match_count(job_titles, qualifications)\n res += f\"<p>У {count[1] - count[0]} человек из {count[1]} не совпадают профессия и должность.</p>\"\n res += \"<p>Топ 5 квалификаций менеджеров:<br>\"\n for item in get_top('jobTitle', 'qualification', 'менеджер'):\n res += f\"{item[0]} {item[1]}</br>\"\n res += \"</p><p>Топ 5 должностей инженеров:<br>\"\n for item in get_top('qualification', 'jobTitle', 'инженер'):\n res += f\"{item[0]} {item[1]}</br>\"\n res += \"</p>\"\n return res\n\n\ndef get_list_field(field):\n con = sqlite3.connect('works.sqlite')\n res = list(con.execute(f'select {field} from works'))\n con.close()\n return res\n\n\ndef dict_factory(cursor, row):\n # обертка для преобразования\n # полученной строки. (взята из документации)\n d = {}\n for idx, col in enumerate(cursor.description):\n d[col[0]] = row[idx]\n return d\n\n\ndef get_cv():\n con = sqlite3.connect('works.sqlite')\n con.row_factory = dict_factory\n res = list(con.execute('select * from works limit 20'))\n con.close()\n return res\n\n\n@app.route('/plot.png')\ndef plot_png():\n fig = create_figure()\n output = io.BytesIO()\n FigureCanvas(fig).print_png(output)\n return Response(output.getvalue(), mimetype='image/png')\n\n\ndef create_figure():\n fig = Figure()\n axis = fig.add_subplot(1, 1, 1)\n xs = range(100)\n ys = [random.randint(1, 50) for x in xs]\n axis.plot(xs, ys)\n return fig\n\n\ndef get_match_count(first_list, second_list):\n return len(list((filter(lambda x: contains(x[0], x[1]) or contains(x[1], x[0]), zip(first_list, second_list))))),\\\n len(list(zip(first_list, second_list)))\n\n\ndef contains(sub_text, text):\n words = str(sub_text).lower().replace('-', ' ').split()\n for word in words:\n if word in str(text).lower():\n return True\n return False\n\n\ndef get_top(search_field, return_field, value):\n con = sqlite3.connect('works.sqlite')\n cur = con.cursor()\n cur.execute(f\"SELECT LOWER({return_field}), count(*) AS 'count' FROM works \"\n f\"WHERE {return_field} IS NOT NULL AND \"\n f\"(LOWER({search_field}) like '%{value}%')\"\n f\"GROUP BY LOWER({return_field}) \"\n f\"ORDER BY count DESC LIMIT 5\")\n return cur.fetchall()\n\n\napp.run()\n"
] |
[
[
"matplotlib.backends.backend_agg.FigureCanvasAgg",
"matplotlib.figure.Figure"
]
] |
bobbyphilip/basicpython3
|
[
"4d2bc87acb13734a8d1f2bbfd589d52983febf6c"
] |
[
"code/puzzles/castleescape.py"
] |
[
"#!/usr/bin/python3\nimport sys\nimport matplotlib.pyplot as plt\nfrom random import randint\n\ndef main():\n '''\n 4 prisoners isolated in cells in a castle. They are given a fair coin, and the choice to toss it.\n If all tosses attempted are heads, they will all be released.\n If no one attempts it or someone tosses a tail, they will stay imprisoned.\n They are given a random number generator.\n https://fivethirtyeight.com/features/can-you-flip-your-way-to-freedom/\n '''\n '''\n Pick a number betwwen 0 and 100. Everyone generates a random number between 0 and 100.\n If it is >= the picked number, toss the coin. \n If picked number is 0, then everyone will toss, escape change of 1/(2^4)\n If picked number is 100, then no one will toss, and chance is 0%\n Somewhere in middle is the optimal number\n '''\n reps = 10000\n numberofprisoners = 4\n wincount = [0 for i in range(0,100)]\n for baselinenumber in range(0,100):\n for repcounter in range(0, reps):\n win=False\n for i in range(0, numberofprisoners):\n generatednumber = randint(0, 99)\n if generatednumber >= baselinenumber:\n heads = randint(0, 1)\n if heads:\n win = True\n else:\n win = False\n break\n if win:\n wincount[baselinenumber] += 1\n winpercent = [x*100/reps for x in wincount]\n highestIndex =0\n highestValue =0\n for i in range(0,100):\n winrate = winpercent[i]\n if winrate>highestValue:\n highestValue = winrate\n highestIndex = i\n print(winpercent)\n print(' best number choice is ',highestIndex, ' and the win rate is ',highestValue)\n plt.plot(winpercent)\n plt.ylabel('Success possibilty')\n plt.xlabel('number generated')\n plt.show()\n# This is the standard boilerplate that calls the main() function.\nif __name__ == '__main__':\n main()\n"
] |
[
[
"matplotlib.pyplot.plot",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel"
]
] |
pgniewko/vistools
|
[
"b4a8d91a9cd73fad1d7e6d83ef98ad82c4d8e305"
] |
[
"src/shellswire/shellswire.py"
] |
[
"#! /usr/bin/env python\n\nimport sys\nimport numpy as np\nfrom mayavi import mlab\nimport networkx as nx\n\n\ndef draw_bonds_color(coords, bonds, scale_factor=.1, resolution=2):\n '''\n color by coordination number\n '''\n nn = bonds\n G = nx.Graph()\n G.add_edges_from(nn)\n deg = np.array([G.degree(i) for i in G.nodes()])\n idx4 = np.where(deg <= 4)\n idx5 = np.where(deg == 5)\n idx6 = np.where(deg == 6)\n idx7 = np.where(deg == 7)\n idx8 = np.where(deg >= 8)\n \n x,y,z = coords.T\n mlab.points3d(x[idx4], y[idx4], z[idx4], scale_factor=scale_factor, resolution=resolution, color = (0,0,1))\n mlab.points3d(x[idx5], y[idx5], z[idx5], scale_factor=scale_factor, resolution=resolution, color = (0,0,1))\n mlab.points3d(x[idx6], y[idx6], z[idx6], scale_factor=scale_factor, resolution=resolution, color = (.6,.6,.6))\n mlab.points3d(x[idx7], y[idx7], z[idx7], scale_factor=scale_factor, resolution=resolution, color = (1,0,0))\n mlab.points3d(x[idx8], y[idx8], z[idx8], scale_factor=scale_factor, resolution=resolution, color = (.2,.2,.7))\n points = mlab.points3d(x, y, z, scale_factor=scale_factor/10,resolution=4, color = tuple(np.random.random(3)))\n points.mlab_source.dataset.lines = nn\n points.mlab_source.update()\n mlab.pipeline.surface(points, representation='wireframe', color=(0.2, 0.2, 0.2))\n \n return \n\n\ndef draw_bonds(coords, bonds, scale_factor=.1, resolution=2, cc=(0.3, 0.3, 0.3), skip_verts=True):\n '''\n unicolor\n '''\n x, y, z = coords.T\n if skip_verts:\n points = mlab.points3d(x, y, z, scale_mode='none', scale_factor=0, resolution=resolution, color=cc)\n else:\n points = mlab.points3d(x, y, z, scale_mode='none', scale_factor=scale_factor, resolution=resolution, color=cc)\n\n points.mlab_source.dataset.lines = bonds\n points.mlab_source.update()\n mlab.pipeline.surface(points, representation='wireframe', color=(0.5, 0.5, 0.5))\n return \n\n\ndef pbc_image(c, Lc):\n nc = c\n if c < 0.0:\n nc += Lc\n \n if c >= Lc:\n nc -= Lc\n \n return nc\n\n\ndef scale_coords(xyz_l, bx, by, bz, size_=5.0):\n\n maxb = max( max(bx, by), bz)\n scale = size_ / maxb\n print (\"Scaling factor:\", scale)\n for xyz in xyz_l:\n xyz[0] *= scale\n xyz[1] *= scale\n xyz[2] *= scale\n \n return xyz_l, scale\n\n\ndef get_registered_verts(filename):\n fin = open(filename) \n vertex_map = {}\n reversed_vertex_map = {}\n \n for line in fin:\n if line.startswith(\"VMAP\"):\n pairs = line.split()\n vname = pairs[1]\n cell_id = int(pairs[2])\n v_id = int(pairs[3])\n vertex_map[vname] = [cell_id, v_id]\n reversed_vertex_map[ (cell_id, v_id) ] = vname\n\n fin.close()\n \n return vertex_map, reversed_vertex_map\n\n\ndef get_triangles(filename):\n fin = open(filename)\n triangles_list = []\n \n for line in fin:\n if line.startswith(\"SHELLTRIANG\"):\n pairs = line.rstrip('\\n').split()\n cellid = int(pairs[1])\n vid1 = int(pairs[3])\n vid2 = int(pairs[4])\n vid3 = int(pairs[5])\n triangles_list.append( [cellid, vid1, vid2, vid3] )\n\n fin.close()\n\n return triangles_list\n\n\ndef get_coord_hash(fname):\n fin = open(fname)\n tra_xyz = []\n tra_xyz_hash = {}\n line_counter = 0\n x_box = 0\n y_box = 0\n z_box = 0\n\n cc = 0\n\n for line in fin:\n line_counter += 1\n\n pairs = line.rstrip('\\n').split()\n\n if line_counter == 1:\n num_verts = int(pairs[0])\n x_box = float(pairs[1])\n y_box = float(pairs[2])\n z_box = float(pairs[3])\n Lx = 2.0 * x_box\n Ly = 2.0 * y_box\n Lz = 2.0 * z_box\n\n if line_counter > 1:\n vname = pairs[0]\n x = float(pairs[1])\n y = float(pairs[2])\n z = float(pairs[3])\n x += x_box\n y += y_box\n z += z_box\n \n tra_xyz.append( [x, y, z] )\n tra_xyz_hash[vname] = cc\n cc += 1\n\n fin.close()\n\n return tra_xyz_hash, tra_xyz, Lx, Ly, Lz\n\n\ndef get_xyz_bds_fcts(triangles_list, reversed_vertex_map, tra_xyz, tra_hash, cell_ids):\n x = []\n y = []\n z = []\n \n cells_xyz = []\n cells_bds = []\n cells_tri = []\n\n for triangle in triangles_list:\n tcellid = triangle[0]\n vid1 = triangle[1]\n vid2 = triangle[2]\n vid3 = triangle[3]\n\n vid1_name = reversed_vertex_map[ (tcellid, vid1) ]\n vid2_name = reversed_vertex_map[ (tcellid, vid2) ]\n vid3_name = reversed_vertex_map[ (tcellid, vid3) ]\n\n vix1 = tra_hash[vid1_name] \n vix2 = tra_hash[vid2_name]\n vix3 = tra_hash[vid3_name]\n \n cells_tri.append( [vix1, vix2, vix3] )\n cells_bds.append( (min(vix1, vix2), max(vix1, vix2)) )\n cells_bds.append( (min(vix1, vix3), max(vix1, vix3)) )\n cells_bds.append( (min(vix2, vix3), max(vix2, vix3)) )\n\n cells_bds = list( set(cells_bds) )\n return cells_bds, cells_tri\n\n\nfile_name = sys.argv[1]\ntop_fname = sys.argv[2]\ncolor_flag = int(sys.argv[3])\n\ntra_hash, tra_xyz, Lx, Ly, Lz = get_coord_hash(file_name)\ntra_xyz, sc = scale_coords(tra_xyz, 0.5*Lx, 0.5*Ly, 0.5*Lz)\nLx *= sc\nLy *= sc\nLz *= sc\nvertex_map, reversed_vertex_map = get_registered_verts(top_fname)\ntriangles_list = get_triangles(top_fname)\ncells_bds, cells_tri = get_xyz_bds_fcts(triangles_list, reversed_vertex_map, tra_xyz, tra_hash, [1])\n\nbds = []\nfor el in cells_bds:\n bds.append(el)\n\nbds = np.array(bds, dtype=int)\n\nfct = []\nfor el in cells_tri:\n fct.append(el)\n\nfct = np.array(fct, dtype=int)\n\nar = []\nfor xyz in tra_xyz:\n ar.append(xyz)\n\nar = np.array(ar)\nx, y, z = ar.T\n\n\nf = mlab.figure(0, size=(600, 600), bgcolor=(1, 1, 1))\nmesh = mlab.triangular_mesh(x, y, z, fct, color=(.8, .8, .8))\n\n\nif color_flag == 1: \n draw_bonds_color(ar, bds, scale_factor=.1, resolution=8)\nelif color_flag == 0:\n draw_bonds(ar, bds, scale_factor=.1, resolution=8)\nelif color_flag == -1:\n draw_bonds(ar, bds, scale_factor=.1, resolution=8, skip_verts=True)\nelse:\n pass\n\neps=0.1\nblack = (0,0,0)\nwhite = (1,1,1)\nmlab.plot3d([0, Lx], [0, 0], [0, 0], color=black, tube_radius=eps)\nmlab.plot3d([0, 0], [0, Ly], [0, 0], color=black, tube_radius=eps)\nmlab.plot3d([0, 0], [0, 0], [0, Lz], color=black, tube_radius=eps)\nmlab.plot3d([Lx, Lx], [0, Ly], [0, 0], color=black, tube_radius=eps)\nmlab.plot3d([0, Lx], [Ly, Ly], [0, 0], color=black, tube_radius=eps)\nmlab.plot3d([Lx, Lx], [0, 0], [0, Lz], color=black, tube_radius=eps)\nmlab.plot3d([Lx, Lx], [Ly, Ly], [0, Lz], color=black, tube_radius=eps)\nmlab.plot3d([0, 0], [Ly, Ly], [0, Lz], color=black, tube_radius=eps)\nmlab.plot3d([0, Lx], [0, 0], [Lz, Lz], color=black, tube_radius=eps)\nmlab.plot3d([Lx, Lx], [0, Ly], [Lz, Lz], color=black, tube_radius=eps)\nmlab.plot3d([0, 0], [0, Ly], [Lz, Lz], color=black, tube_radius=eps)\nmlab.plot3d([0, Lx], [Ly, Ly], [Lz, Lz], color=black, tube_radius=eps)\n\n\nmlab.show()\n\n\n"
] |
[
[
"numpy.random.random",
"numpy.array",
"numpy.where"
]
] |
yifan0330/NiMARE
|
[
"cb542af17c4f969afd05e4fd381a1200a1e4817c",
"cb542af17c4f969afd05e4fd381a1200a1e4817c"
] |
[
"nimare/utils.py",
"examples/02_meta-analyses/05_plot_correctors.py"
] |
[
"\"\"\"Utility functions for NiMARE.\"\"\"\nimport contextlib\nimport datetime\nimport inspect\nimport logging\nimport multiprocessing as mp\nimport os\nimport os.path as op\nimport re\nfrom functools import wraps\nfrom tempfile import mkstemp\n\nimport joblib\nimport nibabel as nib\nimport numpy as np\nimport pandas as pd\nfrom nilearn.input_data import NiftiMasker\n\nfrom nimare import references\nfrom nimare.due import due\n\nLGR = logging.getLogger(__name__)\n\n\ndef _check_ncores(n_cores):\n \"\"\"Check number of cores used for method.\n\n .. versionadded:: 0.0.12\n Moved from Estimator._check_ncores into its own function.\n \"\"\"\n if n_cores <= 0:\n n_cores = mp.cpu_count()\n elif n_cores > mp.cpu_count():\n LGR.warning(\n f\"Desired number of cores ({n_cores}) greater than number \"\n f\"available ({mp.cpu_count()}). Setting to {mp.cpu_count()}.\"\n )\n n_cores = mp.cpu_count()\n return n_cores\n\n\ndef get_resource_path():\n \"\"\"Return the path to general resources, terminated with separator.\n\n Resources are kept outside package folder in \"datasets\".\n Based on function by Yaroslav Halchenko used in Neurosynth Python package.\n \"\"\"\n return op.abspath(op.join(op.dirname(__file__), \"resources\") + op.sep)\n\n\ndef get_template(space=\"mni152_2mm\", mask=None):\n \"\"\"Load template file.\n\n .. versionchanged:: 0.0.11\n\n - Remove the ``mask=\"gm\"`` option.\n - Replace the nilearn templates with ones downloaded directly from TemplateFlow.\n\n Parameters\n ----------\n space : {'mni152_1mm', 'mni152_2mm', 'ale_2mm'}, optional\n Template to load. Default is 'mni152_2mm'.\n The options are:\n\n - mni152_1mm: The MNI152NLin6Asym template at 1mm3 resolution,\n downloaded from TemplateFlow. The shape of this template is 182x218x182 voxels.\n - mni152_2mm: The MNI152NLin6Asym template at 2mm3 resolution,\n downloaded from TemplateFlow. The shape of this template is 91x109x91 voxels.\n - ale_2mm: The template used is the MNI152NLin6Asym template at 2mm3 resolution,\n but if ``mask='brain'``, then a brain mask taken from GingerALE will be used.\n The brain mask corresponds to GingerALE's \"more conservative\" mask.\n The shape of this template is 91x109x91 voxels.\n mask : {None, 'brain'}, optional\n Whether to return the raw T1w template (None) or a brain mask ('brain').\n Default is None.\n\n Returns\n -------\n img : :obj:`~nibabel.nifti1.Nifti1Image`\n Template image object.\n \"\"\"\n template_dir = op.join(get_resource_path(), \"templates\")\n if space == \"mni152_1mm\":\n if mask is None:\n img = nib.load(op.join(template_dir, \"tpl-MNI152NLin6Asym_res-01_T1w.nii.gz\"))\n elif mask == \"brain\":\n img = nib.load(\n op.join(template_dir, \"tpl-MNI152NLin6Asym_res-01_desc-brain_mask.nii.gz\")\n )\n else:\n raise ValueError(f\"Mask option '{mask}' not supported\")\n elif space == \"mni152_2mm\":\n if mask is None:\n img = nib.load(op.join(template_dir, \"tpl-MNI152NLin6Asym_res-02_T1w.nii.gz\"))\n elif mask == \"brain\":\n img = nib.load(\n op.join(template_dir, \"tpl-MNI152NLin6Asym_res-02_desc-brain_mask.nii.gz\")\n )\n else:\n raise ValueError(f\"Mask option '{mask}' not supported\")\n elif space == \"ale_2mm\":\n if mask is None:\n img = nib.load(op.join(template_dir, \"tpl-MNI152NLin6Asym_res-02_T1w.nii.gz\"))\n elif mask == \"brain\":\n # Not the same as the nilearn brain mask, but should correspond to\n # the default \"more conservative\" MNI152 mask in GingerALE.\n img = nib.load(op.join(template_dir, \"MNI152_2x2x2_brainmask.nii.gz\"))\n else:\n raise ValueError(f\"Mask option '{mask}' not supported\")\n else:\n raise ValueError(f\"Space '{space}' not supported\")\n\n # Coerce to array-image\n img = nib.Nifti1Image(img.get_fdata(), affine=img.affine, header=img.header)\n return img\n\n\ndef get_masker(mask):\n \"\"\"Get an initialized, fitted nilearn Masker instance from passed argument.\n\n Parameters\n ----------\n mask : str, :class:`nibabel.nifti1.Nifti1Image`, or any nilearn Masker\n\n Returns\n -------\n masker : an initialized, fitted instance of a subclass of\n `nilearn.input_data.base_masker.BaseMasker`\n \"\"\"\n if isinstance(mask, str):\n mask = nib.load(mask)\n\n if isinstance(mask, nib.nifti1.Nifti1Image):\n # Coerce to array-image\n mask = nib.Nifti1Image(mask.get_fdata(), affine=mask.affine, header=mask.header)\n\n mask = NiftiMasker(mask)\n\n if not (hasattr(mask, \"transform\") and hasattr(mask, \"inverse_transform\")):\n raise ValueError(\n \"mask argument must be a string, a nibabel image, or a Nilearn Masker instance.\"\n )\n\n # Fit the masker if needed\n if not hasattr(mask, \"mask_img_\"):\n mask.fit()\n\n return mask\n\n\ndef vox2mm(ijk, affine):\n \"\"\"Convert matrix subscripts to coordinates.\n\n .. versionchanged:: 0.0.8\n\n * [ENH] This function was part of `nimare.transforms` in previous versions (0.0.3-0.0.7)\n\n Parameters\n ----------\n ijk : (X, 3) :obj:`numpy.ndarray`\n Matrix subscripts for coordinates being transformed.\n One row for each coordinate, with three columns: i, j, and k.\n affine : (4, 4) :obj:`numpy.ndarray`\n Affine matrix from image.\n\n Returns\n -------\n xyz : (X, 3) :obj:`numpy.ndarray`\n Coordinates in image-space.\n\n Notes\n -----\n From here:\n http://blog.chrisgorgolewski.org/2014/12/how-to-convert-between-voxel-and-mm.html\n \"\"\"\n xyz = nib.affines.apply_affine(affine, ijk)\n return xyz\n\n\ndef mm2vox(xyz, affine):\n \"\"\"Convert coordinates to matrix subscripts.\n\n .. versionchanged:: 0.0.8\n\n * [ENH] This function was part of `nimare.transforms` in previous versions (0.0.3-0.0.7)\n\n Parameters\n ----------\n xyz : (X, 3) :obj:`numpy.ndarray`\n Coordinates in image-space.\n One row for each coordinate, with three columns: x, y, and z.\n affine : (4, 4) :obj:`numpy.ndarray`\n Affine matrix from image.\n\n Returns\n -------\n ijk : (X, 3) :obj:`numpy.ndarray`\n Matrix subscripts for coordinates being transformed.\n\n Notes\n -----\n From here:\n http://blog.chrisgorgolewski.org/2014/12/how-to-convert-between-voxel-and-mm.html\n \"\"\"\n ijk = nib.affines.apply_affine(np.linalg.inv(affine), xyz).astype(int)\n return ijk\n\n\n@due.dcite(\n references.LANCASTER_TRANSFORM,\n description=\"Introduces the Lancaster MNI-to-Talairach transform, \"\n \"as well as its inverse, the Talairach-to-MNI \"\n \"transform.\",\n)\n@due.dcite(\n references.LANCASTER_TRANSFORM_VALIDATION,\n description=\"Validates the Lancaster MNI-to-Talairach and Talairach-to-MNI transforms.\",\n)\ndef tal2mni(coords):\n \"\"\"Convert coordinates from Talairach space to MNI space.\n\n .. versionchanged:: 0.0.8\n\n * [ENH] This function was part of `nimare.transforms` in previous versions (0.0.3-0.0.7)\n\n Parameters\n ----------\n coords : (X, 3) :obj:`numpy.ndarray`\n Coordinates in Talairach space to convert.\n Each row is a coordinate, with three columns.\n\n Returns\n -------\n coords : (X, 3) :obj:`numpy.ndarray`\n Coordinates in MNI space.\n Each row is a coordinate, with three columns.\n\n Notes\n -----\n Python version of BrainMap's tal2icbm_other.m.\n\n This function converts coordinates from Talairach space to MNI\n space (normalized using templates other than those contained\n in SPM and FSL) using the tal2icbm transform developed and\n validated by Jack Lancaster at the Research Imaging Center in\n San Antonio, Texas.\n http://www3.interscience.wiley.com/cgi-bin/abstract/114104479/ABSTRACT\n \"\"\"\n # Find which dimensions are of size 3\n shape = np.array(coords.shape)\n if all(shape == 3):\n LGR.info(\"Input is an ambiguous 3x3 matrix.\\nAssuming coords are row vectors (Nx3).\")\n use_dim = 1\n elif not any(shape == 3):\n raise AttributeError(\"Input must be an Nx3 or 3xN matrix.\")\n else:\n use_dim = np.where(shape == 3)[0][0]\n\n # Transpose if necessary\n if use_dim == 1:\n coords = coords.transpose()\n\n # Transformation matrices, different for each software package\n icbm_other = np.array(\n [\n [0.9357, 0.0029, -0.0072, -1.0423],\n [-0.0065, 0.9396, -0.0726, -1.3940],\n [0.0103, 0.0752, 0.8967, 3.6475],\n [0.0000, 0.0000, 0.0000, 1.0000],\n ]\n )\n\n # Invert the transformation matrix\n icbm_other = np.linalg.inv(icbm_other)\n\n # Apply the transformation matrix\n coords = np.concatenate((coords, np.ones((1, coords.shape[1]))))\n coords = np.dot(icbm_other, coords)\n\n # Format the output, transpose if necessary\n out_coords = coords[:3, :]\n if use_dim == 1:\n out_coords = out_coords.transpose()\n return out_coords\n\n\n@due.dcite(\n references.LANCASTER_TRANSFORM,\n description=\"Introduces the Lancaster MNI-to-Talairach transform, \"\n \"as well as its inverse, the Talairach-to-MNI \"\n \"transform.\",\n)\n@due.dcite(\n references.LANCASTER_TRANSFORM_VALIDATION,\n description=\"Validates the Lancaster MNI-to-Talairach and Talairach-to-MNI transforms.\",\n)\ndef mni2tal(coords):\n \"\"\"Convert coordinates from MNI space Talairach space.\n\n .. versionchanged:: 0.0.8\n\n * [ENH] This function was part of `nimare.transforms` in previous versions (0.0.3-0.0.7)\n\n Parameters\n ----------\n coords : (X, 3) :obj:`numpy.ndarray`\n Coordinates in MNI space to convert.\n Each row is a coordinate, with three columns.\n\n Returns\n -------\n coords : (X, 3) :obj:`numpy.ndarray`\n Coordinates in Talairach space.\n Each row is a coordinate, with three columns.\n\n Notes\n -----\n Python version of BrainMap's icbm_other2tal.m.\n This function converts coordinates from MNI space (normalized using\n templates other than those contained in SPM and FSL) to Talairach space\n using the icbm2tal transform developed and validated by Jack Lancaster at\n the Research Imaging Center in San Antonio, Texas.\n http://www3.interscience.wiley.com/cgi-bin/abstract/114104479/ABSTRACT\n \"\"\"\n # Find which dimensions are of size 3\n shape = np.array(coords.shape)\n if all(shape == 3):\n LGR.info(\"Input is an ambiguous 3x3 matrix.\\nAssuming coords are row vectors (Nx3).\")\n use_dim = 1\n elif not any(shape == 3):\n raise AttributeError(\"Input must be an Nx3 or 3xN matrix.\")\n else:\n use_dim = np.where(shape == 3)[0][0]\n\n # Transpose if necessary\n if use_dim == 1:\n coords = coords.transpose()\n\n # Transformation matrices, different for each software package\n icbm_other = np.array(\n [\n [0.9357, 0.0029, -0.0072, -1.0423],\n [-0.0065, 0.9396, -0.0726, -1.3940],\n [0.0103, 0.0752, 0.8967, 3.6475],\n [0.0000, 0.0000, 0.0000, 1.0000],\n ]\n )\n\n # Apply the transformation matrix\n coords = np.concatenate((coords, np.ones((1, coords.shape[1]))))\n coords = np.dot(icbm_other, coords)\n\n # Format the output, transpose if necessary\n out_coords = coords[:3, :]\n if use_dim == 1:\n out_coords = out_coords.transpose()\n return out_coords\n\n\ndef _dict_to_df(id_df, data, key=\"labels\"):\n \"\"\"Load a given data type in NIMADS-format dictionary into DataFrame.\n\n Parameters\n ----------\n id_df : :obj:`pandas.DataFrame`\n DataFrame with columns for identifiers. Index is [studyid]-[expid].\n data : :obj:`dict`\n NIMADS-format dictionary storing the raw dataset, from which\n relevant data are loaded into DataFrames.\n key : {'labels', 'metadata', 'text', 'images'}\n Which data type to load.\n\n Returns\n -------\n df : :obj:`pandas.DataFrame`\n DataFrame with id columns from id_df and new columns for the\n requested data type.\n \"\"\"\n exp_dict = {}\n for pid in data.keys():\n for expid in data[pid][\"contrasts\"].keys():\n exp = data[pid][\"contrasts\"][expid]\n id_ = f\"{pid}-{expid}\"\n\n if key not in data[pid][\"contrasts\"][expid].keys():\n continue\n exp_dict[id_] = exp[key]\n\n temp_df = pd.DataFrame.from_dict(exp_dict, orient=\"index\")\n df = pd.merge(id_df, temp_df, left_index=True, right_index=True, how=\"outer\")\n df = df.reset_index(drop=True)\n df = df.replace(to_replace=\"None\", value=np.nan)\n # replace nan with none\n df = df.where(pd.notnull(df), None)\n return df\n\n\ndef _dict_to_coordinates(data, masker, space):\n \"\"\"Load coordinates in NIMADS-format dictionary into DataFrame.\"\"\"\n # Required columns\n columns = [\"id\", \"study_id\", \"contrast_id\", \"x\", \"y\", \"z\", \"space\"]\n core_columns = columns.copy() # Used in contrast for loop\n\n all_dfs = []\n for pid in data.keys():\n for expid in data[pid][\"contrasts\"].keys():\n if \"coords\" not in data[pid][\"contrasts\"][expid].keys():\n continue\n\n exp_columns = core_columns.copy()\n exp = data[pid][\"contrasts\"][expid]\n\n # Required info (ids, x, y, z, space)\n n_coords = len(exp[\"coords\"][\"x\"])\n rep_id = np.array([[f\"{pid}-{expid}\", pid, expid]] * n_coords).T\n\n space_arr = exp[\"coords\"].get(\"space\")\n space_arr = np.array([space_arr] * n_coords)\n temp_data = np.vstack(\n (\n rep_id,\n np.array(exp[\"coords\"][\"x\"]),\n np.array(exp[\"coords\"][\"y\"]),\n np.array(exp[\"coords\"][\"z\"]),\n space_arr,\n )\n )\n\n # Optional information\n for k in list(set(exp[\"coords\"].keys()) - set(core_columns)):\n k_data = exp[\"coords\"][k]\n if not isinstance(k_data, list):\n k_data = np.array([k_data] * n_coords)\n exp_columns.append(k)\n\n if k not in columns:\n columns.append(k)\n temp_data = np.vstack((temp_data, k_data))\n\n # Place data in list of dataframes to merge\n con_df = pd.DataFrame(temp_data.T, columns=exp_columns)\n all_dfs.append(con_df)\n\n if not all_dfs:\n return pd.DataFrame(\n {\n \"id\": [],\n \"study_id\": [],\n \"contrast_id\": [],\n \"x\": [],\n \"y\": [],\n \"z\": [],\n \"space\": [],\n },\n )\n\n df = pd.concat(all_dfs, axis=0, join=\"outer\", sort=False)\n df = df[columns].reset_index(drop=True)\n df = df.replace(to_replace=\"None\", value=np.nan)\n # replace nan with none\n df = df.where(pd.notnull(df), None)\n df[[\"x\", \"y\", \"z\"]] = df[[\"x\", \"y\", \"z\"]].astype(float)\n df = _transform_coordinates_to_space(df, masker, space)\n return df\n\n\ndef _transform_coordinates_to_space(df, masker, space):\n \"\"\"Convert xyz coordinates in a DataFrame to ijk indices for a given target space.\n\n Parameters\n ----------\n df : :obj:`pandas.DataFrame`\n masker : :class:`~nilearn.input_data.NiftiMasker` or similar\n Masker object defining the space and location of the area of interest\n (e.g., 'brain').\n space : :obj:`str`\n String describing the stereotactic space and resolution of the masker.\n\n Returns\n -------\n df : :obj:`pandas.DataFrame`\n DataFrame with IJK columns either added or overwritten.\n \"\"\"\n # Now to apply transformations!\n if \"mni\" in space.lower() or \"ale\" in space.lower():\n transform = {\"MNI\": None, \"TAL\": tal2mni, \"Talairach\": tal2mni}\n elif \"tal\" in space.lower():\n transform = {\"MNI\": mni2tal, \"TAL\": None, \"Talairach\": None}\n else:\n raise ValueError(f\"Unrecognized space: {space}\")\n\n found_spaces = df[\"space\"].unique()\n for found_space in found_spaces:\n if found_space not in transform.keys():\n LGR.warning(\n f\"Not applying transforms to coordinates in unrecognized space '{found_space}'\"\n )\n alg = transform.get(found_space, None)\n idx = df[\"space\"] == found_space\n if alg:\n df.loc[idx, [\"x\", \"y\", \"z\"]] = alg(df.loc[idx, [\"x\", \"y\", \"z\"]].values)\n df.loc[idx, \"space\"] = space\n\n return df\n\n\ndef _validate_df(df):\n \"\"\"Check that an input is a DataFrame and has a column for 'id'.\"\"\"\n assert isinstance(df, pd.DataFrame)\n assert \"id\" in df.columns\n\n\ndef _validate_images_df(image_df):\n \"\"\"Check and update image paths in DataFrame.\n\n Parameters\n ----------\n image_df : :class:`pandas.DataFrame`\n DataFrame with one row for each study and one column for each image\n type. Cells contain paths to image files.\n\n Returns\n -------\n image_df : :class:`pandas.DataFrame`\n DataFrame with updated paths and columns.\n \"\"\"\n valid_suffixes = [\".brik\", \".head\", \".nii\", \".img\", \".hed\"]\n\n # Find columns in the DataFrame with images\n file_cols = []\n for col in image_df.columns:\n vals = [v for v in image_df[col].values if isinstance(v, str)]\n fc = any([any([vs in v for vs in valid_suffixes]) for v in vals])\n if fc:\n file_cols.append(col)\n\n # Clean up DataFrame\n # Find out which columns have full paths and which have relative paths\n abs_cols = []\n for col in file_cols:\n files = image_df[col].tolist()\n abspaths = [f == op.abspath(f) for f in files if isinstance(f, str)]\n if all(abspaths):\n abs_cols.append(col)\n elif not any(abspaths):\n if not col.endswith(\"__relative\"):\n image_df = image_df.rename(columns={col: col + \"__relative\"})\n else:\n raise ValueError(\n f\"Mix of absolute and relative paths detected for images in column '{col}'\"\n )\n\n # Set relative paths from absolute ones\n if len(abs_cols):\n all_files = list(np.ravel(image_df[abs_cols].values))\n all_files = [f for f in all_files if isinstance(f, str)]\n\n if len(all_files) == 1:\n # In the odd case where there's only one absolute path\n shared_path = op.dirname(all_files[0]) + op.sep\n else:\n shared_path = _find_stem(all_files)\n\n # Get parent *directory* if shared path includes common prefix.\n if not shared_path.endswith(op.sep):\n shared_path = op.dirname(shared_path) + op.sep\n LGR.info(f\"Shared path detected: '{shared_path}'\")\n\n image_df_out = image_df.copy() # To avoid SettingWithCopyWarning\n for abs_col in abs_cols:\n image_df_out[abs_col + \"__relative\"] = image_df[abs_col].apply(\n lambda x: x.split(shared_path)[1] if isinstance(x, str) else x\n )\n\n image_df = image_df_out\n\n return image_df\n\n\ndef _listify(obj):\n \"\"\"Wrap all non-list or tuple objects in a list.\n\n This provides a simple way to accept flexible arguments.\n \"\"\"\n return obj if isinstance(obj, (list, tuple, type(None), np.ndarray)) else [obj]\n\n\ndef _round2(ndarray):\n \"\"\"Round X.5 to the nearest integer away from zero.\n\n Numpy rounds X.5 values to nearest even integer.\n \"\"\"\n onedarray = ndarray.flatten()\n signs = np.sign(onedarray) # pylint: disable=no-member\n idx = np.where(np.abs(onedarray - np.round(onedarray)) == 0.5)[0]\n x = np.abs(onedarray)\n y = np.round(x)\n y[idx] = np.ceil(x[idx])\n y *= signs\n rounded = y.reshape(ndarray.shape)\n return rounded.astype(int)\n\n\ndef _try_prepend(value, prefix):\n \"\"\"Try to prepend a value to a string with a separator ('/').\n\n If not a string, will just return the original value.\n \"\"\"\n if isinstance(value, str):\n return op.join(prefix, value)\n else:\n return value\n\n\ndef _find_stem(arr):\n \"\"\"Find longest common substring in array of strings.\n\n From https://www.geeksforgeeks.org/longest-common-substring-array-strings/\n \"\"\"\n # Determine size of the array\n n_items_in_array = len(arr)\n\n # Take first word from array as reference\n reference_string = arr[0]\n n_chars_in_first_item = len(reference_string)\n\n res = \"\"\n for i_char in range(n_chars_in_first_item):\n # Generate all starting substrings of our reference string\n stem = reference_string[:i_char]\n\n j_item = 1 # Retained in case of an array with only one item\n for j_item in range(1, n_items_in_array):\n # Check if the generated stem is common to to all words\n if not arr[j_item].startswith(stem):\n break\n\n # If current substring is present in all strings and its length is\n # greater than current result\n if (j_item + 1 == n_items_in_array) and (len(res) < len(stem)):\n res = stem\n\n return res\n\n\ndef _uk_to_us(text):\n \"\"\"Convert UK spellings to US based on a converter.\n\n .. versionadded:: 0.0.2\n\n Parameters\n ----------\n text : :obj:`str`\n\n Returns\n -------\n text : :obj:`str`\n\n Notes\n -----\n The english_spellings.csv file is from http://www.tysto.com/uk-us-spelling-list.html.\n \"\"\"\n SPELL_DF = pd.read_csv(op.join(get_resource_path(), \"english_spellings.csv\"), index_col=\"UK\")\n SPELL_DICT = SPELL_DF[\"US\"].to_dict()\n\n if isinstance(text, str):\n # Convert British to American English\n pattern = re.compile(r\"\\b(\" + \"|\".join(SPELL_DICT.keys()) + r\")\\b\")\n text = pattern.sub(lambda x: SPELL_DICT[x.group()], text)\n return text\n\n\ndef use_memmap(logger, n_files=1):\n \"\"\"Memory-map array to a file, and perform cleanup after.\n\n .. versionadded:: 0.0.8\n\n Parameters\n ----------\n logger : :obj:`logging.Logger`\n A Logger with which to log information about the function.\n n_files : :obj:`int`, optional\n Number of memory-mapped files to create and manage.\n\n Notes\n -----\n This function is used as a decorator to methods in which memory-mapped arrays may be used.\n It will only be triggered if the class to which the method belongs has a ``memory_limit``\n attribute that is set to something other than ``None``.\n\n It will set an attribute within the method's class named ``memmap_filenames``, which is a list\n of filename strings, with ``n_files`` elements.\n If ``memory_limit`` is None, then it will be a list of ``Nones``.\n\n Files generated by this function will be stored in the NiMARE data directory and will be\n removed after the wrapped method finishes.\n \"\"\"\n\n def inner_function(function):\n @wraps(function)\n def memmap_context(self, *args, **kwargs):\n if hasattr(self, \"memory_limit\") and self.memory_limit:\n self.memmap_filenames, filenames = [], []\n for i_file in range(n_files):\n start_time = datetime.datetime.now().strftime(\"%Y%m%dT%H%M%S\")\n _, filename = mkstemp(prefix=self.__class__.__name__, suffix=start_time)\n logger.debug(f\"Temporary file written to {filename}\")\n self.memmap_filenames.append(filename)\n filenames.append(filename)\n else:\n filenames = self.memmap_filenames = [None] * n_files\n\n try:\n return function(self, *args, **kwargs)\n except:\n for filename in filenames:\n logger.error(f\"{function.__name__} failed, removing {filename}\")\n raise\n finally:\n if hasattr(self, \"memory_limit\") and self.memory_limit:\n for filename in filenames:\n if os.path.isfile(filename):\n logger.debug(f\"Removing temporary file: {filename}\")\n os.remove(filename)\n else:\n logger.debug(f\"Temporary file DNE: {filename}\")\n\n return memmap_context\n\n return inner_function\n\n\nBYTE = 2\nKILOBYTE = BYTE**10\nBYTE_CONVERSION = {\n \"kb\": KILOBYTE,\n \"mb\": KILOBYTE**2,\n \"gb\": KILOBYTE**3,\n \"tb\": KILOBYTE**4,\n}\n\n\ndef _determine_chunk_size(limit, arr, multiplier=1):\n \"\"\"Determine how many arrays can be read into memory at once.\n\n Parameters\n ----------\n limit : :obj:`str`\n String representation of memory limit, can use:\n kb, mb, gb, and tb as suffix (e.g., \"4gb\").\n arr : :obj:`numpy.array`\n Representative numpy array.\n multiplier : :obj:`int`\n Adjustment for processes that have more or\n less overhead than expected.\n \"\"\"\n limit = limit.lower()\n size, representation = re.search(r\"([0-9]+)([a-z]+)\", limit).groups()\n\n limit_bytes = float(size) * BYTE_CONVERSION[representation] * multiplier\n\n arr_bytes = arr.size * arr.itemsize\n\n chunk_size = int(limit_bytes // arr_bytes)\n\n if chunk_size == 0:\n arr_size = arr_bytes // BYTE_CONVERSION[\"mb\"]\n raise RuntimeError(f\"memory limit: {limit} too small for array with size {arr_size}mb\")\n\n return chunk_size\n\n\ndef _safe_transform(imgs, masker, memory_limit=\"1gb\", dtype=\"auto\", memfile=None):\n \"\"\"Apply a masker with limited memory usage.\n\n Parameters\n ----------\n imgs : list of niimgs\n List of images upon which to apply the masker.\n masker : nilearn masker\n Masker object to apply to images.\n memory_limit : :obj:`str`, optional\n String representation of memory limit, can use:\n kb, mb, gb, and tb as suffix (e.g., \"4gb\").\n dtype : :obj:`str`, optional\n Target datatype of masked array.\n Default is \"auto\", which uses the datatype of the niimgs.\n memfile : :obj:`str` or None, optional\n Name of a memory-mapped file. If None, memory-mapping will not be used.\n\n Returns\n -------\n masked_data : :obj:`numpy.ndarray` or :obj:`numpy.memmap`\n Masked data in a 2D array.\n Either an ndarray (if memfile is None) or a memmap array (if memfile is a string).\n \"\"\"\n assert isinstance(memfile, (type(None), str))\n\n first_img_data = masker.transform(imgs[0])\n masked_shape = (len(imgs), first_img_data.size)\n if memfile:\n masked_data = np.memmap(\n memfile,\n dtype=first_img_data.dtype if dtype == \"auto\" else dtype,\n mode=\"w+\",\n shape=masked_shape,\n )\n else:\n masked_data = np.empty(\n masked_shape,\n dtype=first_img_data.dtype if dtype == \"auto\" else dtype,\n )\n\n # perform transform on chunks of the input maps\n chunk_size = _determine_chunk_size(memory_limit, first_img_data)\n map_chunks = [imgs[i : i + chunk_size] for i in range(0, len(imgs), chunk_size)]\n idx = 0\n for map_chunk in map_chunks:\n end_idx = idx + len(map_chunk)\n map_chunk_data = masker.transform(map_chunk)\n masked_data[idx:end_idx, :] = map_chunk_data\n idx = end_idx\n\n return masked_data\n\n\ndef _add_metadata_to_dataframe(\n dataset,\n dataframe,\n metadata_field,\n target_column,\n filter_func=np.mean,\n):\n \"\"\"Add metadata from a Dataset to a DataFrame.\n\n .. versionadded:: 0.0.8\n\n This is particularly useful for kernel transformers or estimators where a given metadata field\n is necessary (e.g., ALEKernel with \"sample_size\"), but we want to just use the coordinates\n DataFrame instead of passing the full Dataset.\n\n Parameters\n ----------\n dataset : :obj:`~nimare.dataset.Dataset`\n Dataset containing study IDs and metadata to feed into dataframe.\n dataframe : :obj:`pandas.DataFrame`\n DataFrame containing study IDs, into which Dataset metadata will be merged.\n metadata_field : :obj:`str`\n Metadata field in ``dataset``.\n target_column : :obj:`str`\n Name of the column that will be added to ``dataframe``, containing information from the\n Dataset.\n filter_func : :obj:`function`, optional\n Function to apply to the metadata so that it fits as a column in a DataFrame.\n Default is ``numpy.mean``.\n\n Returns\n -------\n dataframe : :obj:`pandas.DataFrame`\n Updated DataFrame with ``target_column`` added.\n \"\"\"\n dataframe = dataframe.copy()\n\n if metadata_field in dataset.get_metadata():\n # Collect metadata from Dataset\n metadata = dataset.get_metadata(field=metadata_field, ids=dataset.ids)\n metadata = [[m] for m in metadata]\n # Create a DataFrame with the metadata\n metadata = pd.DataFrame(\n index=dataset.ids,\n data=metadata,\n columns=[metadata_field],\n )\n # Reduce the metadata (if in list/array format) to single values\n metadata[target_column] = metadata[metadata_field].apply(filter_func)\n # Merge metadata df into coordinates df\n dataframe = dataframe.merge(\n right=metadata,\n left_on=\"id\",\n right_index=True,\n sort=False,\n validate=\"many_to_one\",\n suffixes=(False, False),\n how=\"left\",\n )\n else:\n LGR.warning(\n f\"Metadata field '{metadata_field}' not found. \"\n \"Set a constant value for this field as an argument, if possible.\"\n )\n\n return dataframe\n\n\ndef _check_type(obj, clss, **kwargs):\n \"\"\"Check variable type and initialize if necessary.\n\n .. versionadded:: 0.0.8\n\n Parameters\n ----------\n obj\n Object to check and initialized if necessary.\n clss\n Target class of the object.\n kwargs\n Dictionary of keyword arguments that can be used when initializing the object.\n\n Returns\n -------\n obj\n Initialized version of the object.\n \"\"\"\n # Allow both instances and classes for the input.\n if not issubclass(type(obj), clss) and not issubclass(obj, clss):\n raise ValueError(f\"Argument {type(obj)} must be a kind of {clss}\")\n elif not inspect.isclass(obj) and kwargs:\n LGR.warning(\n f\"Argument {type(obj)} has already been initialized, so arguments \"\n f\"will be ignored: {', '.join(kwargs.keys())}\"\n )\n elif inspect.isclass(obj):\n obj = obj(**kwargs)\n return obj\n\n\ndef _boolean_unmask(data_array, bool_array):\n \"\"\"Unmask data based on a boolean array, with NaNs in empty voxels.\n\n Parameters\n ----------\n data_array : 1D or 2D :obj:`numpy.ndarray`\n Masked data array.\n bool_array : 1D :obj:`numpy.ndarray`\n Boolean mask array. Must have the same number of ``True`` entries as elements in the\n second dimension of ``data_array``.\n\n Returns\n -------\n unmasked_data : 1D or 2D :obj:`numpy.ndarray`\n Unmasked data array.\n If 1D, first dimension is the same size as the first (and only) dimension of\n ``boolean_array``.\n If 2D, first dimension is the same size as the first dimension of ``data_array``, while\n second dimension is the same size as the first (and only) dimension of ``boolean_array``.\n All elements corresponding to ``False`` values in ``boolean_array`` will have NaNs.\n \"\"\"\n assert data_array.ndim in (1, 2)\n assert bool_array.ndim == 1\n assert bool_array.sum() == data_array.shape[-1]\n\n unmasked_data = np.full(\n shape=bool_array.shape + data_array.T.shape[1:],\n fill_value=np.nan,\n dtype=data_array.dtype,\n )\n unmasked_data[bool_array] = data_array\n unmasked_data = unmasked_data.T\n return unmasked_data\n\n\n@contextlib.contextmanager\ndef tqdm_joblib(tqdm_object):\n \"\"\"Context manager to patch joblib to report into tqdm progress bar given as argument.\n\n From https://stackoverflow.com/a/58936697/2589328.\n \"\"\"\n\n class TqdmBatchCompletionCallback(joblib.parallel.BatchCompletionCallBack):\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n\n def __call__(self, *args, **kwargs):\n tqdm_object.update(n=self.batch_size)\n return super().__call__(*args, **kwargs)\n\n old_batch_callback = joblib.parallel.BatchCompletionCallBack\n joblib.parallel.BatchCompletionCallBack = TqdmBatchCompletionCallback\n try:\n yield tqdm_object\n finally:\n joblib.parallel.BatchCompletionCallBack = old_batch_callback\n tqdm_object.close()\n\n\ndef unique_rows(ar):\n \"\"\"Remove repeated rows from a 2D array.\n\n In particular, if given an array of coordinates of shape\n (Npoints, Ndim), it will remove repeated points.\n\n Parameters\n ----------\n ar : 2-D ndarray\n The input array.\n\n Returns\n -------\n ar_out : 2-D ndarray\n A copy of the input array with repeated rows removed.\n\n Raises\n ------\n ValueError : if `ar` is not two-dimensional.\n\n Notes\n -----\n The function will generate a copy of `ar` if it is not\n C-contiguous, which will negatively affect performance for large\n input arrays.\n\n This is taken from skimage. See :func:`skimage.util.unique_rows`.\n\n Examples\n --------\n >>> ar = np.array([[1, 0, 1],\n ... [0, 1, 0],\n ... [1, 0, 1]], np.uint8)\n >>> unique_rows(ar)\n array([[0, 1, 0],\n [1, 0, 1]], dtype=uint8)\n\n Copyright (C) 2019, the scikit-image team\n All rights reserved.\n \"\"\"\n if ar.ndim != 2:\n raise ValueError(\"unique_rows() only makes sense for 2D arrays, \" \"got %dd\" % ar.ndim)\n # the view in the next line only works if the array is C-contiguous\n ar = np.ascontiguousarray(ar)\n # np.unique() finds identical items in a raveled array. To make it\n # see each row as a single item, we create a view of each row as a\n # byte string of length itemsize times number of columns in `ar`\n ar_row_view = ar.view(\"|S%d\" % (ar.itemsize * ar.shape[1]))\n _, unique_row_indices = np.unique(ar_row_view, return_index=True)\n ar_out = ar[unique_row_indices]\n return ar_out\n",
"\"\"\"\n\n.. _metas_correctors:\n\n===================\nThe Corrector class\n===================\n\nHere we take a look at multiple comparisons correction in meta-analyses.\n\"\"\"\n\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom nilearn.plotting import plot_stat_map\n\n###############################################################################\n# Download data\n# -----------------------------------------------------------------------------\nfrom nimare.extract import download_nidm_pain\n\ndset_dir = download_nidm_pain()\n\n###############################################################################\n# Load Dataset\n# -----------------------------------------------------------------------------\nimport os\n\nfrom nimare.dataset import Dataset\nfrom nimare.utils import get_resource_path\n\ndset_file = os.path.join(get_resource_path(), \"nidm_pain_dset.json\")\ndset = Dataset(dset_file)\ndset.update_path(dset_dir)\n\nmask_img = dset.masker.mask_img\n\n###############################################################################\n# .. _corrector-cbma-example:\n#\n# Multiple comparisons correction in coordinate-based meta-analyses\n# -----------------------------------------------------------------------------\n# .. tip::\n# For more information multiple comparisons correction and CBMA in NiMARE,\n# see :ref:`multiple comparisons correction`.\nfrom nimare.meta.cbma.ale import ALE\n\n# First, we need to fit the Estimator to the Dataset.\nmeta = ALE(null_method=\"approximate\")\nresults = meta.fit(dset)\n\n# We can check which FWE correction methods are available for the ALE Estimator\n# with the ``inspect`` class method.\nfrom nimare.correct import FWECorrector\n\nprint(FWECorrector.inspect(results))\n\n###############################################################################\n# Apply the Corrector to the MetaResult\n# =============================================================================\n# Now that we know what FWE correction methods are available, we can use one.\n#\n# The \"montecarlo\" method is a special one that is implemented within the\n# Estimator, rather than in the Corrector.\ncorr = FWECorrector(method=\"montecarlo\", n_iters=50, n_cores=2)\ncres = corr.transform(results)\n\nDISTS_TO_PLOT = [\n \"values_desc-size_level-cluster_corr-fwe_method-montecarlo\",\n \"values_desc-mass_level-cluster_corr-fwe_method-montecarlo\",\n \"values_level-voxel_corr-fwe_method-montecarlo\",\n]\nXLABELS = [\n \"Maximum Cluster Size (Voxels)\",\n \"Maximum Cluster Mass\",\n \"Maximum Summary Statistic (ALE Value)\",\n]\n\nfig, axes = plt.subplots(figsize=(8, 8), nrows=3)\nnull_dists = cres.estimator.null_distributions_\n\nfor i_ax, dist_name in enumerate(DISTS_TO_PLOT):\n xlabel = XLABELS[i_ax]\n sns.histplot(x=null_dists[dist_name], bins=40, ax=axes[i_ax])\n axes[i_ax].set_title(dist_name)\n axes[i_ax].set_xlabel(xlabel)\n axes[i_ax].set_xlim(0, None)\n\nfig.tight_layout()\n\n###############################################################################\n# Show corrected results\n# =============================================================================\nMAPS_TO_PLOT = [\n \"z\",\n \"z_desc-size_level-cluster_corr-FWE_method-montecarlo\",\n \"z_desc-mass_level-cluster_corr-FWE_method-montecarlo\",\n \"z_level-voxel_corr-FWE_method-montecarlo\",\n]\nTITLES = [\n \"Uncorrected z-statistics\",\n \"Cluster-size FWE-corrected z-statistics\",\n \"Cluster-mass FWE-corrected z-statistics\",\n \"Voxel-level FWE-corrected z-statistics\",\n]\n\nfig, axes = plt.subplots(figsize=(8, 10), nrows=4)\n\nfor i_ax, map_name in enumerate(MAPS_TO_PLOT):\n title = TITLES[i_ax]\n plot_stat_map(\n cres.get_map(map_name),\n draw_cross=False,\n cmap=\"RdBu_r\",\n threshold=0.5,\n cut_coords=[0, 0, -8],\n figure=fig,\n axes=axes[i_ax],\n )\n axes[i_ax].set_title(title)\n\n###############################################################################\n# Multiple comparisons correction in image-based meta-analyses\n# -----------------------------------------------------------------------------\nfrom nimare.correct import FDRCorrector\nfrom nimare.meta.ibma import Stouffers\n\nmeta = Stouffers(resample=True)\nresults = meta.fit(dset)\nprint(f\"FWECorrector options: {FWECorrector.inspect(results)}\")\nprint(f\"FDRCorrector options: {FDRCorrector.inspect(results)}\")\n\n###############################################################################\n# Note that the FWECorrector does not support a \"montecarlo\" method for the\n# Stouffers Estimator.\n# This is because NiMARE does not have a Monte Carlo-based method implemented\n# for most IBMA algorithms.\n\n###############################################################################\n# Apply the Corrector to the MetaResult\n# =============================================================================\ncorr = FDRCorrector(method=\"indep\", alpha=0.05)\ncres = corr.transform(results)\n\n###############################################################################\n# Show corrected results\n# =============================================================================\nfig, axes = plt.subplots(figsize=(8, 6), nrows=2)\nplot_stat_map(\n cres.get_map(\"z\"),\n draw_cross=False,\n cmap=\"RdBu_r\",\n threshold=0.5,\n cut_coords=[0, 0, -8],\n figure=fig,\n axes=axes[0],\n)\naxes[0].set_title(\"Uncorrected z-statistics\")\nplot_stat_map(\n cres.get_map(\"z_corr-FDR_method-indep\"),\n draw_cross=False,\n cmap=\"RdBu_r\",\n threshold=0.5,\n cut_coords=[0, 0, -8],\n figure=fig,\n axes=axes[1],\n)\naxes[1].set_title(\"FDR-corrected z-statistics\")\n"
] |
[
[
"numpy.dot",
"pandas.merge",
"numpy.vstack",
"pandas.DataFrame",
"numpy.round",
"numpy.where",
"numpy.unique",
"numpy.full",
"numpy.ceil",
"numpy.ravel",
"pandas.concat",
"pandas.notnull",
"numpy.linalg.inv",
"numpy.ascontiguousarray",
"numpy.memmap",
"pandas.DataFrame.from_dict",
"numpy.array",
"numpy.abs",
"numpy.ones",
"numpy.sign",
"numpy.empty"
],
[
"matplotlib.pyplot.subplots"
]
] |
jackred/CW2_GERMAN_SIGN
|
[
"988a99d6012ae95bec778a91785c76a2ca40ba87"
] |
[
"src/preprocess.py"
] |
[
"# -*- Mode: Python; tab-width: 8; indent-tabs-mode: nil; python-indent-offset: 4 -*-\n# vim:set et sts=4 ts=4 tw=80:\n# This Source Code Form is subject to the terms of the MIT License.\n# If a copy of the ML was not distributed with this\n# file, You can obtain one at https://opensource.org/licenses/MIT\n\n# author: JackRed <jackred@tuta.io>\n\nfrom sklearn.model_selection import train_test_split\nimport numpy as np\nfrom sklearn.cluster import KMeans\nfrom skimage.exposure import match_histograms, equalize_hist\nfrom skimage.transform import resize\nfrom skimage.filters import threshold_isodata, sobel, roberts, scharr, \\\n prewitt, gaussian, median\nfrom skimage.segmentation import slic, felzenszwalb, watershed\nfrom skimage.color import label2rgb, rgb2gray # , gray2rgb\nfrom skimage.future.graph import rag_mean_color, cut_threshold\nfrom skimage.morphology import disk\nfrom skimage.filters.rank import enhance_contrast, median as fr_median, mean, \\\n autolevel\nfrom skimage.measure import block_reduce\n\nFILTER = {'s': sobel, 'r': roberts, 'p': prewitt, 'c': scharr, 'm': median,\n 'g': gaussian}\nCONTRAST = {'e': enhance_contrast, 'm': fr_median, 'a': mean, 'l': autolevel}\n# a for mean cause average, and l for autolevel cause level, of course\n\n\ndef split_data(data, train_size=0.7):\n data_train, data_test = train_test_split(data,\n shuffle=False,\n train_size=train_size)\n return data_train, data_test\n\n\ndef randomize(data, rand):\n np.random.seed(rand)\n np.random.shuffle(data)\n return data\n\n\ndef pooling(row, d):\n dim = int(len(row) ** (1/2))\n img = row.reshape(dim, dim)\n return block_reduce(img, d, func=np.max).flatten()\n\n\ndef pooling_images(data, l):\n return np.array([pooling(i, (l, l)) for i in data])\n\n\ndef resize_img(row, d):\n dim = int(len(row) ** (1/2))\n img = row.reshape(dim, dim)\n return resize(img, d).flatten()\n\n\ndef resize_img_square(row, l):\n return resize_img(row, (l, l))\n\n\ndef resize_batch(b, d):\n return np.array([resize_img_square(i, d) for i in b])\n\n\ndef mean_image(label, data):\n return np.array([x.sum(axis=0) / len(x) for x in\n [data[label == i] for i in np.unique(label)]])\n\n\ndef mean_images_global(data):\n return data.mean(0)\n\n\ndef old_segment(image, n_c):\n kmeans = KMeans(n_clusters=n_c, random_state=0).fit(image.reshape(-1, 1))\n return kmeans.labels_ * (255/(n_c-1))\n\n\ndef old_segment_images(rows, n_c):\n return np.array([old_segment(i, n_c) for i in rows])\n\n\ndef adjust_histogram(img, mean):\n return match_histograms(img, mean)\n\n\ndef adjust_histograms(data):\n mean = mean_images_global(data)\n return np.array([adjust_histogram(i, mean) for i in data])\n\n\ndef equalize_histogram(img):\n return (equalize_hist(img) * 255)\n\n\ndef equalize_histograms(data):\n return np.array([equalize_histogram(i) for i in data])\n\n\ndef binarise(img):\n try:\n th = threshold_isodata(img)\n return (img > th) * 255\n except:\n return img\n\ndef binarise_images(data):\n return np.array([binarise(i) for i in data])\n\n\ndef watershed_g(img):\n gradient = sobel(img)\n labels = watershed(gradient)\n return labels\n\n\ndef cut_thr(img, labels, n=10):\n g = rag_mean_color(img, labels)\n labels2 = cut_threshold(labels, g, n)\n return labels2\n\n\nSEGMENT = {'s': slic, 'w': watershed_g, 'f': felzenszwalb, 't': cut_thr}\n\n\ndef segment(img, s):\n dim = int(len(img) ** (1/2))\n img = img.reshape(dim, dim)\n labels = SEGMENT[s[0]](img)\n if len(s) == 2:\n labels = cut_thr(img, labels)\n return rgb2gray(label2rgb(labels, img, kind='avg')).flatten()\n\n\ndef segment_images(data, s):\n return np.array([segment(i, s) for i in data])\n\n\ndef filters(img, ed):\n dim = int(len(img) ** (1/2))\n img = img.reshape(dim, dim)\n return FILTER[ed](img).flatten()\n\n\ndef filter_images(data, ed):\n return np.array([filters(i, ed) for i in data])\n\n\ndef contrast(img, fr):\n dim = int(len(img) ** (1/2))\n img = img.reshape(dim, dim).astype(np.uint16)\n return CONTRAST[fr[0]](img, disk(fr[1])).flatten()\n\n\ndef contrast_images(data, fr):\n return np.array([contrast(i, fr) for i in data])\n\n\ndef extract_col(data, index):\n if index is not None:\n return data[:, np.unique(index)]\n else:\n return data\n"
] |
[
[
"sklearn.cluster.KMeans",
"numpy.random.seed",
"numpy.unique",
"sklearn.model_selection.train_test_split",
"numpy.random.shuffle"
]
] |
cogsys-tuebingen/uninas
|
[
"06729b9cf517ec416fb798ae387c5bd9c3a278ac"
] |
[
"uninas/training/optimizers/common.py"
] |
[
"from torch.optim.sgd import SGD\nfrom torch.optim.adam import Adam\nfrom torch.optim.rmsprop import RMSprop\nfrom uninas.utils.args import Argument\nfrom uninas.training.optimizers.abstract import WrappedOptimizer\nfrom uninas.register import Register\n\n\n@Register.optimizer()\nclass SGDOptimizer(WrappedOptimizer):\n optimizer_cls = SGD\n\n @classmethod\n def args_to_add(cls, index=None) -> [Argument]:\n \"\"\" list arguments to add to argparse when this class (or a child class) is chosen \"\"\"\n return [\n Argument('lr', default=0.01, type=float, help='learning rate'),\n Argument('momentum', default=0.9, type=float, help='momentum'),\n Argument('nesterov', default='False', type=str, help='use nesterov', is_bool=True),\n ] + super().args_to_add(index)\n\n\n@Register.optimizer()\nclass RMSPropOptimizer(WrappedOptimizer):\n optimizer_cls = RMSprop\n\n @classmethod\n def args_to_add(cls, index=None) -> [Argument]:\n \"\"\" list arguments to add to argparse when this class (or a child class) is chosen \"\"\"\n return [\n Argument('lr', default=0.01, type=float, help='learning rate'),\n Argument('alpha', default=0.99, type=float, help='alpha value'),\n Argument('eps', default=1e-8, type=float, help='epsilon value'),\n Argument('momentum', default=0.0, type=float, help='momentum'),\n Argument('centered', default='False', type=str, help='centered', is_bool=True),\n ] + super().args_to_add(index)\n\n\n@Register.optimizer()\nclass AdamOptimizer(WrappedOptimizer):\n\n @classmethod\n def optimizer_cls(cls, params=None, lr=0.01, beta1=0.0, beta2=0.0, eps=1e-8, weight_decay=1e-5, amsgrad=False):\n return Adam(params=params, lr=lr, betas=(beta1, beta2), eps=eps, weight_decay=weight_decay, amsgrad=amsgrad)\n\n @classmethod\n def args_to_add(cls, index=None) -> [Argument]:\n \"\"\" list arguments to add to argparse when this class (or a child class) is chosen \"\"\"\n return [\n Argument('lr', default=0.01, type=float, help='learning rate'),\n Argument('eps', default=1e-8, type=float, help='epsilon value'),\n Argument('beta1', default=0.9, type=float, help='beta1 value'),\n Argument('beta2', default=0.999, type=float, help='beta2 value'),\n Argument('amsgrad', default='False', type=str, help='use amsgrad', is_bool=True),\n ] + super().args_to_add(index)\n"
] |
[
[
"torch.optim.adam.Adam"
]
] |
CV-YYDS/YOLOv3
|
[
"a433064721dfc932509aaed6cb44a785b24bc768"
] |
[
"model/layers/activate.py"
] |
[
"import torch\r\nimport torch.nn as nn\r\nimport torch.nn.functional as F\r\n\r\n\r\nclass Mish(nn.Module):\r\n def __init__(self):\r\n super(Mish).__init__()\r\n\r\n def forward(self, x):\r\n x = x * (torch.tanh(F.softplus(x)))\r\n return x\r\n\r\n\r\nclass Swish(nn.Module):\r\n def __init__(self):\r\n super(Swish, self).__init__()\r\n\r\n def forward(self, x):\r\n x = x * F.sigmoid(x)\r\n return x"
] |
[
[
"torch.nn.functional.sigmoid",
"torch.nn.functional.softplus"
]
] |
antu3199/cs486-project-hanabi
|
[
"655152cea4cd2459b2a7ae036b39ad24730364af"
] |
[
"agents/rainbow/third_party/dopamine/checkpointer.py"
] |
[
"# coding=utf-8\n# Copyright 2018 The Dopamine Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"A checkpointing mechanism for Dopamine agents.\n\nThis Checkpointer expects a base directory where checkpoints for different\niterations are stored. Specifically, Checkpointer.save_checkpoint() takes in\nas input a dictionary 'data' to be pickled to disk. At each iteration, we\nwrite a file called 'cpkt.#', where # is the iteration number. The\nCheckpointer also cleans up old files, maintaining up to the CHECKPOINT_DURATION\nmost recent iterations.\n\nThe Checkpointer writes a sentinel file to indicate that checkpointing was\nglobally successful. This means that all other checkpointing activities\n(saving the Tensorflow graph, the replay buffer) should be performed *prior*\nto calling Checkpointer.save_checkpoint(). This allows the Checkpointer to\ndetect incomplete checkpoints.\n\n#### Example\n\nAfter running 10 iterations (numbered 0...9) with base_directory='/checkpoint',\nthe following files will exist:\n```\n /checkpoint/cpkt.6\n /checkpoint/cpkt.7\n /checkpoint/cpkt.8\n /checkpoint/cpkt.9\n /checkpoint/sentinel_checkpoint_complete.6\n /checkpoint/sentinel_checkpoint_complete.7\n /checkpoint/sentinel_checkpoint_complete.8\n /checkpoint/sentinel_checkpoint_complete.9\n```\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\nimport pickle\nimport tensorflow as tf\n\nCHECKPOINT_DURATION = 4\n\n\ndef get_latest_checkpoint_number(base_directory):\n \"\"\"Returns the version number of the latest completed checkpoint.\n\n Args:\n base_directory: str, directory in which to look for checkpoint files.\n\n Returns:\n int, the iteration number of the latest checkpoint, or -1 if none was found.\n \"\"\"\n glob = os.path.join(base_directory, 'sentinel_checkpoint_complete.*')\n def extract_iteration(x):\n return int(x[x.rfind('.') + 1:])\n try:\n checkpoint_files = tf.gfile.Glob(glob)\n except tf.errors.NotFoundError:\n return -1\n try:\n latest_iteration = max(extract_iteration(x) for x in checkpoint_files)\n return latest_iteration\n except ValueError:\n return -1\n\n\nclass Checkpointer(object):\n \"\"\"Class for managing checkpoints for Dopamine agents.\n \"\"\"\n\n def __init__(self, base_directory, checkpoint_file_prefix='ckpt',\n checkpoint_frequency=1):\n \"\"\"Initializes Checkpointer.\n\n Args:\n base_directory: str, directory where all checkpoints are saved/loaded.\n checkpoint_file_prefix: str, prefix to use for naming checkpoint files.\n checkpoint_frequency: int, the frequency at which to checkpoint.\n\n Raises:\n ValueError: if base_directory is empty, or not creatable.\n \"\"\"\n if not base_directory:\n raise ValueError('No path provided to Checkpointer.')\n self._checkpoint_file_prefix = checkpoint_file_prefix\n self._checkpoint_frequency = checkpoint_frequency\n self._base_directory = base_directory\n try:\n tf.gfile.MakeDirs(base_directory)\n except tf.errors.PermissionDeniedError:\n # We catch the PermissionDeniedError and issue a more useful exception.\n raise ValueError('Unable to create checkpoint path: {}.'.format(\n base_directory))\n\n def _generate_filename(self, file_prefix, iteration_number):\n \"\"\"Returns a checkpoint filename from prefix and iteration number.\"\"\"\n filename = '{}.{}'.format(file_prefix, iteration_number)\n return os.path.join(self._base_directory, filename)\n\n def _save_data_to_file(self, data, filename):\n \"\"\"Saves the given 'data' object to a file.\"\"\"\n with tf.gfile.GFile(filename, 'w') as fout:\n pickle.dump(data, fout)\n\n def save_checkpoint(self, iteration_number, data):\n \"\"\"Saves a new checkpoint at the current iteration_number.\n\n Args:\n iteration_number: int, the current iteration number for this checkpoint.\n data: Any (picklable) python object containing the data to store in the\n checkpoint.\n \"\"\"\n if iteration_number % self._checkpoint_frequency != 0:\n return\n\n filename = self._generate_filename(self._checkpoint_file_prefix,\n iteration_number)\n self._save_data_to_file(data, filename)\n filename = self._generate_filename('sentinel_checkpoint_complete',\n iteration_number)\n with tf.gfile.GFile(filename, 'wb') as fout:\n fout.write('done')\n\n self._clean_up_old_checkpoints(iteration_number)\n\n def _clean_up_old_checkpoints(self, iteration_number):\n \"\"\"Removes sufficiently old checkpoints.\"\"\"\n # After writing a the checkpoint and sentinel file, we garbage collect files\n # that are CHECKPOINT_DURATION * self._checkpoint_frequency versions old.\n stale_iteration_number = iteration_number - (self._checkpoint_frequency *\n CHECKPOINT_DURATION)\n\n if stale_iteration_number >= 0:\n stale_file = self._generate_filename(self._checkpoint_file_prefix,\n stale_iteration_number)\n stale_sentinel = self._generate_filename('sentinel_checkpoint_complete',\n stale_iteration_number)\n try:\n tf.gfile.Remove(stale_file)\n tf.gfile.Remove(stale_sentinel)\n except tf.errors.NotFoundError:\n # Ignore if file not found.\n tf.logging.info('Unable to remove {} or {}.'.format(stale_file,\n stale_sentinel))\n\n def _load_data_from_file(self, filename):\n if not tf.gfile.Exists(filename):\n return None\n with tf.gfile.GFile(filename, 'rb') as fin:\n return pickle.load(fin)\n\n def load_checkpoint(self, iteration_number):\n \"\"\"Tries to reload a checkpoint at the selected iteration number.\n\n Args:\n iteration_number: The checkpoint iteration number to try to load.\n\n Returns:\n If the checkpoint files exist, two unpickled objects that were passed in\n as data to save_checkpoint; returns None if the files do not exist.\n \"\"\"\n checkpoint_file = self._generate_filename(self._checkpoint_file_prefix,\n iteration_number)\n return self._load_data_from_file(checkpoint_file)\n"
] |
[
[
"tensorflow.gfile.Exists",
"tensorflow.gfile.GFile",
"tensorflow.gfile.MakeDirs",
"tensorflow.gfile.Glob",
"tensorflow.gfile.Remove"
]
] |
muwangshu/AverageDistance
|
[
"28e22bfb36021607be9d7900282e54b467450263"
] |
[
"avgdist/RPTinPolygon/RndPointinPolygon.py"
] |
[
"#Fast algorithm to generate random points in a polygon.\nimport shapely\nfrom ..EARCut import earcut\nfrom numpy import array, sqrt, abs, where\nfrom shapely.geometry import Polygon, Point\nfrom random import uniform, random\n\n\ndef getRndPointinPolygon(plg, count):\n \"\"\"[summary]\n\n Args:\n plg ([type]): [description]\n count ([type]): [description]\n\n Returns:\n [type]: [description]\n \"\"\"\n coordlist = list(plg.exterior.coords)[:-1]\n coords = [0 for i in range(2 * len(coordlist))]\n for i in range(len(coordlist)):\n coords[2 * i], coords[2 * i + 1] = coordlist[i]\n triangles = earcut.earcut(coords)\n\n cumulativeDistribution = array(generateDistribution(triangles, coordlist))\n pnts = []\n for i in range(count):\n rnd = random()\n index = where(cumulativeDistribution > rnd)[0][0]\n t0 = triangles[3 * index]\n t1 = triangles[3 * index + 1]\n t2 = triangles[3 * index + 2]\n p = getRPTinTriangle(coordlist[t0], coordlist[t1], coordlist[t2])\n pnts.append(Point(p[0], p[1]))\n return pnts\n\n\ndef calTrArea(a, b, c):\n \"\"\"[summary]\n\n Args:\n a ([type]): [description]\n b ([type]): [description]\n c ([type]): [description]\n\n Returns:\n [type]: [description]\n \"\"\"\n return abs(a[0] * (b[1] - c[1]) + b[0] * (c[1] - a[1]) + c[0] * (a[1] - b[1])) / 2\n\n\ndef generateDistribution(triangles, coordlist):\n \"\"\"[summary]\n\n Args:\n triangles ([type]): [description]\n coordlist ([type]): [description]\n\n Returns:\n [type]: [description]\n \"\"\"\n trArea = []\n totalArea = 0\n for i in range(len(triangles) // 3):\n t0 = triangles[3 * i]\n t1 = triangles[3 * i + 1]\n t2 = triangles[3 * i + 2]\n trArea.append(calTrArea(coordlist[t0], coordlist[t1], coordlist[t2]))\n totalArea += trArea[i]\n\n cumulativeDistribution = []\n lastValue = 0\n for i in range(len(triangles) // 3):\n nextValue = lastValue + trArea[i] / totalArea\n cumulativeDistribution.append(nextValue)\n lastValue = nextValue\n return cumulativeDistribution\n\n\ndef selectRandomTriangle(cumulativeDistribution):\n \"\"\"[summary]\n\n Args:\n cumulativeDistribution ([type]): [description]\n\n Returns:\n [type]: [description]\n \"\"\"\n rnd = random()\n index = list(filter(lambda i: i > 0.6, cumulativeDistribution))[0]\n return triangles[index]\n\n\ndef getRPTinTriangle(a, b, c):\n \"\"\"[summary]\n\n Args:\n a ([type]): [description]\n b ([type]): [description]\n c ([type]): [description]\n\n Returns:\n [type]: [description]\n \"\"\"\n # make basis vectors from a->b and a->c\n u = (b[0] - a[0], b[1] - a[1])\n v = (c[0] - a[0], c[1] - a[1])\n\n # pick a random point in the unit square\n unit = (random(), random())\n\n # if the point is outside the triangle, remap it inside\n # by mirroring it along the diagonal\n if unit[0] + unit[1] > 1:\n unit = (1 - unit[1], 1 - unit[0])\n\n # now transform it to fit the basis\n return (unit[0] * u[0] + unit[1] * v[0] + a[0], unit[0] * u[1] + unit[1] * v[1] + a[1])\n\n\nif __name__ == \"__main__\":\n\n y1 = sqrt(4 - 0.05**2)\n plg = Polygon([(-0.05, y1), (0.05, y1), (0.05, y1 - 0.01), (0, y1 - 0.01), (0, 1.01), (0.05, 1.01),\n (0.05, 1), (-0.05, 1), (-0.05, 1.01), (0, 1.01), (0, y1 - 0.01), (-0.05, y1 - 0.01)])\n coordlist = list(plg.exterior.coords)[:-1]\n coords = [0 for i in range(2 * len(coordlist))]\n for i in range(len(coordlist)):\n coords[2 * i], coords[2 * i + 1] = coordlist[i]\n triangles = earcut.earcut(coords)\n\n cumulativeDistribution = array(generateDistribution(triangles, coordlist))\n for i in range(500):\n rnd = random()\n index = where(cumulativeDistribution > rnd)[0][0]\n t0 = triangles[3 * index]\n t1 = triangles[3 * index + 1]\n t2 = triangles[3 * index + 2]\n print(getRPTinTriangle(coordlist[t0], coordlist[t1], coordlist[t2]))\n"
] |
[
[
"numpy.abs",
"numpy.where",
"numpy.sqrt"
]
] |
madpilot/flatcam
|
[
"82169e73225c9ffdb97cc67d5f243eafbe734f1a"
] |
[
"PlotCanvas.py"
] |
[
"# ###########################################################\n# FlatCAM: 2D Post-processing for Manufacturing #\n# http://caram.cl/software/flatcam #\n# Author: Juan Pablo Caram (c) #\n# Date: 2/5/2014 #\n# MIT Licence #\n# ###########################################################\n\nfrom PyQt5 import QtCore\nimport FlatCAMApp\nimport logging\n\n# Prevent conflict with Qt5 and above.\nfrom matplotlib import use as mpl_use\n\nmpl_use(\"Qt5Agg\")\n\nfrom matplotlib.figure import Figure\nfrom matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas\nfrom matplotlib.backends.backend_agg import FigureCanvasAgg\n\nlog = logging.getLogger('base')\n\n\nclass CanvasCache(QtCore.QObject):\n \"\"\"\n\n Case story #1:\n\n 1) No objects in the project.\n 2) Object is created (new_object() emits object_created(obj)).\n on_object_created() adds (i) object to collection and emits\n (ii) new_object_available() then calls (iii) object.plot()\n 3) object.plot() creates axes if necessary on\n app.collection.figure. Then plots on it.\n 4) Plots on a cache-size canvas (in background).\n 5) Plot completes. Bitmap is generated.\n 6) Visible canvas is painted.\n\n \"\"\"\n\n # Signals:\n # A bitmap is ready to be displayed.\n new_screen = QtCore.pyqtSignal()\n\n def __init__(self, plotcanvas, app, dpi=50):\n super(CanvasCache, self).__init__()\n\n self.app = app\n\n self.plotcanvas = plotcanvas\n self.dpi = dpi\n\n self.figure = Figure(dpi=dpi)\n\n self.axes = self.figure.add_axes([0.0, 0.0, 1.0, 1.0], alpha=1.0)\n self.axes.set_frame_on(False)\n self.axes.set_xticks([])\n self.axes.set_yticks([])\n\n self.canvas = FigureCanvasAgg(self.figure)\n\n self.cache = None\n\n def run(self):\n log.debug(\"CanvasCache Thread Started!\")\n\n self.plotcanvas.update_screen_request.connect(self.on_update_req)\n\n self.app.new_object_available.connect(self.on_new_object_available)\n\n def on_update_req(self, extents):\n \"\"\"\n Event handler for an updated display request.\n\n :param extents: [xmin, xmax, ymin, ymax, zoom(optional)]\n \"\"\"\n\n # log.debug(\"Canvas update requested: %s\" % str(extents))\n\n # Note: This information below might be out of date. Establish\n # a protocol regarding when to change the canvas in the main\n # thread and when to check these values here in the background,\n # or pass this data in the signal (safer).\n # log.debug(\"Size: %s [px]\" % str(self.plotcanvas.get_axes_pixelsize()))\n # log.debug(\"Density: %s [units/px]\" % str(self.plotcanvas.get_density()))\n\n # Move the requested screen portion to the main thread\n # and inform about the update:\n\n self.new_screen.emit()\n\n # Continue to update the cache.\n\n def on_new_object_available(self):\n log.debug(\"A new object is available. Should plot it!\")\n\n\nclass PlotCanvas(QtCore.QObject):\n \"\"\"\n Class handling the plotting area in the application.\n \"\"\"\n\n # Signals:\n # Request for new bitmap to display. The parameter\n # is a list with [xmin, xmax, ymin, ymax, zoom(optional)]\n update_screen_request = QtCore.pyqtSignal(list)\n\n def __init__(self, container, app):\n \"\"\"\n The constructor configures the Matplotlib figure that\n will contain all plots, creates the base axes and connects\n events to the plotting area.\n\n :param container: The parent container in which to draw plots.\n :rtype: PlotCanvas\n \"\"\"\n\n super(PlotCanvas, self).__init__()\n\n self.app = app\n\n # Options\n self.x_margin = 15 # pixels\n self.y_margin = 25 # Pixels\n\n # Parent container\n self.container = container\n\n # Plots go onto a single matplotlib.figure\n self.figure = Figure(dpi=50) # TODO: dpi needed?\n self.figure.patch.set_visible(False)\n\n # These axes show the ticks and grid. No plotting done here.\n # New axes must have a label, otherwise mpl returns an existing one.\n self.axes = self.figure.add_axes([0.05, 0.05, 0.9, 0.9], label=\"base\", alpha=0.0)\n self.axes.set_aspect(1)\n self.axes.grid(True)\n self.axes.axhline(color='Black')\n self.axes.axvline(color='Black')\n\n # The canvas is the top level container (FigureCanvasQTAgg)\n self.canvas = FigureCanvas(self.figure)\n # self.canvas.setFocusPolicy(QtCore.Qt.ClickFocus)\n # self.canvas.setFocus()\n\n # self.canvas.set_hexpand(1)\n # self.canvas.set_vexpand(1)\n # self.canvas.set_can_focus(True) # For key press\n\n # Attach to parent\n # self.container.attach(self.canvas, 0, 0, 600, 400) # TODO: Height and width are num. columns??\n self.container.addWidget(self.canvas) # Qt\n\n # Copy a bitmap of the canvas for quick animation.\n # Update every time the canvas is re-drawn.\n self.background = self.canvas.copy_from_bbox(self.axes.bbox)\n\n # ## Bitmap Cache\n self.cache = CanvasCache(self, self.app)\n self.cache_thread = QtCore.QThread()\n self.cache.moveToThread(self.cache_thread)\n # super(PlotCanvas, self).connect(self.cache_thread, QtCore.SIGNAL(\"started()\"), self.cache.run)\n self.cache_thread.started.connect(self.cache.run)\n # self.connect()\n self.cache_thread.start()\n self.cache.new_screen.connect(self.on_new_screen)\n\n # Events\n self.canvas.mpl_connect('button_press_event', self.on_mouse_press)\n self.canvas.mpl_connect('button_release_event', self.on_mouse_release)\n self.canvas.mpl_connect('motion_notify_event', self.on_mouse_move)\n # self.canvas.connect('configure-event', self.auto_adjust_axes)\n self.canvas.mpl_connect('resize_event', self.auto_adjust_axes)\n # self.canvas.add_events(Gdk.EventMask.SMOOTH_SCROLL_MASK)\n # self.canvas.connect(\"scroll-event\", self.on_scroll)\n self.canvas.mpl_connect('scroll_event', self.on_scroll)\n self.canvas.mpl_connect('key_press_event', self.on_key_down)\n self.canvas.mpl_connect('key_release_event', self.on_key_up)\n self.canvas.mpl_connect('draw_event', self.on_draw)\n\n self.mouse = [0, 0]\n self.key = None\n\n self.pan_axes = []\n self.panning = False\n\n def on_new_screen(self):\n\n # log.debug(\"Cache updated the screen!\")\n pass\n\n def on_key_down(self, event):\n \"\"\"\n\n :param event:\n :return:\n \"\"\"\n FlatCAMApp.App.log.debug('on_key_down(): ' + str(event.key))\n self.key = event.key\n\n def on_key_up(self, event):\n \"\"\"\n\n :param event:\n :return:\n \"\"\"\n self.key = None\n\n def mpl_connect(self, event_name, callback):\n \"\"\"\n Attach an event handler to the canvas through the Matplotlib interface.\n\n :param event_name: Name of the event\n :type event_name: str\n :param callback: Function to call\n :type callback: func\n :return: Connection id\n :rtype: int\n \"\"\"\n return self.canvas.mpl_connect(event_name, callback)\n\n def mpl_disconnect(self, cid):\n \"\"\"\n Disconnect callback with the give id.\n :param cid: Callback id.\n :return: None\n \"\"\"\n self.canvas.mpl_disconnect(cid)\n\n def connect(self, event_name, callback):\n \"\"\"\n Attach an event handler to the canvas through the native Qt interface.\n\n :param event_name: Name of the event\n :type event_name: str\n :param callback: Function to call\n :type callback: function\n :return: Nothing\n \"\"\"\n self.canvas.connect(event_name, callback)\n\n def clear(self):\n \"\"\"\n Clears axes and figure.\n\n :return: None\n \"\"\"\n\n # Clear\n self.axes.cla()\n try:\n self.figure.clf()\n except KeyError:\n FlatCAMApp.App.log.warning(\"KeyError in MPL figure.clf()\")\n\n # Re-build\n self.figure.add_axes(self.axes)\n self.axes.set_aspect(1)\n self.axes.grid(True)\n\n # Re-draw\n self.canvas.draw_idle()\n\n def adjust_axes(self, xmin, ymin, xmax, ymax):\n \"\"\"\n Adjusts all axes while maintaining the use of the whole canvas\n and an aspect ratio to 1:1 between x and y axes. The parameters are an original\n request that will be modified to fit these restrictions.\n\n :param xmin: Requested minimum value for the X axis.\n :type xmin: float\n :param ymin: Requested minimum value for the Y axis.\n :type ymin: float\n :param xmax: Requested maximum value for the X axis.\n :type xmax: float\n :param ymax: Requested maximum value for the Y axis.\n :type ymax: float\n :return: None\n \"\"\"\n\n # FlatCAMApp.App.log.debug(\"PC.adjust_axes()\")\n\n width = xmax - xmin\n height = ymax - ymin\n try:\n r = width / height\n except ZeroDivisionError:\n FlatCAMApp.App.log.error(\"Height is %f\" % height)\n return\n canvas_w, canvas_h = self.canvas.get_width_height()\n canvas_r = float(canvas_w) / canvas_h\n x_ratio = float(self.x_margin) / canvas_w\n y_ratio = float(self.y_margin) / canvas_h\n\n if r > canvas_r:\n ycenter = (ymin + ymax) / 2.0\n newheight = height * r / canvas_r\n ymin = ycenter - newheight / 2.0\n ymax = ycenter + newheight / 2.0\n else:\n xcenter = (xmax + xmin) / 2.0\n newwidth = width * canvas_r / r\n xmin = xcenter - newwidth / 2.0\n xmax = xcenter + newwidth / 2.0\n\n # Adjust axes\n for ax in self.figure.get_axes():\n if ax._label != 'base':\n ax.set_frame_on(False) # No frame\n ax.set_xticks([]) # No tick\n ax.set_yticks([]) # No ticks\n ax.patch.set_visible(False) # No background\n ax.set_aspect(1)\n ax.set_xlim((xmin, xmax))\n ax.set_ylim((ymin, ymax))\n ax.set_position([x_ratio, y_ratio, 1 - 2 * x_ratio, 1 - 2 * y_ratio])\n\n # Sync re-draw to proper paint on form resize\n self.canvas.draw()\n\n # #### Temporary place-holder for cached update #####\n self.update_screen_request.emit([0, 0, 0, 0, 0])\n\n def auto_adjust_axes(self, *args):\n \"\"\"\n Calls ``adjust_axes()`` using the extents of the base axes.\n\n :rtype : None\n :return: None\n \"\"\"\n\n xmin, xmax = self.axes.get_xlim()\n ymin, ymax = self.axes.get_ylim()\n self.adjust_axes(xmin, ymin, xmax, ymax)\n\n def zoom(self, factor, center=None):\n \"\"\"\n Zooms the plot by factor around a given\n center point. Takes care of re-drawing.\n\n :param factor: Number by which to scale the plot.\n :type factor: float\n :param center: Coordinates [x, y] of the point around which to scale the plot.\n :type center: list\n :return: None\n \"\"\"\n\n xmin, xmax = self.axes.get_xlim()\n ymin, ymax = self.axes.get_ylim()\n width = xmax - xmin\n height = ymax - ymin\n\n if center is None or center == [None, None]:\n center = [(xmin + xmax) / 2.0, (ymin + ymax) / 2.0]\n\n # For keeping the point at the pointer location\n relx = (xmax - center[0]) / width\n rely = (ymax - center[1]) / height\n\n new_width = width / factor\n new_height = height / factor\n\n xmin = center[0] - new_width * (1 - relx)\n xmax = center[0] + new_width * relx\n ymin = center[1] - new_height * (1 - rely)\n ymax = center[1] + new_height * rely\n\n # Adjust axes\n for ax in self.figure.get_axes():\n ax.set_xlim((xmin, xmax))\n ax.set_ylim((ymin, ymax))\n\n # Async re-draw\n self.canvas.draw_idle()\n\n # #### Temporary place-holder for cached update #####\n self.update_screen_request.emit([0, 0, 0, 0, 0])\n\n def pan(self, x, y):\n xmin, xmax = self.axes.get_xlim()\n ymin, ymax = self.axes.get_ylim()\n width = xmax - xmin\n height = ymax - ymin\n\n # Adjust axes\n for ax in self.figure.get_axes():\n ax.set_xlim((xmin + x * width, xmax + x * width))\n ax.set_ylim((ymin + y * height, ymax + y * height))\n\n # Re-draw\n self.canvas.draw_idle()\n\n # #### Temporary place-holder for cached update #####\n self.update_screen_request.emit([0, 0, 0, 0, 0])\n\n def new_axes(self, name):\n \"\"\"\n Creates and returns an Axes object attached to this object's Figure.\n\n :param name: Unique label for the axes.\n :return: Axes attached to the figure.\n :rtype: Axes\n \"\"\"\n\n return self.figure.add_axes([0.05, 0.05, 0.9, 0.9], label=name)\n\n def on_scroll(self, event):\n \"\"\"\n Scroll event handler.\n\n :param event: Event object containing the event information.\n :return: None\n \"\"\"\n\n # So it can receive key presses\n # self.canvas.grab_focus()\n self.canvas.setFocus()\n\n # Event info\n # z, direction = event.get_scroll_direction()\n\n if self.key is None:\n\n if event.button == 'up':\n self.zoom(1.5, self.mouse)\n else:\n self.zoom(1 / 1.5, self.mouse)\n return\n\n if self.key == 'shift':\n\n if event.button == 'up':\n self.pan(0.3, 0)\n else:\n self.pan(-0.3, 0)\n return\n\n if self.key == 'control':\n\n if event.button == 'up':\n self.pan(0, 0.3)\n else:\n self.pan(0, -0.3)\n return\n\n def on_mouse_press(self, event):\n\n # Check for middle mouse button press\n if event.button == self.app.mouse_pan_button:\n\n # Prepare axes for pan (using 'matplotlib' pan function)\n self.pan_axes = []\n for a in self.figure.get_axes():\n if (event.x is not None and event.y is not None and a.in_axes(event) and\n a.get_navigate() and a.can_pan()):\n a.start_pan(event.x, event.y, 1)\n self.pan_axes.append(a)\n\n # Set pan view flag\n if len(self.pan_axes) > 0:\n self.panning = True\n\n def on_mouse_release(self, event):\n\n # Check for middle mouse button release to complete pan procedure\n if event.button == self.app.mouse_pan_button:\n for a in self.pan_axes:\n a.end_pan()\n\n # Clear pan flag\n self.panning = False\n\n def on_mouse_move(self, event):\n \"\"\"\n Mouse movement event hadler. Stores the coordinates. Updates view on pan.\n\n :param event: Contains information about the event.\n :return: None\n \"\"\"\n self.mouse = [event.xdata, event.ydata]\n\n # Update pan view on mouse move\n if self.panning is True:\n for a in self.pan_axes:\n a.drag_pan(1, event.key, event.x, event.y)\n\n # Async re-draw (redraws only on thread idle state, uses timer on backend)\n self.canvas.draw_idle()\n\n # #### Temporary place-holder for cached update #####\n self.update_screen_request.emit([0, 0, 0, 0, 0])\n\n def on_draw(self, renderer):\n\n # Store background on canvas redraw\n self.background = self.canvas.copy_from_bbox(self.axes.bbox)\n\n def get_axes_pixelsize(self):\n \"\"\"\n Axes size in pixels.\n\n :return: Pixel width and height\n :rtype: tuple\n \"\"\"\n bbox = self.axes.get_window_extent().transformed(self.figure.dpi_scale_trans.inverted())\n width, height = bbox.width, bbox.height\n width *= self.figure.dpi\n height *= self.figure.dpi\n return width, height\n\n def get_density(self):\n \"\"\"\n Returns unit length per pixel on horizontal\n and vertical axes.\n\n :return: X and Y density\n :rtype: tuple\n \"\"\"\n xpx, ypx = self.get_axes_pixelsize()\n\n xmin, xmax = self.axes.get_xlim()\n ymin, ymax = self.axes.get_ylim()\n width = xmax - xmin\n height = ymax - ymin\n\n return width / xpx, height / ypx\n"
] |
[
[
"matplotlib.backends.backend_agg.FigureCanvasAgg",
"matplotlib.use",
"matplotlib.backends.backend_qt5agg.FigureCanvasQTAgg",
"matplotlib.figure.Figure"
]
] |
dioph/Light-Curve
|
[
"92693d92d74bd2e5ceaa03f3cc8d24c6ceb9a4ca"
] |
[
"litecurve/cleanest.py"
] |
[
"import numpy as np\nfrom astropy.stats import LombScargle as ls\nfrom matplotlib import pyplot as plt\n\n\ndef cleanest(x, y, n=1):\n '''\n removes sequentially the n first frequencies from y(x) lightcurve\n returns cleanest lightcurve y(x) and its periodogram a2\n '''\n p = np.linspace(0.5, 50.5, 1001)\n f = 1. / p\n for i in range(n):\n #y /= max(y)\n a1 = ls(x, y).power(f)\n bf = f[np.argmax(a1)]\n print('REMOVENDO {0:.2f}'.format(1/bf))\n yf = ls(x, y).model(x, bf)\n d = y - yf + 1\n a2 = ls(x, d).power(f)\n plt.subplot(n+1, 2, 2*i+1)\n plt.plot(x, y, 'r')\n plt.plot(x, yf, 'k')\n\n plt.subplot(n+1, 2, 2*i+2)\n plt.ylim([0.0, 1.0])\n plt.plot(p, a1, 'b')\n \n y = d\n else:\n plt.subplot(n+1, 2, 2*n+1)\n plt.plot(x, y, 'r')\n plt.subplot(n+1, 2, 2*n+2)\n plt.ylim([0.0, 1.0])\n plt.plot(p, a2, 'b')\n plt.show()\n return y, a2\n\n\ndef cleany(x, y, n=1):\n '''\n removes the nth best frequency from y(x) lightcurve\n returns new d(x) lightcurve and its periodogram a2\n '''\n p = np.linspace(0.5, 50.5, 1001)\n f = 1. / p\n a = ls(x, y).power(f)\n y2 = y\n for i in range(n):\n a1 = ls(x, y).power(f)\n bf = f[np.argmax(a1)]\n print('REMOVENDO {0:.2f}'.format(1/bf))\n yf = ls(x, y).model(x, bf)\n d = y - yf + 1\n a2 = ls(x, d).power(f)\n y = d \n else:\n plt.subplot(221)\n plt.plot(x, y2, 'r')\n plt.plot(x, yf, 'k')\n plt.subplot(222)\n plt.ylim([0.0, 1.0])\n plt.plot(p, a, 'b')\n d = y2 - yf + 1\n a2 = ls(x, d).power(f)\n plt.subplot(223)\n plt.plot(x, d, 'r')\n plt.subplot(224)\n plt.ylim([0.0, 1.0])\n plt.plot(p, a2, 'b')\n plt.show()\n return d, a2\n\n\ndef join(x, y, n=1):\n '''\n joins n first frequencies in y(x) lightcurve\n returns joined y2(x) lightcurve and array bp of length n with best periods\n '''\n p = np.linspace(0.5, 50.5, 1001)\n f = 1. / p\n a = ls(x, y).power(f)\n plt.subplot(221)\n plt.plot(x, y, 'r')\n y2 = np.ones(len(y))\n bp = []\n for i in range(n):\n a1 = ls(x, y).power(f)\n bf = f[np.argmax(a1)]\n print('REMOVENDO {0:.2f}'.format(1/bf))\n bp.append(1/bf)\n yf = ls(x, y).model(x, bf)\n plt.plot(x, yf, 'k')\n d = y - yf + 1\n a2 = ls(x, d).power(f)\n y = d\n y2 += yf - 1\n else:\n plt.subplot(222)\n plt.ylim([0.0, 1.0])\n plt.plot(p, a, 'b')\n a2 = ls(x, y2).power(f)\n plt.subplot(223)\n plt.plot(x, y2, 'r')\n plt.subplot(224)\n plt.ylim([0.0, 1.0])\n plt.plot(p, a2, 'b')\n plt.show()\n return y2, bp\n"
] |
[
[
"numpy.linspace",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.subplot",
"numpy.argmax",
"matplotlib.pyplot.show"
]
] |
Gjacquenot/sktime-dl
|
[
"e519bf5983f9ed60b04b0d14f4fe3fa049a82f04"
] |
[
"sktime_dl/tests/test_classifiers.py"
] |
[
"from sktime.datasets import load_basic_motions\nfrom sktime.datasets import load_italy_power_demand\n\nfrom sktime_dl.classification import LSTMFCNClassifier\nfrom sktime_dl.classification import CNTCClassifier\nfrom sktime_dl.utils.model_lists import SMALL_NB_EPOCHS\nfrom sktime_dl.utils.model_lists import construct_all_classifiers\n\n\ndef test_basic_univariate(network=CNTCClassifier(nb_epochs=SMALL_NB_EPOCHS)):\n \"\"\"\n just a super basic test with gunpoint,\n load data,\n construct classifier,\n fit,\n score\n \"\"\"\n\n print(\"Start test_basic()\")\n\n X_train, y_train = load_italy_power_demand(split=\"train\", return_X_y=True)\n X_test, y_test = load_italy_power_demand(split=\"test\", return_X_y=True)\n\n network.fit(X_train[:10], y_train[:10])\n\n print(network.score(X_test[:10], y_test[:10]))\n print(\"End test_basic()\")\n\n\ndef test_pipeline(network=CNTCClassifier(nb_epochs=SMALL_NB_EPOCHS)):\n \"\"\"\n slightly more generalised test with sktime pipelines\n load data,\n construct pipeline with classifier,\n fit,\n score\n \"\"\"\n\n print(\"Start test_pipeline()\")\n\n from sklearn.pipeline import Pipeline\n\n # just a simple (useless) pipeline for the purposes of testing\n # that the keras network is compatible with that system\n steps = [(\"clf\", network)]\n clf = Pipeline(steps)\n\n X_train, y_train = load_italy_power_demand(split=\"train\", return_X_y=True)\n X_test, y_test = load_italy_power_demand(split=\"test\", return_X_y=True)\n\n clf.fit(X_train[:10], y_train[:10])\n\n print(clf.score(X_test[:10], y_test[:10]))\n print(\"End test_pipeline()\")\n\n\ndef test_highLevelsktime(network=LSTMFCNClassifier(nb_epochs=SMALL_NB_EPOCHS)):\n \"\"\"\n truly generalised test with sktime tasks/strategies\n load data, build task\n construct classifier, build strategy\n fit,\n score\n \"\"\"\n\n print(\"start test_highLevelsktime()\")\n\n from sktime.benchmarking.tasks import TSCTask\n from sktime.benchmarking.strategies import TSCStrategy\n from sklearn.metrics import accuracy_score\n\n train = load_italy_power_demand(split=\"train\")\n test = load_italy_power_demand(split=\"test\")\n task = TSCTask(target=\"class_val\", metadata=train)\n\n strategy = TSCStrategy(network)\n strategy.fit(task, train.iloc[:10])\n\n y_pred = strategy.predict(test.iloc[:10])\n y_test = test.iloc[:10][task.target]\n print(accuracy_score(y_test, y_pred))\n\n print(\"End test_highLevelsktime()\")\n\n\ndef test_basic_multivariate(network=CNTCClassifier(nb_epochs=SMALL_NB_EPOCHS)):\n \"\"\"\n just a super basic test with basicmotions,\n load data,\n construct classifier,\n fit,\n score\n \"\"\"\n print(\"Start test_multivariate()\")\n X_train, y_train = load_basic_motions(split=\"train\", return_X_y=True)\n X_test, y_test = load_basic_motions(split=\"test\", return_X_y=True)\n\n network.fit(X_train, y_train)\n\n print(network.score(X_test, y_test))\n print(\"End test_multivariate()\")\n\n\ndef test_all_networks():\n for name, network in construct_all_classifiers(SMALL_NB_EPOCHS).items():\n print(\"\\n\\t\\t\" + name + \" testing started\")\n # test_basic_univariate(network)\n test_basic_multivariate(network)\n # test_pipeline(network)\n test_highLevelsktime(network)\n print(\"\\t\\t\" + name + \" testing finished\")\n\n\nif __name__ == \"__main__\":\n test_all_networks()\n"
] |
[
[
"sklearn.pipeline.Pipeline",
"sklearn.metrics.accuracy_score"
]
] |
haerynkim/bme590final
|
[
"78ce4c54dc7a2be6fe17cf55471f105dc53547de"
] |
[
"server.py"
] |
[
"from flask import Flask, jsonify, request\nfrom pymodm import connect\nfrom pymodm import MongoModel, fields\nimport datetime\nimport base64\nimport io as io2\nimport numpy as np\nfrom skimage import io as im\nfrom skimage import io, exposure\nfrom PIL import Image\nimport logging\nlogging.basicConfig(filename='log.txt', level=logging.DEBUG, filemode='w')\n\napp = Flask(__name__)\nconnect(\"mongodb://bme590:Dukebm3^@ds253889.mlab.com:53889/imageprocessor\")\n\n\nclass ImageDB(MongoModel):\n \"\"\"\n\n This class initializes the stored data fields for the image processor\n MongoDB database.\n\n Attributes:\n patient_id (str): unique patient number.\n original (list): associated original image for each upload\n histogram_count (int): number of times histogram\n equalization was conducted.\n contrast_count (int): number of times contrast stretching\n was conducted.\n log_count (int): number of times log compression\n was conducted.\n reverse_count (int): number of times reverse video\n was conducted.\n images (list): list of original image and processed images.\n processor (list): list of completed processor actions.\n images_time_stamp (list): list of timestamps of completed\n processor actions.\n notes (list): extraneous notes provided by user.\n\n \"\"\"\n patient_id = fields.CharField(primary_key=True)\n original = fields.ListField()\n histogram_count = fields.IntegerField()\n contrast_count = fields.IntegerField()\n log_count = fields.IntegerField()\n reverse_count = fields.IntegerField()\n images = fields.ListField()\n processor = fields.ListField()\n images_time_stamp = fields.ListField()\n notes = fields.ListField()\n\n\n@app.route(\"/\", methods=[\"GET\"])\ndef greeting():\n \"\"\"\n\n Returns \"Welcome to the image processor\"\n and confirms connection with the web server.\n\n Returns:\n (str): welcome: \"Welcome to the image processor\"\n\n \"\"\"\n\n welcome = \"Welcome to the image processor!\"\n return jsonify(welcome), 200\n\n\ndef add_new_patient(patient_id, original_file):\n \"\"\"\n\n Adds a new patient to the image processor\n and initializes image processor counts.\n\n Returns:\n (str): confirmation of new patient's\n initialization\n\n \"\"\"\n patient = ImageDB(int(format(patient_id)),\n histogram_count=0,\n contrast_count=0,\n log_count=0,\n reverse_count=0)\n patient.save()\n try:\n patient.original.append(original_file)\n except AttributeError:\n patient.original = original_file\n patient.save()\n new_patient = 'New Patient Initialized with ID: ' + str(format(patient_id))\n return print(new_patient), 200\n\n\n@app.route(\"/data/all/<patient_id>\", methods=[\"GET\"])\ndef get_all_data(patient_id):\n \"\"\"\n\n Returns stored counts information for a patient\n as a JSON dictionary\n\n Args:\n patient_id (str): string specifying patient id.\n\n Returns:\n (dict): dict_array: dictionary of all stored data\n\n \"\"\"\n try:\n u = ImageDB.objects.raw({\"_id\": str(patient_id)}).first()\n dict_array = {\n \"original\": u.original,\n \"histogram_count\": u.histogram_count,\n \"contrast_count\": u.contrast_count,\n \"log_count\": u.log_count,\n \"reverse_count\": u.reverse_count,\n \"images\": u.images,\n \"processor\": u.processor,\n \"images_time_stamp\": u.images_time_stamp,\n \"notes\": u.notes,\n }\n except ImageDB.DoesNotExist:\n dict_array = 'DNE'\n return jsonify(dict_array), 200\n\n\n@app.route(\"/data/stack/<patient_id>\", methods=[\"GET\"])\ndef get_stack(patient_id):\n \"\"\"\n\n Returns a list of all images processed for a\n specified patient ID\n\n Args:\n patient_id (str): usually patient mrn.\n\n Returns:\n (dict): dict_array: dictionary containing list of images.\n\n \"\"\"\n try:\n u = ImageDB.objects.raw({\"_id\": str(format(patient_id))}).first()\n dict_array = {\n \"images\": u.images,\n }\n except ImageDB.DoesNotExist:\n dict_array = 'DNE'\n return jsonify(dict_array), 200\n\n\n@app.route(\"/data/<patient_id>\", methods=[\"GET\"])\ndef get_data(patient_id):\n \"\"\"\n\n Returns the stored image processing counts for a\n patient as a JSON dictionary\n\n Args:\n patient_id (str): string specifying patient id.\n\n Returns:\n (dict): dict_array: dictionary of image processor counts.\n\n \"\"\"\n try:\n u = ImageDB.objects.raw({\"_id\": str(patient_id)}).first()\n dict_array = {\n \"histogram_count\": u.histogram_count,\n \"contrast_count\": u.contrast_count,\n \"log_count\": u.log_count,\n \"reverse_count\": u.reverse_count,\n }\n except ImageDB.DoesNotExist:\n dict_array = 'DNE'\n return jsonify(dict_array), 200\n\n\n@app.route(\"/data/last/<patient_id>\", methods=[\"GET\"])\ndef get_last(patient_id):\n \"\"\"\n\n Returns the original and most recent images in an image\n processing tree.\n\n Args:\n patient_id (str): string specifying patient id.\n\n Returns:\n (dict): dict_array: dictionary of images.\n\n \"\"\"\n try:\n u = ImageDB.objects.raw({\"_id\": str(patient_id)}).first()\n dict_array = {\n \"original\": u.original[0],\n \"last_process\": u.images[-1],\n }\n except ImageDB.DoesNotExist:\n dict_array = 'DNE'\n return jsonify(dict_array), 200\n\n\n@app.route(\"/new_image\", methods=[\"POST\"])\ndef new_image():\n \"\"\"\n\n Receives a JSON request with an image and\n applies the specified image processing algorithm.\n\n Args:\n patient_id (str): specifies patient id.\n process_id (str): specifies type of algorithm.\n image_file (str): image as b64 string.\n\n Returns:\n (str): confirmation: upload confirmation of image\n\n \"\"\"\n r = request.get_json()\n patient_id = r['patient_id']\n process_id = r['process_id']\n image_file_encoded = r['image_file']\n notes = r['notes']\n original = r['original']\n image_file = decode_b64_image(image_file_encoded)\n try:\n patient = ImageDB.objects.raw({\"_id\": str(patient_id)}).first()\n except ImageDB.DoesNotExist:\n print('Could Not find user')\n new = add_new_patient(patient_id, image_file)\n logging.debug(new)\n if process_id is 1:\n processor = 'Histogram Equalization'\n patient.histogram_count += 1\n processed_image = histogram_equalization(image_file)\n logging.debug(processor + ' was conducted')\n elif process_id is 2:\n processor = 'Contrast Switch'\n patient.contrast_count += 1\n processed_image = contrast_stretch(image_file)\n logging.debug(processor + ' was conducted')\n elif process_id is 3:\n processor = 'Log Compression'\n patient.log_count += 1\n processed_image = log_compression(image_file)\n logging.debug(processor + ' was conducted')\n elif process_id is 4:\n processor = 'Reverse Video'\n patient.reverse_count += 1\n processed_image = reverse_video(image_file)\n logging.debug(processor + ' was conducted')\n elif process_id is 0:\n processor = 'Raw Image'\n processed_image = image_file\n logging.debug(processor)\n else:\n return jsonify('Not a valid ID')\n try:\n patient.original.append(original)\n except AttributeError:\n patient.original = original\n patient.save()\n out = encode_file_as_b64(processed_image)\n save_image(patient_id, processor, out, notes)\n return jsonify(out), 200\n\n\ndef save_image(patient_id, processor, image_file, notes):\n \"\"\"\n\n This function updates the database by appending an image,\n processor type, timestamp, and notes for a specific patient_id.\n\n Args:\n patient_id (str): specifies patient id.\n processor (str): specifies type of algorithm.\n image_file (str): processed image file to be saved.\n notes (str): Any notes the user would like additionally saved.\n\n Returns:\n\n \"\"\"\n patient = ImageDB.objects.raw({\"_id\": str(patient_id)}).first()\n try:\n patient.images.append(image_file)\n except AttributeError:\n patient.images = image_file\n try:\n patient.images_time_stamp.append(datetime.datetime.now())\n except AttributeError:\n patient.images_time_stamp = datetime.datetime.now()\n try:\n patient.processor.append(processor)\n except AttributeError:\n patient.processor = processor\n try:\n patient.notes.append(notes)\n except AttributeError:\n patient.notes = notes\n patient.save()\n logging.debug('Patient saved')\n return\n\n\ndef decode_b64_image(base64_string):\n \"\"\"\n\n This function takes in a base64 string and decodes it into an\n image array.\n\n Args:\n base64_string (str): specifies base64\n representation of an image.\n\n Returns:\n PIL image object (array): reconstructed_image\n\n \"\"\"\n temp = open(\"temporary.png\", \"wb\")\n temp.write(base64.b64decode(base64_string))\n temp.close()\n reconstructed_image = im.imread(\"temporary.png\")\n return reconstructed_image\n\n\ndef encode_file_as_b64(image_array):\n \"\"\"\n\n This function takes in an image array and encodes it into its\n base64 representation.\n\n Args:\n image_array : PIL image\n\n Returns:\n (str): image_string: base64 representation of image\n\n \"\"\"\n image = Image.fromarray(image_array)\n buffer = io2.BytesIO()\n image.save(buffer, format=\"PNG\")\n image_bytes = buffer.getvalue()\n image_string = base64.b64encode(image_bytes).decode(\"utf-8\")\n # with open(image_path, \"rb\") as image_file:\n # return base64.b64encode(image_file.read())\n return image_string\n\n\ndef make_gray(pil_image):\n \"\"\"\n\n This function takes in an image array and converts it to\n gray scale.\n\n Args:\n PIL_array : image array\n\n Returns:\n PIL image object (array) : processed_image: gray scale image\n\n \"\"\"\n image = Image.fromarray(pil_image)\n gray_scale = image.convert('LA')\n # gray = np.array(gray_scale)\n processed_image = gray_scale\n return processed_image\n\n\ndef is_gray(pil_image):\n \"\"\"\n\n This function takes in an image array and determines\n if it's in gray scale. Adapted from: joaoricardo000\n on stackoverflow.com\n\n Args:\n PIL_array : image array\n\n Returns:\n (bool): gray scale: if the image is gray scale.\n\n \"\"\"\n\n image = Image.fromarray(pil_image)\n imageRGB = image.convert('RGB')\n w, h = imageRGB.size\n for i in range(w):\n for j in range(h):\n r, g, b = imageRGB.getpixel((i, j))\n if r != g != b:\n return False\n return True\n\n\ndef histogram_equalization(pil_image):\n \"\"\"\n\n This function takes in an image array, determines if it's gray scale\n (and converts if it isn't), and performs histogram equalization.\n\n Args:\n pil_image : image array\n\n Returns:\n PIL image object (array): processed_image: image array with\n histogram equalization applied.\n\n \"\"\"\n if not is_gray(pil_image):\n gray = make_gray(pil_image)\n gray.save('temp.png')\n gray = io.imread('temp.png')\n else:\n gray = pil_image\n equalized = exposure.equalize_hist(gray)\n normalized = 255 * equalized\n processed_image = normalized.astype('uint8')\n return processed_image\n\n\ndef contrast_stretch(pil_image):\n \"\"\"\n\n This function takes in an image array and performs\n contrast stretching.\n\n Args:\n pil_image : image array\n\n Returns:\n PIL image object (array): processed_image: image array\n with contrast stretching applied.\n\n \"\"\"\n p2 = np.percentile(pil_image, 2)\n p98 = np.percentile(pil_image, 98)\n rescaled_image = exposure.rescale_intensity(pil_image, in_range=(p2, p98))\n processed_image = rescaled_image\n return processed_image\n\n\ndef log_compression(pil_image):\n \"\"\"\n\n This function takes in an image array and performs\n log compression.\n Adapted from: https://homepages.inf.ed.ac.uk/rbf/HIPR2/pixlog.htm\n\n Args:\n pil_image : image array\n\n Returns:\n PIL image object (array): processed_image: image array with\n log compression applied.\n\n \"\"\"\n # Adapted from:\n # https://homepages.inf.ed.ac.uk/rbf/HIPR2/pixlog.htm\n c = 255 / (np.log10(1 + np.amax(pil_image)))\n for pixel in np.nditer(pil_image, op_flags=['readwrite']):\n pixel[...] = c * np.log10(1 + pixel)\n processed_image = pil_image.astype('uint8')\n return processed_image\n\n\ndef reverse_video(pil_image):\n \"\"\"\n\n This function takes in an image array and performs\n reverse video by subtracting each pixel from 255.\n\n Args:\n pil_image : image array\n\n Returns:\n PIL image object (array): processed_image: image array with\n reverse video applied.\n\n \"\"\"\n for pixel in np.nditer(pil_image, op_flags=['readwrite']):\n pixel[...] = 255 - pixel\n processed_image = pil_image.astype('uint8')\n return processed_image\n\n\nif __name__ == \"__main__\":\n connect(\"mongodb://bme590:Dukebm3^@ds253889.mlab.com:53889/imageprocessor\")\n # app.run(host=\"127.0.0.1\")\n app.run(host=\"0.0.0.0\")\n"
] |
[
[
"numpy.amax",
"numpy.log10",
"numpy.nditer",
"numpy.percentile"
]
] |
alexlokotochek/predictive-alerting
|
[
"dea92a248653e9002284875e04b2a3c2f0870144"
] |
[
"example-app/app_prometheus.py"
] |
[
"import time\n\nimport argparse\nfrom scipy.stats import poisson, gamma\nfrom prometheus_client import Summary, start_http_server\n\nparser = argparse.ArgumentParser()\n\nparser.add_argument(\n 'rps',\n default=100,\n type=int,\n nargs='?',\n)\nparser.add_argument(\n 'response_time_avg',\n default=100,\n type=int,\n nargs='?',\n)\nparser.add_argument(\n 'prometheus_port',\n default=8000,\n type=int,\n nargs='?',\n)\nparser.add_argument(\n 'prometheus_metric',\n default='example_app_test_metric',\n type=str,\n nargs='?',\n)\n\n\ndef gen_distances(mu, N):\n return [1. + x for x in poisson.rvs(mu=mu, size=N)]\n\n\ndef gen_response_times(alpha, N):\n return gamma.rvs(a=alpha, size=N)\n\n\ndef send_batch(alpha, mu, send_func, batch_size=100):\n response_times = gen_response_times(alpha, batch_size)\n distances_between_requests = gen_distances(mu, batch_size)\n for distance, response_time in zip(distances_between_requests, response_times):\n # sleep for distance milliseconds before the next request\n time.sleep(distance / 1000)\n # send response time\n send_func(response_time)\n\n\ndef run_app():\n args = parser.parse_args()\n\n start_http_server(args.prometheus_port)\n\n summary = Summary(args.prometheus_metric, '')\n send_func = lambda value: summary.observe(value)\n\n rps = args.rps\n assert rps > 0, 'RPS should be > 0'\n\n # Mu and alpha have these formulas - more info in ipynb\n mu = 1000 / rps\n alpha = args.response_time_avg\n assert alpha > 0, 'response_time_avg should be > 0'\n\n while(True):\n send_batch(alpha, mu, send_func)\n \n\n \nif __name__ == '__main__':\n run_app()\n"
] |
[
[
"scipy.stats.gamma.rvs",
"scipy.stats.poisson.rvs"
]
] |
cohenINSA/relative-rotation
|
[
"e677fd29fccf15314deb8f52dce49da41df80a8e"
] |
[
"code/eval.py"
] |
[
"#!/usr/bin/env python3\n\n# Import packages\nimport argparse\nimport os\n\nfrom tqdm import tqdm\nimport torch\nimport torch.nn.functional as F\n\nfrom net import ResBase, ResClassifier\nfrom data_loader import DatasetGeneratorMultimodal, MyTransformer\nfrom utils import make_paths, add_base_args, default_paths, map_to_device\n\n# Prepare default dataset paths\ndata_root_source, data_root_target, split_source_train, split_source_test, split_target = make_paths()\n\n# Parse arguments\nparser = argparse.ArgumentParser()\nadd_base_args(parser)\nparser.add_argument('--output_path', default='eval_result')\nargs = parser.parse_args()\ndefault_paths(args)\nargs.data_root = args.data_root_target\nargs.test_file = args.test_file_target\n\ndevice = torch.device('cuda:{}'.format(args.gpu))\n\n# Data loader (center crop, no random flip)\ntest_transform = MyTransformer([int((256 - 224) / 2), int((256 - 224) / 2)], False)\ntest_set = DatasetGeneratorMultimodal(args.data_root, args.test_file, ds_name=args.target, do_rot=False)\ntest_loader = torch.utils.data.DataLoader(test_set,\n shuffle=True,\n batch_size=args.batch_size,\n num_workers=args.num_workers)\n\n# Setup network\ninput_dim_F = 2048 if args.net == 'resnet50' else 512\nnetG_rgb = ResBase(architecture=args.net).to(device)\nnetG_depth = ResBase(architecture=args.net).to(device)\nnetF = ResClassifier(input_dim=input_dim_F * 2, class_num=args.class_num, extract=False,\n dropout_p=args.dropout_p).to(device)\nnetG_rgb.eval()\nnetG_depth.eval()\nnetF.eval()\n\n# Run name\nhp_list = [args.task, args.net, args.epoch, args.lr, args.lr_mult, args.batch_size, args.weight_rot, args.weight_ent]\nhp_string = '_'.join(map(str, hp_list)) + args.suffix\n\nprint(\"Run: {}\".format(hp_string))\n\nif not os.path.exists(args.output_path):\n os.mkdir(args.output_path)\n\n# Create a CSV file\nwith open(os.path.join(args.output_path, hp_string + '.csv'), 'w') as fp:\n for epoch in range(5, args.epoch + 1, 5):\n # Load network weights\n netG_rgb.load_state_dict(\n torch.load(os.path.join(args.snapshot, hp_string + \"_netG_rgb_epoch\" + str(epoch) + \".pth\"),\n map_location=device))\n netG_depth.load_state_dict(\n torch.load(os.path.join(args.snapshot, hp_string + \"_netG_depth_epoch\" + str(epoch) + \".pth\"),\n map_location=device))\n netF.load_state_dict(\n torch.load(os.path.join(args.snapshot, hp_string + \"_netF_rgbd_epoch\" + str(epoch) + \".pth\"),\n map_location=device))\n\n correct = 0\n total = 0\n with tqdm(total=len(test_loader), desc=\"TestEpoch{}\".format(epoch)) as pb:\n # Load batches\n for (imgs_rgb, imgs_depth, labels) in test_loader:\n # Move tensors to GPU\n imgs_rgb, imgs_depth, labels = map_to_device(device, (imgs_rgb, imgs_depth, labels))\n # Compute features\n feat_rgb, _ = netG_rgb(imgs_rgb)\n feat_depth, _ = netG_depth(imgs_depth)\n # Compute predictions\n pred = netF(torch.cat((feat_rgb, feat_depth), 1))\n pred = F.softmax(pred, dim=1)\n correct += (torch.argmax(pred, dim=1) == labels).sum().item()\n total += labels.shape[0]\n\n pb.update(1)\n\n accuracy = correct / total\n # stdout\n print(\"{} @{} epochs: overall accuracy = {}\".format(hp_string, epoch, accuracy))\n # CSV\n fp.write(\"{},{},{}\\n\".format(hp_string, epoch, accuracy))\n fp.flush()\n"
] |
[
[
"torch.nn.functional.softmax",
"torch.argmax",
"torch.utils.data.DataLoader",
"torch.cat"
]
] |
carusyte/ADNC
|
[
"4a5dfa5be1aca9f815794c2c276ec220a1eb591d"
] |
[
"adnc/model/memory_units/dnc_cell.py"
] |
[
"# Copyright 2018 Jörg Franke\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\nimport numpy as np\nimport tensorflow as tf\n\nfrom adnc.model.memory_units.base_cell import BaseMemoryUnitCell\nfrom adnc.model.utils import oneplus, layer_norm, unit_simplex_initialization\n\n\"\"\"\nThe vanilla DNC memory unit.\n\"\"\"\n\nclass DNCMemoryUnitCell(BaseMemoryUnitCell):\n def __init__(self, input_size, memory_length, memory_width, read_heads, bypass_dropout=False, dnc_norm=False,\n seed=100, reuse=False, analyse=False, dtype=tf.float32, name='dnc_mu'):\n\n super().__init__(input_size, memory_length, memory_width, read_heads, bypass_dropout, dnc_norm, seed, reuse,\n analyse, dtype, name)\n\n\n @property\n def state_size(self):\n init_memory = tf.TensorShape([self.h_N, self.h_W])\n init_usage_vector = tf.TensorShape([self.h_N])\n init_write_weighting = tf.TensorShape([self.h_N])\n init_precedence_weightings = tf.TensorShape([self.h_N])\n init_link_mat = tf.TensorShape([self.h_N, self.h_N])\n init_read_weighting = tf.TensorShape([self.h_RH, self.h_N])\n return (init_memory, init_usage_vector, init_write_weighting, init_precedence_weightings,\n init_link_mat, init_read_weighting)\n\n def zero_state(self, batch_size, dtype=tf.float32):\n\n init_memory = tf.fill([batch_size, self.h_N, self.h_W], tf.cast(1 / (self.h_N * self.h_W), dtype=dtype))\n init_usage_vector = tf.zeros([batch_size, self.h_N], dtype=dtype)\n init_write_weighting = unit_simplex_initialization(self.rng, batch_size, [self.h_N], dtype=dtype)\n init_precedence_weightings = tf.zeros([batch_size, self.h_N], dtype=dtype)\n\n init_link_mat = tf.zeros([batch_size, self.h_N, self.h_N], dtype=dtype)\n init_read_weighting = unit_simplex_initialization(self.rng, batch_size, [self.h_RH, self.h_N], dtype=dtype)\n zero_states = (init_memory, init_usage_vector, init_write_weighting, init_precedence_weightings,\n init_link_mat, init_read_weighting,)\n\n return zero_states\n\n def analyse_state(self, batch_size, dtype=tf.float32):\n\n alloc_gate = tf.zeros([batch_size, 1], dtype=dtype)\n free_gates = tf.zeros([batch_size, self.h_RH, 1], dtype=dtype)\n write_gate = tf.zeros([batch_size, 1], dtype=dtype)\n write_keys = tf.zeros([batch_size, 1, self.h_W], dtype=dtype)\n write_strengths = tf.zeros([batch_size, 1], dtype=dtype)\n write_vector = tf.zeros([batch_size, 1, self.h_W], dtype=dtype)\n erase_vector = tf.zeros([batch_size, 1, self.h_W], dtype=dtype)\n read_keys = tf.zeros([batch_size, self.h_RH, self.h_W], dtype=dtype)\n read_strengths = tf.zeros([batch_size, self.h_RH, 1], dtype=dtype)\n read_modes = tf.zeros([batch_size, self.h_RH, 3], dtype=dtype)\n\n analyse_states = alloc_gate, free_gates, write_gate, write_keys, write_strengths, write_vector, \\\n erase_vector, read_keys, read_strengths, read_modes\n\n return analyse_states\n\n def __call__(self, inputs, pre_states, scope=None):\n\n self.h_B = inputs.get_shape()[0].value\n\n link_matrix_inv_eye, memory_ones, batch_memory_range = self._create_constant_value_tensors(self.h_B, self.dtype)\n self.const_link_matrix_inv_eye = link_matrix_inv_eye\n self.const_memory_ones = memory_ones\n self.const_batch_memory_range = batch_memory_range\n\n pre_memory, pre_usage_vector, pre_write_weightings, pre_precedence_weighting, pre_link_matrix, pre_read_weightings = pre_states\n\n weighted_input = self._weight_input(inputs)\n\n control_signals = self._create_control_signals(weighted_input)\n alloc_gate, free_gates, write_gate, write_keys, write_strengths, write_vector, \\\n erase_vector, read_keys, read_strengths, read_modes = control_signals\n\n alloc_weightings, usage_vector = self._update_alloc_and_usage_vectors(pre_write_weightings, pre_read_weightings,\n pre_usage_vector, free_gates)\n write_content_weighting = self._calculate_content_weightings(pre_memory, write_keys, write_strengths)\n write_weighting = self._update_write_weighting(alloc_weightings, write_content_weighting, write_gate,\n alloc_gate)\n memory = self._update_memory(pre_memory, write_weighting, write_vector, erase_vector)\n link_matrix, precedence_weighting = self._update_link_matrix(pre_link_matrix, write_weighting,\n pre_precedence_weighting)\n forward_weightings, backward_weightings = self._make_read_forward_backward_weightings(link_matrix,\n pre_read_weightings)\n read_content_weightings = self._calculate_content_weightings(memory, read_keys, read_strengths)\n read_weightings = self._make_read_weightings(forward_weightings, backward_weightings, read_content_weightings,\n read_modes)\n read_vectors = self._read_memory(memory, read_weightings)\n read_vectors = tf.reshape(read_vectors, [self.h_B, self.h_W * self.h_RH])\n\n if self.bypass_dropout:\n input_bypass = tf.nn.dropout(inputs, self.bypass_dropout)\n else:\n input_bypass = inputs\n\n output = tf.concat([read_vectors, input_bypass], axis=-1)\n\n if self.analyse:\n output = (output, control_signals)\n\n return output, (memory, usage_vector, write_weighting, precedence_weighting, link_matrix, read_weightings)\n\n def _create_constant_value_tensors(self, batch_size, dtype):\n\n link_matrix_inv_eye = 1 - tf.constant(np.identity(self.h_N), dtype=dtype, name=\"link_matrix_inv_eye\")\n memory_ones = tf.ones([batch_size, self.h_N, self.h_W], dtype=dtype, name=\"memory_ones\")\n\n batch_range = tf.range(0, batch_size, delta=1, dtype=tf.int32, name=\"batch_range\")\n repeat_memory_length = tf.fill([self.h_N], tf.constant(self.h_N, dtype=tf.int32), name=\"repeat_memory_length\")\n batch_memory_range = tf.matmul(tf.expand_dims(batch_range, -1), tf.expand_dims(repeat_memory_length, 0),\n name=\"batch_memory_range\")\n return link_matrix_inv_eye, memory_ones, batch_memory_range\n\n def _weight_input(self, inputs):\n\n input_size = inputs.get_shape()[1].value\n total_signal_size = (3 + self.h_RH) * self.h_W + 5 * self.h_RH + 3\n\n with tf.variable_scope('{}'.format(self.name), reuse=self.reuse):\n w_x = tf.get_variable(\"mu_w_x\", (input_size, total_signal_size),\n initializer=tf.contrib.layers.xavier_initializer(seed=self.seed),\n collections=['memory_unit', tf.GraphKeys.GLOBAL_VARIABLES], dtype=self.dtype)\n\n b_x = tf.get_variable(\"mu_b_x\", (total_signal_size,), initializer=tf.constant_initializer(0.),\n collections=['memory_unit', tf.GraphKeys.GLOBAL_VARIABLES], dtype=self.dtype)\n\n weighted_input = tf.matmul(inputs, w_x) + b_x\n\n if self.dnc_norm:\n weighted_input = layer_norm(weighted_input, name='layer_norm', dtype=self.dtype,\n collection='memory_unit')\n return weighted_input\n\n def _create_control_signals(self, weighted_input):\n\n write_keys = weighted_input[:, : self.h_W] # W\n write_strengths = weighted_input[:, self.h_W: self.h_W + 1] # 1\n erase_vector = weighted_input[:, self.h_W + 1: 2 * self.h_W + 1] # W\n write_vector = weighted_input[:, 2 * self.h_W + 1: 3 * self.h_W + 1] # W\n alloc_gates = weighted_input[:, 3 * self.h_W + 1: 3 * self.h_W + 2] # 1\n write_gates = weighted_input[:, 3 * self.h_W + 2: 3 * self.h_W + 3] # 1\n read_keys = weighted_input[:, 3 * self.h_W + 3: (self.h_RH + 3) * self.h_W + 3] # R * W\n read_strengths = weighted_input[:,\n (self.h_RH + 3) * self.h_W + 3: (self.h_RH + 3) * self.h_W + 3 + 1 * self.h_RH] # R\n read_modes = weighted_input[:, (self.h_RH + 3) * self.h_W + 3 + 1 * self.h_RH: (\n self.h_RH + 3) * self.h_W + 3 + 4 * self.h_RH] # 3R\n free_gates = weighted_input[:, (self.h_RH + 3) * self.h_W + 3 + 4 * self.h_RH: (\n self.h_RH + 3) * self.h_W + 3 + 5 * self.h_RH] # R\n\n alloc_gates = tf.sigmoid(alloc_gates, 'alloc_gates')\n free_gates = tf.sigmoid(free_gates, 'free_gates')\n free_gates = tf.expand_dims(free_gates, 2)\n write_gates = tf.sigmoid(write_gates, 'write_gates')\n\n write_keys = tf.expand_dims(write_keys, axis=1)\n write_strengths = oneplus(write_strengths)\n # write_strengths = tf.expand_dims(write_strengths, axis=2)\n write_vector = tf.reshape(write_vector, [self.h_B, 1, self.h_W])\n erase_vector = tf.sigmoid(erase_vector, 'erase_vector')\n erase_vector = tf.reshape(erase_vector, [self.h_B, 1, self.h_W])\n\n read_keys = tf.reshape(read_keys, [self.h_B, self.h_RH, self.h_W])\n read_strengths = oneplus(read_strengths)\n read_strengths = tf.expand_dims(read_strengths, axis=2)\n read_modes = tf.reshape(read_modes, [self.h_B, self.h_RH, 3]) # 3 read modes\n read_modes = tf.nn.softmax(read_modes, dim=2)\n\n return alloc_gates, free_gates, write_gates, write_keys, write_strengths, write_vector, \\\n erase_vector, read_keys, read_strengths, read_modes\n\n def _update_alloc_and_usage_vectors(self, pre_write_weightings, pre_read_weightings, pre_usage_vector, free_gates):\n\n retention_vector = tf.reduce_prod(1 - free_gates * pre_read_weightings, axis=1, keepdims=False,\n name='retention_prod')\n usage_vector = (\n pre_usage_vector + pre_write_weightings - pre_usage_vector * pre_write_weightings) * retention_vector\n\n sorted_usage, free_list = tf.nn.top_k(-1 * usage_vector, self.h_N)\n sorted_usage = -1 * sorted_usage\n\n cumprod_sorted_usage = tf.cumprod(sorted_usage, axis=1, exclusive=True)\n corrected_free_list = free_list + self.const_batch_memory_range\n\n cumprod_sorted_usage_re = [tf.reshape(cumprod_sorted_usage, [-1, ]), ]\n corrected_free_list_re = [tf.reshape(corrected_free_list, [-1]), ]\n\n stitched_usage = tf.dynamic_stitch(corrected_free_list_re, cumprod_sorted_usage_re, name=None)\n\n stitched_usage = tf.reshape(stitched_usage, [self.h_B, self.h_N])\n\n alloc_weighting = (1 - usage_vector) * stitched_usage\n\n return alloc_weighting, usage_vector\n\n @staticmethod\n def _update_write_weighting(alloc_weighting, write_content_weighting, write_gate, alloc_gate):\n\n write_weighting = write_gate * (alloc_gate * alloc_weighting + (1 - alloc_gate) * write_content_weighting)\n\n return write_weighting\n\n def _update_memory(self, pre_memory, write_weighting, write_vector, erase_vector):\n\n write_w = tf.expand_dims(write_weighting, 2)\n erase_matrix = tf.multiply(pre_memory, (self.const_memory_ones - tf.matmul(write_w, erase_vector)))\n write_matrix = tf.matmul(write_w, write_vector)\n return erase_matrix + write_matrix\n\n def _update_link_matrix(self, pre_link_matrix, write_weighting, pre_precedence_weighting):\n\n precedence_weighting = (1 - tf.reduce_sum(write_weighting, 1,\n keepdims=True)) * pre_precedence_weighting + write_weighting\n\n add_mat = tf.matmul(tf.expand_dims(write_weighting, axis=2),\n tf.expand_dims(pre_precedence_weighting, axis=1))\n erase_mat = 1 - tf.expand_dims(write_weighting, 1) - tf.expand_dims(write_weighting, 2)\n\n updated_link_mat = erase_mat * pre_link_matrix + add_mat\n link_matrix = self.const_link_matrix_inv_eye * updated_link_mat\n\n return link_matrix, precedence_weighting\n\n @staticmethod\n def _make_read_forward_backward_weightings(link_matrix, pre_read_weightings):\n\n forward_weightings = tf.matmul(pre_read_weightings, link_matrix)\n backward_weightings = tf.matmul(pre_read_weightings, link_matrix, adjoint_b=True)\n\n return forward_weightings, backward_weightings\n\n @staticmethod\n def _make_read_weightings(forward_weightings, backward_weightings, read_content_weightings, read_modes):\n\n read_weighting = tf.expand_dims(read_modes[:, :, 0], 2) * backward_weightings + \\\n tf.expand_dims(read_modes[:, :, 1], 2) * read_content_weightings + \\\n tf.expand_dims(read_modes[:, :, 2], 2) * forward_weightings\n\n return read_weighting\n"
] |
[
[
"tensorflow.concat",
"tensorflow.zeros",
"tensorflow.reduce_sum",
"tensorflow.cast",
"tensorflow.nn.top_k",
"tensorflow.dynamic_stitch",
"tensorflow.contrib.layers.xavier_initializer",
"tensorflow.cumprod",
"tensorflow.nn.dropout",
"tensorflow.TensorShape",
"tensorflow.matmul",
"tensorflow.reduce_prod",
"numpy.identity",
"tensorflow.nn.softmax",
"tensorflow.constant",
"tensorflow.range",
"tensorflow.reshape",
"tensorflow.sigmoid",
"tensorflow.ones",
"tensorflow.expand_dims",
"tensorflow.constant_initializer"
]
] |
szufix/mapel
|
[
"9eaacf7963021ea3eab701a14efd82cf1bfc5c5b"
] |
[
"mapel/voting/elections/single_peaked.py"
] |
[
"import random as rand\nimport numpy as np\nfrom random import *\n\nfrom scipy.special import binom\n\n\ndef generate_sp_party(model=None, num_voters=None, num_candidates=None, params=None) -> np.ndarray:\n candidates = [[] for _ in range(num_candidates)]\n _ids = [i for i in range(num_candidates)]\n\n for j in range(params['num_parties']):\n for w in range(params['num_winners']):\n _id = j * params['num_winners'] + w\n candidates[_id] = [rand.gauss(params['party'][j][0], params['var'])]\n\n mapping = [x for _, x in sorted(zip(candidates, _ids))]\n\n if model == 'conitzer_party':\n votes = generate_ordinal_sp_conitzer_votes(num_voters=num_voters, num_candidates=num_candidates)\n elif model == 'walsh_party':\n votes = generate_ordinal_sp_walsh_votes(num_voters=num_voters, num_candidates=num_candidates)\n for i in range(num_voters):\n for j in range(num_candidates):\n votes[i][j] = mapping[votes[i][j]]\n\n return votes\n\n\ndef generate_ordinal_sp_conitzer_votes(num_voters=None, num_candidates=None) -> np.ndarray:\n \"\"\" helper function: generate conitzer single-peaked elections \"\"\"\n\n votes = np.zeros([num_voters, num_candidates])\n\n for j in range(num_voters):\n votes[j][0] = rand.randint(0, num_candidates - 1)\n left = votes[j][0] - 1\n right = votes[j][0] + 1\n for k in range(1, num_candidates):\n side = rand.choice([0, 1])\n if side == 0:\n if left >= 0:\n votes[j][k] = left\n left -= 1\n else:\n votes[j][k] = right\n right += 1\n else:\n if right < num_candidates:\n votes[j][k] = right\n right += 1\n else:\n votes[j][k] = left\n left -= 1\n\n return votes\n\n\ndef generate_ordinal_spoc_conitzer_votes(num_voters=None, num_candidates=None) -> np.ndarray:\n \"\"\" helper function: generate spoc_conitzer single-peaked elections\"\"\"\n\n votes = np.zeros([num_voters, num_candidates])\n\n for j in range(num_voters):\n votes[j][0] = rand.randint(0, num_candidates - 1)\n left = votes[j][0] - 1\n left %= num_candidates\n right = votes[j][0] + 1\n right %= num_candidates\n for k in range(1, num_candidates):\n side = rand.choice([0, 1])\n if side == 0:\n votes[j][k] = left\n left -= 1\n left %= num_candidates\n else:\n votes[j][k] = right\n right += 1\n right %= num_candidates\n\n return votes\n\n\ndef generate_ordinal_sp_walsh_votes(num_voters=None, num_candidates=None) -> np.ndarray:\n \"\"\" helper function: generate walsh single-peaked elections\"\"\"\n\n votes = np.zeros([num_voters, num_candidates])\n\n for j in range(num_voters):\n votes[j] = walsh_sp(0, num_candidates - 1)\n\n return votes.astype(int)\n\n\n# AUXILIARY\ndef walsh_sp(a, b):\n if a == b:\n return [a]\n elif rand.choice([0, 1]) == 0:\n return walsh_sp(a + 1, b) + [a]\n else:\n return walsh_sp(a, b - 1) + [b]\n\n\n### MATRICES ###\n\n# WALSH\n\ndef f(i, j):\n if i < 0: return 0\n return (1.0 / (2 ** (i + j))) * binom(i + j, i)\n\n\ndef probW(m, i, t):\n # probability that c_i is ranked t among m candidates\n return 0.5 * f(i - 1, m - t - (i - 1)) + 0.5 * f(i - t, m - i)\n\n\n# RANDOM CONITZER\n\ndef random_conitzer(C):\n # generate a random vote from the Conitzer model_id for axis\n # C[0], ..., C[m-1]\n m = len(C)\n center = randint(0, m - 1)\n left = center\n right = center\n vote = [C[center]]\n for i in range(m - 1):\n L = False\n R = False\n\n if left > 0 and right < m - 1:\n if random() < 0.5:\n L = True\n else:\n R = True\n elif left > 0:\n L = True\n else:\n R = True\n\n if L:\n left -= 1\n vote.append(C[left])\n else:\n right += 1\n vote.append(C[right])\n\n return vote\n\n\n# CONITZER\n\ndef g(m, i, j):\n if i > j: return 0\n if i == j: return 1.0 / m\n if i == 1 and j < m: return g(m, 1, j - 1) + 0.5 * g(m, 2, j)\n if j == m and i > 1: return g(m, i + 1, m) + 0.5 * g(m, i, m - 1)\n if i == 1 and j == m: return 1.0\n return 1.0 / m\n\n\n# return 0.5*g(m,i+1,j) + 0.5*g(m,i,j-1)\n\n\ndef probC(m, i, t):\n # probability that c_i is ranked t among m candidates\n p = 0.0\n if t == 1: return 1.0 / m\n\n if i - (t - 1) > 1:\n p += 0.5 * g(m, i - (t - 1), i - 1)\n elif i - (t - 1) == 1:\n p += g(m, i - (t - 1), i - 1)\n\n if i + (t - 1) < m:\n p += 0.5 * g(m, i + 1, i + (t - 1))\n elif i + (t - 1) == m:\n p += g(m, i + 1, i + (t - 1))\n\n return p\n\n\nPRECISION = 1000\nDIGITS = 4\n\n\ndef get_conitzer_matrix(m):\n return get_conitzer_vectors(m).transpose()\n\n\ndef get_walsh_matrix(m):\n return get_walsh_vectors(m).transpose()\n\n\ndef get_conitzer_vectors(m):\n P = np.zeros([m, m])\n for i in range(m):\n for j in range(m):\n P[i][j] = probC(m, i + 1, j + 1)\n return P\n\n\ndef simconitzer(m):\n P = [[0] * m for _ in range(m)]\n T = 100000\n\n C = list(range(m))\n for t in range(T):\n if t % 10000 == 0: print(t)\n v = random_conitzer(C)\n for i in range(m):\n P[v[i]][i] += 1\n\n for j in range(m):\n for i in range(m):\n P[i][j] = str(int(PRECISION * (P[i][j] / T))).rjust(DIGITS)\n return P\n\n\ndef get_walsh_vectors(m):\n P = np.zeros([m, m])\n for i in range(m):\n for t in range(m):\n P[i][t] = probW(m, i + 1, t + 1)\n return P\n"
] |
[
[
"scipy.special.binom",
"numpy.zeros"
]
] |
scaldas/federated
|
[
"d46aef1f7d3915977b3a67eb0df709b7e28fca67",
"d46aef1f7d3915977b3a67eb0df709b7e28fca67"
] |
[
"optimization/shared/iterative_process_builder_test.py",
"targeted_attack/emnist_with_targeted_attack.py"
] |
[
"# Copyright 2019, Google LLC.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"Tests for shared iterative process builder.\"\"\"\n\nimport collections\n\nfrom absl import flags\nfrom absl import logging\nfrom absl.testing import parameterized\n\nimport numpy as np\nimport tensorflow as tf\nimport tensorflow_federated as tff\n\nfrom optimization.shared import iterative_process_builder\n\nFLAGS = flags.FLAGS\n\nFLAGS.client_optimizer = 'sgd'\nFLAGS.client_learning_rate = 0.1\nFLAGS.server_optimizer = 'sgd'\nFLAGS.server_learning_rate = 1.0\n\n\n_Batch = collections.namedtuple('Batch', ['x', 'y'])\n\n\ndef _batch_fn():\n batch = _Batch(\n x=np.ones([1, 784], dtype=np.float32), y=np.ones([1, 1], dtype=np.int64))\n return batch\n\n\ndef _get_input_spec():\n input_spec = _Batch(\n x=tf.TensorSpec(shape=[None, 784], dtype=tf.float32),\n y=tf.TensorSpec([None, 1], dtype=tf.int64))\n return input_spec\n\n\ndef model_builder():\n return tff.simulation.models.mnist.create_keras_model(compile_model=False)\n\n\ndef loss_builder():\n return tf.keras.losses.SparseCategoricalCrossentropy()\n\n\ndef metrics_builder():\n return [tf.keras.metrics.SparseCategoricalAccuracy()]\n\n\nclass IterativeProcessBuilderTest(tf.test.TestCase, parameterized.TestCase):\n\n def _run_rounds(self, iterproc, client_datasets, num_rounds):\n train_outputs = []\n state = iterproc.initialize()\n for round_num in range(num_rounds):\n state, metrics = iterproc.next(state, client_datasets)\n train_outputs.append(metrics)\n logging.info('Round %d: %s', round_num, metrics)\n return state, train_outputs\n\n def test_iterative_process_no_schedule_decreases_loss(self):\n FLAGS.client_lr_schedule = 'constant'\n FLAGS.server_lr_schedule = 'constant'\n federated_data = [[_batch_fn()]]\n input_spec = _get_input_spec()\n iterproc = iterative_process_builder.from_flags(input_spec, model_builder,\n loss_builder,\n metrics_builder)\n _, train_outputs = self._run_rounds(iterproc, federated_data, 4)\n self.assertLess(train_outputs[-1]['loss'], train_outputs[0]['loss'])\n\n def test_iterative_process_with_custom_client_weight_fn_decreases_loss(self):\n FLAGS.client_lr_schedule = 'constant'\n FLAGS.server_lr_schedule = 'constant'\n federated_data = [[_batch_fn()]]\n input_spec = _get_input_spec()\n\n def client_weight_fn(local_outputs):\n return 1.0 / (1.0 + local_outputs['loss'][-1])\n\n iterproc = iterative_process_builder.from_flags(\n input_spec,\n model_builder,\n loss_builder,\n metrics_builder,\n client_weight_fn=client_weight_fn)\n _, train_outputs = self._run_rounds(iterproc, federated_data, 4)\n self.assertLess(train_outputs[-1]['loss'], train_outputs[0]['loss'])\n\n @parameterized.named_parameters(('inv_lin_decay', 'inv_lin_decay'),\n ('inv_sqrt_decay', 'inv_sqrt_decay'))\n def test_iterative_process_with_inv_time_client_schedule(self, sched_type):\n FLAGS.client_lr_schedule = 'constant'\n FLAGS.client_lr_decay_steps = 1\n FLAGS.client_lr_decay_rate = 1.0\n FLAGS.client_lr_staircase = False\n FLAGS.server_lr_schedule = 'constant'\n FLAGS.client_lr_schedule = sched_type\n federated_data = [[_batch_fn()]]\n input_spec = _get_input_spec()\n iterproc = iterative_process_builder.from_flags(input_spec, model_builder,\n loss_builder,\n metrics_builder)\n _, train_outputs = self._run_rounds(iterproc, federated_data, 4)\n self.assertLess(train_outputs[-1]['loss'], train_outputs[0]['loss'])\n\n def test_iterative_process_with_exp_decay_client_schedule(self):\n FLAGS.client_lr_schedule = 'exp_decay'\n FLAGS.client_lr_decay_steps = 1\n FLAGS.client_lr_decay_rate = 0.5\n FLAGS.client_lr_staircase = False\n FLAGS.server_lr_schedule = 'constant'\n\n federated_data = [[_batch_fn()]]\n input_spec = _get_input_spec()\n iterproc = iterative_process_builder.from_flags(input_spec, model_builder,\n loss_builder,\n metrics_builder)\n _, train_outputs = self._run_rounds(iterproc, federated_data, 4)\n self.assertLess(train_outputs[-1]['loss'], train_outputs[0]['loss'])\n\n @parameterized.named_parameters(('inv_lin_decay', 'inv_lin_decay'),\n ('inv_sqrt_decay', 'inv_sqrt_decay'))\n def test_iterative_process_with_inv_time_server_schedule(self, sched_type):\n FLAGS.client_lr_schedule = 'constant'\n FLAGS.server_lr_decay_steps = 1\n FLAGS.server_lr_decay_rate = 1.0\n FLAGS.server_lr_staircase = False\n FLAGS.server_lr_schedule = sched_type\n federated_data = [[_batch_fn()]]\n input_spec = _get_input_spec()\n iterproc = iterative_process_builder.from_flags(input_spec, model_builder,\n loss_builder,\n metrics_builder)\n _, train_outputs = self._run_rounds(iterproc, federated_data, 4)\n self.assertLess(train_outputs[-1]['loss'], train_outputs[0]['loss'])\n\n def test_iterative_process_with_exp_decay_server_schedule(self):\n FLAGS.client_lr_schedule = 'constant'\n FLAGS.server_lr_schedule = 'exp_decay'\n FLAGS.server_lr_decay_steps = 1\n FLAGS.server_lr_decay_rate = 0.5\n FLAGS.server_lr_staircase = False\n\n federated_data = [[_batch_fn()]]\n input_spec = _get_input_spec()\n iterproc = iterative_process_builder.from_flags(input_spec, model_builder,\n loss_builder,\n metrics_builder)\n _, train_outputs = self._run_rounds(iterproc, federated_data, 4)\n self.assertLess(train_outputs[-1]['loss'], train_outputs[0]['loss'])\n\n def test_decay_factor_0_does_not_decrease_loss(self):\n FLAGS.client_lr_schedule = 'exp_decay'\n FLAGS.client_lr_decay_steps = 2\n FLAGS.client_lr_decay_rate = 0.0\n FLAGS.client_lr_staircase = True\n FLAGS.server_lr_schedule = 'constant'\n\n federated_data = [[_batch_fn()]]\n input_spec = _get_input_spec()\n iterproc = iterative_process_builder.from_flags(input_spec, model_builder,\n loss_builder,\n metrics_builder)\n _, train_outputs = self._run_rounds(iterproc, federated_data, 4)\n self.assertLess(train_outputs[1]['loss'], train_outputs[0]['loss'])\n self.assertNear(\n train_outputs[2]['loss'], train_outputs[3]['loss'], err=1e-5)\n\n\nif __name__ == '__main__':\n tff.backends.native.set_local_execution_context(max_fanout=25)\n tf.test.main()\n",
"# Copyright 2019, Google LLC.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"Script for federated training of EMNIST classifiers with targeted attack and corrsponding defenses.\"\"\"\n\nimport collections\nimport os\n\nfrom absl import app\nfrom absl import flags\nimport numpy as np\nfrom scipy import io\nimport tensorflow as tf\nimport tensorflow_federated as tff\nimport tensorflow_privacy\n\nfrom targeted_attack import attacked_fedavg\n\nFLAGS = flags.FLAGS\n\n# training parameters\nflags.DEFINE_string('root_output_dir', '/tmp/emnist_grids/',\n 'Root directory for writing experiment output.')\nflags.DEFINE_integer('random_seed', 0, 'Random seed.')\nflags.DEFINE_integer('evaluate_per_rounds', 1, 'Clients number per round.')\nflags.DEFINE_boolean('only_digits', True, 'True: 10 classes, False 62 classes.')\n\n# server parameters\nflags.DEFINE_integer('num_clients_per_round', 5, 'Clients number per round.')\nflags.DEFINE_integer('num_rounds', 300, 'Number of rounds.')\nflags.DEFINE_float('server_learning_rate', 1., 'Server learning rate.')\nflags.DEFINE_float('server_momentum', 0., 'Server learning rate.')\n\n# client parameters\nflags.DEFINE_integer('num_epochs', 5, 'Number of epochs in the client.')\nflags.DEFINE_integer('batch_size', 20, 'Training batch size.')\nflags.DEFINE_float('client_learning_rate', 0.1, 'Client learning rate.')\nflags.DEFINE_float('client_momentum', 0., 'Client learning rate.')\n\n# attack parameters\nflags.DEFINE_integer('attack_freq', 1, 'Attacking frequency of the attacker.')\nflags.DEFINE_integer('task_num', 30,\n 'The number of attack tasks we want to insert.')\nflags.DEFINE_integer(\n 'client_round_num', 5,\n 'Number of local rounds used to compute the malicious update.')\n\n# defense parameters\nflags.DEFINE_float('drop_prob', 0.5, 'Dropping probability of each layer')\nflags.DEFINE_float('norm_bound', 0.33,\n 'The maximum norm for malicious update before boosting.')\nflags.DEFINE_float('l2_norm_clip', 1.0, 'The clipped l2 norm')\nflags.DEFINE_float('mul_factor', 0.,\n 'The multiplication factor to ensure privacy')\n\nkeys = [\n 'random_seed', 'num_clients_per_round', 'num_rounds',\n 'server_learning_rate', 'num_epochs', 'batch_size', 'client_learning_rate',\n 'client_round_num', 'attack_freq', 'task_num', 'drop_prob', 'norm_bound',\n 'l2_norm_clip', 'mul_factor'\n]\n\nuse_nchw_format = False\ndata_format = 'channels_first' if use_nchw_format else 'channels_last'\ndata_shape = [1, 28, 28] if use_nchw_format else [28, 28, 1]\n\n\ndef preprocess(dataset):\n \"\"\"Preprocess dataset.\"\"\"\n\n def element_fn(element):\n return collections.OrderedDict([\n ('x', tf.reshape(element['pixels'], data_shape)),\n ('y', tf.reshape(element['label'], [-1])),\n ])\n\n return dataset.repeat(FLAGS.num_epochs).map(element_fn).batch(\n FLAGS.batch_size)\n\n\ndef load_malicious_dataset(num_tasks):\n \"\"\"Load malicious dataset consisting of malicious target samples.\"\"\"\n url_malicious_dataset = 'https://storage.googleapis.com/tff-experiments-public/targeted_attack/emnist_malicious/emnist_target.mat'\n filename = 'emnist_target.mat'\n path = tf.keras.utils.get_file(filename, url_malicious_dataset)\n emnist_target_data = io.loadmat(path)\n emnist_target_x = emnist_target_data['target_train_x'][0]\n emnist_target_y = emnist_target_data['target_train_y'][0]\n target_x = np.concatenate(emnist_target_x[-num_tasks:], axis=0)\n target_y = np.concatenate(emnist_target_y[-num_tasks:], axis=0)\n dict_malicious = collections.OrderedDict([('x', target_x), ('y', target_y)])\n dataset_malicious = tf.data.Dataset.from_tensors(dict_malicious)\n return dataset_malicious, target_x, target_y\n\n\ndef load_test_data():\n \"\"\"Load test data for faster evaluation.\"\"\"\n url_test_data = 'https://storage.googleapis.com/tff-experiments-public/targeted_attack/emnist_test_data/emnist_test_data.mat'\n filename = 'emnist_test_data.mat'\n path = tf.keras.utils.get_file(filename, url_test_data)\n emnist_test_data = io.loadmat(path)\n test_image = emnist_test_data['test_x']\n test_label = emnist_test_data['test_y']\n return test_image, test_label\n\n\ndef make_federated_data_with_malicious(client_data,\n dataset_malicious,\n client_ids,\n with_attack=1):\n \"\"\"Make federated dataset with potential attackers.\"\"\"\n benign_dataset = [\n preprocess(client_data.create_tf_dataset_for_client(x))\n for x in client_ids\n ]\n malicious_dataset = [dataset_malicious for x in client_ids]\n if with_attack:\n client_type_list = \\\n [tf.cast(0, tf.bool)] * (len(client_ids)-1) + [tf.cast(1, tf.bool)]\n else:\n client_type_list = [tf.cast(0, tf.bool)] * len(client_ids)\n return benign_dataset, malicious_dataset, client_type_list\n\n\ndef sample_clients_with_malicious(client_data,\n client_ids,\n dataset_malicious,\n num_clients=3,\n with_attack=1):\n \"\"\"Sample client and make federated dataset.\"\"\"\n sampled_clients = np.random.choice(client_ids, num_clients)\n federated_train_data, federated_malicious_data, client_type_list = \\\n make_federated_data_with_malicious(client_data, dataset_malicious,\n sampled_clients, with_attack)\n return federated_train_data, federated_malicious_data, client_type_list\n\n\ndef create_keras_model():\n \"\"\"Build compiled keras model.\"\"\"\n num_classes = 10 if FLAGS.only_digits else 62\n model = tf.keras.models.Sequential([\n tf.keras.layers.Conv2D(\n 32,\n kernel_size=(3, 3),\n activation='relu',\n input_shape=data_shape,\n data_format=data_format),\n tf.keras.layers.Conv2D(\n 64, kernel_size=(3, 3), activation='relu', data_format=data_format),\n tf.keras.layers.MaxPool2D(pool_size=(2, 2), data_format=data_format),\n tf.keras.layers.Dropout(0.25),\n tf.keras.layers.Flatten(),\n tf.keras.layers.Dense(128, activation='relu'),\n tf.keras.layers.Dropout(0.5),\n tf.keras.layers.Dense(num_classes, activation='softmax')\n ])\n return model\n\n\ndef evaluate(state, x, y, target_x, target_y, batch_size=100):\n \"\"\"Evaluate the model on both main task and target task.\"\"\"\n keras_model = create_keras_model()\n keras_model.compile(\n loss=tf.keras.losses.SparseCategoricalCrossentropy(),\n metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])\n state.model.assign_weights_to(keras_model)\n test_metrics = keras_model.evaluate(x, y, batch_size=batch_size)\n test_metrics_target = keras_model.evaluate(\n target_x, target_y, batch_size=batch_size)\n return test_metrics, test_metrics_target\n\n\ndef write_print(file_handle, line):\n print(line)\n file_handle.write(line + '\\n')\n\n\ndef log_tfboard(name, value, step):\n tf.summary.scalar(name, value, step=step)\n\n\ndef create_if_not_exists(path):\n try:\n tf.io.gfile.makedirs(path)\n except tf.errors.OpError:\n print('Skipping creation of directory {}, directory already exists'.format(\n path))\n\n\ndef main(argv):\n if len(argv) > 1:\n raise app.UsageError('Too many command-line arguments.')\n config = tf.compat.v1.ConfigProto()\n config.graph_options.rewrite_options.layout_optimizer = 2\n tf.compat.v1.enable_eager_execution(config)\n\n np.random.seed(FLAGS.random_seed)\n\n flag_dict = FLAGS.flag_values_dict()\n configs = '-'.join(\n ['{}={}'.format(k, flag_dict[k]) for k in keys if k != 'root_output_dir'])\n file_name = 'log' + configs\n create_if_not_exists(FLAGS.root_output_dir)\n file_handle = open(os.path.join(FLAGS.root_output_dir, file_name), 'w')\n\n global_step = tf.Variable(1, name='global_step', dtype=tf.int64)\n file_writer = tf.summary.create_file_writer(\n os.path.join(FLAGS.root_output_dir))\n file_writer.set_as_default()\n write_print(file_handle, '=======configurations========')\n write_print(file_handle, configs)\n write_print(file_handle, '=======configurations========')\n # prepare dataset.\n write_print(file_handle, 'Loading Dataset!')\n emnist_train, _ = tff.simulation.datasets.emnist.load_data(\n only_digits=FLAGS.only_digits)\n\n # prepare test set\n write_print(file_handle, 'Loading Test Set!')\n test_image, test_label = load_test_data()\n\n # load malicious dataset\n write_print(file_handle, 'Loading malicious dataset!')\n dataset_malicious, target_x, target_y = load_malicious_dataset(FLAGS.task_num)\n\n # prepare model_fn.\n example_dataset = preprocess(\n emnist_train.create_tf_dataset_for_client(emnist_train.client_ids[0]))\n input_spec = example_dataset.element_spec\n\n def model_fn():\n keras_model = create_keras_model()\n return tff.learning.from_keras_model(\n keras_model,\n input_spec=input_spec,\n loss=tf.keras.losses.SparseCategoricalCrossentropy(),\n metrics=[tf.keras.metrics.SparseCategoricalAccuracy()])\n\n # define server optimizer\n nesterov = True if FLAGS.server_momentum != 0 else False\n\n def server_optimizer_fn():\n return tf.keras.optimizers.SGD(\n learning_rate=FLAGS.server_learning_rate,\n momentum=FLAGS.server_momentum,\n nesterov=nesterov)\n\n # build interative process\n write_print(file_handle, 'Building Iterative Process!')\n client_update_function = attacked_fedavg.ClientProjectBoost(\n boost_factor=float(FLAGS.num_clients_per_round),\n norm_bound=FLAGS.norm_bound,\n round_num=FLAGS.client_round_num)\n query = tensorflow_privacy.GaussianAverageQuery(FLAGS.l2_norm_clip,\n FLAGS.mul_factor,\n FLAGS.num_clients_per_round)\n dp_aggregate_fn = tff.utils.build_dp_aggregate_process(\n tff.learning.framework.weights_type_from_model(model_fn), query)\n iterative_process = attacked_fedavg.build_federated_averaging_process_attacked(\n model_fn=model_fn,\n aggregation_process=dp_aggregate_fn,\n client_update_tf=client_update_function,\n server_optimizer_fn=server_optimizer_fn)\n state = iterative_process.initialize()\n\n # training loop\n for cur_round in range(FLAGS.num_rounds):\n if cur_round % FLAGS.attack_freq == FLAGS.attack_freq // 2:\n with_attack = 1\n write_print(file_handle, 'Attacker appears!')\n else:\n with_attack = 0\n\n # sample clients and make federated dataset\n federated_train_data, federated_malicious_data, client_type_list = \\\n sample_clients_with_malicious(\n emnist_train, client_ids=emnist_train.client_ids,\n dataset_malicious=dataset_malicious,\n num_clients=FLAGS.num_clients_per_round, with_attack=with_attack)\n\n # one round of attacked federated averaging\n write_print(file_handle, 'Round starts!')\n state, train_metrics = iterative_process.next(state, federated_train_data,\n federated_malicious_data,\n client_type_list)\n\n write_print(\n file_handle,\n 'Training round {:2d}, train_metrics={}'.format(cur_round,\n train_metrics))\n\n log_tfboard('train_acc', train_metrics['sparse_categorical_accuracy'],\n global_step)\n log_tfboard('train_loss', train_metrics['loss'], global_step)\n\n # evaluate current model on test data and malicious data\n if cur_round % FLAGS.evaluate_per_rounds == 0:\n test_metrics, test_metrics_target = evaluate(state, test_image,\n test_label, target_x,\n target_y)\n write_print(\n file_handle,\n 'Evaluation round {:2d}, <sparse_categorical_accuracy={},loss={}>'\n .format(cur_round, test_metrics[1], test_metrics[0]))\n write_print(\n file_handle,\n 'Evaluation round {:2d}, <sparse_categorical_accuracy={},loss={}>'\n .format(cur_round, test_metrics_target[1], test_metrics_target[0]))\n log_tfboard('test_acc', test_metrics[1], global_step)\n log_tfboard('test_loss', test_metrics[0], global_step)\n log_tfboard('test_acc_target', test_metrics_target[1], global_step)\n log_tfboard('test_loss_target', test_metrics_target[0], global_step)\n\n global_step.assign_add(1)\n\n\nif __name__ == '__main__':\n app.run(main)\n"
] |
[
[
"tensorflow.keras.losses.SparseCategoricalCrossentropy",
"tensorflow.test.main",
"numpy.ones",
"tensorflow.keras.metrics.SparseCategoricalAccuracy",
"tensorflow.TensorSpec"
],
[
"tensorflow.cast",
"tensorflow.compat.v1.enable_eager_execution",
"numpy.concatenate",
"tensorflow.summary.scalar",
"tensorflow.keras.optimizers.SGD",
"tensorflow.Variable",
"tensorflow.keras.layers.Conv2D",
"scipy.io.loadmat",
"tensorflow.keras.layers.Flatten",
"tensorflow.data.Dataset.from_tensors",
"numpy.random.choice",
"tensorflow.keras.layers.Dense",
"tensorflow.io.gfile.makedirs",
"tensorflow.compat.v1.ConfigProto",
"tensorflow.keras.metrics.SparseCategoricalAccuracy",
"numpy.random.seed",
"tensorflow.keras.losses.SparseCategoricalCrossentropy",
"tensorflow.reshape",
"tensorflow.keras.layers.MaxPool2D",
"tensorflow.keras.utils.get_file",
"tensorflow.keras.layers.Dropout"
]
] |
VJWQ/forecasting
|
[
"0b540aa8fc073f1f9a7725066c2c4fec59c690c6",
"f24bbd59195280ce8697968c172e5120fb2265d2"
] |
[
"Ego4D-Future-Hand-Prediction/slowfast/datasets/utils.py",
"Ego4D-Future-Hand-Prediction/slowfast/visualization/ava_demo_precomputed_boxes.py"
] |
[
"#!/usr/bin/env python3\n\nimport logging\nimport numpy as np\nimport os\nimport random\nimport time\nfrom collections import defaultdict\nimport cv2\nimport torch\nfrom iopath.common.file_io import g_pathmgr\nfrom torch.utils.data.distributed import DistributedSampler\n\nfrom . import transform as transform\n\nlogger = logging.getLogger(__name__)\n\n\ndef retry_load_images(image_paths, retry=10, backend=\"pytorch\"):\n \"\"\"\n This function is to load images with support of retrying for failed load.\n\n Args:\n image_paths (list): paths of images needed to be loaded.\n retry (int, optional): maximum time of loading retrying. Defaults to 10.\n backend (str): `pytorch` or `cv2`.\n\n Returns:\n imgs (list): list of loaded images.\n \"\"\"\n for i in range(retry):\n imgs = []\n for image_path in image_paths:\n with g_pathmgr.open(image_path, \"rb\") as f:\n img_str = np.frombuffer(f.read(), np.uint8)\n img = cv2.imdecode(img_str, flags=cv2.IMREAD_COLOR)\n imgs.append(img)\n\n if all(img is not None for img in imgs):\n if backend == \"pytorch\":\n imgs = torch.as_tensor(np.stack(imgs))\n return imgs\n else:\n logger.warn(\"Reading failed. Will retry.\")\n time.sleep(1.0)\n if i == retry - 1:\n raise Exception(\"Failed to load images {}\".format(image_paths))\n\n\ndef get_sequence(center_idx, half_len, sample_rate, num_frames):\n \"\"\"\n Sample frames among the corresponding clip.\n\n Args:\n center_idx (int): center frame idx for current clip\n half_len (int): half of the clip length\n sample_rate (int): sampling rate for sampling frames inside of the clip\n num_frames (int): number of expected sampled frames\n\n Returns:\n seq (list): list of indexes of sampled frames in this clip.\n \"\"\"\n seq = list(range(center_idx - half_len, center_idx + half_len, sample_rate))\n\n for seq_idx in range(len(seq)):\n if seq[seq_idx] < 0:\n seq[seq_idx] = 0\n elif seq[seq_idx] >= num_frames:\n seq[seq_idx] = num_frames - 1\n return seq\n\n\ndef pack_pathway_output(cfg, frames):\n \"\"\"\n Prepare output as a list of tensors. Each tensor corresponding to a\n unique pathway.\n Args:\n frames (tensor): frames of images sampled from the video. The\n dimension is `channel` x `num frames` x `height` x `width`.\n Returns:\n frame_list (list): list of tensors with the dimension of\n `channel` x `num frames` x `height` x `width`.\n \"\"\"\n if cfg.DATA.REVERSE_INPUT_CHANNEL:\n frames = frames[[2, 1, 0], :, :, :]\n if cfg.MODEL.ARCH in cfg.MODEL.SINGLE_PATHWAY_ARCH:\n frame_list = [frames]\n elif cfg.MODEL.ARCH in cfg.MODEL.MULTI_PATHWAY_ARCH:\n fast_pathway = frames\n # Perform temporal sampling from the fast pathway.\n slow_pathway = torch.index_select(\n frames,\n 1,\n torch.linspace(\n 0, frames.shape[1] - 1, frames.shape[1] // cfg.SLOWFAST.ALPHA\n ).long(),\n )\n frame_list = [slow_pathway, fast_pathway]\n else:\n raise NotImplementedError(\n \"Model arch {} is not in {}\".format(\n cfg.MODEL.ARCH,\n cfg.MODEL.SINGLE_PATHWAY_ARCH + cfg.MODEL.MULTI_PATHWAY_ARCH,\n )\n )\n return frame_list\n\n\ndef spatial_sampling(\n frames,\n spatial_idx=-1,\n min_scale=256,\n max_scale=320,\n crop_size=224,\n random_horizontal_flip=True,\n inverse_uniform_sampling=False,\n):\n \"\"\"\n Perform spatial sampling on the given video frames. If spatial_idx is\n -1, perform random scale, random crop, and random flip on the given\n frames. If spatial_idx is 0, 1, or 2, perform spatial uniform sampling\n with the given spatial_idx.\n Args:\n frames (tensor): frames of images sampled from the video. The\n dimension is `num frames` x `height` x `width` x `channel`.\n spatial_idx (int): if -1, perform random spatial sampling. If 0, 1,\n or 2, perform left, center, right crop if width is larger than\n height, and perform top, center, buttom crop if height is larger\n than width.\n min_scale (int): the minimal size of scaling.\n max_scale (int): the maximal size of scaling.\n crop_size (int): the size of height and width used to crop the\n frames.\n inverse_uniform_sampling (bool): if True, sample uniformly in\n [1 / max_scale, 1 / min_scale] and take a reciprocal to get the\n scale. If False, take a uniform sample from [min_scale,\n max_scale].\n Returns:\n frames (tensor): spatially sampled frames.\n \"\"\"\n assert spatial_idx in [-1, 0, 1, 2]\n if spatial_idx == -1:\n frames, _ = transform.random_short_side_scale_jitter(\n images=frames,\n min_size=min_scale,\n max_size=max_scale,\n inverse_uniform_sampling=inverse_uniform_sampling,\n )\n frames, _ = transform.random_crop(frames, crop_size)\n if random_horizontal_flip:\n frames, _ = transform.horizontal_flip(0.5, frames)\n else:\n # The testing is deterministic and no jitter should be performed.\n # min_scale, max_scale, and crop_size are expect to be the same.\n assert len({min_scale, max_scale, crop_size}) == 1\n frames, _ = transform.random_short_side_scale_jitter(\n frames, min_scale, max_scale\n )\n frames, _ = transform.uniform_crop(frames, crop_size, spatial_idx)\n return frames\n\n\ndef as_binary_vector(labels, num_classes):\n \"\"\"\n Construct binary label vector given a list of label indices.\n Args:\n labels (list): The input label list.\n num_classes (int): Number of classes of the label vector.\n Returns:\n labels (numpy array): the resulting binary vector.\n \"\"\"\n label_arr = np.zeros((num_classes,))\n\n for lbl in set(labels):\n label_arr[lbl] = 1.0\n return label_arr\n\n\ndef aggregate_labels(label_list):\n \"\"\"\n Join a list of label list.\n Args:\n labels (list): The input label list.\n Returns:\n labels (list): The joint list of all lists in input.\n \"\"\"\n all_labels = []\n for labels in label_list:\n for l in labels:\n all_labels.append(l)\n return list(set(all_labels))\n\n\ndef convert_to_video_level_labels(labels):\n \"\"\"\n Aggregate annotations from all frames of a video to form video-level labels.\n Args:\n labels (list): The input label list.\n Returns:\n labels (list): Same as input, but with each label replaced by\n a video-level one.\n \"\"\"\n for video_id in range(len(labels)):\n video_level_labels = aggregate_labels(labels[video_id])\n for i in range(len(labels[video_id])):\n labels[video_id][i] = video_level_labels\n return labels\n\n\ndef load_image_lists(frame_list_file, prefix=\"\", return_list=False):\n \"\"\"\n Load image paths and labels from a \"frame list\".\n Each line of the frame list contains:\n `original_vido_id video_id frame_id path labels`\n Args:\n frame_list_file (string): path to the frame list.\n prefix (str): the prefix for the path.\n return_list (bool): if True, return a list. If False, return a dict.\n Returns:\n image_paths (list or dict): list of list containing path to each frame.\n If return_list is False, then return in a dict form.\n labels (list or dict): list of list containing label of each frame.\n If return_list is False, then return in a dict form.\n \"\"\"\n image_paths = defaultdict(list)\n labels = defaultdict(list)\n with g_pathmgr.open(frame_list_file, \"r\") as f:\n assert f.readline().startswith(\"original_vido_id\")\n for line in f:\n row = line.split()\n # original_vido_id video_id frame_id path labels\n assert len(row) == 5\n video_name = row[0]\n if prefix == \"\":\n path = row[3]\n else:\n path = os.path.join(prefix, row[3])\n image_paths[video_name].append(path)\n frame_labels = row[-1].replace('\"', \"\")\n if frame_labels != \"\":\n labels[video_name].append(\n [int(x) for x in frame_labels.split(\",\")]\n )\n else:\n labels[video_name].append([])\n\n if return_list:\n keys = image_paths.keys()\n image_paths = [image_paths[key] for key in keys]\n labels = [labels[key] for key in keys]\n return image_paths, labels\n return dict(image_paths), dict(labels)\n\n\ndef tensor_normalize(tensor, mean, std):\n \"\"\"\n Normalize a given tensor by subtracting the mean and dividing the std.\n Args:\n tensor (tensor): tensor to normalize.\n mean (tensor or list): mean value to subtract.\n std (tensor or list): std to divide.\n \"\"\"\n if tensor.dtype == torch.uint8:\n tensor = tensor.float()\n tensor = tensor / 255.0\n if type(mean) == list:\n mean = torch.tensor(mean)\n if type(std) == list:\n std = torch.tensor(std)\n tensor = tensor - mean\n tensor = tensor / std\n return tensor\n\n\ndef get_random_sampling_rate(long_cycle_sampling_rate, sampling_rate):\n \"\"\"\n When multigrid training uses a fewer number of frames, we randomly\n increase the sampling rate so that some clips cover the original span.\n \"\"\"\n if long_cycle_sampling_rate > 0:\n assert long_cycle_sampling_rate >= sampling_rate\n return random.randint(sampling_rate, long_cycle_sampling_rate)\n else:\n return sampling_rate\n\n\ndef revert_tensor_normalize(tensor, mean, std):\n \"\"\"\n Revert normalization for a given tensor by multiplying by the std and adding the mean.\n Args:\n tensor (tensor): tensor to revert normalization.\n mean (tensor or list): mean value to add.\n std (tensor or list): std to multiply.\n \"\"\"\n if type(mean) == list:\n mean = torch.tensor(mean)\n if type(std) == list:\n std = torch.tensor(std)\n tensor = tensor * std\n tensor = tensor + mean\n return tensor\n\n\ndef create_sampler(dataset, shuffle, cfg):\n \"\"\"\n Create sampler for the given dataset.\n Args:\n dataset (torch.utils.data.Dataset): the given dataset.\n shuffle (bool): set to ``True`` to have the data reshuffled\n at every epoch.\n cfg (CfgNode): configs. Details can be found in\n slowfast/config/defaults.py\n Returns:\n sampler (Sampler): the created sampler.\n \"\"\"\n sampler = DistributedSampler(dataset) if cfg.NUM_GPUS > 1 else None\n\n return sampler\n\n\ndef loader_worker_init_fn(dataset):\n \"\"\"\n Create init function passed to pytorch data loader.\n Args:\n dataset (torch.utils.data.Dataset): the given dataset.\n \"\"\"\n return None\n",
"#!/usr/bin/env python3\n# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.\n\nimport numpy as np\nimport os\nimport cv2\nimport torch\nimport tqdm\nfrom iopath.common.file_io import g_pathmgr\n\nimport slowfast.utils.checkpoint as cu\nimport slowfast.utils.logging as logging\nfrom slowfast.datasets.ava_helper import parse_bboxes_file\nfrom slowfast.datasets.cv2_transform import scale, scale_boxes\nfrom slowfast.datasets.utils import get_sequence\nfrom slowfast.models import build_model\nfrom slowfast.utils import misc\nfrom slowfast.visualization.utils import process_cv2_inputs\nfrom slowfast.visualization.video_visualizer import VideoVisualizer\n\nlogger = logging.get_logger(__name__)\n\n\nclass AVAVisualizerWithPrecomputedBox:\n \"\"\"\n Visualize action predictions for videos or folder of images with precomputed\n and ground-truth boxes in AVA format.\n \"\"\"\n\n def __init__(self, cfg):\n \"\"\"\n Args:\n cfg (CfgNode): configs. Details can be found in\n slowfast/config/defaults.py\n \"\"\"\n self.source = g_pathmgr.get_local_path(path=cfg.DEMO.INPUT_VIDEO)\n self.fps = None\n if g_pathmgr.isdir(self.source):\n self.fps = cfg.DEMO.FPS\n self.video_name = self.source.split(\"/\")[-1]\n self.source = os.path.join(\n self.source, \"{}_%06d.jpg\".format(self.video_name)\n )\n else:\n self.video_name = self.source.split(\"/\")[-1]\n self.video_name = self.video_name.split(\".\")[0]\n\n self.cfg = cfg\n self.cap = cv2.VideoCapture(self.source)\n if self.fps is None:\n self.fps = self.cap.get(cv2.CAP_PROP_FPS)\n\n self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))\n\n self.display_width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n self.display_height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n\n if not self.cap.isOpened():\n raise IOError(\"Video {} cannot be opened\".format(self.source))\n\n self.output_file = None\n\n if cfg.DEMO.OUTPUT_FILE != \"\":\n self.output_file = self.get_output_file(cfg.DEMO.OUTPUT_FILE)\n\n self.pred_boxes, self.gt_boxes = load_boxes_labels(\n cfg,\n self.video_name,\n self.fps,\n self.display_width,\n self.display_height,\n )\n\n self.seq_length = cfg.DATA.NUM_FRAMES * cfg.DATA.SAMPLING_RATE\n self.no_frames_repeat = cfg.DEMO.SLOWMO\n\n def get_output_file(self, path):\n \"\"\"\n Return a video writer object.\n Args:\n path (str): path to the output video file.\n \"\"\"\n return cv2.VideoWriter(\n filename=path,\n fourcc=cv2.VideoWriter_fourcc(*\"mp4v\"),\n fps=float(30),\n frameSize=(self.display_width, self.display_height),\n isColor=True,\n )\n\n def get_input_clip(self, keyframe_idx):\n \"\"\"\n Get input clip from the video/folder of images for a given\n keyframe index.\n Args:\n keyframe_idx (int): index of the current keyframe.\n Returns:\n clip (list of tensors): formatted input clip(s) corresponding to\n the current keyframe.\n \"\"\"\n seq = get_sequence(\n keyframe_idx,\n self.seq_length // 2,\n self.cfg.DATA.SAMPLING_RATE,\n self.total_frames,\n )\n clip = []\n for frame_idx in seq:\n self.cap.set(cv2.CAP_PROP_POS_FRAMES, frame_idx)\n was_read, frame = self.cap.read()\n if was_read:\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)\n frame = scale(self.cfg.DATA.TEST_CROP_SIZE, frame)\n clip.append(frame)\n else:\n logger.error(\n \"Unable to read frame. Duplicating previous frame.\"\n )\n clip.append(clip[-1])\n\n clip = process_cv2_inputs(clip, self.cfg)\n return clip\n\n def get_predictions(self):\n \"\"\"\n Predict and append prediction results to each box in each keyframe in\n `self.pred_boxes` dictionary.\n \"\"\"\n # Set random seed from configs.\n np.random.seed(self.cfg.RNG_SEED)\n torch.manual_seed(self.cfg.RNG_SEED)\n\n # Setup logging format.\n logging.setup_logging(self.cfg.OUTPUT_DIR)\n\n # Print config.\n logger.info(\"Run demo with config:\")\n logger.info(self.cfg)\n assert (\n self.cfg.NUM_GPUS <= 1\n ), \"Cannot run demo visualization on multiple GPUs.\"\n\n # Build the video model and print model statistics.\n model = build_model(self.cfg)\n model.eval()\n logger.info(\"Start loading model info\")\n misc.log_model_info(model, self.cfg, use_train_input=False)\n logger.info(\"Start loading model weights\")\n cu.load_test_checkpoint(self.cfg, model)\n logger.info(\"Finish loading model weights\")\n logger.info(\"Start making predictions for precomputed boxes.\")\n for keyframe_idx, boxes_and_labels in tqdm.tqdm(\n self.pred_boxes.items()\n ):\n inputs = self.get_input_clip(keyframe_idx)\n boxes = boxes_and_labels[0]\n boxes = torch.from_numpy(np.array(boxes)).float()\n\n box_transformed = scale_boxes(\n self.cfg.DATA.TEST_CROP_SIZE,\n boxes,\n self.display_height,\n self.display_width,\n )\n\n # Pad frame index for each box.\n box_inputs = torch.cat(\n [\n torch.full((box_transformed.shape[0], 1), float(0)),\n box_transformed,\n ],\n axis=1,\n )\n if self.cfg.NUM_GPUS:\n # Transfer the data to the current GPU device.\n if isinstance(inputs, (list,)):\n for i in range(len(inputs)):\n inputs[i] = inputs[i].cuda(non_blocking=True)\n else:\n inputs = inputs.cuda(non_blocking=True)\n\n box_inputs = box_inputs.cuda()\n\n preds = model(inputs, box_inputs)\n\n preds = preds.detach()\n\n if self.cfg.NUM_GPUS:\n preds = preds.cpu()\n\n boxes_and_labels[1] = preds\n\n def draw_video(self):\n \"\"\"\n Draw predicted and ground-truth (if provided) results on the video/folder of images.\n Write the visualized result to a video output file.\n \"\"\"\n all_boxes = merge_pred_gt_boxes(self.pred_boxes, self.gt_boxes)\n common_classes = (\n self.cfg.DEMO.COMMON_CLASS_NAMES\n if len(self.cfg.DEMO.LABEL_FILE_PATH) != 0\n else None\n )\n video_vis = VideoVisualizer(\n num_classes=self.cfg.MODEL.NUM_CLASSES,\n class_names_path=self.cfg.DEMO.LABEL_FILE_PATH,\n top_k=self.cfg.TENSORBOARD.MODEL_VIS.TOPK_PREDS,\n thres=self.cfg.DEMO.COMMON_CLASS_THRES,\n lower_thres=self.cfg.DEMO.UNCOMMON_CLASS_THRES,\n common_class_names=common_classes,\n colormap=self.cfg.TENSORBOARD.MODEL_VIS.COLORMAP,\n mode=self.cfg.DEMO.VIS_MODE,\n )\n\n all_keys = sorted(all_boxes.keys())\n # Draw around the keyframe for 2/10 of the sequence length.\n # This is chosen using heuristics.\n draw_range = [\n self.seq_length // 2 - self.seq_length // 10,\n self.seq_length // 2 + self.seq_length // 10,\n ]\n draw_range_repeat = [\n draw_range[0],\n (draw_range[1] - draw_range[0]) * self.no_frames_repeat\n + draw_range[0],\n ]\n prev_buffer = []\n prev_end_idx = 0\n\n logger.info(\"Start Visualization...\")\n for keyframe_idx in tqdm.tqdm(all_keys):\n pred_gt_boxes = all_boxes[keyframe_idx]\n # Find the starting index of the clip. If start_idx exceeds the beginning\n # of the video, we only choose valid frame from index 0.\n start_idx = max(0, keyframe_idx - self.seq_length // 2)\n # Number of frames from the start of the current clip and the\n # end of the previous clip.\n dist = start_idx - prev_end_idx\n # If there are unwritten frames in between clips.\n if dist >= 0:\n # Get the frames in between previous clip and current clip.\n frames = self._get_frame_range(prev_end_idx, dist)\n # We keep a buffer of frames for overlapping visualization.\n # Write these to the output file.\n for frame in prev_buffer:\n frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)\n self.display(frame)\n # Write them to output file without any visualization\n # since they don't have any corresponding keyframes.\n for frame in frames:\n self.display(frame)\n prev_buffer = []\n num_new_frames = self.seq_length\n\n # If there are overlapping frames in between clips.\n elif dist < 0:\n # Flush all ready frames.\n for frame in prev_buffer[:dist]:\n frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)\n self.display(frame)\n prev_buffer = prev_buffer[dist:]\n num_new_frames = self.seq_length + dist\n # Obtain new frames for the current clip from the input video file.\n new_frames = self._get_frame_range(\n max(start_idx, prev_end_idx), num_new_frames\n )\n new_frames = [\n cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) for frame in new_frames\n ]\n clip = prev_buffer + new_frames\n # Calculate the end of this clip. This will be `prev_end_idx` for the\n # next iteration.\n prev_end_idx = max(start_idx, prev_end_idx) + len(new_frames)\n # For each precomputed or gt boxes.\n for i, boxes in enumerate(pred_gt_boxes):\n if i == 0:\n repeat = self.no_frames_repeat\n current_draw_range = draw_range\n else:\n repeat = 1\n current_draw_range = draw_range_repeat\n # Make sure draw range does not fall out of end of clip.\n current_draw_range[1] = min(\n current_draw_range[1], len(clip) - 1\n )\n ground_truth = boxes[0]\n bboxes = boxes[1]\n label = boxes[2]\n # Draw predictions.\n clip = video_vis.draw_clip_range(\n clip,\n label,\n bboxes=torch.Tensor(bboxes),\n ground_truth=ground_truth,\n draw_range=current_draw_range,\n repeat_frame=repeat,\n )\n # Store the current clip as buffer.\n prev_buffer = clip\n\n # Write the remaining buffer to output file.\n for frame in prev_buffer:\n frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)\n self.display(frame)\n # If we still have some remaining frames in the input file,\n # write those to the output file as well.\n if prev_end_idx < self.total_frames:\n dist = self.total_frames - prev_end_idx\n remaining_clip = self._get_frame_range(prev_end_idx, dist)\n for frame in remaining_clip:\n self.display(frame)\n\n def __call__(self):\n self.get_predictions()\n self.draw_video()\n\n def display(self, frame):\n \"\"\"\n Either display a single frame (BGR image) to a window or write to\n an output file if output path is provided.\n \"\"\"\n if self.output_file is None:\n cv2.imshow(\"SlowFast\", frame)\n else:\n self.output_file.write(frame)\n\n def _get_keyframe_clip(self, keyframe_idx):\n \"\"\"\n Return a clip corresponding to a keyframe index for visualization.\n Args:\n keyframe_idx (int): keyframe index.\n \"\"\"\n start_idx = max(0, keyframe_idx - self.seq_length // 2)\n\n clip = self._get_frame_range(start_idx, self.seq_length)\n\n return clip\n\n def _get_frame_range(self, start_idx, num_frames):\n \"\"\"\n Return a clip of `num_frames` frames starting from `start_idx`. If not enough frames\n from `start_idx`, return the remaining frames from `start_idx`.\n Args:\n start_idx (int): starting idx.\n num_frames (int): number of frames in the returned clip.\n \"\"\"\n was_read = True\n assert start_idx < self.total_frames, \"Start index out of range.\"\n\n self.cap.set(cv2.CAP_PROP_POS_FRAMES, start_idx)\n all_frames = []\n for _ in range(num_frames):\n was_read, frame = self.cap.read()\n if was_read:\n all_frames.append(frame)\n else:\n break\n\n return all_frames\n\n\ndef merge_pred_gt_boxes(pred_dict, gt_dict=None):\n \"\"\"\n Merge data from precomputed and ground-truth boxes dictionaries.\n Args:\n pred_dict (dict): a dict which maps from `frame_idx` to a list of `boxes`\n and `labels`. Each `box` is a list of 4 box coordinates. `labels[i]` is\n a list of labels for `boxes[i]`.\n gt_dict (Optional[dict]): a dict which maps from `frame_idx` to a list of `boxes`\n and `labels`. Each `box` is a list of 4 box coordinates. `labels[i]` is\n a list of labels for `boxes[i]`. Note that label is -1 for predicted boxes.\n Returns:\n merged_dict (dict): merged dictionary from `pred_dict` and `gt_dict` if given.\n It is a dict which maps from `frame_idx` to a list of [`is_gt`, `boxes`, `labels`],\n where `is_gt` is a boolean indicate whether the `boxes` and `labels` are ground-truth.\n \"\"\"\n merged_dict = {}\n for key, item in pred_dict.items():\n merged_dict[key] = [[False, item[0], item[1]]]\n\n if gt_dict is not None:\n for key, item in gt_dict.items():\n if merged_dict.get(key) is None:\n merged_dict[key] = [[True, item[0], item[1]]]\n else:\n merged_dict[key].append([True, item[0], item[1]])\n return merged_dict\n\n\ndef load_boxes_labels(cfg, video_name, fps, img_width, img_height):\n \"\"\"\n Loading boxes and labels from AVA bounding boxes csv files.\n Args:\n cfg (CfgNode): config.\n video_name (str): name of the given video.\n fps (int or float): frames per second of the input video/images folder.\n img_width (int): width of images in input video/images folder.\n img_height (int): height of images in input video/images folder.\n Returns:\n preds_boxes (dict): a dict which maps from `frame_idx` to a list of `boxes`\n and `labels`. Each `box` is a list of 4 box coordinates. `labels[i]` is\n a list of labels for `boxes[i]`. Note that label is -1 for predicted boxes.\n gt_boxes (dict): if cfg.DEMO.GT_BOXES is given, return similar dict as\n all_pred_boxes but for ground-truth boxes.\n \"\"\"\n starting_second = cfg.DEMO.STARTING_SECOND\n\n def sec_to_frameidx(sec):\n return (sec - starting_second) * fps\n\n def process_bboxes_dict(dictionary):\n \"\"\"\n Replace all `keyframe_sec` in `dictionary` with `keyframe_idx` and\n merge all [`box_coordinate`, `box_labels`] pairs into\n [`all_boxes_coordinates`, `all_boxes_labels`] for each `keyframe_idx`.\n Args:\n dictionary (dict): a dictionary which maps `frame_sec` to a list of `box`.\n Each `box` is a [`box_coord`, `box_labels`] where `box_coord` is the\n coordinates of box and 'box_labels` are the corresponding\n labels for the box.\n Returns:\n new_dict (dict): a dict which maps from `frame_idx` to a list of `boxes`\n and `labels`. Each `box` in `boxes` is a list of 4 box coordinates. `labels[i]`\n is a list of labels for `boxes[i]`. Note that label is -1 for predicted boxes.\n \"\"\"\n # Replace all keyframe_sec with keyframe_idx.\n new_dict = {}\n for keyframe_sec, boxes_and_labels in dictionary.items():\n # Ignore keyframes with no boxes\n if len(boxes_and_labels) == 0:\n continue\n keyframe_idx = sec_to_frameidx(keyframe_sec)\n boxes, labels = list(zip(*boxes_and_labels))\n # Shift labels from [1, n_classes] to [0, n_classes - 1].\n labels = [[i - 1 for i in box_label] for box_label in labels]\n boxes = np.array(boxes)\n boxes[:, [0, 2]] *= img_width\n boxes[:, [1, 3]] *= img_height\n new_dict[keyframe_idx] = [boxes.tolist(), list(labels)]\n return new_dict\n\n preds_boxes_path = cfg.DEMO.PREDS_BOXES\n gt_boxes_path = cfg.DEMO.GT_BOXES\n\n preds_boxes, _, _ = parse_bboxes_file(\n ann_filenames=[preds_boxes_path],\n ann_is_gt_box=[False],\n detect_thresh=cfg.AVA.DETECTION_SCORE_THRESH,\n boxes_sample_rate=1,\n )\n preds_boxes = preds_boxes[video_name]\n if gt_boxes_path == \"\":\n gt_boxes = None\n else:\n gt_boxes, _, _ = parse_bboxes_file(\n ann_filenames=[gt_boxes_path],\n ann_is_gt_box=[True],\n detect_thresh=cfg.AVA.DETECTION_SCORE_THRESH,\n boxes_sample_rate=1,\n )\n gt_boxes = gt_boxes[video_name]\n\n preds_boxes = process_bboxes_dict(preds_boxes)\n if gt_boxes is not None:\n gt_boxes = process_bboxes_dict(gt_boxes)\n\n return preds_boxes, gt_boxes\n"
] |
[
[
"torch.linspace",
"torch.utils.data.distributed.DistributedSampler",
"numpy.stack",
"torch.tensor",
"numpy.zeros"
],
[
"torch.manual_seed",
"torch.Tensor",
"numpy.array",
"numpy.random.seed"
]
] |
WangShengguang/NERE
|
[
"4b8166aa348b9db207bb9a1e1da6eed5d567ae6f",
"4b8166aa348b9db207bb9a1e1da6eed5d567ae6f"
] |
[
"nere/re_models/bert_softmax.py",
"nere/torch_trainer.py"
] |
[
"\"\"\"BERT + Softmax for named entity recognition\"\"\"\n\nimport torch\nimport torch.nn as nn\nfrom pytorch_pretrained_bert.modeling import BertModel, BertPreTrainedModel, gelu\nfrom torch.nn import CrossEntropyLoss\n\ntry:\n from apex.normalization.fused_layer_norm import FusedLayerNorm as BertLayerNorm\nexcept ImportError:\n print(\"Better speed can be achieved with apex installed from https://www.github.com/nvidia/apex.\")\n\n\n class BertLayerNorm(nn.Module):\n def __init__(self, hidden_size, eps=1e-12):\n \"\"\"Construct a layernorm module in the TF style (epsilon inside the square root).\n \"\"\"\n super(BertLayerNorm, self).__init__()\n self.weight = nn.Parameter(torch.ones(hidden_size))\n self.bias = nn.Parameter(torch.zeros(hidden_size))\n self.variance_epsilon = eps\n\n def forward(self, x):\n u = x.mean(-1, keepdim=True)\n s = (x - u).pow(2).mean(-1, keepdim=True)\n x = (x - u) / torch.sqrt(s + self.variance_epsilon)\n return self.weight * x + self.bias\n\n\nclass BERTSoftmax(BertPreTrainedModel):\n \"\"\"BERT model for token-level classification.\n This module is composed of the BERT model with a linear layer on top of\n the full hidden state of the last layer.\n\n Args:\n config: a BertConfig class instance with the configuration to build a new model.\n num_labels: the number of classes for the classifier. Default = 2.\n \n Inputs:\n input_ids: a torch.LongTensor of shape (batch_size, seq_length)\n with the word token indices in the vocabulary.\n token_type_ids: an optional torch.LongTensor of shape (batch_size, seq_length) with the token\n types indices selected in [0, 1]. Type 0 corresponds to a `sentence A` and type 1 corresponds to\n a `sentence B` token.\n attention_mask: an optional torch.LongTensor of shape (batch_size, seq_length) with indices\n selected in [0, 1]. It's a mask to be used if the input sequence length is smaller than the max\n input sequence length in the current batch. It's the mask that we typically use for attention when\n a batch has varying length sentences.\n labels: labels for the classification output: torch.LongTensor of shape (batch_size, seq_length)\n with indices selected in [0, ..., num_labels].\n\n Returns:\n if labels is not None:\n Outputs the CrossEntropy classification loss of the output with the labels.\n if labels is None:\n Outputs the classification labels indices of shape (batch_size, seq_length).\n \"\"\"\n\n def __init__(self, config, num_labels, ent_num_lables=20):\n super(BERTSoftmax, self).__init__(config)\n self.num_labels = num_labels # the number of relation labels\n ent_label_dim = 128\n self.ent_label_embeddings = nn.Embedding(ent_num_lables, ent_label_dim)\n self.ent_emb_layer_norm = BertLayerNorm(ent_label_dim * 2, eps=1e-12)\n\n self.fused_layer_norm_1 = BertLayerNorm(config.hidden_size * 3, eps=1e-12)\n self.fused_layer_norm_2 = BertLayerNorm(config.hidden_size, eps=1e-12)\n\n self.bert = BertModel(config)\n self.dropout = nn.Dropout(config.hidden_dropout_prob)\n\n self.fused_layer = nn.Linear(config.hidden_size * 3, config.hidden_size)\n # features_size = ent_label_dim * 2 + config.hidden_size * 3\n self.classifier = nn.Linear(ent_label_dim * 2 + config.hidden_size, num_labels)\n\n self.init_weights()\n\n self.loss_fct = CrossEntropyLoss()\n\n # def init_bert_weights(self, module):\n # \"\"\" Initialize the weights.\n # \"\"\"\n # if isinstance(module, (nn.Linear, nn.Embedding)):\n # # Slightly different from the TF version which uses truncated_normal for initialization\n # # cf https://github.com/pytorch/pytorch/pull/5617\n # module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)\n # elif isinstance(module, BertLayerNorm):\n # module.bias.data.zero_()\n # module.weight.data.fill_(1.0)\n # if isinstance(module, nn.Linear) and module.bias is not None:\n # module.bias.data.zero_()\n\n def init_weights(self):\n self.apply(self.init_bert_weights)\n\n self.ent_label_embeddings.weight.data.normal_(mean=0.0, std=0.2)\n self.ent_emb_layer_norm.weight.data.fill_(1.0)\n self.ent_emb_layer_norm.bias.data.zero_()\n\n self.fused_layer_norm_1.weight.data.fill_(1.0)\n self.fused_layer_norm_1.bias.data.zero_()\n\n self.fused_layer_norm_2.weight.data.fill_(1.0)\n self.fused_layer_norm_2.bias.data.zero_()\n\n self.fused_layer.weight.data.normal_(mean=0.0, std=0.2)\n self.fused_layer.bias.data.zero_()\n\n self.classifier.weight.data.normal_(mean=0.0, std=0.2)\n self.classifier.bias.data.zero_()\n\n def get_ent_features(self, seq_output, ent_masks):\n \"\"\"\n Args:\n seq_output: (batch_size, seq_length, hidden_size)\n ent_mentions: (batch_size, 2, ent_label_dim), 2: 2 mentions, ent_label_dim: `start` and `end` indices\n \"\"\"\n # shape: (batch_size, seq_length, hidden_size)\n # ent_masks_expand = ent_masks.unsqueeze(-1).expand_as(seq_output).half()\n ent_masks_expand = ent_masks.unsqueeze(-1).expand_as(seq_output).float()\n # shape: (batch_size, 1)\n # ent_masks_sum = ent_masks.sum(dim=1).unsqueeze(1).half()\n ent_masks_sum = ent_masks.sum(dim=1).unsqueeze(1).float()\n ones = torch.ones_like(ent_masks_sum)\n ent_masks_sum = torch.where(ent_masks_sum > 0, ent_masks_sum, ones)\n # shape: (batch_size, hidden_size)\n ent_features = seq_output.mul(ent_masks_expand).sum(dim=1).div(ent_masks_sum)\n return ent_features\n\n def forward(self, batch_data, labels=None):\n ent_labels = batch_data['ent_labels']\n e1_masks = batch_data['e1_masks']\n e2_masks = batch_data['e2_masks']\n sents = batch_data['sents']\n\n masks = batch_data['sents'].gt(0)\n\n batch_size = sents.size(0)\n # shape: (batch_size, ent_label_dim*2)\n ent_label_features = self.ent_label_embeddings(ent_labels).view(batch_size, -1)\n ent_label_features = self.ent_emb_layer_norm(ent_label_features)\n\n # shape: (batch_size, seq_length, hidden_size), (batch_size, hidden_size)\n seq_output, pooled_output = self.bert(sents, attention_mask=masks, output_all_encoded_layers=False)\n\n # shape: (batch_size, hidden_size)\n e1_features = self.get_ent_features(seq_output, e1_masks)\n e2_features = self.get_ent_features(seq_output, e2_masks)\n\n # shape: (batch_size, hidden_size*3)\n fused_features = torch.cat((e1_features, e2_features, pooled_output), dim=1)\n fused_features = self.fused_layer_norm_1(fused_features)\n fused_features = self.dropout(fused_features)\n # shape: (batch_size, hidden_size)\n fused_features = self.fused_layer(fused_features)\n fused_features = gelu(fused_features)\n fused_features = self.fused_layer_norm_2(fused_features)\n\n all_features = torch.cat((ent_label_features, fused_features), dim=1)\n\n # shape: (batch_size, features_size)\n all_features = self.dropout(all_features)\n\n logits = self.classifier(all_features)\n label_indices = logits.argmax(dim=1)\n\n if labels is None:\n return label_indices\n else:\n loss = self.loss_fct(logits.view(-1, self.num_labels), labels.view(-1))\n return label_indices, loss\n",
"import logging\nimport os\nfrom pathlib import Path\n\nimport torch\nimport torch.nn as nn\nfrom torch.optim import Adam\nfrom torch.optim.lr_scheduler import LambdaLR\nfrom tqdm import trange\n\nfrom config import Config\nfrom nere.data_helper import DataHelper\nfrom nere.evaluator import Evaluator\n\n\nclass BaseTrainer(object):\n def __init__(self):\n self.global_step = 0\n\n def init_model(self, model):\n model.to(Config.device) # without this there is no error, but it runs in CPU (instead of GPU).\n if Config.gpu_nums > 1 and Config.multi_gpu:\n model = torch.nn.DataParallel(model)\n\n if Config.full_finetuning:\n pass # TODO 参考源代码含义\n param_optimizer = list(model.named_parameters())\n self.no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n self.exclude_params = ['cls.predictions.bias', 'cls.predictions.transform.dense.weight',\n 'cls.predictions.transform.dense.bias',\n 'cls.predictions.transform.LayerNorm.weight',\n 'cls.predictions.transform.LayerNorm.bias', 'cls.predictions.decoder.weight',\n 'cls.seq_relationship.weight', 'cls.seq_relationship.bias']\n\n optimizer_grouped_parameters = [\n {'params': [p for n, p in param_optimizer if\n not any(nd in n for nd in self.no_decay) and n not in self.exclude_params],\n 'weight_decay_rate': 0.01},\n {'params': [p for n, p in param_optimizer if\n any(nd in n for nd in self.no_decay) and n not in self.exclude_params],\n 'weight_decay_rate': 0.0}\n ]\n self.optimizer = Adam(optimizer_grouped_parameters, lr=Config.learning_rate)\n self.scheduler = LambdaLR(self.optimizer, lr_lambda=lambda epoch: 1 / (1 + 0.05 * epoch))\n # model, self.optimizer = amp.initialize(model, self.optimizer, opt_level=\"O1\") # 这里是“欧一”，不是“零一”\n return model\n\n def backfoward(self, loss, model):\n if Config.gpu_nums > 1 and Config.multi_gpu:\n loss = loss.mean() # mean() to average on multi-gpu\n if Config.gradient_accumulation_steps > 1:\n loss = loss / Config.gradient_accumulation_steps\n # https://zhuanlan.zhihu.com/p/79887894\n # with amp.scale_loss(loss, self.optimizer) as scaled_loss:\n # scaled_loss.backward()\n # compute gradients of all variables wrt loss\n loss.backward(retain_graph=True)\n\n if self.global_step % Config.gradient_accumulation_steps == 0:\n # gradient clipping\n nn.utils.clip_grad_norm_(parameters=model.parameters(), max_norm=Config.clip_grad)\n # performs updates using calculated gradients\n self.optimizer.step()\n # clear previous gradients\n self.optimizer.zero_grad()\n return loss\n\n\nclass Trainer(BaseTrainer):\n def __init__(self, model_name, task):\n super().__init__()\n self.model_name = model_name\n self.task = task\n self.model_dir = os.path.join(Config.torch_ckpt_dir, task)\n self.model_path = os.path.join(self.model_dir, model_name + \".bin\")\n os.makedirs(self.model_dir, exist_ok=True)\n # evaluate\n self.evaluator = Evaluator(task, model_name, framework=\"torch\", load_model=False)\n self.best_val_f1 = 0\n self.best_loss = 100\n self.patience_counter = 0\n #\n self.data_helper = DataHelper()\n self.fixed_seq_len = None\n\n def get_re_model(self):\n from nere.re_models import BERTMultitask, BERTSoftmax, ATT_BiLSTM, BiLSTM_ATT, ACNN, BiLSTM\n vocab_size = len(self.data_helper.tokenizer.vocab)\n num_ent_tags = len(self.data_helper.ent_tag2id)\n num_rel_tags = len(self.data_helper.rel_label2id)\n if self.model_name == 'BERTSoftmax':\n model = BERTSoftmax.from_pretrained(Config.bert_pretrained_dir, num_labels=num_rel_tags)\n elif self.model_name == 'BERTMultitask':\n model = BERTMultitask.from_pretrained(Config.bert_pretrained_dir, num_labels=num_rel_tags)\n elif self.model_name == \"BiLSTM_ATT\":\n model = BiLSTM_ATT(vocab_size, num_ent_tags, num_rel_tags, Config.ent_emb_dim, Config.batch_size)\n elif self.model_name == \"ATT_BiLSTM\":\n self.fixed_seq_len = Config.max_sequence_len\n model = ATT_BiLSTM(vocab_size, num_ent_tags, num_rel_tags,\n Config.ent_emb_dim, Config.batch_size, self.fixed_seq_len)\n elif self.model_name == \"BiLSTM\":\n model = BiLSTM(vocab_size, num_ent_tags, num_rel_tags)\n elif self.model_name == \"ACNN\":\n model = ACNN(vocab_size, num_ent_tags, num_rel_tags, Config.ent_emb_dim,\n Config.max_sequence_len)\n else:\n raise ValueError(\"Unknown RE model {}\".format(self.model_name))\n return model\n\n def get_ner_model(self):\n from nere.ner_models import BERTCRF, BiLSTM, BERTSoftmax, BiLSTM_ATT\n\n num_ent_tags = len(self.data_helper.ent_tag2id)\n vocab_size = len(self.data_helper.tokenizer.vocab)\n\n if self.model_name == 'BERTCRF':\n model = BERTCRF.from_pretrained(Config.bert_pretrained_dir, num_labels=num_ent_tags)\n elif self.model_name == 'BERTSoftmax':\n model = BERTSoftmax.from_pretrained(Config.bert_pretrained_dir, num_labels=num_ent_tags)\n elif self.model_name == \"BiLSTM\":\n # self.fixed_seq_len = Config.max_sequence_len\n model = BiLSTM(vocab_size, num_ent_tags, Config.ent_emb_dim, Config.batch_size)\n elif self.model_name == \"BiLSTM_ATT\":\n self.fixed_seq_len = Config.max_sequence_len\n model = BiLSTM_ATT(vocab_size, num_ent_tags, Config.ent_emb_dim, Config.batch_size, self.fixed_seq_len)\n else:\n raise ValueError(\"Unknown NER model {}\".format(self.model_name))\n return model\n\n def get_model(self):\n if self.task == \"ner\":\n model = self.get_ner_model()\n elif self.task == \"re\":\n model = self.get_re_model()\n else:\n raise ValueError(self.task)\n if Config.load_pretrain and Path(self.model_path).is_file():\n model.load_state_dict(torch.load(self.model_path)) # 断点续训\n logging.info(\"* load model from {}\".format(self.model_path))\n model = self.init_model(model)\n return model\n\n def save_best_loss_model(self, loss, model):\n if loss <= self.best_loss:\n torch.save(model.state_dict(), self.model_path)\n self.best_loss = loss\n _log = \"loss: {:.3f}, save to :{}\".format(loss, self.model_path)\n logging.info(_log)\n\n def evaluate_save(self, model):\n # with torch.no_grad(): # 适用于测试阶段，不需要反向传播\n self.evaluator.set_model(model=model, fixed_seq_len=self.fixed_seq_len)\n acc, precision, recall, f1 = self.evaluator.test(data_type=\"valid\")\n # torch.save(model.state_dict(), self.model_path)\n if f1 >= self.best_val_f1:\n torch.save(model.state_dict(), self.model_path)\n logging.info(\"** - Found new best F1：{:.3f} ,save to model_path: {}\".format(f1, self.model_path))\n self.best_val_f1 = f1\n self.patience_counter = 0\n else:\n self.patience_counter += 1\n return acc, precision, recall, f1\n\n def train_step(self, batch_data, model):\n if self.task == \" ner\":\n pred, loss = model(input_ids=batch_data[\"sents\"], attention_mask=batch_data[\"sents\"].gt(0),\n labels=batch_data[\"ent_tags\"])\n elif self.task == \"re\":\n pred, loss = model(batch_data, batch_data[\"rel_labels\"])\n else:\n raise ValueError(self.task)\n return pred, loss\n\n def run(self, mode):\n \"\"\"\n https://www.pytorchtutorial.com/pytorch-note5-save-and-restore-models/#i-2\n :param mode:\n :return:\n \"\"\"\n model = self.get_model()\n if mode != \"train\":\n self.evaluator.set_model(model=model, fixed_seq_len=self.fixed_seq_len)\n acc, precision, recall, f1 = self.evaluator.test(data_type=mode)\n _test_log = \"* model: {} {}, test acc: {:.3f}, precision: {:.3f}, recall: {:.3f}, f1: {:.3f}\".format(\n self.task, self.model_name, acc, precision, recall, f1)\n logging.info(_test_log)\n print(_test_log)\n return\n # evaluate\n self.evaluator.set_model(model=model, fixed_seq_len=self.fixed_seq_len)\n acc, precision, recall, f1 = self.evaluator.test(data_type=\"valid\")\n _log_str = (\"acc: {:.3f}, precision: {:.3f}, recall: {:.3f}, f1: {:.3f}\".format(acc, precision, recall, f1))\n print(_log_str)\n logging.info(_log_str)\n self.best_val_f1 = f1\n # init done\n logging.info(\"{}-{} start train , epoch_nums:{}...\".format(self.task, self.model_name, Config.max_epoch_nums))\n for epoch_num in trange(1, Config.max_epoch_nums + 1,\n desc=\"{} {} train epoch num\".format(self.task, self.model_name)):\n model.train()\n for batch_data in self.data_helper.batch_iter(self.task, data_type=\"train\", batch_size=Config.batch_size,\n re_type=\"torch\", fixed_seq_len=self.fixed_seq_len):\n try:\n if self.task == \"ner\":\n pred, loss = model(input_ids=batch_data[\"sents\"], attention_mask=batch_data[\"sents\"].gt(0),\n labels=batch_data[\"ent_tags\"])\n acc, precision, recall, f1 = self.evaluator.evaluate_ner(\n batch_y_ent_ids=batch_data[\"ent_tags\"].tolist(), batch_pred_ent_ids=pred.tolist())\n else: # self.task == \"re\":\n pred, loss = model(batch_data, batch_data[\"rel_labels\"])\n acc, precision, recall, f1 = self.evaluator.get_re_metrics(\n y_true=batch_data[\"rel_labels\"].tolist(), y_pred=pred.tolist())\n except Exception as e:\n logging.error(e)\n continue\n self.backfoward(loss, model)\n self.global_step += 1\n self.scheduler.step(epoch=epoch_num) # 更新学习率\n # if self.global_step % Config.check_step == 0:\n # logging.info(\"train {} {} epoch_num: {}, global_step:{} loss: {:.3f}, \"\n # \"acc: {:.3f}, precision: {:.3f}, recall: {:.3f}, f1: {:.3f}\".format(\n # self.task, self.model_name, epoch_num, self.global_step, loss.item(), acc, precision, recall, f1))\n # print(\"* global_step:{} loss: {:.3f}\".format(self.global_step, loss.item()))\n # self.save_best_loss_model(loss)\n acc, precision, recall, f1 = self.evaluate_save(model)\n logging.info(\"valid {} {} epoch_num: {}, acc: {:.3f}, precision: {:.3f}, recall: {:.3f}, f1: {:.3f}\".format(\n self.task, self.model_name, epoch_num, acc, precision, recall, f1))\n logging.info(\"epoch_num: {} end .\\n\".format(epoch_num))\n # Early stopping and logging best f1\n if self.patience_counter >= Config.patience_num and epoch_num > Config.min_epoch_nums:\n break\n logging.info(\"{}, Best val f1: {:.3f} best loss:{:.3f}\".format(\n self.model_name, self.best_val_f1, self.best_loss))\n"
] |
[
[
"torch.nn.CrossEntropyLoss",
"torch.nn.Dropout",
"torch.ones",
"torch.cat",
"torch.zeros",
"torch.sqrt",
"torch.nn.Embedding",
"torch.nn.Linear",
"torch.where",
"torch.ones_like"
],
[
"torch.optim.Adam",
"torch.nn.DataParallel",
"torch.optim.lr_scheduler.LambdaLR",
"torch.load"
]
] |
gsgoncalves/K-NRM
|
[
"b7bc8c44ddf6c8d0bc14a399beb05c9c1956fe2f"
] |
[
"knrm/model/model_base.py"
] |
[
"# Copyright (c) 2017, Carnegie Mellon University. All rights reserved.\n#\n# Use of the K-NRM package is subject to the terms of the software license set\n# forth in the LICENSE file included with this software, and also available at\n# https://github.com/AdeDZY/K-NRM/blob/master/LICENSE\n\nimport tensorflow as tf\nimport numpy as np\nfrom knrm.data import DataGenerator\nfrom traitlets.config import Configurable\nfrom traitlets import (\n Int,\n Float,\n # Bool,\n)\n\n# import sys\n\n# sys.reload()\n# sys.setdefaultencoding('UTF8')\n\n\nclass BaseNN(Configurable):\n n_bins = Int(11, help=\"number of kernels (including exact match)\").tag(config=True)\n max_q_len = Int(10, help='max q len').tag(config=True)\n max_d_len = Int(50, help='max document len').tag(config=True)\n batch_size = Int(16, help=\"minibatch size\").tag(config=True)\n max_epochs = Float(10, help=\"maximum number of epochs\").tag(config=True)\n eval_frequency = Int(10000, help=\"print out minibatch every * steps\").tag(config=True)\n checkpoint_steps = Int(10000, help=\"stroe trained data every * steps\").tag(config=True)\n embedding_size = Int(300, help=\"embedding dimension\").tag(config=True)\n vocabulary_size = Int(2000000, help=\"vocabulary size\").tag(config=True)\n\n def __init__(self, **kwargs):\n super(BaseNN, self).__init__(**kwargs)\n\n # generator\n self.data_generator = DataGenerator(config=self.config)\n self.val_data_generator = DataGenerator(config=self.config)\n self.test_data_generator = DataGenerator(config=self.config)\n\n @staticmethod\n def kernal_mus(n_kernels, use_exact):\n \"\"\"\n get the mu for each guassian kernel. Mu is the middle of each bin\n :param n_kernels: number of kernels (including exact match). first one is exact match\n :param use_exact:\n :return: l_mu, a list of mu.\n \"\"\"\n if use_exact:\n l_mu = [1]\n else:\n l_mu = [2]\n if n_kernels == 1:\n return l_mu\n\n bin_size = 2.0 / (n_kernels - 1) # score range from [-1, 1]\n l_mu.append(1 - bin_size / 2) # mu: middle of the bin\n for i in range(1, n_kernels - 1):\n l_mu.append(l_mu[i] - bin_size)\n return l_mu\n\n @staticmethod\n def kernel_sigmas(n_kernels, lamb, use_exact):\n \"\"\"\n get sigmas for each gaussian kernel.\n :param n_kernels: number of kernels (including exactmath.)\n :param lamb:\n :param use_exact:\n :return: l_sigma, a list of simga\n \"\"\"\n bin_size = 2.0 / (n_kernels - 1)\n l_sigma = [0.00001] # for exact match. small variance -> exact match\n if n_kernels == 1:\n return l_sigma\n\n l_sigma += [bin_size * lamb] * (n_kernels - 1)\n return l_sigma\n\n @staticmethod\n def weight_variable(shape):\n tmp = np.sqrt(6.0) / np.sqrt(shape[0] + shape[1])\n initial = tf.random_uniform(shape, minval=-tmp, maxval=tmp)\n return tf.Variable(initial)\n\n @staticmethod\n def re_pad(D, batch_size):\n D = np.array(D)\n D[D < 0] = 0\n if len(D) < batch_size:\n tmp = np.zeros((batch_size - len(D), D.shape[1]))\n D = np.concatenate((D, tmp), axis=0)\n return D\n\n def gen_mask(self, Q, D, use_exact=True):\n \"\"\"\n Generate mask for the batch. Mask padding and OOV terms.\n Exact matches is also masked if use_exact == False.\n :param Q: a batch of queries, [batch_size, max_len_q]\n :param D: a batch of documents, [batch_size, max_len_d]\n :param use_exact: mask exact matches if set False.\n :return: a mask of shape [batch_size, max_len_q, max_len_d].\n \"\"\"\n mask = np.zeros((self.batch_size, self.max_q_len, self.max_d_len))\n for b in range(len(Q)):\n for q in range(len(Q[b])):\n if Q[b, q] > 0:\n mask[b, q, D[b] > 0] = 1\n if not use_exact:\n mask[b, q, D[b] == Q[b, q]] = 0\n return mask\n\n\n"
] |
[
[
"numpy.sqrt",
"tensorflow.Variable",
"numpy.concatenate",
"numpy.array",
"tensorflow.random_uniform",
"numpy.zeros"
]
] |
roark-z/Sprite-Lighter
|
[
"ba6a3f8816406c7911c418fc00be72ec4147e4d4"
] |
[
"launch.py"
] |
[
"import torch\nimport models\nimport numpy as np\nfrom PIL import Image, ImageFilter\n\n# load model\nmodel = torch.load(\"network.bin\", map_location=torch.device('cpu'))\nmodel.eval()\n\n# open input image\nimg = torch.tensor(np.array(Image.open(\"in.png\").convert(\"RGB\").resize((32, 32))))\nimg = torch.reshape(img, (3, 32, 32))\nimg = img.unsqueeze(0).type(torch.FloatTensor)\n\n# get prediction\ny = model.forward(img)\ny.squeeze_()\ny = y.reshape(32, 32, 3)\n\n# save prediction\na = Image.fromarray(np.uint8(np.clip(y.detach().numpy(), 0, 255)))\na = a.filter(ImageFilter.MedianFilter(size=1))\na.resize((32, 32), Image.NEAREST).save(\"out.png\")\n"
] |
[
[
"torch.device",
"torch.reshape"
]
] |
brunoklaus/MercadoLibre_2020
|
[
"8349ab473dd26ce6345f0ca8772d1f1711fb4c06"
] |
[
"src/nn/domain_string_identifier.py"
] |
[
"'''\nCreated on 18 de nov de 2020\n\n@author: klaus\n'''\n\n\n'''\nCreated on 16 de nov de 2020\n\n@author: klaus\n'''\nimport jsonlines\nfrom folders import DATA_DIR, SUBMISSIONS_DIR\nfrom input.read_input import TRAIN_LINES, NUM_DOMS, get_emb, get_emb_Kstr\nimport os\nfrom os import path\nimport pandas as pd\nimport numpy as np\nimport igraph as ig\nfrom input.read_input import read_item_data, get_mappings\n\nfrom sentence_transformers import SentenceTransformer\nimport tensorflow as tf\nphysical_devices = tf.config.list_physical_devices('GPU')\ntf.config.experimental.set_memory_growth(physical_devices[0], enable=True)\n\nsentence_model = SentenceTransformer('distiluse-base-multilingual-cased-v2')\n\n\n\nNUM_WORDS = 5\n\nBS = 64\n\ndef preprocess_title(tit):\n tit = tit.lower().strip().split(' ')[:NUM_WORDS]\n tit = tit + [' ']*(NUM_WORDS-len(tit))\n return tit\n\ndef title_generator(mode='train'):\n df = read_item_data()\n NUM_DOMS = pd.unique(df['domain_id']).size\n dom_to_id = dict([(x,i) for i,x in enumerate(pd.unique(df['domain_id']))])\n NUM_DOMS = pd.unique(df['domain_id']).size\n \n BATCH_X = []\n BATCH_Y = []\n \n while True:\n line_id = 0\n for tit,dom in (zip(df['title'],df['domain_id'])):\n target = np.zeros((NUM_DOMS,),dtype=np.float32)\n target[dom_to_id[dom]] = 1\n \n tit = preprocess_title(tit)\n \n embeddings = sentence_model.encode(tit)\n \n BATCH_X.append(embeddings[None,:,:])\n BATCH_Y.append(target[None,:])\n \n if line_id % BS == 0:\n X = np.concatenate(BATCH_X,axis=0)\n Y = np.concatenate(BATCH_Y,axis=0)\n BATCH_X = []\n BATCH_Y = []\n yield X,Y\n line_id += 1\n\n@tf.function\ndef smooth_labels(labels, factor=0.001):\n # smooth the labels\n labels = tf.cast(labels,tf.float32)\n labels *= (1 - factor)\n labels += (factor / tf.cast(tf.shape(labels)[1],tf.float32))\n # returned the smoothed labels\n return labels\n\ndef xent(Y1,Y2):\n\n Y1 = tf.reshape(Y1,(-1,NUM_DOMS))\n Y2 = tf.reshape(Y2,(-1,NUM_DOMS))\n\n Y1 = smooth_labels(Y1)\n Y2 = smooth_labels(Y2)\n return - tf.reduce_sum(Y1 * tf.math.log(Y2),axis=-1) \n\ndef get_model():\n from tensorflow import keras\n from tensorflow.keras import layers\n \n inp_x = keras.Input((NUM_WORDS,512))\n x = tf.keras.layers.BatchNormalization()(inp_x)\n x = tf.keras.layers.Dense(128,activation=tf.nn.relu)(inp_x)\n \n x = layers.LSTM(64)(x) \n x = layers.Dense(NUM_DOMS)(x)\n x = layers.Softmax()(x)\n \n train_model = keras.Model(inputs=[inp_x],outputs=[x])\n \n \n\n\n optimizer = tf.keras.optimizers.Adam(learning_rate=3e-3)\n \n train_model.compile(optimizer=optimizer,loss=xent,metrics=['acc'])\n print(train_model.summary())\n return train_model\n\n\nDOMAIN_IDENTIFIER_PATH = path.join(DATA_DIR,'model','domain_identifier.h5')\n\ndef train_model():\n train_model = get_model()\n from tensorflow import TensorShape as ts\n import tensorflow.keras as keras\n \n train_ds = tf.data.Dataset.from_generator( title_generator,output_types =(tf.float32,tf.float32),\n output_shapes =(ts([None,NUM_WORDS,512]),\n ts([None,NUM_DOMS]))\n )\n train_model.load_weights(DOMAIN_IDENTIFIER_PATH)\n train_model.fit(\n x=train_ds,\n steps_per_epoch= TRAIN_LINES // BS,\n epochs=1)\n # Calling `save('my_model')` creates a SavedModel folder `my_model`.\n \n train_model.save_weights(DOMAIN_IDENTIFIER_PATH)\n\n\ndoms = pd.unique(read_item_data()['domain_id'])\ndef load_model():\n train_model = get_model()\n train_model.load_weights(DOMAIN_IDENTIFIER_PATH)\n return train_model\ndef predict_model(train_model,query_list,return_numeric=False,return_emb=False):\n \"\"\"\n Returns prediction of train_model on batch of input\n \"\"\"\n from tensorflow import TensorShape as ts\n import tensorflow.keras as keras\n \n \n x= np.reshape(np.array([preprocess_title(tit) for tit in query_list]),(-1,))\n \n x = get_emb_Kstr(x,x)\n \n \n \n\n input_batch = np.reshape(x,((-1,NUM_WORDS,512)))\n if return_emb:\n return input_batch\n \n \n #input_batch = np.concatenate(np.array([np.array([sentence_model.encode(preprocess_title(tit))]) for tit in query_list]),axis=0 )\n pred = train_model.predict(input_batch)\n #for i in range(pred.shape[0]):\n # print((query_list[i], doms[np.argmax(pred[i,:])]) ,np.max(pred[i,:]))\n if return_numeric:\n return pred\n else:\n return np.array([doms[np.argmax(pred[i,:])] for i in range(pred.shape[0]) if isinstance(doms[np.argmax(pred[i,:])],str ) ])\n\n \n return pred\n for i in range(pred.shape[0]):\n print((query_list[i], doms[np.argmax(pred[i,:])]) ,np.max(pred[i,:]))\n \n \nif __name__ == \"__main__\":\n #create_graph_domain()\n print(predict_model(load_model(),['RELOGIO SMARTWATCH','TV 40 polegadas','Jogo FIFA Xbox','Calça jeans','Placa NVIDIA']))\n\n \n \n"
] |
[
[
"tensorflow.cast",
"numpy.concatenate",
"numpy.max",
"tensorflow.config.list_physical_devices",
"tensorflow.keras.Input",
"tensorflow.config.experimental.set_memory_growth",
"numpy.reshape",
"numpy.argmax",
"numpy.zeros",
"tensorflow.TensorShape",
"tensorflow.shape",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.Model",
"pandas.unique",
"tensorflow.reshape",
"tensorflow.math.log",
"tensorflow.keras.optimizers.Adam",
"tensorflow.keras.layers.BatchNormalization",
"tensorflow.keras.layers.LSTM",
"tensorflow.keras.layers.Softmax"
]
] |
EBosi/BOFdat
|
[
"30447be0759eac1811d05634bda198cdb192592f"
] |
[
"BOFdat/core/maintenance.py"
] |
[
"\"\"\"\nMaintenance\n===========\n\nGrowth associated maintenance (GAM) is defined as the energy cost of growth, namely polymerization of macromolecules.\nNon-Growth associated maintenance (NGAM) represent all the extra costs that the cell must overcome to operate.\nThis package offers two options for the user:\n1- Calculate GAM and NGAM from experimental data\n2- Estimate GAM and NGAM from theorical values\n\n\"\"\"\ndef _import_model(path_to_model):\n import cobra\n extension = path_to_model.split('.')[-1]\n if extension == 'json':\n return cobra.io.load_json_model(path_to_model)\n elif extension == 'xml':\n return cobra.io.read_sbml_model(path_to_model)\n else:\n raise Exception('Model format not compatible, provide xml or json')\n\ndef _import_data(path_to_data):\n import pandas as pd\n import warnings\n\n data = pd.read_csv(path_to_data)\n '''\n #1- This file should have a header\n for i in data.columns:\n try:\n float(i)\n raise ValueError('Provide file header')\n except:\n pass\n '''\n return data\n\ndef experimental_maintenance(path_to_data, path_to_model,show_GAM=False):\n \"\"\"\n\n Growth-associated maintenance (GAM) is the ATP cost of assembling macromolecules in the organism.\n This function calculates GAM from provided path to experimental data. This data includes growth rates on\n different carbon sources, the associated uptake rate for each carbon source and the secretion rates of metabolic\n wastes. More information on the format in which to provide the experimental data is available on GitHub.\n\n :param path_to_data: The data file is the outcome of the HPLC growth, uptake and secretion rate experiment.\n\n :param path_to_model: The path to the model, json or sbml formats supported\n\n :param show_GAM: bool, will associate colors with carbon sources for easier display later\n\n :return: a dictionary {GAM:value, NGAM:value}\n \"\"\"\n\n #From experimental data growth rate on a given carbon source\n #Obtain best fit from model to experimental data\n def get_carbon_sources(data):\n return [c for c in data.Source]\n\n def attribute_colors(data,carbon_sources):\n # Attribute colors to carbon sources for ploting\n # Set a color palette\n import seaborn as sb\n color_palette = sb.color_palette('deep',len(carbon_sources))\n data['color'] = ''\n for i in len(carbon_sources):\n data.loc[data.Source == carbon_sources[i], 'color'] = color_palette[i]\n\n return data\n\n def get_biomass_objective_function(model):\n from cobra.util.solver import linear_reaction_coefficients\n return linear_reaction_coefficients(model).keys()[0]\n\n def atp_cost(model):\n solution = model.optimize().f\n if solution == None:\n solution = 0\n return solution\n\n def calculate_gam(model,data,show_GAM):\n import pandas as pd\n #Build the output matrix\n #Contains the ATP costs for each carbon source\n raw_GAM = pd.DataFrame(index=[data.loc[i,'Source'] for i in data.index],\n columns=['Growth_rate', 'ATP', 'ATP_min', 'ATP_max', 'ATP_err']\n )\n raw_GAM['Growth_rate'] = [data.loc[i,'GR'] for i in data.index]\n\n carbon_sources = get_carbon_sources(data)\n if show_GAM:\n data = attribute_colors(data,carbon_sources)\n else:\n data = data\n\n #Set parameters for all models\n #Set lower bound of BOF to 0\n #Get biomass objective function\n biomass = get_biomass_objective_function(model)\n biomass.lower_bound = 0.\n biomass.objective_coefficient = 0.\n\n # remove GAM from biomass function\n for key, value in biomass.metabolites.items():\n if abs(value) > 50:\n biomass.add_metabolites({key: -value})\n #Set carbon sources to 0\n '''\n Will need to prepare the model to run the simulations\n '''\n #model.reactions.EX_glc_LPAREN_e_RPAREN_.lower_bound = 0\n #Optimize for ATP maintenance\n model.reactions.ATPM.lower_bound = 0\n model.reactions.ATPM.objective_coefficient = 1.\n\n #model.reactions.EX_o2_LPAREN_e_RPAREN_.lower_bound = -1000\n atp, atp_min, atp_max, atp_err = [],[],[],[]\n for i in data.index:\n\n c_source = data.loc[i, 'Source']\n #Get growth rate\n growth_rate = data.loc[i, 'GR']\n growth_rate_err = data.loc[i, 'GR_std']\n #Get substrate uptake rate for the carbon source\n # gur = Glucose uptake rate\n substrate_uptake_rate = data.loc[i, 'SUR']\n # sur - substrate uptake rate\n substrate_uptake_rate_err = data.loc[i, 'SUR_std']\n\n # Mean\n #Excretion rates\n #Requires that the data file is generated appropriately\n for j in range(6,len(data.columns)):\n #Force flux through excretion\n if j % 2 == 0:\n mean_excretion = data.loc[i,data.columns[j]]\n model.reactions.get_by_id(data.columns[j]).lower_bound = mean_excretion\n\n '''\n Should return some errors if the file is not generated appropriately\n '''\n #Fix biomass at growth rate\n biomass.lower_bound = growth_rate\n\n # Iterate the Carbon source as %s\n model.reactions.get_by_id('%s' %(c_source,)).lower_bound = -1 * substrate_uptake_rate\n\n #Obtain solution and determine ATP cost\n atp.append(atp_cost(model))\n\n #Include experimental error in calculation\n # For both the excretion (max) and uptake (min) to get the max range\n #Minimum\n #Set biomass to growth rate\n biomass.lower_bound = growth_rate + growth_rate_err\n #Set uptake rate to the carbon source uptake rate\n model.reactions.get_by_id('%s' % c_source).lower_bound = -1 * (substrate_uptake_rate - substrate_uptake_rate_err)\n for j in range(6,len(data.columns)):\n #Force flux through excretion\n if j % 2 == 0:\n mean_excretion = data.loc[i,data.columns[j]]\n std_excretion = data.loc[i,data.columns[j+1]]\n model.reactions.get_by_id(data.columns[j]).lower_bound = mean_excretion - std_excretion\n\n atp_min.append(atp_cost(model))\n\n #Maximum\n biomass.lower_bound = growth_rate - growth_rate_err\n for j in range(6,len(data.columns)):\n #Force flux through excretion\n if j % 2 == 0:\n mean_excretion = data.loc[i,data.columns[j]]\n std_excretion = data.loc[i,data.columns[j+1]]\n model.reactions.get_by_id(data.columns[j]).lower_bound = mean_excretion + std_excretion\n\n atp_max.append(atp_cost(model))\n\n delta = atp_max[i] - atp_min[i]\n atp_err.append(delta / 2)\n\n #Reset uptake to 0\n model.reactions.get_by_id('%s' % c_source).lower_bound = 0.\n #Reset secretion to 0\n for j in range(6,len(data.columns)):\n #Force flux through excretion\n if j % 2 == 0:\n mean_excretion = 0\n model.reactions.get_by_id(data.columns[j]).lower_bound = mean_excretion\n\n '''\n Will have to define whether the aerobic/anaerobic option should be included\n '''\n # model.reactions.EX_o2_LPAREN_e_RPAREN_.lower_bound = -1000\n raw_GAM['ATP'] = atp\n raw_GAM['ATP_min'] = atp_min\n raw_GAM['ATP_max'] = atp_max\n raw_GAM['ATP_err'] = atp_err\n\n return raw_GAM\n\n def show_gam(raw_GAM):\n import seaborn as sns\n import numpy as np\n import matplotlib.pyplot as plt\n sns.set_style('whitegrid')\n x = raw_GAM['Growth_rate']\n y = raw_GAM['ATP']\n #Fit with np.polyfit\n m, b = np.polyfit(x, y, 1)\n\n print('m', m, 'b', b)\n\n #Get correlation\n x = raw_GAM['Growth_rate']\n y = raw_GAM['ATP']\n correlation = np.corrcoef(x, y)[0, 1]\n print('R2=', correlation ** 2)\n plt.scatter(raw_GAM['Growth_rate'], raw_GAM['ATP'])\n # plt.scatter(filtered_data['GR'],filtered_data['ATP'], color=filtered_data['color'], marker=filtered_data['marker'].tolist())\n plt.ylabel('ATP')\n plt.xlabel('Growth rate')\n plt.xlim([0, 1.1])\n plt.ylim([0, 110])\n plt.show()\n #plt.savefig('all_data.png')\n #plt.savefig('all_data.svg')\n plt.close()\n '''\n plt.errorbar(filtered_data['GR'], filtered_data['ATP'], xerr=filtered_data['GR_std'],\n yerr=filtered_data['ATP_err'], fmt='.', ecolor='black')\n # plt.scatter(filtered_data['GR'],filtered_data['ATP'], color=filtered_data['color'])\n plt.plot(x, m * x + b, '-')\n\n plt.xlim([0, 1.1])\n plt.ylim([0, 120])\n plt.savefig('all_data_w_errors.png')\n plt.savefig('all_data_w_errors.svg')\n # embed()\n\n plt.show()\n plt.close()\n\n # plt.plot(x, y, '.')\n plt.scatter(filtered_data['GR'], filtered_data['ATP'], color=filtered_data['color'])\n plt.plot(x, m * x + b, '-')\n plt.xlim([0, 1.1])\n plt.ylim([0, 90])\n # plt.savefig('GAM_est.svg')\n plt.savefig('GAM_all_data_fit.png')\n plt.savefig('GAM_all_data_fit.svg')\n plt.show()\n plt.close()\n\n # for CI calc: combine dataset with std erors\n data2 = pd.DataFrame()\n data2 = data2.append(pd.DataFrame({'GR': filtered_data['GR'].tolist(), 'ATP': filtered_data['ATP'].tolist()}))\n\n # positive error\n test1 = filtered_data['GR'] + filtered_data['GR_std']\n test2 = filtered_data['ATP'] + filtered_data['ATP_err']\n data2 = data2.append(pd.DataFrame({'GR': test1, 'ATP': test2}))\n\n # negative error\n test1 = filtered_data['GR'] - filtered_data['GR_std']\n test2 = filtered_data['ATP'] - filtered_data['ATP_err']\n data2 = data2.append(pd.DataFrame({'GR': test1, 'ATP': test2}))\n\n # positive error\n # test1=filtered_data['GR']+filtered_data['GR_std']\n # test2=filtered_data['ATP']-filtered_data['ATP_err']\n # data2=data2.append(pd.DataFrame({'GR':test1,'ATP':test2}))\n\n # negative error\n # test1=filtered_data['GR']-filtered_data['GR_std']\n # test2=filtered_data['ATP']+filtered_data['ATP_err']\n # data2=data2.append(pd.DataFrame({'GR':test1,'ATP':test2}))\n\n\n\n sns.lmplot(x='GR', y='ATP', data=data2)\n plt.savefig('GAM_all_data_fit_CI.png')\n plt.savefig('GAM_all_data_fit_CI.svg')\n\n x = data2['GR']\n y = data2['ATP']\n\n # fit with np.polyfit\n m, b = np.polyfit(x, y, 1)\n print m, b\n\n plt.show()\n\n # embed()\n '''\n\n return {'GAM': m, 'NGAM': b}\n\n #1- Import model\n model = _import_model(path_to_model)\n #2- Import experimental data\n data = _import_data(path_to_data)\n #3- Calculate GAM\n raw_GAM = calculate_gam(model, data,show_GAM)\n #4-\n gams=show_gam(raw_GAM)\n #Grs = growth rates\n #new_gams_calc_grs(gams)\n\n return gams\n\ndef update_maintenance_costs(gams,model,RNA_atp):\n \"\"\"\n This function updates the cost of maintenance in the BOF and the ATPM function.\n As of version 0.1.1 BOFdat assumes that the ATP maintenance reaction in the model is named ATPM and the\n biomass is set as the first objective of the model.\n\n :param gams: the dictionary generated by the experimental_maintenance function {GAM:x,NGAM:y}\n\n :param model: the model to update\n\n :param RNA_atp: the atp coefficient from the RNA\n\n \"\"\"\n\n #Add the atp consumption to the biomass\n from BOFdat import update\n BOFdat.update.update_maintenance(gams,model,RNA_atp)\n\n'''\nFunctions yet to be implemented\ndef theorical_GAM(protein_percent, rna_percent, dna_percent,CP = 4.324, CD = 1.365, CR = 0.406):\n #From experimental data: % of dry weight for each category\n'''\n\n\n\n"
] |
[
[
"numpy.polyfit",
"pandas.read_csv",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.ylim",
"pandas.DataFrame",
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.close",
"numpy.corrcoef",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel"
]
] |
GnssTao/ginan
|
[
"b69593b584f75e03238c1c667796e2030391fbed"
] |
[
"scripts/gn_lib/gn_const.py"
] |
[
"'''Constants to be declared here'''\nfrom numpy import datetime64 as _datetime64\nfrom pandas import CategoricalDtype as _CategoricalDtype, DataFrame as _DataFrame\n\nGPS_ORIGIN = _datetime64('1980-01-06 00:00:00')\nJ2000_ORIGIN = _datetime64('2000-01-01 12:00:00')\n\nSECS_IN_WEEK = 604800\nSEC_IN_DAY = 86400\nSEC_IN_YEAR = 31557600\n\nC_LIGHT = 299792458.0 # speed of light (m/s)\nOMEGA_E = 7.2921151467E-5 # rad/sec WGS84 value of earth's rotation rate\n\n# https://www.iers.org/SharedDocs/Publikationen/EN/IERS/Documents/ac/sinex/sinex_v201_appendix1_pdf.pdf\nTYPE_CATEGORY = _CategoricalDtype(categories = [\n 'STAX','STAY','STAZ','VELX','VELY','VELZ','XGC','YGC','ZGC','RS_RA','RS_DE','RS_RAR',\n 'RS_DER','RS_PL','LOD','UT','XPO','YPO','XPOR','YPOR','NUT_LN','NUT_OB','NUTRLN','NUTROB',\n 'SAT__X','SAT__Y','SAT__Z','SAT_VX','SAT_VY','SAT_VZ','SAT_RP','SAT_GX','SAT_GZ','SATYBI',\n 'TROTOT','TRODRY','TROWET','TGNTOT','TGNWET','TGNDRY','TGETOT','TGEWET','TGEDRY','RBIAS',\n 'TBIAS','SBIAS','ZBIAS','AXI_OF','SATA_Z','SATA_X','SATA_Y',\n 'ALOG_E','TLOG_E','ALOG_N','TLOG_N','ALOG_H','TLOG_H',\n 'AEXP_E','TEXP_E','AEXP_N','TEXP_N','AEXP_H','TEXP_H'])\n\nTECHNIQUE_CATEGORY = _CategoricalDtype(categories = ['C','D','L','M','P','R'])\n\nUNIT_CATEGORY = _CategoricalDtype(categories = ['m','m/y','m/s2','ppb','ms','msd2',\n 'mas','ma/d','rad','rd/y','rd/d'])\n\nPT_CATEGORY = _CategoricalDtype(categories = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',\n 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'])\n\nPRN_CATEGORY = _CategoricalDtype(categories = [\n 'G01', 'G02', 'G03', 'G04', 'G05', 'G06', 'G07', 'G08', 'G09',\n 'G10', 'G11', 'G12', 'G13', 'G14', 'G15', 'G16', 'G17', 'G18',\n 'G19', 'G20', 'G21', 'G22', 'G23', 'G24', 'G25', 'G26', 'G27',\n 'G28', 'G29', 'G30', 'G31', 'G32', 'G33', 'G34', 'G35', 'G36',\n 'R01', 'R02', 'R03', 'R04', 'R05', 'R06', 'R07', 'R08', 'R09',\n 'R10', 'R11', 'R12', 'R13', 'R14', 'R15', 'R16', 'R17', 'R18',\n 'R19', 'R20', 'R21', 'R22', 'R23', 'R24',\n 'E01', 'E02', 'E03', 'E04', 'E05', 'E06', 'E07', 'E08', 'E09',\n 'E10', 'E11', 'E12', 'E13', 'E14', 'E15', 'E16', 'E17', 'E18',\n 'E19', 'E20', 'E21', 'E22', 'E23', 'E24', 'E25', 'E26', 'E27',\n 'E28', 'E29', 'E30', 'E31', 'E32', 'E33', 'E34', 'E35', 'E36',\n 'C01', 'C02', 'C03', 'C04', 'C05', 'C06', 'C07', 'C08', 'C09',\n 'C10', 'C11', 'C12', 'C13', 'C14', 'C15', 'C16', 'C17', 'C18',\n 'C19', 'C20', 'C21', 'C22', 'C23', 'C24', 'C25', 'C26', 'C27',\n 'C28', 'C29', 'C30', 'C31', 'C32', 'C33', 'C34', 'C35', 'C36',\n 'C37', 'C38', 'C39', 'C40', 'C41', 'C42', 'C43', 'C44', 'C45',\n 'C46',\n 'C57', 'C58', 'C59', 'C60', 'C61'])\n\nSTATE_TYPES_CATEGORY = _CategoricalDtype(categories =[\n 'PHASE_BIAS', 'REC_POS', 'REC_SYS_BIAS', 'TROP', 'SAT_CLOCK', 'AMBIGUITY','EOP','EOP_RATE','DCB','IONOSPHERIC']) # 'ONE' removed\n\n#GeodePy\nclass Ellipsoid:\n __doc__ = 'ellipsoid class doc placeholder'\n def __init__(self, semimaj, inversef):\n self.semimaj = float(semimaj) # a\n self.semimajsq = semimaj * semimaj # a**2\n self.inversef = inversef # inverse of the first flattening factor\n self.flatten = 1 / self.inversef # first flattening factor\n self.semimin = self.semimaj * (1 - self.flatten) # b\n self.semiminsq = self.semimin * self.semimin # b**2\n self.ecc1sq = self.flatten * (2 - self.flatten)\n self.ecc2sq = self.ecc1sq / (1 - self.ecc1sq)\n# self.ecc1 = sqrt(self.ecc1sq)\n# self.n = float(self.f / (2 - self.f))\n# self.n2 = self.n ** 2\n# self.meanradius = (2 * self.semimaj + self.semimin)/3\n\n# Geodetic Reference System 1980\n# www.epsg-registry.org/export.htm?gml=urn:ogc:def:ellipsoid:EPSG::7019\nGRS80 = Ellipsoid(6378137, 298.257222101)\n\n# World Geodetic System 1984\n# www.epsg-registry.org/export.htm?gml=urn:ogc:def:ellipsoid:EPSG::7030\nWGS84 = Ellipsoid(6378137, 298.257223563)\n\n# Australian National Spheroid\n# www.epsg-registry.org/export.htm?gml=urn:ogc:def:ellipsoid:EPSG::7003\nANS = Ellipsoid(6378160, 298.25)\n\n# International (Hayford) 1924\n# www.epsg-registry.org/export.htm?gml=urn:ogc:def:ellipsoid:EPSG::7022\nINTL24 = Ellipsoid(6378388, 297)\n\nSISRE_COEF_DF = _DataFrame( data = [[0.99,\t0.98,\t0.98,\t0.98,\t0.98],\n [127,\t54,\t49,\t45,\t61 ]],\n columns=['C_IGSO','C','G','R','E'],\n index = ['alpha','beta'])"
] |
[
[
"pandas.CategoricalDtype",
"pandas.DataFrame",
"numpy.datetime64"
]
] |
roussel-ryan/turn_key_bayesian_exploration
|
[
"1ff94c2515f09275fda170f5bdde3a4ffa81d636"
] |
[
"demo/constrained.py"
] |
[
"import torch\nfrom torch.distributions import Normal\nfrom botorch.acquisition import analytic \nfrom botorch.acquisition import acquisition\n\nfrom botorch.utils.transforms import t_batch_mode_transform\n\n\nclass ConstrainedAcquisitionFunction(acquisition.AcquisitionFunction):\n def __init__(self, model, constraints):\n '''\n Acquisition function that biases away from points that were observed \n to not satisfy a given constraint.\n\n Arguments\n ---------\n model : model\n A fitted model, usually seperate from objective models\n\n constraints: dict \n A dictionary of the form `{i: [lower, upper]}`, where\n `i` is the output index, and `lower` and `upper` are lower and upper\n bounds on that output (resp. interpreted as -Inf / Inf if None)\n\n Shamelessly adapted/stolen from BoTorch ConstrainedEI\n https://botorch.org/v/0.3.0/api/_modules/botorch/acquisition/analytic.html\n\n\n '''\n self.constraints = constraints\n \n super().__init__(model)\n self._preprocess_constraint_bounds(constraints = constraints)\n\n @t_batch_mode_transform(expected_q=1)\n def forward(self, X):\n posterior = self.model.posterior(X)\n means = posterior.mean.squeeze(dim = -2)\n sigmas = posterior.variance.squeeze(dim = -2).sqrt().clamp_min(1e-9)\n\n prob_feas = self._compute_prob_feas(X=X, means=means, sigmas=sigmas)\n\n return prob_feas.squeeze(dim=-1)\n \n def _preprocess_constraint_bounds(self, constraints):\n r\"\"\"Set up constraint bounds.\n\n Args:\n constraints: A dictionary of the form `{i: [lower, upper]}`, where\n `i` is the output index, and `lower` and `upper` are lower and upper\n bounds on that output (resp. interpreted as -Inf / Inf if None)\n \"\"\"\n con_lower, con_lower_inds = [], []\n con_upper, con_upper_inds = [], []\n con_both, con_both_inds = [], []\n con_indices = list(constraints.keys())\n if len(con_indices) == 0:\n raise ValueError(\"There must be at least one constraint.\")\n for k in con_indices:\n if constraints[k][0] is not None and constraints[k][1] is not None:\n if constraints[k][1] <= constraints[k][0]:\n raise ValueError(\"Upper bound is less than the lower bound.\")\n con_both_inds.append(k)\n con_both.append([constraints[k][0], constraints[k][1]])\n elif constraints[k][0] is not None:\n con_lower_inds.append(k)\n con_lower.append(constraints[k][0])\n elif constraints[k][1] is not None:\n con_upper_inds.append(k)\n con_upper.append(constraints[k][1])\n # tensor-based indexing is much faster than list-based advanced indexing\n self.register_buffer(\"con_lower_inds\", torch.tensor(con_lower_inds))\n self.register_buffer(\"con_upper_inds\", torch.tensor(con_upper_inds))\n self.register_buffer(\"con_both_inds\", torch.tensor(con_both_inds))\n \n # tensor indexing\n self.register_buffer(\"con_both\", torch.tensor(con_both, dtype=torch.float))\n self.register_buffer(\"con_lower\", torch.tensor(con_lower, dtype=torch.float))\n self.register_buffer(\"con_upper\", torch.tensor(con_upper, dtype=torch.float))\n\n def _compute_prob_feas(self, X, means, sigmas):\n \"\"\"Compute feasibility probability for each batch of x.\n\n Args:\n X: A `(b) x 1 x d`-dim Tensor of `(b)` t-batches of `d`-dim design\n points each.\n means: A `(b) x m`-dim Tensor of means.\n sigmas: A `(b) x m`-dim Tensor of standard deviations.\n Returns:\n A `(b) x 1`-dim tensor of feasibility probabilities\n\n Note: This function does case-work for upper bound, \n lower bound, and both-sided bounds. \n Another way to do it would be to use 'inf' and -'inf' for the\n one-sided bounds and use the logic for the both-sided case. But this\n causes an issue with autograd since we get 0 * inf.\n TODO: Investigate further.\n \"\"\"\n output_shape = X.shape[:-2] + torch.Size([1])\n prob_feas = torch.ones(output_shape, device=X.device, dtype=X.dtype)\n\n if len(self.con_lower_inds) > 0:\n self.con_lower_inds = self.con_lower_inds.to(device=X.device)\n normal_lower = self._construct_dist(means, sigmas, self.con_lower_inds)\n prob_l = 1 - normal_lower.cdf(self.con_lower)\n prob_feas = prob_feas.mul(torch.prod(prob_l, dim=-1, keepdim=True))\n\n if len(self.con_upper_inds) > 0:\n self.con_upper_inds = self.con_upper_inds.to(device=X.device)\n normal_upper = self._construct_dist(means, sigmas, self.con_upper_inds)\n prob_u = normal_upper.cdf(self.con_upper)\n prob_feas = prob_feas.mul(torch.prod(prob_u, dim=-1, keepdim=True))\n\n if len(self.con_both_inds) > 0:\n self.con_both_inds = self.con_both_inds.to(device=X.device)\n normal_both = self._construct_dist(means, sigmas, self.con_both_inds)\n prob_u = normal_both.cdf(self.con_both[:, 1])\n prob_l = normal_both.cdf(self.con_both[:, 0])\n prob_feas = prob_feas.mul(torch.prod(prob_u - prob_l,\n dim=-1, keepdim=True))\n return prob_feas\n\n\n def _construct_dist(self, means, sigmas, inds):\n mean = means.index_select(dim = -1, index = inds)\n sigma = sigmas.index_select(dim = -1, index = inds)\n return Normal(loc = mean, scale = sigma)\n"
] |
[
[
"torch.Size",
"torch.ones",
"torch.tensor",
"torch.distributions.Normal",
"torch.prod"
]
] |
MitchellAcoustics/Soundscapy
|
[
"bf450f583c076a9adaeed0b5a3617475d4be5315"
] |
[
"soundscapy/ssid/database.py"
] |
[
"import os\nimport sys\n\nmyPath = os.path.dirname(os.path.abspath(__file__))\nsys.path.insert(0, myPath + \"/../../\")\n\nimport csv\nfrom datetime import date\nfrom pathlib import Path\nimport warnings\n\nimport numpy as np\nimport pandas as pd\n\n# Constants and Labels\nfrom soundscapy.ssid.parameters import (\n CATEGORISED_VARS,\n IGNORE_LIST,\n LOCATION_IDS,\n PARAM_LIST,\n SURVEY_VARS,\n)\n\nDEFAULT_CATS = [\n \"indexing\",\n \"sound_source_dominance\",\n \"raw_PAQs\",\n \"overall_soundscape\",\n]\n\n# General helper functions\n_flatten = lambda t: [item for sublist in t for item in sublist]\n\n# Dealing with Surveys!\nclass SurveyFrame(pd.DataFrame):\n # TODO Add Documentation\n # TODO Add Example doctesting\n _analysis_date = date.today().isoformat()\n\n @property\n def _constructor(self):\n return SurveyFrame\n\n @classmethod\n def create_empty(\n self,\n variable_categories: list = DEFAULT_CATS,\n add_columns: list = [],\n index=None,\n dtype=None,\n ):\n # input sanity\n if not set(variable_categories).issubset(list(CATEGORISED_VARS.keys())):\n raise ValueError(\n \"Category not found in defined sets of variables. See parameters.CATEGORISED_VARS\"\n )\n\n cols = _flatten(\n [CATEGORISED_VARS.get(k, \"col_missing\") for k in variable_categories]\n )\n if add_columns:\n cols.extend(add_columns)\n\n return SurveyFrame(columns=cols, index=index, dtype=dtype)\n\n @classmethod\n def from_csv(\n self,\n filepath,\n clean_cols=False, # TODO: Change to True when clean_cols func created\n use_RecordID_as_index: bool = True,\n variable_categories: list = DEFAULT_CATS,\n drop_columns=[],\n add_columns=[],\n nrows=None,\n ):\n # TODO: Write docs\n # input sanity\n if not set(variable_categories).issubset(list(CATEGORISED_VARS.keys())):\n raise ValueError(\n \"Category not found in defined sets of variables. See parameters.CATEGORISED_VARS\"\n )\n\n use_cols = SurveyFrame._get_the_cols(variable_categories, add_columns)\n\n all_cols = _flatten(CATEGORISED_VARS.values())\n index_col = \"record_id\" if use_RecordID_as_index else None\n index_col = False if \"record_id\" not in use_cols else index_col\n\n # TODO Deal with use_cols not in file, right now raises ValueError from pandas\n # Deal with it using aliases. `try` block?\n # put into own function? def _pandas_read_csv_w_aliases()\n # or maybe just a `+check_col_names` function?\n\n use_cols = SurveyFrame._check_csv_col_names(filepath, use_cols)\n\n df = pd.read_csv(\n filepath,\n sep=\",\",\n header=0,\n usecols=use_cols,\n index_col=index_col,\n skipinitialspace=True,\n nrows=nrows,\n )\n df = df.drop(drop_columns, axis=1)\n\n sf = SurveyFrame(df)\n sf._csv_file = filepath\n\n if clean_cols:\n sf = sf.clean_cols()\n\n return sf\n\n #! from_excel not really tested!\n @classmethod\n def from_excel(\n self,\n filepath,\n clean_cols=False, # TODO: Change to True when clean_cols func created\n use_RecordID_as_index: bool = True,\n variable_categories: list = DEFAULT_CATS,\n drop_columns=[],\n add_columns=[],\n nrows=None,\n ):\n # TODO: Write docs\n # input sanity\n if not set(variable_categories).issubset(list(CATEGORISED_VARS.keys())):\n raise ValueError(\n \"Category not found in defined sets of variables. See parameters.CATEGORISED_VARS\"\n )\n\n use_cols = SurveyFrame._get_the_cols(variable_categories, add_columns)\n\n all_cols = _flatten(CATEGORISED_VARS.values())\n index_col = \"record_id\" if use_RecordID_as_index else None\n index_col = False if \"record_id\" not in use_cols else index_col\n\n # TODO Deal with use_cols not in file, right now raises ValueError from pandas\n # Deal with it using aliases. `try` block?\n # put into own function? def _pandas_read_csv_w_aliases()\n # or maybe just a `+check_col_names` function?\n\n use_cols = SurveyFrame._check_excel_col_names(filepath, use_cols)\n\n df = pd.read_excel(\n filepath, header=0, usecols=use_cols, index_col=index_col, nrows=nrows,\n )\n df = df.drop(drop_columns, axis=1)\n\n sf = SurveyFrame(df)\n sf._csv_file = filepath\n\n if clean_cols:\n sf = sf.clean_cols()\n\n return sf\n\n @staticmethod\n def _get_the_cols(variable_categories, add_columns):\n use_cols = _flatten(\n [CATEGORISED_VARS.get(k, \"col_missing\") for k in variable_categories]\n )\n if add_columns:\n use_cols.extend(add_columns)\n\n if not variable_categories and not add_columns:\n use_cols = None\n return use_cols\n\n # TODO: clean_cols function\n # TODO: complex_paqs function\n\n @staticmethod\n def _check_csv_col_names(filepath, use_cols):\n \"\"\"Compares the desired columns with those present in the csv file.\n\n Where a column is requested but not present, we check element-wise through the provided aliases from parameters.SURVEY_VARS and try those instead. If an alias is present in the file, we'll pass it to pandas to read in the csv.\n\n Parameters\n ----------\n filepath : filepath_or_buffer\n csv file to pass to pandas.read_csv()\n use_cols : list\n columns (variable) labels you'd like to read in\n\n Returns\n -------\n list\n use_cols with missing items replaced by their alias\n \"\"\"\n # TODO Tests for _check_csv_col_names()\n with open(filepath, newline=\"\") as f:\n reader = csv.reader(f)\n headers = next(reader)\n\n # Pull out items in cols but not in csv header\n missing_headers = np.setdiff1d(use_cols, headers)\n if len(missing_headers) > 0:\n for missing_item in missing_headers:\n if missing_item in SURVEY_VARS.keys():\n aliases = SURVEY_VARS[missing_item][\"aliases\"]\n for alias in aliases:\n if alias in headers:\n use_cols.remove(missing_item)\n use_cols.append(alias)\n\n else:\n # TODO Search through all aliases to find which label it matches with\n # How?\n warnings.warn(\n f\"Warning: Can't find a matching alias for {missing_item} which is in the csv. Removing it before passing to pandas.\"\n )\n use_cols.remove(missing_item)\n\n return use_cols # Exit if nothing is missing\n\n @staticmethod\n def _check_excel_col_names(filepath, use_cols):\n \"\"\"Compares the desired columns with those present in the csv file.\n\n Where a column is requested but not present, we check element-wise through the provided aliases from parameters.SURVEY_VARS and try those instead. If an alias is present in the file, we'll pass it to pandas to read in the csv.\n\n Parameters\n ----------\n filepath : filepath_or_buffer\n csv file to pass to pandas.read_csv()\n use_cols : list\n columns (variable) labels you'd like to read in\n\n Returns\n -------\n list\n use_cols with missing items replaced by their alias\n \"\"\"\n # TODO Tests for _check_csv_col_names()\n headers = pd.read_excel(filepath, header=None, nrows=1).iloc[0].array\n\n # Pull out items in cols but not in csv header\n missing_headers = np.setdiff1d(use_cols, headers)\n if len(missing_headers) > 0:\n for missing_item in missing_headers:\n if missing_item in SURVEY_VARS.keys():\n aliases = SURVEY_VARS[missing_item][\"aliases\"]\n for alias in aliases:\n if alias in headers:\n use_cols.remove(missing_item)\n use_cols.append(alias)\n\n else:\n # TODO Search through all aliases to find which label it matches with\n # How?\n warnings.warn(\n f\"Warning: Can't find a matching alias for {missing_item} which is in the csv. Removing it before passing to pandas.\"\n )\n use_cols.remove(missing_item)\n\n return use_cols # Exit if nothing is missing\n\n def fill_missing_paqs(self, fill_val=3):\n self[CATEGORISED_VARS[\"raw_PAQs\"]] = self[CATEGORISED_VARS[\"raw_PAQs\"]].fillna(\n value=fill_val\n )\n return self\n\n def calculate_complex_paqs(\n self, scale_to_one: bool = True, fill_na: bool = True, fill_val=3\n ):\n \"\"\"Calculate the complex Pleasant and Eventful projections of the PAQs.\n Uses the projection formulae from ISO 12913 Part 3:\n\n P =(p−a)+cos45°*(ca−ch)+cos45°*(v−m)\n E =(e−u)+cos45°*(ch−ca)+cos45°*(v−m)\n\n Parameters\n ----------\n scale_to_one : bool, optional\n Scale the complex values from -1 to 1, by default True\n fill_na : bool, optional\n Fill missing raw_PAQ values, by default True\n fill_val : int, optional\n Value to fill missing raw_PAQs with, by default 3\n\n Returns\n -------\n (pd.Series, pd.Series)\n pandas Series containing the new complex Pleasant and Eventful vectors\n \"\"\"\n if fill_na:\n self = self.fill_missing_paqs(fill_val=fill_val)\n\n # TODO: Add check for raw_PAQ column names\n # TODO: add handling for if sf already contains Pleasant and Eventful values\n\n proj = np.cos(np.deg2rad(45))\n scale = 4 + np.sqrt(32)\n\n # TODO: Add if statements for too much missing data\n # P =(p−a)+cos45°\u0019(ca−ch)+cos45°\u0019(v−m)\n complex_pleasant = (\n (self.pleasant.fillna(0) - self.annoying.fillna(0))\n + proj * (self.calm.fillna(0) - self.chaotic.fillna(0))\n + proj * (self.vibrant.fillna(0) - self.monotonous.fillna(0))\n )\n Pleasant = complex_pleasant / scale if scale_to_one else complex_pleasant\n\n # E =(e−u)+cos45°\u0019(ch−ca)+cos45°\u0019(v−m)\n complex_eventful = (\n (self.eventful.fillna(0) - self.uneventful.fillna(0))\n + proj * (self.chaotic.fillna(0) - self.calm.fillna(0))\n + proj * (self.vibrant.fillna(0) - self.monotonous.fillna(0))\n )\n Eventful = complex_eventful / scale if scale_to_one else complex_eventful\n \n return Pleasant, Eventful\n\n\n# Dealing with Directories!\ndef collect_all_dirs(\n root_directory: Path,\n location_ids: list,\n param_list: list,\n include_TS: bool = True,\n include_spectrum: bool = True,\n include_WAV: bool = True,\n):\n \"\"\"Iterate throughout the SSID DB file structure to extract TimeSeries, SpectrumData, WAV directory paths.\n\n Parameters\n ----------\n root_directory : Path\n The city-level SSID directory\n location_ids : list\n A subset of LocationIDs to include in the filepath collection\n param_list : list\n A subset of parameters to include in the filepath collection\n include_TS : bool, optional\n Collect TimeSeries dirs?, by default True\n include_spectrum : bool, optional\n Collect SpectrumData dirs?, by default True\n include_WAV : bool, optional\n Collect WAV dirs?, by default True\n\n Returns\n -------\n tuple of lists\n A tuple containing the full lists of TimeSeries, SpectrumData, and WAV directories.\n These lists contain WindowsPath objects.\n \n Examples\n ________\n >>> full_ts_list, full_spectrum_list, full_wav_list = collect_all_dirs(TEST_DIR, [\"LocationA\", \"LocationB\"], PARAM_LIST)\n >>> len(full_ts_list)\n 33\n >>> len(full_spectrum_list)\n 6\n >>> len(full_wav_list)\n 3\n \"\"\"\n\n # Input tests\n if not isinstance(root_directory, Path):\n raise TypeError(\n \"The directory should be provided as a WindowsPath object from pathlib.\"\n )\n if not root_directory.is_dir():\n raise FileNotFoundError(\"Path does not exist.\")\n\n # Collect list of session id directories\n session_dirs = [session for session in root_directory.iterdir() if session.is_dir()]\n session_dirs = [session for session in session_dirs if \"OFF\" in session.name]\n\n new_session_dirs = [\n [session for location in location_ids if (location in session.name)]\n for session in session_dirs\n ]\n\n session_dirs = [\n val for sublist in new_session_dirs for val in sublist\n ] # Remove blank entries\n\n bin_dirs = []\n for session in session_dirs:\n bin_dir = [\n child\n for child in session.iterdir()\n if child.is_dir() and \"BIN\" in child.name\n ][0]\n bin_dirs.append(bin_dir)\n\n if include_TS:\n # Collect Time Series parameter directories\n full_ts_list = _ts_dirs(bin_dirs, param_list)\n else:\n full_ts_list = []\n\n if include_spectrum:\n # Collect Spectrum directories\n full_spectrum_list = _spectrum_dirs(bin_dirs)\n else:\n full_spectrum_list = []\n\n if include_WAV:\n # Collect WAV directories\n full_wav_list = _wav_dirs(bin_dirs)\n else:\n full_wav_list = []\n\n return full_ts_list, full_spectrum_list, full_wav_list\n\n\ndef _spectrum_dirs(bin_dirs):\n spectrum_dirs = []\n for directory in bin_dirs:\n spectrum_dir = [\n child\n for child in directory.iterdir()\n if child.is_dir() and \"SpectrumData\" in child.name\n ][0]\n spectrum_dirs.append(spectrum_dir)\n\n full_spectrum_list = []\n for directory in spectrum_dirs:\n spectrum_dir = [child for child in directory.iterdir() if child.is_dir()]\n full_spectrum_list.append(spectrum_dir)\n\n full_spectrum_list = [val for sublist in full_spectrum_list for val in sublist]\n return full_spectrum_list\n\n\ndef _ts_dirs(bin_dirs, param_list):\n # Collect Time Series parameter directories\n ts_dirs = []\n for directory in bin_dirs:\n ts_dir = [\n child\n for child in directory.iterdir()\n if child.is_dir() and \"TimeSeries\" in child.name\n ][0]\n ts_dirs.append(ts_dir)\n\n param_dirs = []\n for directory in ts_dirs:\n param_dir = [child for child in directory.iterdir() if child.is_dir()]\n param_dirs.append(param_dir)\n param_dirs = [val for sublist in param_dirs for val in sublist]\n\n full_ts_list = [\n [directory for param in param_list if (param + \"_TS\" in directory.name)]\n for directory in param_dirs\n ]\n\n full_ts_list = [val for sublist in full_ts_list for val in sublist]\n return full_ts_list\n\n\ndef _wav_dirs(bin_dirs):\n # Collect Wav directories\n wav_dirs = []\n for directory in bin_dirs:\n wav_dir = [\n child\n for child in directory.iterdir()\n if child.is_dir() and \"WAV\" in child.name\n ][0]\n wav_dirs.append(wav_dir)\n\n return wav_dirs\n\n\nif __name__ == \"__main__\":\n import doctest\n\n TEST_DIR = Path(\"../../soundscapy/test/test_DB\")\n doctest.testmod(verbose=False, optionflags=doctest.ELLIPSIS)\n"
] |
[
[
"pandas.read_excel",
"pandas.read_csv",
"numpy.sqrt",
"numpy.setdiff1d",
"numpy.deg2rad"
]
] |
Guest400123064/fed-iris
|
[
"daf443cbaf315486804ce08cf491eb85dc06b87c"
] |
[
"client/src/core/graph.py"
] |
[
"import torch\nimport torch.nn as nn\nfrom easydict import EasyDict\n\n\nclass IrisModel(nn.Module):\n\n def __init__(self, config: EasyDict=EasyDict()):\n\n # We know exactly that the iris data set \n # contains 4 factors and 3 classes; therefore\n # the model structure is hard-coded\n super().__init__()\n self.linear = nn.Linear(4, 3)\n self.config = config\n\n def forward(self, x):\n \n # Evaluate the linear part, comput three scores\n # for each one of the three possible classes\n z = self.linear(x)\n return z\n\n def predict(self, x):\n\n # Prediction, return class index\n self.linear.eval()\n with torch.no_grad():\n z = self.linear(x)\n p = torch.softmax(z, 1)\n i = torch.argmax(p, 1)\n return i\n\n\nclass IrisLoss(nn.Module):\n\n def __init__(self, config: EasyDict=EasyDict()):\n\n # For details, refer to\n # <torch.nn.CrossEntropyLoss>\n # official documentations\n super().__init__()\n self.loss = nn.CrossEntropyLoss()\n self.config = config\n\n def forward(self, pred, label):\n\n # Input predictions (pred) should\n # be the scores (linear part) INSTEAD OF\n # the probabilities (after softmax applied)\n l = self.loss(pred, label)\n return l\n\n\nclass IrisOptimizer:\n\n @staticmethod\n def init(params, config: EasyDict=EasyDict()):\n\n o = torch.optim.SGD(\n params, \n lr=config.get('lr', 0.01),\n momentum=config.get('momentum', 0),\n nesterov=config.get('nesterov', False)\n )\n return o\n"
] |
[
[
"torch.softmax",
"torch.nn.CrossEntropyLoss",
"torch.nn.Linear",
"torch.no_grad",
"torch.argmax"
]
] |
janzkyle23/models
|
[
"a8ae09e23d309f8893619387a7133bcc4db3d8a9"
] |
[
"official/nlp/bert/run_pretraining.py"
] |
[
"# Copyright 2019 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ==============================================================================\n\"\"\"Run masked LM/next sentence pre-training for BERT in TF 2.x.\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom absl import app\nfrom absl import flags\nfrom absl import logging\nimport gin\nimport tensorflow as tf\n\nfrom official.modeling import model_training_utils\nfrom official.modeling import performance\nfrom official.nlp import optimization\nfrom official.nlp.bert import bert_models\nfrom official.nlp.bert import common_flags\nfrom official.nlp.bert import configs\nfrom official.nlp.bert import input_pipeline\nfrom official.utils.misc import distribution_utils\n\n\nflags.DEFINE_string('input_files', None,\n 'File path to retrieve training data for pre-training.')\n# Model training specific flags.\nflags.DEFINE_integer(\n 'max_seq_length', 128,\n 'The maximum total input sequence length after WordPiece tokenization. '\n 'Sequences longer than this will be truncated, and sequences shorter '\n 'than this will be padded.')\nflags.DEFINE_integer('max_predictions_per_seq', 20,\n 'Maximum predictions per sequence_output.')\nflags.DEFINE_integer('train_batch_size', 32, 'Total batch size for training.')\nflags.DEFINE_integer('num_steps_per_epoch', 1000,\n 'Total number of training steps to run per epoch.')\nflags.DEFINE_float('warmup_steps', 10000,\n 'Warmup steps for Adam weight decay optimizer.')\n\ncommon_flags.define_common_bert_flags()\ncommon_flags.define_gin_flags()\n\nFLAGS = flags.FLAGS\n\n\ndef get_pretrain_dataset_fn(input_file_pattern, seq_length,\n max_predictions_per_seq, global_batch_size):\n \"\"\"Returns input dataset from input file string.\"\"\"\n def _dataset_fn(ctx=None):\n \"\"\"Returns tf.data.Dataset for distributed BERT pretraining.\"\"\"\n input_patterns = input_file_pattern.split(',')\n batch_size = ctx.get_per_replica_batch_size(global_batch_size)\n train_dataset = input_pipeline.create_pretrain_dataset(\n input_patterns,\n seq_length,\n max_predictions_per_seq,\n batch_size,\n is_training=True,\n input_pipeline_context=ctx)\n return train_dataset\n\n return _dataset_fn\n\n\ndef get_loss_fn(loss_factor=1.0):\n \"\"\"Returns loss function for BERT pretraining.\"\"\"\n\n def _bert_pretrain_loss_fn(unused_labels, losses, **unused_args):\n return tf.reduce_mean(losses) * loss_factor\n\n return _bert_pretrain_loss_fn\n\n\ndef run_customized_training(strategy,\n bert_config,\n max_seq_length,\n max_predictions_per_seq,\n model_dir,\n steps_per_epoch,\n steps_per_loop,\n epochs,\n initial_lr,\n warmup_steps,\n input_files,\n train_batch_size):\n \"\"\"Run BERT pretrain model training using low-level API.\"\"\"\n\n train_input_fn = get_pretrain_dataset_fn(input_files, max_seq_length,\n max_predictions_per_seq,\n train_batch_size)\n\n def _get_pretrain_model():\n \"\"\"Gets a pretraining model.\"\"\"\n pretrain_model, core_model = bert_models.pretrain_model(\n bert_config, max_seq_length, max_predictions_per_seq)\n optimizer = optimization.create_optimizer(\n initial_lr, steps_per_epoch * epochs, warmup_steps)\n pretrain_model.optimizer = performance.configure_optimizer(\n optimizer,\n use_float16=common_flags.use_float16(),\n use_graph_rewrite=common_flags.use_graph_rewrite())\n return pretrain_model, core_model\n\n trained_model = model_training_utils.run_customized_training_loop(\n strategy=strategy,\n model_fn=_get_pretrain_model,\n loss_fn=get_loss_fn(\n loss_factor=1.0 /\n strategy.num_replicas_in_sync if FLAGS.scale_loss else 1.0),\n model_dir=model_dir,\n train_input_fn=train_input_fn,\n steps_per_epoch=steps_per_epoch,\n steps_per_loop=steps_per_loop,\n epochs=epochs,\n sub_model_export_name='pretrained/bert_model')\n\n return trained_model\n\n\ndef run_bert_pretrain(strategy):\n \"\"\"Runs BERT pre-training.\"\"\"\n\n bert_config = configs.BertConfig.from_json_file(FLAGS.bert_config_file)\n if not strategy:\n raise ValueError('Distribution strategy is not specified.')\n\n # Runs customized training loop.\n logging.info('Training using customized training loop TF 2.0 with distrubuted'\n 'strategy.')\n\n performance.set_mixed_precision_policy(common_flags.dtype())\n\n return run_customized_training(\n strategy,\n bert_config,\n FLAGS.max_seq_length,\n FLAGS.max_predictions_per_seq,\n FLAGS.model_dir,\n FLAGS.num_steps_per_epoch,\n FLAGS.steps_per_loop,\n FLAGS.num_train_epochs,\n FLAGS.learning_rate,\n FLAGS.warmup_steps,\n FLAGS.input_files,\n FLAGS.train_batch_size)\n\n\ndef main(_):\n # Users should always run this script under TF 2.x\n assert tf.version.VERSION.startswith('2.')\n gin.parse_config_files_and_bindings(FLAGS.gin_file, FLAGS.gin_param)\n if not FLAGS.model_dir:\n FLAGS.model_dir = '/tmp/bert20/'\n strategy = distribution_utils.get_distribution_strategy(\n distribution_strategy=FLAGS.distribution_strategy,\n num_gpus=FLAGS.num_gpus,\n tpu_address=FLAGS.tpu)\n if strategy:\n print('***** Number of cores used : ', strategy.num_replicas_in_sync)\n\n run_bert_pretrain(strategy)\n\n\nif __name__ == '__main__':\n app.run(main)\n"
] |
[
[
"tensorflow.version.VERSION.startswith",
"tensorflow.reduce_mean"
]
] |
hunter-packages/tvm
|
[
"d68bfa0f3a080a425a7ffd8d054d55022eeb9fc1"
] |
[
"nnvm/python/nnvm/frontend/tensorflow.py"
] |
[
"# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n# pylint: disable=import-self, invalid-name, unused-argument, too-many-lines\n\"\"\"TF: Tensorflow frontend.\"\"\"\nfrom __future__ import absolute_import as _abs\nfrom __future__ import print_function\n\nimport warnings\n# Numpy support\nimport numpy as np\n\nimport tvm\nfrom .. import symbol as _sym\nfrom .. import graph as _graph\nfrom .. compiler import graph_util, build_module\nfrom .common import get_nnvm_op, AttrConverter as AttrConvert\n\n__all__ = ['from_tensorflow']\n\nclass AttrCvt(object):\n \"\"\"A Wrapper to handle some common jobs:\n \"\"\"\n def __init__(self, op_name, transforms=None,\n excludes=None, disables=None, ignores=None,\n extras=None, custom_check=None):\n self._op_name = op_name\n self._transforms = transforms if transforms else {}\n self._excludes = excludes if excludes else []\n self._disables = disables if disables else []\n self._ignores = ignores if ignores else []\n self._extras = extras if extras else {}\n self._custom_check = custom_check\n\n def __call__(self, inputs, attrs, *args):\n self._ignores.append('_output_shapes')\n self._ignores.append('_input_shapes')\n self._ignores.append('T')\n self._ignores.append('use_cudnn_on_gpu')\n self._ignores.append('_node_name')\n self._ignores.append('is_training')\n self._ignores.append('_target_layout')\n self._ignores.append('_input_0d_mismatch')\n # Retain the names\n try:\n attrs['name'] = attrs['_node_name']\n except KeyError:\n pass\n return AttrConvert(self._op_name, self._transforms, self._excludes,\n self._disables, self._ignores, self._extras,\n self._custom_check)(inputs, attrs, *args)\n\ndef _get_pad_pair(input1d, kernel1d, stride1d):\n if input1d % stride1d == 0:\n pad = max(kernel1d - stride1d, 0)\n else:\n pad = max(kernel1d - (input1d % stride1d), 0)\n\n pad_before = pad // 2\n pad_after = pad - pad_before\n\n return [pad_before, pad_after]\n\ndef _math_name_picker(surfix):\n def _impl(attr):\n return 'broadcast_' + surfix\n return _impl\n\ndef _dimension_picker(prefix, surfix=''):\n def _impl(attr):\n kernel = attr['kernel_shape']\n if len(kernel) == 2:\n return prefix + '2d' + surfix\n raise tvm.error.OpAttributeUnimplemented(\n 'Non-2D kernels are not supported for operator {}.'.format(prefix))\n return _impl\n\ndef _dimension_constraint():\n def _dim_check(attrs):\n if len(attrs['kernel_shape']) == 2:\n return True\n return False\n return _dim_check, \"Only 2d kernel supported.\"\n\ndef _infer_channels(inputs, params, transpose=False):\n \"\"\"A hack for getting 'channles' or 'units' since tensorflow don't provide\n these attributes. We check the shape of weights provided to get the number.\n \"\"\"\n g = _graph.create(inputs)\n shape_dict = {k: v.shape for k, v in params.items()}\n _, out_shapes = graph_util.infer_shape(g, **shape_dict)\n channels = out_shapes[0][0] if not transpose else out_shapes[0][1]\n return channels\n\ndef _rsqrt():\n def _impl(inputs, attr, *args):\n return AttrCvt(op_name=\"__pow_scalar__\", extras={'scalar': -0.5})(inputs, attr)\n return _impl\n\ndef _argx(func, func_name):\n \"\"\" A common wrapper for argmin and argmax operations \"\"\"\n def _impl(inputs, attr, params):\n try:\n # In Tensorflow, `axis` argument is a Tensor, not attribute. We\n # support the case where it inputs from a scalar constant.\n axis_input_name = inputs[1].list_output_names()[0]\n axis_input_vlaue = params[axis_input_name].asnumpy()[0]\n except (IndexError, KeyError):\n raise TypeError( \\\n \"Unsupported argument for `{}` : `axis` should be a constant\".format(func_name))\n return func(inputs[0], axis=axis_input_vlaue, keepdims=False)\n return _impl\n\ndef _elemwise(name):\n def _impl(inputs, attr, *args):\n assert len(inputs) == 2, \"{} take 2 inputs, {} given\".format(name, len(inputs))\n op_name = _math_name_picker(name)(attr)\n return get_nnvm_op(op_name)(*inputs)\n return _impl\n\ndef _pooling(name):\n def _impl(inputs, attr, params):\n\n attr['data_format'] = attr['data_format'].decode(\"utf-8\")\n flip_layout = False\n\n input_shape = attr['_input_shapes'][inputs[0]]\n\n if attr['data_format'] == 'NHWC':\n attr['kernel_shape'] = (attr['ksize'][1], attr['ksize'][2])\n attr['strides'] = (attr['strides'][1], attr['strides'][2])\n elif attr['data_format'] == 'NCHW':\n attr['kernel_shape'] = (attr['ksize'][2], attr['ksize'][3])\n attr['strides'] = (attr['strides'][2], attr['strides'][3])\n else:\n msg = 'Value {} in attribute \"data_format\" of operator Pooling is not valid.'\n raise tvm.error.OpAttributeInvalid(msg.format(attr['data_format']))\n\n if attr['_target_layout'] == \"NCHW\" and attr['data_format'] == \"NHWC\":\n tmp_shape = attr['_input_shapes'][inputs[0]]\n input_shape = [tmp_shape[ii] for ii in (0, 3, 1, 2)]\n inputs[0] = _sym.transpose(inputs[0], axes=(0, 3, 1, 2))\n attr['data_format'] = \"NCHW\"\n flip_layout = True\n\n # Fix padding\n attr['padding'] = attr['padding'].decode(\"utf-8\")\n\n if attr['padding'] == 'VALID':\n attr['padding'] = [0, 0]\n elif attr['padding'] == 'SAME':\n stride_h, stride_w = attr['strides']\n kernel_h, kernel_w = attr['kernel_shape']\n if attr['data_format'] == 'NHWC':\n in_h = input_shape[1]\n in_w = input_shape[2]\n else:\n in_h = input_shape[2]\n in_w = input_shape[3]\n\n pad_v = _get_pad_pair(in_h, kernel_h, stride_h)\n pad_h = _get_pad_pair(in_w, kernel_w, stride_w)\n\n attr['padding'] = [pad_v[0], pad_h[0], pad_v[1], pad_h[1]]\n else:\n msg = 'Value {} in attribute \"padding\" of operator Pooling is not valid.'\n raise tvm.error.OpAttributeUnimplemented(msg.format(attr['padding']))\n\n if name == \"avg_pool\":\n attr['count_include_pad'] = False\n\n out = AttrCvt(\n op_name=_dimension_picker(name),\n transforms={\n 'kernel_shape':'pool_size',\n 'data_format':'layout'},\n ignores=['ksize'],\n extras={'ceil_mode': False},\n custom_check=_dimension_constraint())(inputs, attr)\n\n if flip_layout:\n out = _sym.transpose(out, axes=(0, 2, 3, 1))\n\n return out\n return _impl\n\ndef _conv(opname):\n def _impl(inputs, attr, params):\n attr['data_format'] = attr['data_format'].decode(\"utf-8\")\n flip_layout = False\n\n # NCHW Layout require weights transpose\n if attr['data_format'] == 'NCHW':\n tmp_shape = attr['_input_shapes'][inputs[1]]\n tmp_shape = [tmp_shape[ii] for ii in (3, 2, 0, 1)]\n inputs[1] = _sym.transpose(inputs[1], axes=(3, 2, 0, 1))\n attr['_input_shapes'][inputs[1]] = tmp_shape\n\n input_shape = attr['_input_shapes'][inputs[0]]\n weights_shape = attr['_input_shapes'][inputs[1]]\n\n if attr['_target_layout'] == \"NCHW\" and attr['data_format'] == \"NHWC\":\n input_shape = [input_shape[ii] for ii in (0, 3, 1, 2)]\n inputs[0] = _sym.transpose(inputs[0], axes=(0, 3, 1, 2))\n if opname == 'conv':\n weights_shape = [weights_shape[ii] for ii in (3, 2, 0, 1)]\n inputs[1] = _sym.transpose(inputs[1], axes=(3, 2, 0, 1))\n else:\n weights_shape = [weights_shape[ii] for ii in (2, 3, 0, 1)]\n inputs[1] = _sym.transpose(inputs[1], axes=(2, 3, 0, 1))\n\n attr['data_format'] = \"NCHW\"\n attr['strides'] = [attr['strides'][ii] for ii in (0, 3, 1, 2)]\n flip_layout = True\n\n if attr['data_format'] == 'NHWC':\n kernel_h, kernel_w, _, depth_mult = weights_shape\n attr['kernel_shape'] = (weights_shape[0], weights_shape[1])\n if opname == 'conv':\n attr['channels'] = weights_shape[3]\n else:\n attr['channels'] = input_shape[3] * depth_mult\n\n if 'dilations' in attr:\n attr['dilations'] = (attr['dilations'][1], attr['dilations'][2])\n attr['strides'] = (attr['strides'][1], attr['strides'][2])\n elif attr['data_format'] == 'NCHW':\n depth_mult, _, kernel_h, kernel_w = weights_shape\n attr['kernel_shape'] = (weights_shape[2], weights_shape[3])\n if opname == 'conv':\n attr['channels'] = weights_shape[0]\n else:\n attr['channels'] = input_shape[0] * depth_mult\n if attr['channels'] < 0:\n attr['channels'] *= -1\n\n if 'dilations' in attr:\n attr['dilations'] = (attr['dilations'][2], attr['dilations'][3])\n attr['strides'] = (attr['strides'][2], attr['strides'][3])\n else:\n msg = 'Value {} in attribute \"data_format\" of operator Conv is not valid.'\n raise tvm.error.OpAttributeInvalid(msg.format(attr['data_format']))\n\n\n if opname == 'depthwise':\n attr['groups'] = attr['channels']\n\n # Fix padding\n attr['padding'] = attr['padding'].decode(\"utf-8\")\n\n if attr['padding'] == 'VALID':\n attr['padding'] = [0, 0]\n elif attr['padding'] == 'SAME':\n stride_h, stride_w = attr['strides']\n kernel_h, kernel_w = attr['kernel_shape']\n if attr['data_format'] == 'NHWC':\n in_h = input_shape[1]\n in_w = input_shape[2]\n else:\n in_h = input_shape[2]\n in_w = input_shape[3]\n\n dilation_h = attr['dilations'][0]\n dilation_w = attr['dilations'][1]\n dilated_kernel_h = (kernel_h - 1) * dilation_h + 1\n dilated_kernel_w = (kernel_w - 1) * dilation_w + 1\n pad_v = _get_pad_pair(in_h, dilated_kernel_h, stride_h)\n pad_h = _get_pad_pair(in_w, dilated_kernel_w, stride_w)\n\n if attr['data_format'] == 'NHWC':\n inputs[0] = _sym.pad(data=inputs[0],\n pad_width=((0, 0),\n (pad_v[0], pad_v[1]),\n (pad_h[0], pad_h[1]),\n (0, 0)))\n else:\n inputs[0] = _sym.pad(data=inputs[0],\n pad_width=((0, 0),\n (0, 0),\n (pad_v[0], pad_v[1]),\n (pad_h[0], pad_h[1])))\n\n attr['padding'] = [0, 0]\n\n else:\n msg = 'Value {} in attribute \"padding\" of operator Conv is not valid.'\n raise tvm.error.OpAttributeInvalid(msg.format(attr['padding']))\n\n if 'kernel_layout' not in attr:\n if opname == 'conv':\n attr['kernel_layout'] = 'HWIO' if attr['data_format'] == 'NHWC' else 'OIHW'\n else:\n attr['kernel_layout'] = 'HWOI' if attr['data_format'] == 'NHWC' else 'OIHW'\n\n out = AttrCvt(\n op_name=_dimension_picker('conv'),\n transforms={\n 'kernel_shape': 'kernel_size',\n 'data_format': 'layout',\n 'dilations': ('dilation', (0, 0)),\n 'group': ('groups', 1)},\n extras={'use_bias': len(inputs) == 3},\n custom_check=_dimension_constraint())(inputs, attr)\n\n if flip_layout:\n out = _sym.transpose(out, axes=(0, 2, 3, 1))\n\n return out\n return _impl\n\ndef _decode_image():\n def _impl(inputs, attr, params):\n # Image decode wrapper: Expecting user to feed decoded input to next layer drop this layer.\n warnings.warn(\"DecodeJpeg: It's a pass through, \"\n \"please handle preprocessing before input\")\n return inputs[0]\n return _impl\n\ndef _cast():\n def _impl(inputs, attr, params):\n # Convert from tensorflow Dtype to str\n attr['DstT'] = attr['DstT'].name\n return AttrCvt(op_name='cast', transforms={'DstT': 'dtype'},\n ignores=['SrcT', 'Truncate'])(inputs, attr)\n return _impl\n\ndef _expand_dims():\n def _impl(inputs, attr, params):\n dim_input = inputs.pop(1)\n axis = params[dim_input.list_output_names()[0]]\n params.pop(dim_input.list_output_names()[0])\n return _expand_dims_0d_aware(inputs[0], attr, axis=axis.asnumpy()[0])\n return _impl\n\ndef _resize_bilinear():\n def _impl(inputs, attr, params):\n attr['size'] = attr['_output_shapes'][0][1:3]\n inputs.pop(1)\n # NHWC\n attr['layout'] = 'NHWC'\n\n return AttrCvt(op_name=\"resize\",\n ignores=['Tdim'],\n extras={'method': \"BILINEAR\"})(inputs, attr)\n return _impl\n\ndef _check_numerics():\n def _impl(inputs, attr, params):\n # Making a copy node assuming no need to verify\n return AttrCvt(op_name=\"copy\", ignores=['message'])(inputs, attr)\n return _impl\n\n\ndef _matmul():\n def _impl(inputs, attr, params):\n channels = _infer_channels(inputs[1], params, not attr['transpose_b'])\n if attr['transpose_a']:\n inputs[0] = _sym.transpose(inputs[0], axes=(1, 0))\n if not attr['transpose_b']:\n inputs[1] = _sym.transpose(inputs[1], axes=(1, 0))\n return AttrCvt(op_name=\"dense\",\n extras={'use_bias': False, 'units': channels},\n ignores=['transpose_a', 'transpose_b', 'T'])(inputs, attr)\n\n return _impl\n\ndef _undef():\n def _impl(inputs, attr, params):\n return _sym.__undef__()\n return _impl\n\ndef _identity():\n def _impl(inputs, attr, params):\n return inputs[0]\n return _impl\n\ndef _concatV2():\n def _impl(inputs, attr, params):\n pop_node = inputs.pop(len(inputs)-1)\n axis = params[pop_node.list_output_names()[0]]\n params.pop(pop_node.list_output_names()[0])\n return AttrCvt(\n op_name=\"concatenate\", ignores=['T', 'N', 'Tidx'],\n extras={'axis': axis.asnumpy()[0]})(inputs, attr)\n return _impl\n\ndef _concat():\n def _impl(inputs, attr, params):\n pop_node = inputs.pop(0)\n axis = params[pop_node.list_output_names()[0]]\n params.pop(pop_node.list_output_names()[0])\n return AttrCvt(\n op_name=\"concatenate\", ignores=['N'],\n extras={'axis': axis.asnumpy()[0]})(inputs, attr)\n return _impl\n\ndef _pack():\n def _impl(inputs, attr, params):\n axis = int(attr[\"axis\"])\n inputs_reshaped = [_expand_dims_0d_aware(i, attr, axis=axis, num_newaxis=1) for i in inputs]\n return _sym.concatenate(*inputs_reshaped, axis=axis, name=attr[\"_node_name\"])\n\n return _impl\n\ndef _slice():\n def _impl(inputs, attr, params):\n begin = params.pop(inputs[1].list_output_names()[0]).asnumpy().tolist()\n size = params.pop(inputs[2].list_output_names()[0]).asnumpy().tolist()\n data_shape = attr['_input_shapes'][inputs[0]]\n data_dim = len(data_shape)\n end = size\n for i in range(data_dim):\n if size[i] == -1:\n end[i] = data_shape[i] - begin[i]\n else:\n end[i] += begin[i]\n return _sym.strided_slice(inputs[0], begin=begin, end=size)\n return _impl\n\ndef _reshape():\n def _impl(inputs, attr, params):\n try:\n pop_node = inputs[1]\n shape_arg = params.pop(pop_node.list_output_names()[0])\n inputs.pop(1)\n\n return AttrCvt(\n op_name=\"reshape\",\n extras={'shape':tuple(shape_arg.asnumpy())},\n ignores=['Tshape'])(inputs, attr)\n except KeyError:\n # Shape operator is already pruned, hence\n # try to infer shape by precompute prune if possible.\n if all(in_node in params for in_node in inputs[1].list_input_names()):\n graph = _graph.create(_sym.Group(inputs[1]))\n params_pre = {k: params[k] for k in inputs[1].list_input_names()}\n params_new = build_module._run_graph(graph, params_pre)\n inputs.pop(1)\n return AttrCvt(\n op_name=\"reshape\",\n extras={'shape':tuple(params_new[0].asnumpy().flatten())},\n ignores=['Tshape'])(inputs, attr)\n raise tvm.error.OpAttributeUnimplemented(\n 'Attribute \"dynamic shape\" of operator Reshape is not supported.')\n return _impl\n\ndef _bias_add():\n def _impl(inputs, attr, params):\n return _sym.broadcast_add(inputs[0], inputs[1])\n return _impl\n\ndef _squeeze():\n def _impl(inputs, attr, params):\n return AttrCvt(\n op_name=\"squeeze\",\n transforms={'squeeze_dims':'axis'},\n ignores=['T'])(inputs, attr)\n return _impl\n\ndef _fused_batch_norm():\n def _impl(inputs, attr, params):\n # Tensorflow: (data, gamma, beta, moving_mean, moving_variance)\n # NNVM: (data, gamma, beta, moving_mean, moving_varience)\n axis = 3\n need_cast = False\n\n if 'data_format' in attr:\n attr['data_format'] = attr['data_format'].decode(\"utf-8\")\n if attr['data_format'] == 'NCHW':\n axis = 1\n if 'U' in attr:\n need_cast = True\n inputs[0] = _sym.cast(inputs[0], dtype=attr['U'].name)\n\n out = AttrCvt(op_name='batch_norm',\n transforms={'scale_after_normalization':'scale',\n 'variance_epsilon':'epsilon'},\n extras={'axis': axis},\n ignores=['data_format', 'U'],\n disables=['momentum'])(inputs, attr)\n\n if need_cast:\n out = _sym.cast(out, dtype=attr['T'].name)\n return out\n return _impl\n\ndef _batch_norm():\n def _impl(inputs, attr, params):\n # Rearrange inputs from\n # (data, moving_mean, moving_variance, beta, gamma)\n # to\n # (data, gamma, beta, moving_mean, moving_var)\n new_inputs = [inputs[0], inputs[4], inputs[3], inputs[1], inputs[2]]\n\n axis = 3\n if 'data_format' in attr:\n attr['data_format'] = attr['data_format'].decode(\"utf-8\")\n if attr['data_format'] == 'NCHW':\n axis = 1\n\n return AttrCvt(\n op_name='batch_norm',\n transforms={'scale_after_normalization':'scale', 'variance_epsilon':'epsilon'},\n extras={'axis': axis},\n ignores=['data_format'],\n disables=['momentum'])(new_inputs, attr)\n return _impl\n\ndef _relu6():\n def _impl(inputs, attr, params):\n return _sym.clip(inputs[0], a_min=0, a_max=6, name=attr['_node_name'])\n return _impl\n\ndef _shape():\n def _impl(inputs, attr, params):\n return np.array(attr['_input_shapes'][inputs[0]], dtype='int32')\n return _impl\n\ndef _fill():\n def _impl(inputs, attr, params):\n fill_arg = params.pop(inputs.pop(1).list_output_names()[0])\n new_inputs = []\n return AttrCvt(\n op_name='full',\n extras={'shape':inputs[0],\n 'fill_value':fill_arg.asnumpy()[0], 'dtype':attr['T'].name},\n ignores=['index_type', 'T'])(new_inputs, attr)\n return _impl\n\ndef _lrn():\n def _impl(inputs, attr, params):\n attr_new = {}\n depth_radius = attr.get('depth_radius', 5)\n size = (depth_radius * 2) + 1\n attr_new['axis'] = 3 # Fix axis, NHWC format\n attr_new['size'] = size\n attr_new['bias'] = attr.get('bias', 1)\n attr_new['alpha'] = attr.get('alpha', 1) * size\n attr_new['beta'] = attr.get('beta', 0.5)\n return AttrCvt(op_name='lrn')(inputs, attr_new)\n return _impl\n\ndef _sum():\n def _impl(inputs, attr, params):\n axis = params.pop(inputs[1].list_output_names()[0]).asnumpy()\n # convert to tuple for preventing invalid parameter format error\n axis = tuple(axis)\n return AttrCvt(\n op_name='sum',\n extras={'axis': axis},\n transforms={'keep_dims':'keepdims'},\n ignores=['name', 'Tidx'])(inputs[0], attr)\n return _impl\n\ndef _square():\n def _impl(inputs, attr, params):\n return _sym.elemwise_mul(inputs[0], inputs[0])\n return _impl\n\ndef _gather_v2():\n \"Tensorflow now support only gatherv2\"\n def _impl(inputs, attr, params):\n axis = params[inputs.pop(2).list_output_names()[0]].asnumpy()[0]\n new_input = []\n new_input.append(inputs.pop(0))\n new_input.append(inputs.pop(0))\n return AttrCvt(\n op_name=\"take\",\n extras={'axis':axis},\n ignores=['Tindices', 'Tparams', 'validate_indices', \\\n 'Taxis', '_class'])(new_input, attr)\n return _impl\n\ndef _infer_out_shapes(inputs, params):\n \"\"\"A method to get the output shape of an intermediate node in the NNVM graph.\"\"\"\n g = _graph.create(inputs)\n shape_dict = {k: v.shape for k, v in params.items()}\n _, out_shapes = graph_util.infer_shape(g, **shape_dict)\n return out_shapes\n\ndef _stridedSlice():\n def _impl(inputs, attr, params):\n \"\"\"Strided Slice.\n Operator description: https://www.tensorflow.org/api_docs/python/tf/strided_slice\n Tensorflow mask validation: https://github.com/tensorflow/tensorflow/blob/master/\n tensorflow/core/util/strided_slice_op.cc#L147-L368\n \"\"\"\n begin = params.pop(inputs[1].list_output_names()[0]).asnumpy().tolist()\n end = params.pop(inputs[2].list_output_names()[0]).asnumpy().tolist()\n stride = params.pop(inputs[3].list_output_names()[0]).asnumpy().tolist()\n begin_mask = int(attr.get('begin_mask', 0))\n end_mask = int(attr.get('end_mask', 0))\n ellipsis_mask = int(attr.get('ellipsis_mask', 0))\n new_axis_mask = int(attr.get('new_axis_mask', 0))\n shrink_axis_mask = int(attr.get('shrink_axis_mask', 0))\n data_shape = attr['_input_shapes'][inputs[0]]\n data_dim = len(data_shape)\n stride_dim = len(stride)\n\n def _transform_mask(stride_dim, ellipsis_mask):\n \"\"\"Handle mask inputs to create new begin, end, stride and output shape\"\"\"\n m_begin = [0] * data_dim\n m_end = [0] * data_dim\n m_stride = [0] * data_dim\n fshape_indices = []\n #Count new axis after ellipsis_mask, consider while applying ellipsis_mask.\n ellipsis_seen = False\n new_axes_after_ellipsis = 0\n for i in range(stride_dim):\n mask = 1 << i\n if ellipsis_seen and (mask & new_axis_mask) != 0:\n new_axes_after_ellipsis += 1\n if (mask & ellipsis_mask) != 0:\n ellipsis_seen = True\n if not ellipsis_seen:\n #Used later for extending the stride attributes in the below loop.\n ellipsis_mask |= (1 << stride_dim)\n stride_dim += 1\n final_index = 0\n for index in range(stride_dim):\n mask = 1 << index\n if mask & ellipsis_mask:\n #Identify the end index for applying ellipsis_mask\n to_index = min(((data_dim - (stride_dim-index)) + 1 \\\n + new_axes_after_ellipsis), data_dim)\n for i in range(final_index, to_index):\n m_begin[final_index] = 0\n m_end[final_index] = data_shape[final_index]\n m_stride[final_index] = 1\n fshape_indices.append(final_index)\n final_index += 1\n elif mask &new_axis_mask:\n fshape_indices.append(-1)\n elif not mask & new_axis_mask:\n if final_index == len(m_begin):\n break\n if mask & begin_mask:\n m_begin[final_index] = data_shape[final_index] \\\n if stride[index] < 0 else 0\n elif begin[index]:\n m_begin[final_index] = begin[index]\n if mask & end_mask:\n m_end[final_index] = 0 if stride[index] < 0 \\\n else data_shape[final_index]\n elif end[index]:\n m_end[final_index] = end[index]\n m_stride[final_index] = stride[index]\n if mask & shrink_axis_mask:\n #Tensorflow make axis with shrink_axis_mask as dimension 1\n m_begin[final_index] = data_shape[final_index] + begin[index] \\\n if begin[index] < 0 else begin[index]\n m_end[final_index] = begin[index] + 1\n m_stride[final_index] = 1\n fshape_indices.append(-2)\n else:\n fshape_indices.append(final_index)\n\n final_index += 1\n return m_begin, m_end, m_stride, fshape_indices\n\n fshape_indices = None\n if begin_mask or end_mask or ellipsis_mask or new_axis_mask or shrink_axis_mask:\n begin, end, stride, fshape_indices = _transform_mask(stride_dim, ellipsis_mask)\n out = _sym.strided_slice(inputs[0], begin=begin, end=end, stride=stride)\n out_shape = _infer_out_shapes(out, params)[0]\n if not fshape_indices:\n fshape_indices = range(len(out_shape))\n\n #Create final output shape.\n final_output = []\n for gather_index in fshape_indices:\n if gather_index == -1:\n final_output.append(1)\n elif gather_index == -2:\n pass\n else:\n final_output.append(out_shape[gather_index])\n # Prevent 0-dim tensors which are not accepted by nnvm\n if not final_output:\n final_output.append(1)\n return _sym.reshape(out, shape=tuple(final_output))\n return _impl\n\ndef _LSTMBlockCell():\n def _impl(inputs, in_state_c, in_state_h, attr, params):\n \"\"\"LSTM Block cell.\n Calculations are described in: https://github.com/tensorflow/tensorflow/blob/\n r1.8/tensorflow/contrib/rnn/python/ops/lstm_ops.py#L41-L114\n\n Parameters\n ----------\n inputs : nnvm.Symbol\n Input data\n in_state_c: list of nnvm.Symbol\n Cell state input values for all the layers\n in_state_h: list of nnvm.Symbol\n Hidden state input values for all the layers\n attrs : dict\n Dict of operator attributes\n params : dict\n List of pretrained weights and bias\n\n Returns\n -------\n sym : nnvm.Symbol\n Converted nnvm Symbol\n output: nnvm.Symbol\n Output state value.\n \"\"\"\n in_data = inputs[0]\n in_weight = inputs[3]\n in_bias = inputs[7]\n forget_bias = attr.pop('forget_bias')\n input_shape = attr['_input_shapes'][inputs[0]]\n weight_shape = attr['_input_shapes'][inputs[3]]\n batch_size, input_size = input_shape[0], input_shape[1]\n num_hidden_layers = weight_shape[1]\n num_hidden = num_hidden_layers // 4\n\n in_data = _sym.reshape(in_data,\n shape=(batch_size, input_size))\n ixh = _sym.concatenate(*[in_data, in_state_h], axis=1)\n in_weight = _sym.transpose(in_weight)\n gates = _sym.dense(ixh, in_weight, in_bias, use_bias=True,\n units=num_hidden_layers)\n gate_list = _sym.split(gates, indices_or_sections=4, axis=1)\n in_gate = _sym.sigmoid(gate_list[0])\n in_transform = _sym.tanh(gate_list[1])\n forget_gate = _sym.sigmoid(gate_list[2])\n forget_gate = forget_gate + forget_bias\n out_gate = _sym.sigmoid(gate_list[3])\n next_c = _sym.broadcast_add(_sym.broadcast_mul(forget_gate, in_state_c),\n _sym.broadcast_mul(in_gate, in_transform))\n next_h = out_gate * _sym.tanh(next_c)\n out_state = _sym.concatenate(*[next_c, next_h])\n out_state = _sym.reshape(out_state,\n shape=(2, batch_size, num_hidden))\n return next_h, out_state\n return _impl\n\n\ndef _pad(name):\n def _impl(inputs, attr, params):\n padlist_key = inputs[1].list_output_names()[0]\n if padlist_key in params:\n padlist = params.pop(padlist_key).asnumpy()\n else:\n raise tvm.error.OpAttributeRequired(\n 'Required attribute \"{}\" not found in operator Pad.'.format(padlist_key))\n paddings = tuple([tuple(l) for l in padlist])\n attr['pad_width'] = paddings\n attr['pad_value'] = 0\n new_inputs = [inputs[0]]\n if name == 'PadV2':\n constant_values = params.pop(inputs[2].list_output_names()[0]).asnumpy()\n attr['pad_value'] = constant_values[0]\n return AttrCvt(\n op_name='pad',\n ignores=['Tpaddings'],)(new_inputs, attr)\n return _impl\n\n\ndef _transpose():\n def _impl(inputs, attr, params):\n # If perm is not specified, axes is left empty,\n # otherwise its value is get from params\n param_name = inputs[1].list_output_names()[0]\n axes = params.get(param_name, tvm.nd.array([])).asnumpy()\n return _sym.transpose(inputs[0], axes=tuple(axes))\n return _impl\n\ndef _rank():\n def _impl(inputs, attr, params):\n input_shape = attr['_input_shapes'][inputs[0]]\n\n name = attr[\"_node_name\"]\n params[name] = tvm.nd.array([len(input_shape)])\n return _sym.Variable(name=name, shape=params[name].shape)\n return _impl\n\ndef _range():\n def _impl(inputs, attr, params):\n start = params.pop(inputs[0].list_output_names()[0]).asnumpy()[0]\n limit = params.pop(inputs[1].list_output_names()[0]).asnumpy()[0]\n delta = params.pop(inputs[2].list_output_names()[0]).asnumpy()[0]\n\n name = attr[\"_node_name\"]\n params[name] = tvm.nd.array([start, limit, delta])\n return _sym.Variable(name=name, shape=params[name].shape)\n return _impl\n\ndef _elu():\n def _impl(inputs, attr, params):\n alpha = 1.0\n return -alpha * _sym.relu(1 - _sym.exp(inputs[0])) + _sym.relu(inputs[0])\n return _impl\n\ndef _selu():\n def _impl(inputs, attr, params):\n alpha = 1.6732632423543772848170429916717\n gamma = 1.0507009873554804934193349852946\n return gamma * (-alpha * _sym.relu(1 - _sym.exp(inputs[0])) + _sym.relu(inputs[0]))\n return _impl\n\ndef _mean():\n def _impl(inputs, attr, params):\n axis = params.pop(inputs[1].list_output_names()[0])\n return AttrCvt(op_name=\"mean\", ignores=['Tdim', 'Tidx'],\n transforms={'keep_dims': 'keepdims'},\n extras={'axis': tuple(axis.asnumpy())})(inputs[0], attr)\n return _impl\n\ndef _broadcast(name):\n def _impl(inputs, attr, params):\n op_name = _math_name_picker(name)(attr)\n return AttrCvt(\n op_name=op_name,\n ignores=['name', 'Tidx']\n )(inputs, attr)\n return _impl\n\ndef _split(has_size_vector):\n # TF documentation https://www.tensorflow.org/api_docs/python/tf/split\n def _impl(inputs, attr, params):\n try:\n # order and number of inputs are different:\n # if has_size_vector:\n # https://www.tensorflow.org/api_docs/cc/class/tensorflow/ops/split-v\n # else:\n # https://www.tensorflow.org/api_docs/cc/class/tensorflow/ops/split\n\n # in addition, `axis` and `num_or_size_splits` can be tensors in TensorFlow,\n # we can only support constants\n if has_size_vector:\n input_node_index = 0\n input_axis_index = 2\n size_splits_input_name = inputs[1].list_output_names()[0]\n size_splits = params[size_splits_input_name].asnumpy()\n section_beginnings = np.cumsum(size_splits)[:-1]\n indices_or_sections = tuple(section_beginnings)\n else:\n input_node_index = 1\n input_axis_index = 0\n indices_or_sections = attr['num_split']\n input_node = inputs[input_node_index]\n axis_input_name = inputs[input_axis_index].list_output_names()[0]\n axis_input_value = params[axis_input_name].asnumpy()[0]\n except (IndexError, KeyError):\n raise TypeError( \\\n \"Unsupported argument for split: `axis` and `num_or_size_splits` \" \\\n \"should be constants\")\n return _sym.split(input_node,\n indices_or_sections=indices_or_sections,\n axis=axis_input_value)\n return _impl\n\ndef _unpack():\n def _impl(inputs, attr, params):\n input_node = inputs[0]\n axis = attr['axis']\n input_shape = attr['_input_shapes'][input_node]\n axis_length = input_shape[axis]\n if axis_length < 0:\n raise TypeError(\"Unstack with unknown axis length\")\n splitted = _sym.split(input_node,\n indices_or_sections=axis_length,\n axis=axis,\n name=attr.get('_node_name', 'unstack'))\n\n return _sym.Group([_sym.squeeze(split_item, axis=axis) for split_item in splitted])\n return _impl\n\ndef _expand_dims_0d_aware(data, attr, axis, num_newaxis=1):\n if data in attr['_input_0d_mismatch']:\n return data if num_newaxis == 1 else \\\n _sym.expand_dims(data, axis=axis, num_newaxis=num_newaxis-1)\n\n return _sym.expand_dims(data, axis=axis, num_newaxis=num_newaxis)\n\ndef _logical(name):\n def _impl(inputs, attr, params):\n return AttrCvt(op_name=name)(inputs, attr)\n return _impl\n\n# compatible operators that do NOT require any conversion.\n_identity_list = []\n\n# _convert_map defines maps of name to converter functor(callable)\n# for 1 to 1 mapping, use Renamer if nothing but name is different\n# use AttrCvt if attributes need to be converted\n# for 1 to N mapping(composed), use custom callable functions\n# for N to 1 mapping, currently not supported(?)\n_convert_map = {\n 'ArgMax' : _argx(_sym.argmax, 'argmax'),\n 'ArgMin' : _argx(_sym.argmin, 'argmin'),\n 'AvgPool' : _pooling('avg_pool'),\n 'BatchNormWithGlobalNormalization' : _batch_norm(),\n 'BiasAdd' : _bias_add(),\n 'Cast' : _cast(),\n 'Ceil' : AttrCvt('ceil'),\n 'CheckNumerics' : _check_numerics(),\n 'Concat' : _concat(),\n 'ConcatV2' : _concatV2(),\n 'Conv2D' : _conv('conv'),\n 'DecodeJpeg' : _decode_image(),\n 'Elu' : _elu(),\n 'ExpandDims' : _expand_dims(),\n 'Floor' : AttrCvt('floor'),\n 'Identity' : _identity(),\n 'MatMul' : _matmul(),\n 'MaxPool' : _pooling('max_pool'),\n 'Add' : _elemwise('add'),\n 'Sub' : _elemwise('sub'),\n 'Mul' : _elemwise('mul'),\n 'RealDiv' : _elemwise('div'),\n 'Maximum' : _elemwise('max'),\n 'Minimum' : _elemwise('min'),\n 'Sum' : _sum(),\n 'Square' : _square(),\n 'Pack' : _pack(),\n 'Slice' : _slice(),\n 'LeakyRelu' : AttrCvt('leaky_relu'),\n 'Relu' : AttrCvt('relu'),\n 'Reshape' : _reshape(),\n 'ResizeBilinear' : _resize_bilinear(),\n 'Selu' : _selu(),\n 'Softmax' : AttrCvt('softmax', {'axis': ('axis', 1)}),\n 'Rsqrt' : _rsqrt(),\n 'Squeeze' : _squeeze(),\n 'FusedBatchNorm' : _fused_batch_norm(),\n 'FusedBatchNormV2' : _fused_batch_norm(),\n 'Relu6' : _relu6(),\n 'DepthwiseConv2dNative' : _conv('depthwise'),\n 'Shape' : _shape(),\n 'Sigmoid' : AttrCvt('sigmoid'),\n 'Fill' : _fill(),\n 'GatherV2' : _gather_v2(),\n 'StridedSlice' : _stridedSlice(),\n 'LRN' : _lrn(),\n 'Pad' : _pad('Pad'),\n 'PadV2' : _pad('PadV2'),\n 'Range' : _range(),\n 'Rank' : _rank(),\n 'Transpose' : _transpose(),\n 'Tanh' : AttrCvt('tanh'),\n 'Mean' : _mean(),\n 'LogicalAnd' : _logical('logical_and'),\n 'LogicalOr' : _logical('logical_or'),\n 'LogicalNot' : _logical('logical_not'),\n 'Less' : _broadcast('less'),\n 'Greater' : _broadcast('greater'),\n 'LessEqual' : _broadcast('less_equal'),\n 'GreaterEqual' : _broadcast('greater_equal'),\n 'Equal' : _broadcast('equal'),\n 'NotEqual' : _broadcast('not_equal'),\n 'Split' : _split(False),\n 'SplitV' : _split(True),\n 'Unpack' : _unpack(),\n}\n\n# _convert_map_rnn defines maps of rnn operator name to\n# converter functor(callable) for 1 to 1 mapping.\n_convert_map_rnn = {\n 'LSTMBlockCell' : _LSTMBlockCell(),\n}\n\nclass RecurrentNetworks(object):\n \"\"\"Recurrent network layer handlers.\n\n Handle Layer operations.\n ToDo: Operators like RNN/GRU layer concepts also can be handled here\n\n Parameters\n ----------\n nodes : list\n list of graph nodes used for tensorflow parsing.\n\n out_rnn : list\n List of RecurrentNetwork outputs. This output will be appended to the\n 'head' nodes of the graph.\n\n graph : tensorflow graph definition object\n The loaded tensorflow GraphDef\n\n convert_map : dict\n Dict of name : callable, where name is the op's name that\n require conversion to nnvm, callable are functions which\n take attrs and return (new_op_name, new_attrs)\n \"\"\"\n def __init__(self, nodes, out_rnn, graph, convert_map):\n self._graph = graph\n self._convert_map = convert_map\n self._nodes = nodes\n self._out_rnn = out_rnn\n self._cur_lstm_layer = 0\n self._layer_name_list = []\n self._recurrent_ops_layer_map = {\n 'LSTMBlockCell' : self._LSTMBlockCellLayer(),\n }\n\n def _LSTMBlockCellLayer(self):\n \"\"\"LSTMBlockCell layer handler.\n\n Parameters\n ----------\n op_name : str\n Operator name, eg:LSTMBlockCell\n\n layer_name : str list\n Layer name is used for creating the state input placeholder.\n\n inputs : nnvm.Symbol\n Input data\n\n attrs : dict\n Dict of operator attributes\n\n params : dict\n List of pretrained weights and bias\n\n num_layers : int\n Total number of LSTM layer presented in the graph\n\n Returns\n -------\n sym : nnvm.sym.Symbol\n The returned nnvm symbol\n \"\"\"\n def _impl(op_name, layer_name, inputs, attrs, params, num_layers):\n in_state_c_name = layer_name+'_c'\n in_state_h_name = layer_name+'_h'\n\n def _init_state(num_layers, batch_size, num_hidden):\n \"\"\"Create the initial states for the first layer in the graph.\"\"\"\n in_state_c = _sym.Variable(in_state_c_name,\n shape=(num_layers, batch_size, num_hidden))\n in_state_h = _sym.Variable(in_state_h_name,\n shape=(num_layers, batch_size, num_hidden))\n return in_state_c, in_state_h\n\n def _get_cur_input_state(in_state_c, in_state_h, num_layers,\n layer, batch_size, num_hidden):\n \"\"\"Select the appropriate states for the current layer\"\"\"\n in_state_c_tup = _sym.split(in_state_c,\n indices_or_sections=num_layers, axis=0)\n in_state_h_tup = _sym.split(in_state_h,\n indices_or_sections=num_layers, axis=0)\n cur_in_state_c = _sym.reshape(in_state_c_tup[layer],\n shape=(batch_size, num_hidden))\n cur_in_state_h = _sym.reshape(in_state_h_tup[layer],\n shape=(batch_size, num_hidden))\n return cur_in_state_c, cur_in_state_h\n\n def _LSTMBlockCellWrapper(inputs, attr, params,\n num_layers, layer):\n \"\"\"LSTM cell warapper to prepare the inputs\"\"\"\n input_shape = attr['_input_shapes'][inputs[0]]\n weight_shape = attr['_input_shapes'][inputs[3]]\n batch_size = input_shape[0]\n num_hidden = weight_shape[1] // 4\n\n if layer == 0:\n #Create initial states placeholder in case of first layer\n in_state_c, in_state_h = _init_state(num_layers,\n batch_size, num_hidden)\n else:\n in_state_c = self._nodes[in_state_c_name]\n in_state_h = self._nodes[in_state_h_name]\n\n cur_in_state_c, cur_in_state_h = _get_cur_input_state( \\\n in_state_c, in_state_h,\n num_layers, layer,\n batch_size, num_hidden)\n output, out_state = self._convert_map[op_name](inputs, cur_in_state_c,\n cur_in_state_h,\n attr, params)\n return output, out_state, in_state_c, in_state_h\n\n sym, cur_out_state, in_state_c, in_state_h = \\\n _LSTMBlockCellWrapper(inputs, attrs, params,\n num_layers, self._cur_lstm_layer)\n self._nodes[in_state_c_name] = in_state_c\n self._nodes[in_state_h_name] = in_state_h\n cur_out_state = _sym.expand_dims(cur_out_state, axis=0, num_newaxis=1)\n self._out_rnn.append(cur_out_state)\n self._cur_lstm_layer += 1\n return sym\n return _impl\n\n def process_op(self, op_name, inputs, attrs, params):\n \"\"\"Process recurrent layer operators.\n\n List '_recurrent_ops_layer_map' map each Layer based operators with its\n layer handlers. Total number of layers are calculated to form the input\n data shapes.\n\n Parameters\n ----------\n op_name : str\n Operator name, such as LSTMBlockCell\n\n inputs : nnvm.Symbol\n Input data\n\n attrs : dict\n Dict of operator attributes\n\n params : dict\n List of pretrained weights and bias\n\n Returns\n -------\n sym : nnvm.sym.Symbol\n The returned nnvm symbol\n \"\"\"\n def _get_abs_layer_name(node):\n \"\"\"Identify the layer name is already handled. Return the absolute name\n \"\"\"\n if not self._layer_name_list:\n self._layer_name_list.append(node.name)\n return node.name\n\n for _name in self._layer_name_list:\n if _name in node.name:\n abs_name = _name\n else:\n self._layer_name_list.append(node.name)\n abs_name = node.name\n return abs_name\n\n #Find number of layers of this same operator node in the graph\n #and also read the inputs name for the current op.\n num_layers = 0\n for _, node in enumerate(self._graph.node):\n if node.op == op_name:\n layer_name = _get_abs_layer_name(node)\n num_layers += 1\n\n sym = self._recurrent_ops_layer_map[op_name](op_name, layer_name, inputs, attrs,\n params, num_layers)\n return sym\n\nclass GraphProto(object):\n \"\"\" A helper class for handling nnvm graph copying from Tensorflow GraphDef.\n Definition:\n https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/framework/graph.proto\n \"\"\"\n def __init__(self):\n self._nodes = {}\n self._params = {}\n self._output_shapes = {}\n self._num_param = 0\n self._num_rnn_layer = False\n self._outputs_are_0d = {}\n self._input_shapes = {}\n\n def from_tensorflow(self, graph, layout=\"NHWC\", shape=None, outputs=None):\n \"\"\"Construct nnvm nodes from tensorflow graph definition - GraphDef.\n\n Follow the tensorflow graph definition to parse and convert it to NNVM.\n Some of the assumptions listed below.\n\n -> All Placeholders are considered as graph input.\n -> All Const nodes are params.\n -> Last node is assumed as graph output.\n -> _output_shapes : Graph should be frozen with add_shapes=True.\n Or user can pass input shape dictionary optionally.\n -> DecodeJpeg, ResizeBilinear: These are dummy operators.\n Hence user should handle preprocessing outside.\n -> CheckNumerics: No implementation as of now for this.\n Just copies input to output.\n\n Parameters\n ----------\n graph : tensorflow graph definition object\n The loaded tensorflow GraphDef\n\n layout : target layout to be used (Optional)\n NCHW only supported now to enable NHWC models on GPU.\n\n shape : Dictionary of input dimensions (Optional)\n Graph level input shape dictionary.\n\n Returns\n -------\n sym : nnvm.sym.Symbol\n The returned nnvm symbol\n params : dict\n A dict of name: tvm.nd.array pairs, used as pretrained weights\n \"\"\"\n\n try:\n from tensorflow.python.framework import tensor_util\n except ImportError as e:\n raise ImportError(\n \"Unable to import tensorflow which is required {}\".format(e))\n\n missing_operators = self._parse_import_prerequisites(graph)\n\n if missing_operators:\n msg = 'The following operators are not supported in frontend TensorFlow: {}'\n ops = str(list(missing_operators)).strip('[,]')\n raise tvm.error.OpNotImplemented(msg.format(ops))\n\n for node in graph.node:\n if node.op == 'Placeholder':\n # Give priority to user argument.\n if shape and node.name in shape:\n self._input_shapes[node.name] = list(shape[node.name])\n else:\n self._input_shapes[node.name] = \\\n tensor_util.TensorShapeProtoToList(node.attr['shape'].shape)\n for idx, dim in enumerate(self._input_shapes[node.name]):\n if dim < 0:\n self._input_shapes[node.name][idx] = 1\n warnings.warn(\"Use 1 instead of -1 in shape of operator %s.\"\n % node.name)\n\n self._nodes[node.name] = _sym.Variable(name=node.name,\n shape=self._input_shapes[node.name])\n self._output_shapes[node.name] = [self._input_shapes[node.name]]\n self._outputs_are_0d[node.name] = [ \\\n not tshape if isinstance(tshape, list) else False \\\n for tshape in self._output_shapes[node.name]]\n\n # Ignore user's input shape for Non placeholder\n elif node.op == 'Const':\n tensor_value = node.attr['value'].tensor\n self._input_shapes[node.name] = \\\n tensor_util.TensorShapeProtoToList(tensor_value.tensor_shape)\n if shape and node.name in shape:\n warnings.warn(\"Ignore the passed shape. \"\n \"Shape in graphdef will be used for operator %s.\" % node.name)\n\n final_op = None\n # Parse the nodes to re-create TF graph using Symbol API of NNVM\n for node in graph.node:\n # Tensorflow doesn't have separate list for params extraction.\n # Operator name 'Const' is treated as a parameter to build NNVM params dict.\n\n input_shapes = {}\n input_0d_mismatch = set()\n attr = self._parse_attr(node.attr)\n\n # Variable converted to Const will not have only value attr\n if 'value' in attr and node.op == 'Const':\n self._output_shapes[node.name] = [self._input_shapes[node.name]]\n elif '_output_shapes' in attr:\n self._output_shapes[node.name] = \\\n [tensor_util.TensorShapeProtoToList(tshape) \\\n for tshape in attr['_output_shapes']]\n else:\n # Keep the list indexable to avoid key error.\n # Actual value will be filled after node creation.\n # Will infer shapes if the graph is not frozen with add_shapes=True\n self._output_shapes[node.name] = [None]\n\n self._outputs_are_0d[node.name] = [ \\\n not tshape if isinstance(tshape, list) else False \\\n for tshape in self._output_shapes[node.name]]\n\n if node.op == \"Const\":\n # All Const nodes are Param nodes, lets parse\n self._num_param += 1\n for key, value in node.attr.items():\n self._parse_param(key, value, node.name)\n if node.name not in self._nodes:\n raise NotImplementedError( \\\n \"Const {} couldn't be converted to Param.\".format(node.name))\n\n attr = self._parse_attr(node.attr)\n\n elif node.op != \"Placeholder\":\n # Pass the parsed shapes instead\n attr[\"_output_shapes\"] = output_shapes = self._output_shapes[node.name]\n\n # Pass the node name too in attr\n attr[\"_node_name\"] = node.name\n\n # Pass the target layout\n attr[\"_target_layout\"] = layout\n\n # Fill shapes for all inputs in a list\n inputs = []\n for i in node.input:\n # Some TensorFlow operators internally maintain execution layers\n # and their output name includes the layer number along with\n # graph node name. E.g. the node name is 'Model/RNN/cell_0/RnnCell', but the\n # output tensor name is 'Model/RNN/cell_0/RnnCell:0'. In this case,\n # the number has to be ignored for single-output nodes.\n # On the other hand, for multi-output nodes the number is the output index,\n # and the lack of the number implies 0.\n tensor_name = i.split(':')\n node_name = tensor_name[0]\n if node_name in self._nodes:\n in_sym = self._nodes[node_name]\n if len(in_sym.list_output_names()) > 1:\n tensor_slot = int(tensor_name[1]) if len(tensor_name) > 1 else 0\n in_sym = in_sym[tensor_slot]\n input_shape = self._output_shapes[node_name][tensor_slot]\n else:\n tensor_slot = 0\n input_shape = self._output_shapes[node_name][0]\n inputs.append(in_sym)\n input_shapes[in_sym] = input_shape\n # This means the node is 1d in NNVM and 0d in TF.\n # See `_expand_dims_0d_aware`.\n if self._outputs_are_0d[node_name][tensor_slot] and input_shape:\n input_0d_mismatch.add(in_sym)\n attr['_input_shapes'] = input_shapes\n attr['_input_0d_mismatch'] = input_0d_mismatch\n\n inputs = self._fix_extranodes(node.op, attr, inputs)\n op = self._convert_operator(node.op, inputs, attr, graph)\n\n # Check if op is converted to param\n if isinstance(op, np.ndarray):\n self._params[node.name] = tvm.nd.array(op)\n op = _sym.Variable(name=node.name,\n shape=self._params[node.name].shape)\n\n # Assuming only one output.\n self._nodes[node.name] = op\n final_op = op\n\n # Infer shapes even without specifying \"add_shapes=True\"\n if output_shapes == [None]:\n g = _graph.create(final_op)\n self._output_shapes[node.name] = \\\n list(graph_util.infer_shape(g, **self._input_shapes))[-1]\n\n if self._output_shapes[node.name] and shape and node.name in shape:\n assert self._output_shapes[node.name] == list(shape[node.name])\n\n # Infer shapes if passed explicitely\n node_output = self._nodes[node.name]\n if shape and (not self._output_shapes[node.name][0]\n or -1 in self._output_shapes[node.name][0]):\n g = _graph.create(node_output)\n shape_dict = {k: v.shape for k, v in self._params.items()}\n shape_dict.update(shape)\n _, out_shapes = graph_util.infer_shape(g, **shape_dict)\n self._output_shapes[node.name] = out_shapes\n\n out = []\n if outputs is None:\n out.append(final_op)\n else:\n for out_name in outputs:\n if \":\" in out_name:\n out_name, out_num = out_name.split(\":\")\n out_num = int(out_num)\n out.append(self._nodes[out_name][out_num])\n else:\n out.append(self._nodes[out_name])\n\n #Add the RNN outputs also with 'head' nodes of the nnvm graph\n if self._num_rnn_layer:\n out_rnn = _sym.concatenate(*self._out_rnn, axis=0)\n out.append(out_rnn)\n\n if isinstance(out, list):\n out = _sym.Group(out) if len(out) > 1 else out[0]\n\n return out, self._params\n\n def _parse_import_prerequisites(self, graph):\n \"\"\" Calculate the named preconditions from TensorFlow `graph`.\n Return prerequisites for parsing:\n a. Set of operator names which don't have their mapping in TVM, i.e.\n which are not supported\n \"\"\"\n missing_operators = set()\n for node in graph.node:\n if node.op == \"Placeholder\":\n pass\n elif node.op == \"Const\":\n pass\n else:\n if any([node.op in t for t in [_identity_list, _convert_map, _convert_map_rnn]]):\n pass\n else:\n missing_operators.add(node.op)\n\n return missing_operators\n\n def _parse_param(self, key, value, name):\n try:\n from tensorflow.python.framework import tensor_util\n except ImportError as e:\n raise ImportError(\n \"Unable to import tensorflow which is required {}\".format(e))\n\n if key == 'value':\n np_array = tensor_util.MakeNdarray(value.tensor)\n\n if np_array.dtype == np.dtype(object):\n # Object types are generally tensorflow DT_STRING (DecodeJpeg op).\n # Just leave it as placeholder.\n self._nodes[name] = _sym.Variable(name=name)\n return\n\n array_ndim = len(np_array.shape)\n if array_ndim == 0:\n new_array = np.empty([1], dtype=np_array.dtype)\n new_array[0] = np_array\n self._params[name] = tvm.nd.array(new_array)\n else:\n self._params[name] = tvm.nd.array(np_array)\n self._nodes[name] = _sym.Variable(name=name,\n shape=self._params[name].shape)\n else:\n if key not in ('dtype', '_output_shapes', '_class'):\n raise NotImplementedError \\\n (\"Other attributes for a Const(param) Node {} ? .\".format(key))\n\n def _get_attr(self, buf):\n \"\"\"Returns the value of the attr of this buf with the given `name`.\n\n Args:\n buf: attrvalue protobuf.\n\n Returns:\n The value of the attr, as a Python object.\n\n Raises:\n ValueError: If this op does not have an attr with the given `name`.\n \"\"\"\n fields = [\"s\", \"i\", \"f\", \"b\", \"type\", \"shape\", \"tensor\", \"func\"]\n\n x = buf\n\n ret = []\n\n try:\n from tensorflow.python.framework import dtypes\n except ImportError as e:\n raise ImportError(\n \"Unable to import tensorflow which is required {}\".format(e))\n\n # Treat an empty oneof value as an empty list.\n if not x.WhichOneof(\"value\"):\n return ret\n if x.HasField(\"list\"):\n for f in fields:\n if getattr(x.list, f):\n if f == \"type\":\n ret += [dtypes.as_dtype(x) for x in list(getattr(x.list, f))]\n else:\n ret += list(getattr(x.list, f))\n else:\n for f in fields:\n if x.HasField(f):\n if f == \"type\":\n ret = dtypes.as_dtype(getattr(x, f))\n else:\n ret = getattr(x, f)\n return ret\n\n def _parse_attr(self, attr_proto):\n \"\"\"Convert a list of AttributeProto to a dict, with names as keys.\"\"\"\n attrs = {}\n for key, value in attr_proto.items():\n attrs[key] = self._get_attr(value)\n\n return attrs\n\n def _convert_rnn_operator(self, op_name, inputs,\n attrs, params, graph, convert_map):\n \"\"\"Convert RNN and its variant operators to NNVM operators.\n This converter read the input states of each layers and\n also maintain the output states of each layer in a list.\n\n Parameters\n ----------\n op_name : str\n Operator name, such as LSTMBlockCell\n inputs : list of nnvm.Symbol\n List of input symbols.\n attrs : dict\n Dict of operator attributes\n params : dict\n List of pretrained weights and bias\n graph : Tensorflow graph object\n Graph is to find the number of upcoming same operator to\n calculate the number of layers.\n convert_map : dict\n Dict of name : callable, where name is the op's name that\n require conversion to nnvm, callable are functions which\n take attrs and return (new_op_name, new_attrs)\n\n Returns\n -------\n sym : nnvm.Symbol\n Converted nnvm Symbol\n \"\"\"\n if not self._num_rnn_layer:\n self._out_rnn = []\n self.rnn = RecurrentNetworks(self._nodes, self._out_rnn, graph, convert_map)\n self._num_rnn_layer = True\n sym = self.rnn.process_op(op_name, inputs, attrs, params)\n return sym\n\n def _convert_operator(self, op_name, inputs, attrs,\n graph, identity_list=None, convert_map=None):\n \"\"\"Convert from Tensorflow operator to nnvm operator.\n The converter must specify conversions explicity for incompatible name, and\n apply handlers to operator attributes.\n\n Parameters\n ----------\n op_name : str\n Operator name, such as Conv2D, AvgPool\n inputs : list of nnvm.Symbol\n List of input symbols.\n attrs : dict\n Dict of operator attributes\n identity_list : list\n List of operators that don't require conversion\n convert_map : dict\n Dict of name : callable, where name is the op's name that\n require conversion to nnvm, callable are functions which\n take attrs and return (new_op_name, new_attrs)\n\n Returns\n -------\n sym : nnvm.Symbol\n Converted nnvm Symbol\n \"\"\"\n identity_list = identity_list if identity_list else _identity_list\n convert_map = convert_map if convert_map else _convert_map\n convert_map_rnn = _convert_map_rnn\n if op_name in identity_list:\n sym = get_nnvm_op(op_name)(*inputs, **attrs)\n elif op_name in convert_map:\n sym = convert_map[op_name](inputs, attrs, self._params)\n elif op_name in convert_map_rnn:\n sym = self._convert_rnn_operator(op_name, inputs, attrs,\n self._params, graph,\n convert_map_rnn)\n else:\n raise tvm.error.OpNotImplemented(\n 'Operator {} is not supported in frontend TensorFlow.'.format(op_name))\n return sym\n\n def _fix_extranodes(self, op_name, attr, inputs):\n if op_name == \"Softmax\":\n # Require some times flatten of data before it goes to softmax\n # Need to relook into this with latest softmax axis support.\n op = AttrCvt(op_name='flatten')(inputs, {})\n node_output = op.list_output_names()\n for k, i in zip(list(node_output), range(len(node_output))):\n self._nodes[k] = op[i]\n inputs = [op]\n\n return inputs\n\ndef from_tensorflow(graph, layout=\"NHWC\", shape=None, outputs=None):\n \"\"\" Load tensorflow graph which is a python tensorflow graph object into nnvm graph.\n The companion parameters will be handled automatically.\n\n Parameters\n ----------\n graph : GraphDef object\n Tensorflow GraphDef\n\n Returns\n -------\n sym : nnvm.Symbol\n Compatible nnvm symbol\n\n params : dict of str to tvm.ndarray\n Dict of converted parameters stored in tvm.ndarray format\n \"\"\"\n g = GraphProto()\n sym, params = g.from_tensorflow(graph, layout, shape, outputs)\n return sym, params\n"
] |
[
[
"tensorflow.python.framework.tensor_util.MakeNdarray",
"tensorflow.python.framework.tensor_util.TensorShapeProtoToList",
"numpy.cumsum",
"numpy.dtype",
"tensorflow.python.framework.dtypes.as_dtype",
"numpy.array",
"numpy.empty"
]
] |
ahmetustun/fairseq
|
[
"5ec791d95476beaa1513da14efa9035337bf6a15"
] |
[
"fairseq/tasks/translation_multi_simple_epoch_with_prefix.py"
] |
[
"# Copyright (c) Facebook, Inc. and its affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\nimport datetime\nimport logging\nimport time\n\nimport torch\nfrom fairseq.data import (\n FairseqDataset,\n LanguagePairDataset,\n ListDataset,\n data_utils,\n iterators,\n)\nfrom fairseq.data.multilingual.multilingual_data_manager import (\n MultilingualDatasetManager,\n)\nfrom fairseq.data.multilingual.sampling_method import SamplingMethod\nfrom fairseq.data.prefix_token_dataset import PrefixTokenDataset\nfrom fairseq.tasks import LegacyFairseqTask, register_task\nfrom fairseq.utils import FileContentsAction\n\n\n###\ndef get_time_gap(s, e):\n return (\n datetime.datetime.fromtimestamp(e) - datetime.datetime.fromtimestamp(s)\n ).__str__()\n\n\n###\n\n\nlogger = logging.getLogger(__name__)\n\n\n@register_task(\"translation_multi_simple_epoch_with_prefix\")\nclass TranslationMultiSimpleEpochWithPrefixTask(LegacyFairseqTask):\n \"\"\"\n Translate from one (source) language to another (target) language.\n\n Args:\n langs (List[str]): a list of languages that are being supported\n dicts (Dict[str, fairseq.data.Dictionary]): mapping from supported languages to their dictionaries\n training (bool): whether the task should be configured for training or not\n\n .. note::\n\n The translation task is compatible with :mod:`fairseq-train`,\n :mod:`fairseq-generate` and :mod:`fairseq-interactive`.\n\n The translation task provides the following additional command-line\n arguments:\n\n .. argparse::\n :ref: fairseq.tasks.translation_parser\n :prog:\n \"\"\"\n\n @staticmethod\n def add_args(parser):\n \"\"\"Add task-specific arguments to the parser.\"\"\"\n # fmt: off\n parser.add_argument('-s', '--source-lang', default=None, metavar='SRC',\n help='inference source language')\n parser.add_argument('-t', '--target-lang', default=None, metavar='TARGET',\n help='inference target language')\n parser.add_argument('--lang-pairs', default=None, metavar='PAIRS',\n help='comma-separated list of language pairs (in training order): en-de,en-fr,de-fr',\n action=FileContentsAction)\n parser.add_argument('--keep-inference-langtok', action='store_true',\n help='keep language tokens in inference output (e.g. for analysis or debugging)')\n parser.add_argument('--encoder-prefix-length', type=int, metavar='N', default=20,\n help='encoder prefix embedding length')\n parser.add_argument('--decoder-prefix-length', type=int, metavar='N', default=20,\n help='decoder prefix embedding length')\n\n SamplingMethod.add_arguments(parser)\n MultilingualDatasetManager.add_args(parser)\n # fmt: on\n\n def __init__(self, args, langs, dicts, training):\n super().__init__(args)\n self.langs = langs\n self.dicts = dicts\n self.training = training\n if training:\n self.lang_pairs = args.lang_pairs\n else:\n self.lang_pairs = [\"{}-{}\".format(args.source_lang, args.target_lang)]\n # eval_lang_pairs for multilingual translation is usually all of the\n # lang_pairs. However for other multitask settings or when we want to\n # optimize for certain languages we want to use a different subset. Thus\n # the eval_lang_pairs class variable is provided for classes that extend\n # this class.\n self.eval_lang_pairs = self.lang_pairs\n # model_lang_pairs will be used to build encoder-decoder model pairs in\n # models.build_model(). This allows multitask type of sub-class can\n # build models other than the input lang_pairs\n self.model_lang_pairs = self.lang_pairs\n self.source_langs = [d.split(\"-\")[0] for d in self.lang_pairs]\n self.target_langs = [d.split(\"-\")[1] for d in self.lang_pairs]\n for d in self.dicts.values():\n if args.encoder_prefix_length != 0:\n for p in range(args.encoder_prefix_length):\n d.add_symbol(f\"[prefix:enc:{p}]\")\n\n if args.decoder_prefix_length != 0:\n for p in range(args.decoder_prefix_length):\n d.add_symbol(f\"[prefix:dec:{p}]\")\n\n self.check_dicts(self.dicts, self.source_langs, self.target_langs)\n src_dict = self.dicts[self.source_langs[0]]\n tgt_dict = self.dicts[self.target_langs[0]]\n self.src_prefixes = None\n if not args.encoder_prefix_length == 0:\n self.src_prefixes = [src_dict.index(f'[prefix:enc:{p}]') for p in range(args.encoder_prefix_length)]\n\n self.tgt_prefixes = None\n if not args.decoder_prefix_length == 0:\n self.tgt_prefixes = [tgt_dict.index(f'[prefix:dec:{p}]') for p in range(args.decoder_prefix_length)]\n\n self.sampling_method = SamplingMethod.build_sampler(args, self)\n self.data_manager = MultilingualDatasetManager.setup_data_manager(\n args, self.lang_pairs, langs, dicts, self.sampling_method\n )\n\n def check_dicts(self, dicts, source_langs, target_langs):\n if self.args.source_dict is not None or self.args.target_dict is not None:\n # no need to check whether the source side and target side are sharing dictionaries\n return\n src_dict = dicts[source_langs[0]]\n tgt_dict = dicts[target_langs[0]]\n for src_lang in source_langs:\n assert (\n src_dict == dicts[src_lang]\n ), \"Diffrent dictionary are specified for different source languages; \"\n \"TranslationMultiSimpleEpochTask only supports one shared dictionary across all source languages\"\n for tgt_lang in target_langs:\n assert (\n tgt_dict == dicts[tgt_lang]\n ), \"Diffrent dictionary are specified for different target languages; \"\n \"TranslationMultiSimpleEpochTask only supports one shared dictionary across all target languages\"\n\n @classmethod\n def setup_task(cls, args, **kwargs):\n langs, dicts, training = MultilingualDatasetManager.prepare(\n cls.load_dictionary, args, **kwargs\n )\n return cls(args, langs, dicts, training)\n\n def has_sharded_data(self, split):\n return self.data_manager.has_sharded_data(split)\n\n def load_dataset(self, split, epoch=1, combine=False, **kwargs):\n \"\"\"Load a given dataset split.\n\n Args:\n split (str): name of the split (e.g., train, valid, test)\n \"\"\"\n if split in self.datasets:\n dataset = self.datasets[split]\n if self.has_sharded_data(split):\n if self.args.virtual_epoch_size is not None:\n if dataset.load_next_shard:\n shard_epoch = dataset.shard_epoch\n else:\n # no need to load next shard so skip loading\n # also this avoid always loading from beginning of the data\n return\n else:\n shard_epoch = epoch\n else:\n # estimate the shard epoch from virtual data size and virtual epoch size\n shard_epoch = self.data_manager.estimate_global_pass_epoch(epoch)\n logger.info(f\"loading data for {split} epoch={epoch}/{shard_epoch}\")\n logger.info(f\"mem usage: {data_utils.get_mem_usage()}\")\n if split in self.datasets:\n del self.datasets[split]\n logger.info(\"old dataset deleted manually\")\n logger.info(f\"mem usage: {data_utils.get_mem_usage()}\")\n self.datasets[split] = self.data_manager.load_dataset(\n split,\n self.training,\n epoch=epoch,\n combine=combine,\n shard_epoch=shard_epoch,\n src_prefixes=self.src_prefixes,\n tgt_prefixes=self.tgt_prefixes,\n **kwargs,\n )\n\n def build_dataset_for_inference(self, src_tokens, src_lengths, constraints=None):\n if constraints is not None:\n raise NotImplementedError(\n \"Constrained decoding with the multilingual_translation task is not supported\"\n )\n\n src_data = ListDataset(src_tokens, src_lengths)\n dataset = LanguagePairDataset(src_data, src_lengths, self.source_dictionary)\n src_langtok_spec, tgt_langtok_spec = self.args.langtoks[\"main\"]\n if self.args.lang_tok_replacing_bos_eos:\n dataset = self.data_manager.alter_dataset_langtok(\n dataset,\n src_eos=self.source_dictionary.eos(),\n src_lang=self.args.source_lang,\n tgt_eos=self.target_dictionary.eos(),\n tgt_lang=self.args.target_lang,\n src_langtok_spec=src_langtok_spec,\n tgt_langtok_spec=tgt_langtok_spec,\n )\n else:\n dataset.src = self.data_manager.src_dataset_tranform_func(\n self.args.source_lang,\n self.args.target_lang,\n dataset=dataset.src,\n spec=src_langtok_spec,\n )\n\n if self.src_prefixes is not None:\n dataset.src = PrefixTokenDataset(dataset.src, self.src_prefixes)\n\n return dataset\n\n def build_generator(\n self,\n models,\n args,\n seq_gen_cls=None,\n extra_gen_cls_kwargs=None,\n ):\n if not getattr(args, \"keep_inference_langtok\", False):\n _, tgt_langtok_spec = self.args.langtoks[\"main\"]\n if tgt_langtok_spec:\n tgt_lang_tok = self.data_manager.get_decoder_langtok(\n self.args.target_lang, tgt_langtok_spec\n )\n extra_gen_cls_kwargs = extra_gen_cls_kwargs or {}\n extra_gen_cls_kwargs[\"symbols_to_strip_from_output\"] = set(self.tgt_prefixes + [tgt_lang_tok])\n\n return super().build_generator(\n models, args, seq_gen_cls=None, extra_gen_cls_kwargs=extra_gen_cls_kwargs\n )\n\n def build_model(self, args):\n return super().build_model(args)\n\n def valid_step(self, sample, model, criterion):\n loss, sample_size, logging_output = super().valid_step(sample, model, criterion)\n return loss, sample_size, logging_output\n\n def inference_step(\n self, generator, models, sample, prefix_tokens=None, constraints=None\n ):\n with torch.no_grad():\n _, tgt_langtok_spec = self.args.langtoks[\"main\"]\n if not self.args.lang_tok_replacing_bos_eos:\n if prefix_tokens is None and tgt_langtok_spec:\n tgt_lang_tok = self.data_manager.get_decoder_langtok(\n self.args.target_lang, tgt_langtok_spec\n )\n src_tokens = sample[\"net_input\"][\"src_tokens\"]\n prefix_tokens = self.tgt_prefixes + [tgt_lang_tok]\n prefix_tokens = torch.Tensor(prefix_tokens).to(src_tokens.dtype).to(src_tokens.device)\n prefix_tokens = prefix_tokens.unsqueeze(0).repeat(src_tokens.shape[0],1)\n return generator.generate(\n models,\n sample,\n prefix_tokens=prefix_tokens,\n constraints=constraints,\n bos_token=self.dicts[self.args.target_lang].eos(),\n )\n else:\n return generator.generate(\n models,\n sample,\n prefix_tokens=prefix_tokens,\n bos_token=self.data_manager.get_decoder_langtok(\n self.args.target_lang, tgt_langtok_spec\n )\n if tgt_langtok_spec\n else self.target_dictionary.eos(),\n )\n\n def reduce_metrics(self, logging_outputs, criterion):\n super().reduce_metrics(logging_outputs, criterion)\n\n def max_positions(self):\n \"\"\"Return the max sentence length allowed by the task.\"\"\"\n return (self.args.max_source_positions, self.args.max_target_positions)\n\n @property\n def source_dictionary(self):\n return self.data_manager.get_source_dictionary(self.source_langs[0])\n\n @property\n def target_dictionary(self):\n return self.data_manager.get_target_dictionary(self.target_langs[0])\n\n def create_batch_sampler_func(\n self,\n max_positions,\n ignore_invalid_inputs,\n max_tokens,\n max_sentences,\n required_batch_size_multiple=1,\n seed=1,\n ):\n def construct_batch_sampler(dataset, epoch):\n splits = [\n s for s, _ in self.datasets.items() if self.datasets[s] == dataset\n ]\n split = splits[0] if len(splits) > 0 else None\n # NEW implementation\n if epoch is not None:\n # initialize the dataset with the correct starting epoch\n dataset.set_epoch(epoch)\n\n # get indices ordered by example size\n start_time = time.time()\n logger.info(f\"start batch sampler: mem usage: {data_utils.get_mem_usage()}\")\n\n with data_utils.numpy_seed(seed):\n indices = dataset.ordered_indices()\n logger.info(\n f\"[{split}] @batch_sampler order indices time: {get_time_gap(start_time, time.time())}\"\n )\n logger.info(f\"mem usage: {data_utils.get_mem_usage()}\")\n\n # filter examples that are too large\n if max_positions is not None:\n my_time = time.time()\n indices = self.filter_indices_by_size(\n indices, dataset, max_positions, ignore_invalid_inputs\n )\n logger.info(\n f\"[{split}] @batch_sampler filter_by_size time: {get_time_gap(my_time, time.time())}\"\n )\n logger.info(f\"mem usage: {data_utils.get_mem_usage()}\")\n\n # create mini-batches with given size constraints\n my_time = time.time()\n batch_sampler = dataset.batch_by_size(\n indices,\n max_tokens=max_tokens,\n max_sentences=max_sentences,\n required_batch_size_multiple=required_batch_size_multiple,\n )\n\n logger.info(\n f\"[{split}] @batch_sampler batch_by_size time: {get_time_gap(my_time, time.time())}\"\n )\n logger.info(\n f\"[{split}] per epoch batch_sampler set-up time: {get_time_gap(start_time, time.time())}\"\n )\n logger.info(f\"mem usage: {data_utils.get_mem_usage()}\")\n\n return batch_sampler\n\n return construct_batch_sampler\n\n # we need to override get_batch_iterator because we want to reset the epoch iterator each time\n def get_batch_iterator(\n self,\n dataset,\n max_tokens=None,\n max_sentences=None,\n max_positions=None,\n ignore_invalid_inputs=False,\n required_batch_size_multiple=1,\n seed=1,\n num_shards=1,\n shard_id=0,\n num_workers=0,\n epoch=1,\n data_buffer_size=0,\n disable_iterator_cache=False,\n ):\n \"\"\"\n Get an iterator that yields batches of data from the given dataset.\n\n Args:\n dataset (~fairseq.data.FairseqDataset): dataset to batch\n max_tokens (int, optional): max number of tokens in each batch\n (default: None).\n max_sentences (int, optional): max number of sentences in each\n batch (default: None).\n max_positions (optional): max sentence length supported by the\n model (default: None).\n ignore_invalid_inputs (bool, optional): don't raise Exception for\n sentences that are too long (default: False).\n required_batch_size_multiple (int, optional): require batch size to\n be a multiple of N (default: 1).\n seed (int, optional): seed for random number generator for\n reproducibility (default: 1).\n num_shards (int, optional): shard the data iterator into N\n shards (default: 1).\n shard_id (int, optional): which shard of the data iterator to\n return (default: 0).\n num_workers (int, optional): how many subprocesses to use for data\n loading. 0 means the data will be loaded in the main process\n (default: 0).\n epoch (int, optional): the epoch to start the iterator from\n (default: 0).\n data_buffer_size (int, optional): number of batches to\n preload (default: 0).\n disable_iterator_cache (bool, optional): don't cache the\n EpochBatchIterator (ignores `FairseqTask::can_reuse_epoch_itr`)\n (default: False).\n Returns:\n ~fairseq.iterators.EpochBatchIterator: a batched iterator over the\n given dataset split\n \"\"\"\n # initialize the dataset with the correct starting epoch\n assert isinstance(dataset, FairseqDataset)\n if dataset in self.dataset_to_epoch_iter:\n return self.dataset_to_epoch_iter[dataset]\n if self.args.sampling_method == \"RoundRobin\":\n batch_iter = super().get_batch_iterator(\n dataset,\n max_tokens=max_tokens,\n max_sentences=max_sentences,\n max_positions=max_positions,\n ignore_invalid_inputs=ignore_invalid_inputs,\n required_batch_size_multiple=required_batch_size_multiple,\n seed=seed,\n num_shards=num_shards,\n shard_id=shard_id,\n num_workers=num_workers,\n epoch=epoch,\n data_buffer_size=data_buffer_size,\n disable_iterator_cache=disable_iterator_cache,\n )\n self.dataset_to_epoch_iter[dataset] = batch_iter\n return batch_iter\n\n construct_batch_sampler = self.create_batch_sampler_func(\n max_positions,\n ignore_invalid_inputs,\n max_tokens,\n max_sentences,\n required_batch_size_multiple=required_batch_size_multiple,\n seed=seed,\n )\n\n epoch_iter = iterators.EpochBatchIterator(\n dataset=dataset,\n collate_fn=dataset.collater,\n batch_sampler=construct_batch_sampler,\n seed=seed,\n num_shards=num_shards,\n shard_id=shard_id,\n num_workers=num_workers,\n epoch=epoch,\n )\n return epoch_iter\n"
] |
[
[
"torch.no_grad",
"torch.Tensor"
]
] |
dyning/AlexNet-Prod
|
[
"54de9dfcf540997ff227bd92d0c7a73dc73c45aa"
] |
[
"pipeline/Step3/AlexNet_paddle/loss_alexnet.py"
] |
[
"import numpy as np\nimport paddle\nimport paddle.nn as nn\nfrom paddlevision.models.alexnet import alexnet\n\nfrom reprod_log import ReprodLogger\n\nif __name__ == \"__main__\":\n paddle.set_device(\"cpu\")\n # load model\n # the model is save into ~/.cache/torch/hub/checkpoints/alexnet-owt-4df8aa71.pth\n\n # def logger\n reprod_logger = ReprodLogger()\n\n model = alexnet(\n pretrained=\"../../weights/alexnet_paddle.pdparams\", num_classes=1000)\n model.eval()\n\n criterion = nn.CrossEntropyLoss()\n\n # read or gen fake data\n fake_data = np.load(\"../../fake_data/fake_data.npy\")\n fake_data = paddle.to_tensor(fake_data)\n\n fake_label = np.load(\"../../fake_data/fake_label.npy\")\n fake_label = paddle.to_tensor(fake_label)\n\n # forward\n out = model(fake_data)\n\n loss = criterion(out, fake_label)\n # \n reprod_logger.add(\"loss\", loss.cpu().detach().numpy())\n reprod_logger.save(\"loss_paddle.npy\")\n"
] |
[
[
"numpy.load"
]
] |
bonskotti/desdeo-emo
|
[
"6a607fa96478fd3c76394ac7b2dafdfd3c08eb2a"
] |
[
"desdeo_emo/selection/oAPD.py"
] |
[
"import numpy as np\nfrom warnings import warn\nfrom typing import List, Callable\nfrom desdeo_emo.selection.SelectionBase import SelectionBase\nfrom desdeo_emo.population.Population import Population\nfrom desdeo_emo.othertools.ReferenceVectors import ReferenceVectors\n\n\nclass Optimistic_APD_Select(SelectionBase):\n \"\"\"The selection operator for the RVEA algorithm. Read the following paper for more\n details.\n R. Cheng, Y. Jin, M. Olhofer and B. Sendhoff, A Reference Vector Guided\n Evolutionary Algorithm for Many-objective Optimization, IEEE Transactions on\n Evolutionary Computation, 2016\n Parameters\n ----------\n pop : Population\n The population instance\n time_penalty_function : Callable\n A function that returns the time component in the penalty function.\n alpha : float, optional\n The RVEA alpha parameter, by default 2\n \"\"\"\n\n def __init__(\n self, pop: Population, time_penalty_function: Callable, alpha: float = 2\n ):\n self.time_penalty_function = time_penalty_function\n self.alpha = alpha\n self.n_of_objectives = pop.problem.n_of_objectives\n self.optimistic_ideal: np.ndarray = pop.ideal_fitness_val\n\n def do(self, pop: Population, vectors: ReferenceVectors) -> List[int]:\n \"\"\"Select individuals for mating on basis of Angle penalized distance.\n\n Parameters\n ----------\n pop : Population\n The current population.\n vectors : ReferenceVectors\n Class instance containing reference vectors.\n\n Returns\n -------\n List[int]\n List of indices of the selected individuals\n \"\"\"\n partial_penalty_factor = self._partial_penalty_factor()\n refV = vectors.neighbouring_angles_current\n\n fitness = pop.fitness - pop.uncertainity\n if self.optimistic_ideal is None:\n self.optimistic_ideal = np.amin(fitness, axis=0)\n else:\n fmin = np.amin(fitness, axis=0)\n self.optimistic_ideal = np.amin(\n np.vstack((self.optimistic_ideal, fmin)), axis=0\n )\n\n translated_fitness = fitness - self.optimistic_ideal\n fitness_norm = np.linalg.norm(translated_fitness, axis=1)\n # TODO check if you need the next line\n fitness_norm = np.repeat(fitness_norm, len(translated_fitness[0, :])).reshape(\n len(fitness), len(fitness[0, :])\n )\n # Convert zeros to eps to avoid divide by zero.\n # Has to be checked!\n fitness_norm[fitness_norm == 0] = np.finfo(float).eps\n normalized_fitness = np.divide(\n translated_fitness, fitness_norm\n ) # Checked, works.\n cosine = np.dot(normalized_fitness, np.transpose(vectors.values))\n if cosine[np.where(cosine > 1)].size:\n warn(\"RVEA.py line 60 cosine larger than 1 decreased to 1\")\n cosine[np.where(cosine > 1)] = 1\n if cosine[np.where(cosine < 0)].size:\n warn(\"RVEA.py line 64 cosine smaller than 0 increased to 0\")\n cosine[np.where(cosine < 0)] = 0\n # Calculation of angles between reference vectors and solutions\n theta = np.arccos(cosine)\n # Reference vector asub_population_indexssignment\n assigned_vectors = np.argmax(cosine, axis=1)\n selection = np.array([], dtype=int)\n # Selection\n # Convert zeros to eps to avoid divide by zero.\n # Has to be checked!\n refV[refV == 0] = np.finfo(float).eps\n for i in range(0, len(vectors.values)):\n sub_population_index = np.atleast_1d(\n np.squeeze(np.where(assigned_vectors == i))\n )\n sub_population_fitness = translated_fitness[sub_population_index]\n if len(sub_population_fitness > 0):\n # APD Calculation\n angles = theta[sub_population_index, i]\n angles = np.divide(angles, refV[i]) # This is correct.\n # You have done this calculation before. Check with fitness_norm\n # Remove this horrible line\n sub_pop_fitness_magnitude = np.sqrt(\n np.sum(np.power(sub_population_fitness, 2), axis=1)\n )\n apd = np.multiply(\n np.transpose(sub_pop_fitness_magnitude),\n (1 + np.dot(partial_penalty_factor, angles)),\n )\n minidx = np.where(apd == np.nanmin(apd))\n if np.isnan(apd).all():\n continue\n selx = sub_population_index[minidx]\n if selection.shape[0] == 0:\n selection = np.hstack((selection, np.transpose(selx[0])))\n else:\n selection = np.vstack((selection, np.transpose(selx[0])))\n return selection.squeeze()\n\n def _partial_penalty_factor(self) -> float:\n \"\"\"Calculate and return the partial penalty factor for APD calculation.\n This calculation does not include the angle related terms, hence the name.\n If the calculated penalty is outside [0, 1], it will round it up/down to 0/1\n\n Returns\n -------\n float\n The partial penalty value\n \"\"\"\n penalty = ((self.time_penalty_function()) ** self.alpha) * self.n_of_objectives\n if penalty < 0:\n penalty = 0\n if penalty > 1:\n penalty = 1\n return penalty\n"
] |
[
[
"numpy.dot",
"numpy.power",
"numpy.amin",
"numpy.isnan",
"numpy.vstack",
"numpy.nanmin",
"numpy.arccos",
"numpy.linalg.norm",
"numpy.finfo",
"numpy.argmax",
"numpy.transpose",
"numpy.array",
"numpy.where",
"numpy.divide"
]
] |
toru-ver4/sample_code
|
[
"9165b4cb07a3cb1b3b5a7f6b3a329be081bddabe",
"8bda35b674d770da5a0e6c210634a77691527fce",
"8bda35b674d770da5a0e6c210634a77691527fce"
] |
[
"2020/020_explain_BT2407/_debug_bt2047_gamut_mapping.py",
"2019/001_make_3dlut/make_3dlut.py",
"2019/011_hdr_to_sdr_tonemapping/tone_mapping_research.py"
] |
[
"# -*- coding: utf-8 -*-\n\"\"\"\nBT2407 実装用の各種LUTを作成する\n===============================\n\n\"\"\"\n\n# import standard libraries\nimport os\n\n# import third-party libraries\nimport numpy as np\nfrom multiprocessing import Pool, cpu_count, Array\nimport matplotlib.pyplot as plt\nfrom colour.models import BT709_COLOURSPACE, BT2020_COLOURSPACE\nfrom colour import Lab_to_XYZ, XYZ_to_RGB, RGB_to_XYZ, XYZ_to_Lab,\\\n Lab_to_LCHab, RGB_COLOURSPACES, RGB_to_RGB, LCHab_to_Lab,\\\n write_LUT, LUT3D\nimport cv2\nfrom scipy import interpolate\n\n# import my libraries\nimport test_pattern_generator2 as tpg\nimport color_space as cs\nimport plot_utility as pu\nimport transfer_functions as tf\nfrom bt2407_parameters import L_SAMPLE_NUM_MAX, H_SAMPLE_NUM_MAX,\\\n GAMUT_BOUNDARY_LUT_LUMINANCE_SAMPLE, GAMUT_BOUNDARY_LUT_HUE_SAMPLE,\\\n get_gamut_boundary_lut_name, get_l_cusp_name, get_focal_name,\\\n get_chroma_map_lut_name\nfrom bt2047_gamut_mapping import get_chroma_lightness_val_specfic_hue,\\\n calc_chroma_lightness_using_length_from_l_focal,\\\n calc_chroma_lightness_using_length_from_c_focal, calc_cusp_lut,\\\n calc_degree_from_cl_data_using_c_focal,\\\n calc_degree_from_cl_data_using_l_focal,\\\n calc_distance_from_c_focal, calc_distance_from_l_focal,\\\n eliminate_inner_gamut_data_c_focal, eliminate_inner_gamut_data_l_focal,\\\n interpolate_chroma_map_lut, merge_lightness_mapping,\\\n bt2407_gamut_mapping_for_rgb_linear\nfrom make_bt2047_luts import calc_value_from_hue_1dlut,\\\n calc_chroma_map_degree2, calc_l_cusp_specific_hue, calc_cusp_in_lc_plane,\\\n _calc_ab_coef_from_cl_point, solve_equation_for_intersection,\\\n calc_cusp_focal_specific_hue\n\n# information\n__author__ = 'Toru Yoshihara'\n__copyright__ = 'Copyright (C) 2019 - Toru Yoshihara'\n__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'\n__maintainer__ = 'Toru Yoshihara'\n__email__ = 'toru.ver.11 at-sign gmail.com'\n\n__all__ = []\n\n\ndef lch_to_lab(lch):\n shape_bak = lch.shape\n aa = lch[..., 1] * np.cos(lch[..., 2])\n bb = lch[..., 1] * np.sin(lch[..., 2])\n return np.dstack((lch[..., 0], aa, bb)).reshape(shape_bak)\n\n\ndef print_blog_param_sub(\n rgb_2020=np.array([1023, 0, 0]), text=\"angle_40\"):\n rgb_2020_linear = (rgb_2020 / 1023) ** 2.4\n lab_2020 = XYZ_to_Lab(\n RGB_to_XYZ(\n rgb_2020_linear, cs.D65, cs.D65,\n BT2020_COLOURSPACE.RGB_to_XYZ_matrix))\n lch_2020 = Lab_to_LCHab(lab_2020)\n\n print(f\"rgb_2020_{text}={rgb_2020}\")\n print(f\"lab_2020_{text}={lab_2020}\")\n print(f\"lch_2020_{text}={lch_2020}\")\n\n\ndef print_blog_param():\n \"\"\"\n ブログ記載用のパラメータを吐く\n \"\"\"\n rgb_40_2020 = np.array([1001, 509, 321])\n rgb_270_2020 = np.array([158, 421, 759])\n\n print_blog_param_sub(rgb_40_2020, \"40\")\n print_blog_param_sub(rgb_270_2020, \"270\")\n\n\ndef _make_debug_luminance_chroma_data_fixed_hue(cl_outer):\n dst_step = 31\n degree = np.linspace(-np.pi/2, np.pi/2, dst_step)\n a1 = np.tan(degree)\n b1 = 50 * np.ones_like(a1)\n a2, b2 = _calc_ab_coef_from_cl_point(cl_outer)\n out_chroma, out_lightness = solve_equation_for_intersection(\n cl_outer, a1, b1, a2, b2, focal=\"L_Focal\")\n # chroma = cl_outer[..., 0]\n # lightness = cl_outer[..., 1]\n # step = GAMUT_BOUNDARY_LUT_HUE_SAMPLE // dst_step\n\n # out_chroma = np.append(chroma[::step], chroma[-1])\n # out_lightness = np.append(lightness[::step], lightness[-1])\n\n return out_lightness, out_chroma\n\n\ndef _check_chroma_map_lut_interpolation(\n hue_idx, hue,\n outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709):\n \"\"\"\n interpolate_chroma_map_lut() の動作確認用のデバッグコード。\n 1. まずはLUT上の LC平面で確認\n 2. 次に補間が働く LC平面で確認\n 3. 今度は補間が働く ab平面で確認\n \"\"\"\n print(hue_idx, np.rad2deg(hue))\n # とりあえず L*C* 平面のポリゴン準備\n cl_inner = get_chroma_lightness_val_specfic_hue(\n hue, get_gamut_boundary_lut_name(inner_color_space_name))\n cl_outer = get_chroma_lightness_val_specfic_hue(\n hue, get_gamut_boundary_lut_name(outer_color_space_name))\n\n # cusp 準備\n lh_inner_lut = np.load(\n get_gamut_boundary_lut_name(inner_color_space_name))\n inner_cusp = calc_cusp_in_lc_plane(hue, lh_inner_lut)\n lh_outer_lut = np.load(\n get_gamut_boundary_lut_name(outer_color_space_name))\n outer_cusp = calc_cusp_in_lc_plane(hue, lh_outer_lut)\n\n # l_cusp, l_focal, c_focal 準備\n l_cusp_lut = np.load(\n get_l_cusp_name(\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name))\n l_focal_lut = np.load(\n get_focal_name(\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name,\n focal_type=\"Lfocal\"))\n c_focal_lut = np.load(\n get_focal_name(\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name,\n focal_type=\"Cfocal\"))\n l_cusp = calc_value_from_hue_1dlut(hue, l_cusp_lut)\n l_focal = calc_value_from_hue_1dlut(hue, l_focal_lut)\n c_focal = calc_value_from_hue_1dlut(hue, c_focal_lut)\n\n # Chroma Mapping の Focalからの距離の LUT データ\n cmap_lut_c = np.load(\n get_chroma_map_lut_name(\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name,\n focal_type=\"Cfocal\"))\n cmap_lut_l = np.load(\n get_chroma_map_lut_name(\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name,\n focal_type=\"Lfocal\"))\n\n # st_degree, ed_degree を 1次元LUTの形で得る\n # st_degree_l[hue] = 30°, ed_degree_l[hue] = 120° 的な？\n inner_cusp_l_lut = calc_cusp_lut(lh_lut=lh_inner_lut)\n st_degree_l, ed_degree_l, st_degree_c, ed_degree_c =\\\n calc_chroma_map_degree2(l_focal_lut, c_focal_lut, inner_cusp_l_lut)\n\n # とりあえず検証用のデータを準備\n # 一応、本番を想定して chroma-lightness から変換するように仕込む\n # hue-degree --> chroma-lightness --> hue_degree --> 補間的な？\n \"\"\" L_focal 基準データ \"\"\"\n lightness_l, chroma_l = _make_debug_luminance_chroma_data_fixed_hue(\n cl_outer)\n hue_array = np.ones(chroma_l.shape[0]) * hue\n cl_data_l = np.dstack((chroma_l, lightness_l))[0]\n test_degree_l = calc_degree_from_cl_data_using_l_focal(\n cl_data=cl_data_l,\n l_focal=calc_value_from_hue_1dlut(hue_array, l_focal_lut))\n hd_data_l = np.dstack((hue_array, test_degree_l))[0]\n len_from_l_focal = calc_distance_from_l_focal(\n chroma_l, lightness_l, l_focal)\n\n \"\"\" C_focal 基準データ \"\"\"\n lightness_c, chroma_c = _make_debug_luminance_chroma_data_fixed_hue(\n cl_outer)\n hue_array = np.ones(chroma_l.shape[0]) * hue\n cl_data_c = np.dstack((chroma_c, lightness_c))[0]\n test_degree_c = calc_degree_from_cl_data_using_c_focal(\n cl_data=cl_data_c,\n c_focal=calc_value_from_hue_1dlut(hue_array, c_focal_lut))\n hd_data_c = np.dstack((hue_array, test_degree_c))[0]\n len_from_c_focal = calc_distance_from_c_focal(\n chroma_c, lightness_c, c_focal)\n\n # まずは cmap_lut 値の Bilinear補間\n cmap_value_l = interpolate_chroma_map_lut(\n cmap_hd_lut=cmap_lut_l, degree_min=st_degree_l,\n degree_max=ed_degree_l, data_hd=hd_data_l)\n cmap_value_c = interpolate_chroma_map_lut(\n cmap_hd_lut=cmap_lut_c, degree_min=st_degree_c,\n degree_max=ed_degree_c, data_hd=hd_data_c)\n\n # 除外データは除外\n restore_idx_l = (len_from_l_focal <= cmap_value_l)\n cmap_value_l[restore_idx_l] = len_from_l_focal[restore_idx_l]\n restore_idx_c = (len_from_c_focal > cmap_value_c)\n cmap_value_c[restore_idx_c] = len_from_c_focal[restore_idx_c]\n\n # 補間して得られた cmap 値から CL平面上における座標を取得\n icn_x_l, icn_y_l = calc_chroma_lightness_using_length_from_l_focal(\n distance=cmap_value_l, degree=test_degree_l, l_focal=l_focal)\n icn_x_c, icn_y_c = calc_chroma_lightness_using_length_from_c_focal(\n distance=cmap_value_c, degree=test_degree_c, c_focal=c_focal)\n\n _debug_plot_check_lightness_mapping_specific_hue(\n hue, cl_inner, cl_outer, l_cusp, inner_cusp, outer_cusp,\n l_cusp, l_focal, c_focal,\n x_val=chroma_l, y_val=lightness_l, map_x=icn_x_l, map_y=icn_y_l,\n focal_type=\"L_focal\", h_idx=hue_idx,\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name)\n _debug_plot_check_lightness_mapping_specific_hue(\n hue, cl_inner, cl_outer, l_cusp, inner_cusp, outer_cusp,\n l_cusp, l_focal, c_focal,\n x_val=chroma_c, y_val=lightness_c, map_x=icn_x_c, map_y=icn_y_c,\n focal_type=\"C_focal\", h_idx=hue_idx,\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name)\n\n\ndef _check_lightness_mapping_specific_hue(\n hue_idx, hue,\n outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709):\n \"\"\"\n interpolate_chroma_map_lut() の動作確認用のデバッグコード。\n \"\"\"\n print(hue_idx, np.rad2deg(hue))\n # とりあえず L*C* 平面のポリゴン準備\n cl_inner = get_chroma_lightness_val_specfic_hue(\n hue, get_gamut_boundary_lut_name(inner_color_space_name))\n cl_outer = get_chroma_lightness_val_specfic_hue(\n hue, get_gamut_boundary_lut_name(outer_color_space_name))\n\n # cusp 準備\n lh_inner_lut = np.load(\n get_gamut_boundary_lut_name(inner_color_space_name))\n inner_cusp = calc_cusp_in_lc_plane(hue, lh_inner_lut)\n lh_outer_lut = np.load(\n get_gamut_boundary_lut_name(outer_color_space_name))\n outer_cusp = calc_cusp_in_lc_plane(hue, lh_outer_lut)\n\n # l_cusp, l_focal, c_focal 準備\n l_cusp_lut = np.load(\n get_l_cusp_name(\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name))\n l_focal_lut = np.load(\n get_focal_name(\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name,\n focal_type=\"Lfocal\"))\n c_focal_lut = np.load(\n get_focal_name(\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name,\n focal_type=\"Cfocal\"))\n l_cusp = calc_value_from_hue_1dlut(hue, l_cusp_lut)\n l_focal = calc_value_from_hue_1dlut(hue, l_focal_lut)\n c_focal = calc_value_from_hue_1dlut(hue, c_focal_lut)\n\n # Chroma Mapping の Focalからの距離の LUT データ\n cmap_lut_c = np.load(\n get_chroma_map_lut_name(\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name,\n focal_type=\"Cfocal\"))\n cmap_lut_l = np.load(\n get_chroma_map_lut_name(\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name,\n focal_type=\"Lfocal\"))\n\n # st_degree, ed_degree を 1次元LUTの形で得る\n # st_degree_l[hue] = 30°, ed_degree_l[hue] = 120° 的な？\n inner_cusp_l_lut = calc_cusp_lut(lh_lut=lh_inner_lut)\n st_degree_l, ed_degree_l, st_degree_c, ed_degree_c =\\\n calc_chroma_map_degree2(l_focal_lut, c_focal_lut, inner_cusp_l_lut)\n\n # とりあえず検証用のデータを準備\n # 一応、本番を想定して chroma-lightness から変換するように仕込む\n # hue-degree --> chroma-lightness --> hue_degree --> 補間的な？\n \"\"\" L_focal 基準データ \"\"\"\n lightness_l, chroma_l = _make_debug_luminance_chroma_data_fixed_hue(\n cl_outer)\n hue_array = np.ones(chroma_l.shape[0]) * hue\n cl_data_l = np.dstack((chroma_l, lightness_l))[0]\n test_degree_l = calc_degree_from_cl_data_using_l_focal(\n cl_data=cl_data_l,\n l_focal=calc_value_from_hue_1dlut(hue_array, l_focal_lut))\n hd_data_l = np.dstack((hue_array, test_degree_l))[0]\n\n \"\"\" C_focal 基準データ \"\"\"\n lightness_c, chroma_c = _make_debug_luminance_chroma_data_fixed_hue(\n cl_outer)\n hue_array = np.ones(chroma_l.shape[0]) * hue\n cl_data_c = np.dstack((chroma_c, lightness_c))[0]\n test_degree_c = calc_degree_from_cl_data_using_c_focal(\n cl_data=cl_data_c,\n c_focal=calc_value_from_hue_1dlut(hue_array, c_focal_lut))\n hd_data_c = np.dstack((hue_array, test_degree_c))[0]\n\n # まずは cmap_lut 値の Bilinear補間\n cmap_value_l = interpolate_chroma_map_lut(\n cmap_hd_lut=cmap_lut_l, degree_min=st_degree_l,\n degree_max=ed_degree_l, data_hd=hd_data_l)\n cmap_value_c = interpolate_chroma_map_lut(\n cmap_hd_lut=cmap_lut_c, degree_min=st_degree_c,\n degree_max=ed_degree_c, data_hd=hd_data_c)\n\n # out of gamut ではないデータは処理をしないようにする\n eliminate_inner_gamut_data_l_focal(\n dst_distance=cmap_value_l, src_chroma=chroma_l,\n src_lightness=lightness_l, l_focal=l_focal)\n eliminate_inner_gamut_data_c_focal(\n dst_distance=cmap_value_c, src_chroma=chroma_c,\n src_lightness=lightness_c, c_focal=c_focal)\n\n # 補間して得られた cmap 値から CL平面上における座標を取得\n icn_x_l, icn_y_l = calc_chroma_lightness_using_length_from_l_focal(\n distance=cmap_value_l, degree=test_degree_l, l_focal=l_focal)\n icn_x_c, icn_y_c = calc_chroma_lightness_using_length_from_c_focal(\n distance=cmap_value_c, degree=test_degree_c, c_focal=c_focal)\n\n # L_Focalベースと C_Focalベースの結果を統合\n icn_x, icn_y = merge_lightness_mapping(\n hd_data_l=hd_data_l, st_degree_l=st_degree_l,\n chroma_map_l=icn_x_l, lightness_map_l=icn_y_l,\n chroma_map_c=icn_x_c, lightness_map_c=icn_y_c)\n\n _debug_plot_check_lightness_mapping_specific_hue(\n hue, cl_inner, cl_outer, l_cusp, inner_cusp, outer_cusp,\n l_cusp, l_focal, c_focal,\n x_val=chroma_l, y_val=lightness_l, map_x=icn_x, map_y=icn_y,\n focal_type=\"All\", h_idx=hue_idx,\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name)\n\n\ndef _debug_plot_check_lightness_mapping_specific_hue(\n hue, cl_inner, cl_outer, lcusp, inner_cusp, outer_cusp,\n l_cusp, l_focal, c_focal, x_val, y_val, map_x, map_y,\n focal_type, h_idx=0, outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709):\n graph_title = f\"HUE = {hue/2/np.pi*360:.1f}°, for {focal_type}\"\n graph_title += f\"={c_focal:.1f}\" if focal_type == \"C_focal\" else \"\"\n fig1, ax1 = pu.plot_1_graph(\n fontsize=22,\n figsize=(16 * 0.9, 9 * 1.0),\n graph_title=graph_title,\n xlabel=\"Chroma\",\n ylabel=\"Lightness\",\n legend_size=17,\n xlim=[-10, 230],\n ylim=[-3, 103],\n xtick=[x * 20 for x in range(12)],\n ytick=[x * 10 for x in range(11)],\n linewidth=3,\n return_figure=True)\n ax1.patch.set_facecolor(\"#E0E0E0\")\n in_color = pu.BLUE\n ou_color = pu.RED\n fo_color = \"#808080\"\n src_color = pu.GREEN\n dst_color = pu.PINK\n\n # gamut boundary\n ax1.plot(\n cl_inner[..., 0], cl_inner[..., 1], c=in_color, label=\"BT.709\")\n ax1.plot(cl_outer[..., 0], cl_outer[..., 1], c=ou_color, label=\"BT.2020\")\n\n # gamut cusp\n ax1.plot(inner_cusp[1], inner_cusp[0], 's', ms=10, mec='k',\n c=in_color, label=\"BT.709 Cusp\")\n ax1.plot(outer_cusp[1], outer_cusp[0], 's', ms=10, mec='k',\n c=ou_color, label=\"BT.2020 Cusp\")\n\n # l_cusp, l_focal, c_focal\n ax1.plot([0], [l_cusp], 'x', ms=12, mew=4, c=in_color, label=\"L_cusp\")\n ax1.plot([0], [l_focal], 'x', ms=12, mew=4, c=ou_color, label=\"L_focal\")\n ax1.plot([c_focal], [0], '*', ms=12, mew=3, c=ou_color, label=\"C_focal\")\n ax1.plot([0, c_focal], [l_focal, 0], '--', c='k')\n\n # intersectionx\n ax1.plot(x_val, y_val, 'o', ms=9, c=src_color, label=\"src point\")\n ax1.plot(map_x, map_y, 'o', ms=6, c=dst_color, label=\"dst point\")\n for x, y in zip(x_val, y_val):\n if y >= (-l_focal * x / c_focal + l_focal):\n aa = (y - l_focal) / x\n bb = l_focal\n xx = 230\n yy = aa * xx + bb\n ax1.plot([0, xx], [l_focal, yy], '--', c=fo_color, lw=1)\n else:\n aa = (y) / (x - c_focal)\n bb = y - aa * x\n xx = 0\n yy = aa * xx + bb\n ax1.plot([0, c_focal], [yy, 0], '--', c=fo_color, lw=1)\n\n # annotation\n diff = ((map_x - x_val) ** 2 + (map_y - y_val) ** 2) ** 0.5\n arrowprops = dict(\n facecolor='#333333', shrink=0.0, headwidth=8, headlength=10,\n width=1)\n for idx in range(len(map_x)):\n if diff[idx] > 0.01:\n st_pos = (x_val[idx], y_val[idx])\n ed_pos = (map_x[idx], map_y[idx])\n ax1.annotate(\n \"\", xy=ed_pos, xytext=st_pos, xycoords='data',\n textcoords='data', ha='left', va='bottom',\n arrowprops=arrowprops)\n\n graph_name = f\"/work/overuse/2020/020_explain_BT2407/lightness_mapping_\"\\\n + f\"{outer_color_space_name}_to_{inner_color_space_name}_\"\\\n + f\"{focal_type}_{h_idx:04d}.png\"\n plt.legend(loc='upper right')\n print(graph_name)\n # plt.savefig(graph_name, bbox_inches='tight', pad_inches=0.1)\n plt.savefig(graph_name) # オプション付けるとエラーになるので外した\n # plt.show()\n plt.close(fig1)\n\n\ndef _check_upper_and_lower_mapping(\n hue_sample_num=10,\n outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709):\n hue_list = np.deg2rad(\n np.linspace(0, 360, hue_sample_num, endpoint=False))\n args = []\n for idx, hue in enumerate(hue_list):\n # _check_chroma_map_lut_interpolation(\n # hue_idx=idx, hue=hue,\n # outer_color_space_name=cs.BT2020,\n # inner_color_space_name=cs.BT709)\n d = dict(\n hue_idx=idx, hue=hue,\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name)\n args.append(d)\n with Pool(cpu_count()) as pool:\n pool.map(thread_wrapper_check_chroma_map_lut_interpolation, args)\n\n\ndef thread_wrapper_check_chroma_map_lut_interpolation(args):\n _check_chroma_map_lut_interpolation(**args)\n\n\ndef _check_lightness_mapping_specific_hue_seq(\n hue_sample_num=16,\n outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709):\n hue_list = np.deg2rad(\n np.linspace(0, 360, hue_sample_num, endpoint=False))\n args = []\n for idx, hue in enumerate(hue_list):\n # _check_lightness_mapping_specific_hue(\n # hue_idx=idx, hue=hue,\n # outer_color_space_name=cs.BT2020,\n # inner_color_space_name=cs.BT709)\n d = dict(\n hue_idx=idx, hue=hue,\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name)\n args.append(d)\n with Pool(cpu_count()) as pool:\n pool.map(thread_wrapper_check_lightness_mapping, args)\n\n\ndef thread_wrapper_check_lightness_mapping(args):\n _check_lightness_mapping_specific_hue(**args)\n\n\ndef _debug_plot_blog_mapping_after(\n src_rgb, dst_rgb, src_lch, dst_lch,\n chroma_min=-5, chroma_max=220, ll_min=0, ll_max=100,\n outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709):\n \"\"\"\n ブログでの説明用にシンプルな Chroma Lightness平面をプロット\n 入力データもプロットするよん。\n \"\"\"\n hue = np.deg2rad(dst_lch[2])\n cl_inner = get_chroma_lightness_val_specfic_hue(\n hue=hue,\n lh_lut_name=get_gamut_boundary_lut_name(inner_color_space_name))\n cl_outer =\\\n get_chroma_lightness_val_specfic_hue(\n hue=hue,\n lh_lut_name=get_gamut_boundary_lut_name(outer_color_space_name))\n l_cusp, l_focal, c_focal = calc_cusp_focal_specific_hue(\n hue=hue,\n outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709)\n\n lh_inner_lut = np.load(\n get_gamut_boundary_lut_name(inner_color_space_name))\n inner_cusp = calc_cusp_in_lc_plane(hue, lh_inner_lut)\n lh_outer_lut = np.load(\n get_gamut_boundary_lut_name(outer_color_space_name))\n outer_cusp = calc_cusp_in_lc_plane(hue, lh_outer_lut)\n\n fig, ax1 = pu.plot_1_graph(\n fontsize=20,\n figsize=(16 * 0.9, 9 * 1.0),\n graph_title=f\"HUE = {hue/2/np.pi*360:.1f}°\",\n graph_title_size=None,\n xlabel=\"Chroma\",\n ylabel=\"Lightness\",\n axis_label_size=None,\n legend_size=17,\n xlim=[chroma_min, chroma_max],\n ylim=[ll_min, ll_max],\n xtick=[20 * x for x in range(12)],\n ytick=[x * 10 for x in range(11)],\n xtick_size=None, ytick_size=None,\n linewidth=3,\n return_figure=True)\n ax1.patch.set_facecolor(\"#E0E0E0\")\n in_color = \"#909090\"\n ou_color = \"#000000\"\n l_cups_line = \"#333333\"\n fo_color = \"#333333\"\n\n # gamut boundary\n ax1.plot(\n cl_inner[..., 0], cl_inner[..., 1], c=in_color,\n label=inner_color_space_name)\n ax1.plot(\n cl_outer[..., 0], cl_outer[..., 1], c=ou_color,\n label=outer_color_space_name)\n ax1.plot(\n src_lch[..., 1], src_lch[..., 0], 'o', c=src_rgb, ms=13,\n label=\"src\")\n ax1.plot(\n dst_lch[..., 1], dst_lch[..., 0], 'o', c=dst_rgb, ms=13,\n label=\"dst\")\n x = dst_lch[..., 1]\n y = dst_lch[..., 0]\n if y >= (-l_focal * x / c_focal + l_focal):\n aa = (y - l_focal) / x\n bb = l_focal\n xx = 230\n yy = aa * xx + bb\n ax1.plot([0, xx], [l_focal, yy], '--', lw=1, c=fo_color)\n else:\n aa = (y) / (x - c_focal)\n bb = y - aa * x\n xx = 0\n yy = aa * xx + bb\n ax1.plot([0, c_focal], [yy, 0], '--', lw=1, c=fo_color)\n\n # Cusp\n ax1.plot(inner_cusp[1], inner_cusp[0], 's', ms=10, mec='k',\n c=in_color, label=f\"{inner_color_space_name} cusp\", zorder=3)\n ax1.plot(outer_cusp[1], outer_cusp[0], 's', ms=10, mec='k',\n c=ou_color, label=f\"{outer_color_space_name} cusp\", zorder=3)\n # if inner_cusp[1] < outer_cusp[1]:\n # ax1.plot([0, outer_cusp[1]], [l_cusp, outer_cusp[0]], '--', lw=1,\n # c=l_cups_line)\n # else:\n # ax1.plot([0, inner_cusp[1]], [l_cusp, inner_cusp[0]], '--', lw=1,\n # c=l_cups_line)\n\n # l_cusp, l_focal, c_focal\n ax1.plot([0], [l_cusp], 'x', ms=12, mew=4, c=pu.BLUE, label=\"L_cusp\",\n zorder=3)\n ax1.plot([0], [l_focal], 'x', ms=12, mew=4, c=pu.RED, label=\"L_focal\",\n zorder=3)\n ax1.plot([c_focal], [0], '*', ms=12, mew=3, c=pu.RED, label=\"C_focal\",\n zorder=3)\n ax1.plot(\n [0, c_focal], [l_focal, 0], '--', c='k', label=\"L_focal to C_focal\")\n if c_focal > chroma_max:\n ax1.text(182, 0, f\"C_focal = {c_focal:.1f}\")\n\n # annotation\n fcolor = 0\n fcolor = np.array([fcolor, fcolor, fcolor])\n arrowprops = dict(\n facecolor=fcolor, shrink=0.0, headwidth=12, headlength=15,\n width=3, alpha=0.6)\n st_pos = (src_lch[1], src_lch[0])\n ed_pos = (dst_lch[1], dst_lch[0])\n ax1.annotate(\n \"\", xy=ed_pos, xytext=st_pos, xycoords='data',\n textcoords='data', ha='left', va='bottom',\n arrowprops=arrowprops)\n\n graph_name = f\"/work/overuse/2020/020_explain_BT2407/\"\\\n + f\"simple_cl_plane_mapping_HUE_\"\\\n + f\"{hue/2/np.pi*360:.1f}.png\"\n plt.legend(loc='upper right')\n plt.savefig(graph_name, bbox_inches='tight', pad_inches=0.1)\n # plt.show()\n plt.close(fig)\n\n\ndef _debug_lightness_mapping_for_rgb(\n outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709):\n rgb_2020_gm24_1 = np.array([1001, 509, 321])\n rgb_2020_gm24_2 = np.array([158, 421, 759])\n rgb_2020_gm24 = np.array([rgb_2020_gm24_1, rgb_2020_gm24_2]) / 1023\n rgb_2020_linear = rgb_2020_gm24 ** 2.4\n\n rgb_709 = bt2407_gamut_mapping_for_rgb_linear(\n rgb_linear=rgb_2020_linear,\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name)\n\n rgb_709_gm24 = np.round((rgb_709 ** (1/2.4) * 1023))\n rgb_709_gm24_on_2020 = RGB_to_RGB(\n rgb_709,\n RGB_COLOURSPACES[inner_color_space_name],\n RGB_COLOURSPACES[outer_color_space_name])\\\n ** (1/2.4)\n print(rgb_709_gm24_on_2020)\n lab_709 = XYZ_to_Lab(\n RGB_to_XYZ(\n rgb_709, cs.D65, cs.D65,\n RGB_COLOURSPACES[inner_color_space_name].RGB_to_XYZ_matrix))\n lch_709 = Lab_to_LCHab(lab_709)\n lab_2020 = XYZ_to_Lab(\n RGB_to_XYZ(\n rgb_2020_linear, cs.D65, cs.D65,\n RGB_COLOURSPACES[outer_color_space_name].RGB_to_XYZ_matrix))\n lch_2020 = Lab_to_LCHab(lab_2020)\n\n _debug_plot_blog_mapping_after(\n src_rgb=rgb_2020_gm24[0], dst_rgb=rgb_709_gm24_on_2020[0],\n src_lch=lch_2020[0], dst_lch=lch_709[0],\n chroma_min=-5, chroma_max=220, ll_min=-3, ll_max=103,\n outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709)\n _debug_plot_blog_mapping_after(\n src_rgb=rgb_2020_gm24[1], dst_rgb=rgb_709_gm24_on_2020[1],\n src_lch=lch_2020[1], dst_lch=lch_709[1],\n chroma_min=-5, chroma_max=220, ll_min=-3, ll_max=103,\n outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709)\n\n print(f\"src_lch={lch_2020}\")\n print(f\"dst_lch={lch_709}\")\n print(f\"src_lab={lab_2020}\")\n print(f\"dst_lab={lab_709}\")\n print(f\"src_rgb={rgb_2020_gm24}\")\n print(f\"dst_rgb={rgb_709_gm24}\")\n print(f\"dst_rgb={rgb_709_gm24_on_2020*255}\")\n\n\ndef _lch_to_rgb(lch, inner_color_space_name, outer_color_space_name):\n lab = LCHab_to_Lab(lch)\n xyz = Lab_to_XYZ(lab)\n rgb_2020 = XYZ_to_RGB(\n xyz, cs.D65, cs.D65,\n RGB_COLOURSPACES[outer_color_space_name].XYZ_to_RGB_matrix)\n rgb_709 = XYZ_to_RGB(\n xyz, cs.D65, cs.D65,\n RGB_COLOURSPACES[inner_color_space_name].XYZ_to_RGB_matrix)\n\n r_judge = (rgb_709[0] >= 0) & (rgb_709[0] <= 1)\n g_judge = (rgb_709[1] >= 0) & (rgb_709[1] <= 1)\n b_judge = (rgb_709[2] >= 0) & (rgb_709[2] <= 1)\n is_in_gamut = (r_judge & g_judge) & b_judge\n\n rgb = np.clip(rgb_2020, 0.0, 1.0)\n\n return rgb, is_in_gamut\n\n\ndef make_cielab_tp_ctrl(\n outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709,\n width=1920, height=1080, h_block_num=16*3, v_block_num=9*3):\n \"\"\"\n CIELABの横軸にHue、縦軸にChromaの\n テストパターンを作る。\n \"\"\"\n lh_lut = np.load(\n get_gamut_boundary_lut_name(color_space_name=outer_color_space_name))\n lightness_lut_sample, hue_lut_sample = lh_lut.shape\n\n cusp_buf = []\n l_cusp_buf = []\n hue_list = np.linspace(0, 2*np.pi, h_block_num, endpoint=False)\n for hue in hue_list:\n cusp_lc_temp = calc_cusp_in_lc_plane(hue, lh_lut)\n cusp_buf.append(cusp_lc_temp)\n l_cusp, l_focal, c_focal = calc_cusp_focal_specific_hue(\n hue=hue,\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name)\n l_cusp_buf.append(l_cusp)\n cusp_lc = np.array(cusp_buf)\n l_cusp = np.array(l_cusp_buf)\n cusp_chroma = cusp_lc[..., 1]\n cusp_lightness = cusp_lc[..., 0]\n\n block_width_list = tpg.equal_devision(width, h_block_num)\n block_height_list = tpg.equal_devision(height, v_block_num)\n\n h_buf = []\n for h_idx in range(h_block_num):\n block_width = block_width_list[h_idx]\n hue = hue_list[h_idx]\n aa = (cusp_lightness[h_idx] - l_cusp[h_idx]) / (cusp_chroma[h_idx] - 0)\n bb = l_cusp[h_idx]\n v_buf = []\n for v_idx in range(v_block_num):\n block_height = block_height_list[v_idx]\n cc = v_idx / (v_block_num - 1) * cusp_chroma[h_idx]\n ll = aa * cc + bb\n lch = np.dstack((ll, cc, np.rad2deg(hue)))[0][0]\n rgb, is_in_gamut = _lch_to_rgb(\n lch,\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name)\n temp_img = np.ones((block_height, block_width, 3))\\\n * rgb\n if not is_in_gamut:\n temp_img[:4, :4] = np.array([0.0, 0.0, 0.0])\n v_buf.append(temp_img)\n # print(f\"hue={np.rad2deg(hue)}, c={cc:.2f}, l={ll:.2f}\")\n # print(f\"hue={np.rad2deg(hue)}, rgb={rgb}, in={is_in_gamut}\")\n h_buf.append(np.vstack(v_buf))\n img = np.hstack(h_buf)\n\n fname = f\"./figures/bt2020_tp_src_{width}x{height}.png\"\n cv2.imwrite(\n fname, np.uint16(np.round((img[..., ::-1] ** (1/2.4)) * 0xFFFF)))\n\n\ndef make_cielab_boundary_tp(\n color_space_name=cs.BT709,\n width=1920, height=1080, h_block_num=16, v_block_num=9):\n hue_list = np.linspace(0, 2*np.pi, h_block_num, endpoint=False)\n\n cusp_buf = []\n lh_lut = np.load(\n get_gamut_boundary_lut_name(color_space_name=color_space_name))\n lightness_lut_sample, hue_lut_sample = lh_lut.shape\n for hue in hue_list:\n cusp_lc_temp = calc_cusp_in_lc_plane(hue, lh_lut)\n cusp_buf.append(cusp_lc_temp)\n cusp_lc = np.array(cusp_buf)\n cusp_lightness_list = cusp_lc[..., 0]\n chroma_max = np.max(cusp_lc[..., 1])\n block_width_list = tpg.equal_devision(width, h_block_num)\n block_height_list = tpg.equal_devision(height, v_block_num)\n\n h_buf = []\n for h_idx in range(h_block_num):\n hue = hue_list[h_idx]\n block_width = block_width_list[h_idx]\n boundary = get_chroma_lightness_val_specfic_hue(\n hue, get_gamut_boundary_lut_name(color_space_name))\n v_buf = []\n cusp_lightness = cusp_lightness_list[h_idx]\n cx = boundary[boundary[..., 1] >= cusp_lightness][..., 0]\n ly = boundary[boundary[..., 1] >= cusp_lightness][..., 1]\n ll_func = interpolate.interp1d(cx, ly)\n for v_idx in range(v_block_num):\n block_height = block_height_list[v_idx]\n cc = v_idx / (v_block_num - 1) * chroma_max\n lower_ok =\\\n (boundary[..., 0] <= cc) & (boundary[..., 1] >= cusp_lightness)\n upper_ok =\\\n (boundary[..., 0] >= cc) & (boundary[..., 1] >= cusp_lightness)\n lower_st_idx = np.argmax(lower_ok)\n st_idx = lower_st_idx\n if np.sum(upper_ok == True) > 0:\n # ll = boundary[st_idx][1]\n ll = ll_func(cc)\n # cc = boundary[st_idx][0]\n lch = np.dstack((ll, cc, np.rad2deg(hue)))\n lab = LCHab_to_Lab(lch)\n xyz = Lab_to_XYZ(lab)\n rgb = XYZ_to_RGB(\n xyz, cs.D65, cs.D65,\n RGB_COLOURSPACES[color_space_name].XYZ_to_RGB_matrix)\n rgb = np.clip(rgb, 0.0, 1.0)\n temp_img = np.ones((block_height, block_width, 3))\\\n * rgb\n else:\n temp_img = np.zeros((block_height, block_width, 3))\n v_buf.append(temp_img)\n h_buf.append(np.vstack(v_buf))\n img = np.hstack(h_buf)\n\n fname = f\"./figures/hue_chroma_tp_{color_space_name}_{width}x{height}.png\"\n cv2.imwrite(\n fname, np.uint16(np.round((img[..., ::-1] ** (1/2.4)) * 0xFFFF)))\n\n\ndef apply_gamaut_mapping_to_image(\n src_img_file=\"./figures/bt2020_tp_src_1920x1080.tiff\",\n outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709):\n\n dst_basename = os.path.basename(os.path.splitext(src_img_file)[0])\n dst_dir = os.path.dirname(src_img_file)\n dst_img_file_709 = os.path.join(dst_dir, dst_basename + \"_bt709.png\")\n dst_img_file_709_mtx = os.path.join(\n dst_dir, dst_basename + \"_bt709_mtx.png\")\n dst_img_file_2020 = os.path.join(dst_dir, dst_basename + \"_bt2020.png\")\n\n rgb_gm24 = cv2.imread(src_img_file, cv2.IMREAD_ANYDEPTH | cv2.IMREAD_COLOR)\n rgb_gm24 = rgb_gm24[..., ::-1]\n rgb_linear = (rgb_gm24 / 0xFFFF) ** 2.4\n rgb_dst_709_linear = bt2407_gamut_mapping_for_rgb_linear(\n rgb_linear=rgb_linear,\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name)\n rgb_dst_709_gm24 = rgb_dst_709_linear ** (1/2.4)\n\n cv2.imwrite(\n dst_img_file_709,\n np.uint16(np.round(rgb_dst_709_gm24[..., ::-1] * 0xFFFF)))\n\n rgb_dst_2020_linear = RGB_to_RGB(\n rgb_dst_709_linear,\n RGB_COLOURSPACES[inner_color_space_name],\n RGB_COLOURSPACES[outer_color_space_name])\n rgb_dst_2020_gm24 = rgb_dst_2020_linear ** (1/2.4)\n cv2.imwrite(\n dst_img_file_2020,\n np.uint16(np.round(rgb_dst_2020_gm24[..., ::-1] * 0xFFFF)))\n\n rgb_dst_709_mtx_linear = RGB_to_RGB(\n rgb_linear,\n RGB_COLOURSPACES[outer_color_space_name],\n RGB_COLOURSPACES[inner_color_space_name])\n rgb_dst_709_mtx_linear = np.clip(rgb_dst_709_mtx_linear, 0.0, 1.0)\n rgb_dst_709_mtx_gm24 = rgb_dst_709_mtx_linear ** (1/2.4)\n cv2.imwrite(\n dst_img_file_709_mtx,\n np.uint16(np.round(rgb_dst_709_mtx_gm24[..., ::-1] * 0xFFFF)))\n\n\ndef make_3dlut(\n grid_num=33,\n outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709,\n tfc=tf.GAMMA24):\n src_rgb_non_linear = LUT3D.linear_table(grid_num)\n src_rgb_non_linear = src_rgb_non_linear.reshape((1, grid_num ** 3, 3))\n src_rgb_linear = tf.eotf(src_rgb_non_linear, tfc)\n dst_rgb_linear = bt2407_gamut_mapping_for_rgb_linear(\n rgb_linear=src_rgb_linear,\n outer_color_space_name=outer_color_space_name,\n inner_color_space_name=inner_color_space_name)\n dst_rgb_non_linear = tf.oetf(dst_rgb_linear, tfc)\n dst_rgb_non_linear = dst_rgb_non_linear.reshape(\n (grid_num, grid_num, grid_num, 3))\n\n file_name = f\"./3DLUT/GamutMapping_{outer_color_space_name}_\"\\\n + f\"to_{inner_color_space_name}_{tfc}_\"\\\n + f\"{grid_num}x{grid_num}x{grid_num}.cube\"\n file_name = file_name.replace(\" \", \"_\")\n lut3d = LUT3D(table=dst_rgb_non_linear, name=file_name)\n write_LUT(lut3d, file_name)\n\n\ndef main_func():\n # print_blog_param()\n # _check_chroma_map_lut_interpolation(0, np.deg2rad(40))\n # _check_upper_and_lower_mapping(\n # hue_sample_num=1025,\n # outer_color_space_name=cs.BT2020,\n # inner_color_space_name=cs.BT709)\n # _check_upper_and_lower_mapping(\n # hue_sample_num=1025,\n # outer_color_space_name=cs.P3_D65,\n # inner_color_space_name=cs.BT709)\n # _check_lightness_mapping_specific_hue_seq(\n # hue_sample_num=1025,\n # outer_color_space_name=cs.BT2020,\n # inner_color_space_name=cs.BT709)\n # _check_lightness_mapping_specific_hue_seq(\n # hue_sample_num=1025,\n # outer_color_space_name=cs.P3_D65,\n # inner_color_space_name=cs.BT709)\n # _debug_lightness_mapping_for_rgb(\n # outer_color_space_name=cs.BT2020,\n # inner_color_space_name=cs.BT709)\n make_cielab_tp_ctrl(\n outer_color_space_name=cs.BT2020,\n inner_color_space_name=cs.BT709,\n width=1920, height=1080,\n h_block_num=int(16*2 + 0.999), v_block_num=int(9*2 + 0.999))\n # make_cielab_boundary_tp(\n # color_space_name=cs.BT709,\n # width=1920, height=1080, h_block_num=16*3, v_block_num=9*3)\n # make_cielab_boundary_tp(\n # color_space_name=cs.BT2020,\n # width=1920, height=1080, h_block_num=16*3, v_block_num=9*3)\n # apply_gamaut_mapping_to_image(\n # src_img_file=\"./figures/bt2020_tp_src_1920x1080.png\",\n # outer_color_space_name=cs.BT2020,\n # inner_color_space_name=cs.BT709)\n # _check_lightness_mapping_specific_hue(\n # hue_idx=0, hue=np.deg2rad(40),\n # outer_color_space_name=cs.BT2020,\n # inner_color_space_name=cs.BT709)\n # _check_lightness_mapping_specific_hue(\n # hue_idx=1, hue=np.deg2rad(270),\n # outer_color_space_name=cs.BT2020,\n # inner_color_space_name=cs.BT709)\n # make_3dlut(\n # grid_num=33,\n # outer_color_space_name=cs.BT2020,\n # inner_color_space_name=cs.BT709,\n # tfc=tf.GAMMA24)\n # make_3dlut(\n # grid_num=65,\n # outer_color_space_name=cs.BT2020,\n # inner_color_space_name=cs.BT709,\n # tfc=tf.GAMMA24)\n # make_3dlut(\n # grid_num=129,\n # outer_color_space_name=cs.BT2020,\n # inner_color_space_name=cs.BT709,\n # tfc=tf.GAMMA24)\n pass\n\n\nif __name__ == '__main__':\n os.chdir(os.path.dirname(os.path.abspath(__file__)))\n main_func()\n",
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\n\"\"\"\nST2084-BT.2020-D65 のデータを 2.4-BT.709-D65 に変換する3DLUTを作る。\nソースが ST2084 なので display reffered な変換とする（system gamma を考慮しない）。\n\"\"\"\n\n# 外部ライブラリのインポート\nimport os\nimport numpy as np\nfrom colour.models import eotf_ST2084\nfrom colour import RGB_to_RGB\nfrom colour.models import BT2020_COLOURSPACE, BT709_COLOURSPACE\n\n# 自作ライブラリのインポート\nimport lut\n\nNOMINAL_WHITE_LUMINANCE = 100\n\n\ndef save_3dlut_csv_with_10bit_depth(grid_num, rgb_in, rgb_out):\n \"\"\"\n ブログ添付用に10bit精度のLUTのcsvファイルを作成する。\n\n Parameters\n ----------\n grid_num : integer\n A number of grid points.\n rgb_in : ndarray\n Grid point data.\n rgb_out : ndarray\n A 3dlut data.\n \"\"\"\n filename = \"./3dlut_for_blog.csv\"\n # 10bit整数型に変換\n rgb_i = np.uint16(np.round(rgb_in * 1023))\n rgb_o = np.uint16(np.round(rgb_out * 1023))\n with open(filename, \"w\") as f:\n # header\n buf = \"{}, {}, {}, {}, {}, {}, {}\\n\".format(\n \"index\", \"R_in\", \"G_in\", \"B_in\", \"R_out\", \"G_out\", \"B_out\")\n f.write(buf)\n\n # body\n for index in range(grid_num ** 3):\n buf = \"{}, {}, {}, {}, {}, {}, {}\\n\".format(\n index,\n rgb_i[0, index, 0], rgb_i[0, index, 1], rgb_i[0, index, 2],\n rgb_o[index, 0], rgb_o[index, 1], rgb_o[index, 2])\n f.write(buf)\n\n\ndef make_3dlut_grid(grid_num=33):\n \"\"\"\n 3DLUTの格子点データを作成\n\n Parameters\n ----------\n grid_num : integer\n A number of grid points.\n\n Returns\n -------\n ndarray\n An Array of the grid points.\n The shape is (1, grid_num ** 3, 3).\n\n Examples\n --------\n >>> make_3dlut_grid(grid_num=3)\n array([[[0. , 0. , 0. ],\n [0.5, 0. , 0. ],\n [1. , 0. , 0. ],\n [0. , 0.5, 0. ],\n [0.5, 0.5, 0. ],\n [1. , 0.5, 0. ],\n [0. , 1. , 0. ],\n [0.5, 1. , 0. ],\n [1. , 1. , 0. ],\n [0. , 0. , 0.5],\n [0.5, 0. , 0.5],\n [1. , 0. , 0.5],\n [0. , 0.5, 0.5],\n [0.5, 0.5, 0.5],\n [1. , 0.5, 0.5],\n [0. , 1. , 0.5],\n [0.5, 1. , 0.5],\n [1. , 1. , 0.5],\n [0. , 0. , 1. ],\n [0.5, 0. , 1. ],\n [1. , 0. , 1. ],\n [0. , 0.5, 1. ],\n [0.5, 0.5, 1. ],\n [1. , 0.5, 1. ],\n [0. , 1. , 1. ],\n [0.5, 1. , 1. ],\n [1. , 1. , 1. ]]])\n \"\"\"\n # np.meshgrid を使って 3次元の格子点座標を生成\n x = np.linspace(0, 1, grid_num)\n rgb_mesh_array = np.meshgrid(x, x, x)\n\n # 後の処理を行いやすくするため shape を変える\n rgb_mesh_array = [x.reshape(1, grid_num ** 3, 1) for x in rgb_mesh_array]\n\n # 格子点のデータ増加が R, G, B の順となるように配列を並べ替えてから\n # np.dstack を使って結合する\n rgb_grid = np.dstack(\n (rgb_mesh_array[2], rgb_mesh_array[0], rgb_mesh_array[1]))\n\n return rgb_grid\n\n\ndef main(grid_num=65):\n # R, G, B の grid point データを準備\n x = make_3dlut_grid(grid_num=grid_num)\n\n # 3DLUT を適用する対象は ST2084 の OETF が掛かっているため、\n # ST2084 の EOTF を掛けて linear に戻す\n linear_luminance = eotf_ST2084(x)\n\n # 単位が輝度(0～10000 nits)になっているので\n # 一般的に使われる 1.0 が 100 nits のスケールに変換\n linear = linear_luminance / NOMINAL_WHITE_LUMINANCE\n\n # 色域を BT.2020 --> BT.709 に変換\n linear_bt709 = RGB_to_RGB(RGB=linear,\n input_colourspace=BT2020_COLOURSPACE,\n output_colourspace=BT709_COLOURSPACE)\n\n # BT.709 の範囲外の値(linear_bt709 < 0.0 と linear_bt709 > 1.0 の領域)をクリップ\n linear_bt709 = np.clip(linear_bt709, 0.0, 1.0)\n\n # BT.709 のガンマ(OETF)をかける\n non_linear_bt709 = linear_bt709 ** (1 / 2.4)\n\n # 自作の LUTライブラリのクソ仕様のため shape を変換する\n lut_for_save = non_linear_bt709.reshape((grid_num ** 3, 3))\n\n # 自作の LUTライブラリを使って .cube の形式で保存\n lut_fname = \"./st2084_bt2020_to_gamma2.4_bt709.cube\"\n lut.save_3dlut(\n lut=lut_for_save, grid_num=grid_num, filename=lut_fname)\n\n save_3dlut_csv_with_10bit_depth(\n grid_num=grid_num, rgb_in=x, rgb_out=lut_for_save)\n\n\nif __name__ == '__main__':\n os.chdir(os.path.dirname(os.path.abspath(__file__)))\n main()\n",
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\nimport os\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport cv2\nfrom sympy import symbols, solve\nfrom sympy.utilities.lambdify import lambdify\nfrom colour import xyY_to_XYZ, XYZ_to_RGB, RGB_to_XYZ, XYZ_to_xyY, RGB_to_RGB\nfrom colour.models import BT2020_COLOURSPACE, BT709_COLOURSPACE\nimport OpenImageIO as oiio\nfrom colour.colorimetry import CMFS, ILLUMINANTS\nfrom colour.models import eotf_BT1886\n\n\n# 自作ライブラリのインポート\nimport TyImageIO as tyio\nimport transfer_functions as tf\nimport plot_utility as pu\nimport test_pattern_generator2 as tpg\nimport color_space as cs\n\nsrc_exr = \"./img/SMPTE ST2084_ITU-R BT.2020_D65_1920x1080_rev03_type1.exr\"\ndst_exr = \"./img/SMPTE ST2084_ITU-R BT.2020_D65_1920x1080_rev03_type1_c.exr\"\nafter_3dlut_exr = \"./img/after_3dlut_with_pq_oetf.exr\"\nsdr_eotf = tf.SRGB\n\nCMFS_NAME = 'CIE 1931 2 Degree Standard Observer'\nD65_WHITE = ILLUMINANTS[CMFS_NAME]['D65']\nUNIVERSAL_COLOR_LIST = [\"#F6AA00\", \"#FFF100\", \"#03AF7A\",\n \"#005AFF\", \"#4DC4FF\", \"#804000\"]\nst_pos_h = 57\nst_pos_v = 289\nh_sample = 1024\n\n\ndef dump_attr(fname, attr):\n print(\"attr data of {} is as follows.\".format(fname))\n print(attr)\n\n\ndef dump_img_info(img):\n print(\"shape: \", img.shape)\n print(\"dtype: \", img.dtype)\n print(\"min: \", np.min(img))\n print(\"max: \", np.max(img))\n\n\ndef correct_pq_exr_gain():\n \"\"\"\n exrファイルだと PQ のピークが 100.0 なので\n 1.0 になるように正規化する。\n \"\"\"\n reader = tyio.TyReader(src_exr)\n img = reader.read()\n dump_attr(src_exr, reader.get_attr())\n dump_img_info(img)\n writer = tyio.TyWriter(img / 100.0, dst_exr)\n writer.write(out_img_type_desc=oiio.FLOAT)\n\n\ndef check_after_3dlut_exr():\n \"\"\"\n 3DLUT通過後のデータを確認\n \"\"\"\n reader = tyio.TyReader(after_3dlut_exr)\n img = reader.read()\n dump_attr(after_3dlut_exr, reader.get_attr())\n dump_img_info(img)\n\n\ndef plot_eetf(eetf):\n \"\"\"\n EETF のプロット\n \"\"\"\n x = np.linspace(0, 1, h_sample)\n y_simulation = youtube_tonemapping(x, 400, 1000)\n y = eetf[st_pos_v, st_pos_h:st_pos_h+h_sample, 1]\n ax1 = pu.plot_1_graph(\n fontsize=20,\n figsize=(10, 8),\n graph_title=\"Tone Mapping Characteristics\",\n graph_title_size=None,\n xlabel=\"ST2084 Code Value\",\n ylabel=\"ST2084 Code Value\",\n axis_label_size=None,\n legend_size=17,\n xtick_size=19,\n ytick_size=19,\n xlim=None,\n ylim=None,\n xtick=[0.1 * x for x in range(11)],\n ytick=[0.05 * x for x in range(11)],\n linewidth=8,\n minor_xtick_num=None,\n minor_ytick_num=None)\n # ax1.set_xscale('log', basex=10.0)\n # ax1.set_yscale('log', basey=10.0)\n # ax1.plot(x_luminance, y_luminance, 'o', label=\"YouTube HDR to SDR EETF\")\n ax1.plot(x, y, '-', label=\"Estimated EETF\")\n # ax1.plot(x, y_18, '-', label=\"18% gray to 100% white\")\n ax1.plot(x, y_simulation, '-', label=\"Estimated Formula\",\n lw=3.5)\n # x_val = [1.0 * (10 ** (x - 4)) for x in range(9)]\n # x_caption = [r\"$10^{{{}}}$\".format(x - 4) for x in range(9)]\n # plt.xticks(x_val, x_caption)\n # y_caption = [r\"$10^{{{}}}$\".format(x - 4) for x in range(9)]\n # y_val = [1.0 * (10 ** (x - 4)) for x in range(9)]\n # plt.yticks(y_val, y_caption)\n plt.legend(loc='upper left')\n plt.savefig(\n \"./blog_img/eetf_codevalue_with_approximation.png\",\n bbox_inches='tight', pad_inches=0.1)\n plt.show()\n\n\ndef plot_eetf_luminance(eetf):\n \"\"\"\n EETF のプロットを輝度値ベースで\n \"\"\"\n img = cv2.imread(\"./img/youtubed_sdr_tp.png\")\n y_ref = ((img[3, :, 1] / 255.0) ** 2.4) * 100\n x = np.linspace(0, 1, h_sample)\n y_simulation = youtube_tonemapping(x, 400, 1000)\n y = eetf[st_pos_v, st_pos_h:st_pos_h+h_sample, 1]\n y_sim_luminance = tf.eotf_to_luminance(y_simulation, tf.ST2084)\n y_luminance = tf.eotf_to_luminance(y, tf.ST2084)\n x_luminance = tf.eotf_to_luminance(x, tf.ST2084)\n ax1 = pu.plot_1_graph(\n fontsize=20,\n figsize=(10, 8),\n graph_title=\"Tone Mapping Characteristics\",\n graph_title_size=None,\n xlabel=\"Luminance [cd/m2]\",\n ylabel=\"Luminance [cd/m2]\",\n axis_label_size=None,\n legend_size=17,\n xtick_size=19,\n ytick_size=19,\n xlim=(-75, 1200),\n ylim=(-5, 105),\n xtick=[x * 100 for x in range(13)],\n ytick=[x * 10 for x in range(11)],\n linewidth=8,\n minor_xtick_num=None,\n minor_ytick_num=None)\n # ax1.set_xscale('log', basex=10.0)\n # ax1.set_yscale('log', basey=10.0)\n # ax1.plot(x_luminance, y_luminance, 'o', label=\"YouTube HDR to SDR EETF\")\n ax1.plot(x_luminance, y_luminance, '-', label=\"Estimated EETF\")\n ax1.plot(x_luminance, y_sim_luminance, '-', label=\"Estimated Formula\",\n lw=3.5)\n # ax1.plot(x_luminance, y_ref, 'o', label=\"youtube\")\n # x_val = [1.0 * (10 ** (x - 4)) for x in range(9)]\n # x_caption = [r\"$10^{{{}}}$\".format(x - 4) for x in range(9)]\n # plt.xticks(x_val, x_caption)\n # y_caption = [r\"$10^{{{}}}$\".format(x - 4) for x in range(9)]\n # y_val = [1.0 * (10 ** (x - 4)) for x in range(9)]\n # plt.yticks(y_val, y_caption)\n plt.legend(loc='upper left')\n plt.savefig(\n \"./blog_img/eetf_luminance_with_approximation.png\",\n bbox_inches='tight', pad_inches=0.1)\n plt.show()\n\n\ndef dump_eetf_info(eetf):\n \"\"\"\n 18% Gray, 100% White などの情報をダンプする\n \"\"\"\n\n x_18_gray = tf.oetf_from_luminance(18.0, tf.ST2084)\n x_100_white = tf.oetf_from_luminance(100.0, tf.ST2084)\n x_ref_white = tf.oetf_from_luminance(250.0, tf.ST2084)\n x_18_idx = int(np.round(x_18_gray * 1023))\n x_100_idx = int(np.round(x_100_white * 1023))\n x_ref_idx = int(np.round(x_ref_white * 1023))\n print(x_18_gray, x_100_white, x_ref_white)\n print(x_18_idx, x_100_idx, x_ref_idx)\n y = eetf[st_pos_v, st_pos_h:st_pos_h+h_sample, 1]\n print(\"18 Gray = {}\".format(y[x_18_idx]))\n print(\"100 white = {}\".format(y[x_100_idx]))\n print(\"250 white = {}\".format(y[x_ref_idx]))\n a = (y[x_100_idx] - y[x_18_idx]) / (x_100_white - x_18_gray)\n b = a * -x_18_gray + y[x_18_idx]\n print(a)\n print(b)\n a = 0.74\n b = a * -x_100_white + y[x_100_idx]\n print(a)\n print(b)\n print(tf.eotf_to_luminance(0.0117522745451, tf.ST2084))\n print(tf.eotf_to_luminance(0.3877303064680016, tf.ST2084))\n\n\ndef conv_hdr10_to_sdr_using_formula(\n in_name=\"./img/test_src_for_youtube_upload_riku.tif\"):\n out_name_body = os.path.basename(os.path.splitext(in_name)[0])\n out_name = \"./blog_img/{}.png\".format(out_name_body)\n img = cv2.imread(\n in_name, cv2.IMREAD_ANYDEPTH | cv2.IMREAD_COLOR)[:, :, ::-1] / 0xFFFF\n\n img = youtube_tonemapping(img)\n img_linear = tf.eotf_to_luminance(img, tf.ST2084) / 100\n img_linear = RGB_to_RGB(img_linear, BT2020_COLOURSPACE, BT709_COLOURSPACE)\n img_linear = np.clip(img_linear, 0.0, 1.0)\n img = tf.oetf(img_linear, tf.GAMMA24)\n img = np.uint8(np.round(img * 0xFF))\n cv2.imwrite(out_name, img[:, :, ::-1])\n\n\ndef analyze_eetf():\n reader = tyio.TyReader(after_3dlut_exr)\n img = reader.read()\n # img_after_sdr_eotf = tf.eotf(img, sdr_eotf)\n img_after_sdr_eotf = img ** 2.4\n # img_after_sdr_eotf = eotf_BT1886(img, L_B=1/2000)\n img_after_pq_oetf = tf.oetf(img_after_sdr_eotf / 100, tf.ST2084)\n eetf = img_after_pq_oetf\n # dump_eetf_info(eetf)\n # plot_eetf(eetf)\n # plot_eetf_luminance(eetf)\n # plot_apply_eetf_luminance()\n # plot_apply_eetf_code_value()\n conv_hdr10_to_sdr_using_formula(\n in_name=\"./img/test_src_for_youtube_upload_riku.tif\")\n conv_hdr10_to_sdr_using_formula(\n in_name=\"./img/test_src_for_youtube_upload_umi.tif\")\n conv_hdr10_to_sdr_using_formula(\n in_name=\"./img/test_tp_image_hdr10_tp.tif\")\n conv_hdr10_to_sdr_using_formula(\n in_name=\"./img/test_gamut_tp_1000nits.tif\")\n\n\ndef spline_example():\n data = [[0.5, 0.5], [0.8, 1.0], [1.0, 1.0]]\n func = get_top_side_bezier(data)\n x = np.linspace(data[0][0], data[2][0], 256)\n y = func(x)\n ax1 = pu.plot_1_graph(\n fontsize=20,\n figsize=(12, 10),\n graph_title=\"interpolation\",\n graph_title_size=None,\n xlabel=None,\n ylabel=None,\n axis_label_size=None,\n legend_size=17,\n xlim=None,\n ylim=None,\n xtick=None,\n ytick=None,\n linewidth=3,\n minor_xtick_num=None,\n minor_ytick_num=None)\n ax1.plot(x, y, 'o', label=\"Original Sample\")\n # ax1.plot(x2, y2_linear, '-', label=\"linear interpolation\")\n # ax1.plot(x2, y2_cubic, '-', label=\"cubic interpolation\")\n plt.legend(loc='upper left')\n # plt.savefig(\"./blog_img/eetf.png\", bbox_inches='tight', pad_inches=0.1)\n plt.show()\n\n\ndef get_top_side_bezier(param=[[0.6, 0.7], [0.8, 1.0], [1.0, 1.0]]):\n \"\"\"\n Note\n ----\n An example of ```top_param``` is bellow.\n {'x0': 0.5, 'y0': 0.5,\n 'x1': 0.7, 'y1': 0.7,\n 'x2': 1.0, 'y2': 0.7}\n \"\"\"\n a_val = param[0][0]\n b_val = param[1][0]\n c_val = param[2][0]\n p_val = param[0][1]\n q_val = param[1][1]\n r_val = param[2][1]\n\n a, b, c, t, x = symbols('a, b, c, t, x')\n f = (1 - t)**2 * a + 2 * (1 - t) * t * b + t**2 * c - x\n\n # x について解く\n # ----------------------\n t = solve(f, t)[1]\n t = t.subs({a: a_val, b: b_val, c: c_val})\n\n # y と t(ここでは u と置いた) の関係式を記述\n # -------------------------------------------\n p, q, r, u, y = symbols('p, q, r, u, y')\n y = (1 - u)**2 * p + 2 * (1 - u) * u * q + u**2 * r\n\n # パラメータ u と事前に求めた t で置き換える\n # -------------------------------------------\n y = y.subs({p: p_val, q: q_val, r: r_val, u: t})\n\n func = lambdify(x, y, 'numpy')\n\n return func\n\n\ndef youtube_linear(x):\n return 0.74 * x + 0.01175\n\n\ndef youtube_tonemapping(x, ks_luminance=400, ke_luminance=1000):\n \"\"\"\n YouTube の HDR to SDR のトーンマップを模倣してみる。\n 中間階調までは直線で、高階調部だけ2次ベジェ曲線で丸める。\n\n 直線の数式は $y = 0.74x + 0.01175$。\n y軸の最大値は 0.508078421517 (100nits)。\n この時の x は $x = (0.508078421517 - 0.01175) / 0.74$ より\n 0.6707140831310812 。ちなみに、リニアなら 473.5 nits。\n\n ks は knee start の略。ke は knee end.\n \"\"\"\n ks_x = tf.oetf_from_luminance(ks_luminance, tf.ST2084)\n ks_y = youtube_linear(ks_x)\n ke_x = tf.oetf_from_luminance(ke_luminance, tf.ST2084)\n ke_y = tf.oetf_from_luminance(100, tf.ST2084)\n mid_x = 0.6707140831310812\n mid_y = ke_y\n bezie = get_top_side_bezier([[ks_x, ks_y], [mid_x, mid_y], [ke_x, ke_y]])\n y = np.select(\n (x < ks_x, x <= ke_x, x > ke_x),\n (youtube_linear(x), bezie(x), ke_y))\n\n return y\n\n\ndef test_plot_youtube_tonemapping(ks_luminance=400, ke_luminance=1000):\n x = np.linspace(0, 1, 1024)\n y = youtube_tonemapping(x, ks_luminance, ke_luminance)\n ax1 = pu.plot_1_graph(\n fontsize=20,\n figsize=(12, 10),\n graph_title=\"Tone mapping characteristics\",\n graph_title_size=None,\n xlabel=\"ST2084 Code Value\",\n ylabel=\"ST2084 Code Value\",\n axis_label_size=None,\n legend_size=17,\n xlim=None,\n ylim=None,\n xtick=None,\n ytick=None,\n linewidth=3,\n minor_xtick_num=None,\n minor_ytick_num=None)\n ax1.plot(x, y, 'o', label=\"emulation\")\n plt.legend(loc='upper left')\n plt.show()\n\n\ndef get_xyY_from_csv(fname=\"./data/bt2020_xyY_data.csv\"):\n data_all = np.loadtxt(fname, delimiter=\",\", skiprows=1).T\n hue_num = len(data_all[1:]) // 3 # 3 is r, g, b.\n data = data_all[1:]\n xyY_all = []\n for h_idx in range(hue_num):\n xyY = np.dstack((data[h_idx*3], data[h_idx*3+1], data[h_idx*3+2]))\n xyY_all.append(xyY)\n\n xyY_all = np.array(xyY_all)\n\n return xyY_all\n\n\ndef make_src_test_pattern(xyY, pixel_num):\n large_xyz = xyY_to_XYZ(xyY)\n xyz_to_rgb_mtx = BT2020_COLOURSPACE.XYZ_to_RGB_matrix\n rgb_linear = XYZ_to_RGB(large_xyz, D65_WHITE, D65_WHITE, xyz_to_rgb_mtx)\n rgb_linear[rgb_linear < 0] = 0.0\n rgb_pq = tf.oetf_from_luminance(rgb_linear * 1000, tf.ST2084)\n rgb_seq = rgb_pq.reshape((1, pixel_num, 3))\n img = np.zeros((1080, 1920, 3), dtype=np.uint16)\n rgb_seq_16bit = np.uint16(np.round(rgb_seq * 0xFFFF))\n img[0, :pixel_num, :] = rgb_seq_16bit\n cv2.imwrite(\"./img/gamut_check_src.tiff\", img[:, :, ::-1])\n\n\ndef restore_dst_test_pattern(fname, pixel_num):\n img = cv2.imread(fname, cv2.IMREAD_ANYDEPTH | cv2.IMREAD_COLOR)[:, :, ::-1]\n rgb_pq = img[0, :pixel_num, :] / 0xFFFF\n rgb_linear = tf.eotf(rgb_pq, tf.GAMMA24)\n rgb_to_xyz_mtx = BT709_COLOURSPACE.RGB_to_XYZ_matrix\n large_xyz = RGB_to_XYZ(rgb_linear, D65_WHITE, D65_WHITE, rgb_to_xyz_mtx)\n xyY = XYZ_to_xyY(large_xyz)\n return xyY\n\n\ndef analyze_gamut_mapping():\n hdr_xyY = get_xyY_from_csv(fname=\"./data/bt2020_xyY_data.csv\")\n pixel_num = hdr_xyY.shape[0] * hdr_xyY.shape[1] * hdr_xyY.shape[2]\n make_src_test_pattern(hdr_xyY, pixel_num)\n sdr_xyY = restore_dst_test_pattern(\n fname=\"./img/gamut_check_dst.tif\", pixel_num=pixel_num)\n plot_xy_move(hdr_xyY.reshape((pixel_num, 3)), sdr_xyY)\n plot_simple_xy_move(hdr_xyY.reshape((pixel_num, 3)), None)\n\n\ndef plot_xy_move(src_xyY, dst_xyY, xmin=0.0, xmax=0.8, ymin=0.0, ymax=0.9):\n \"\"\"\n src は HDR時の xyY, dst は SDR変換後 の xyY.\n \"\"\"\n xy_image = tpg.get_chromaticity_image(\n xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax)\n cmf_xy = tpg._get_cmfs_xy()\n xlim = (min(0, xmin), max(0.8, xmax))\n ylim = (min(0, ymin), max(0.9, ymax))\n figsize_h = 8 * 1.0\n figsize_v = 9 * 1.0\n rate = 1.3\n # gamut の用意\n outer_gamut = np.array(tpg.get_primaries(cs.BT2020)[0])\n inner_gamut = np.array(tpg.get_primaries(cs.BT709)[0])\n outer_name = 'ITR-R BT.2020'\n inner_name = 'ITR-R BT.709'\n ax1 = pu.plot_1_graph(fontsize=20 * rate,\n figsize=(figsize_h, figsize_v),\n graph_title=\"CIE1931 Chromaticity Diagram\",\n xlabel=None, ylabel=None,\n legend_size=18 * rate,\n xlim=xlim, ylim=ylim,\n xtick=[x * 0.1 + xmin for x in\n range(int((xlim[1] - xlim[0])/0.1) + 1)],\n ytick=[x * 0.1 + ymin for x in\n range(int((ylim[1] - ylim[0])/0.1) + 1)],\n xtick_size=17 * rate,\n ytick_size=17 * rate,\n linewidth=4 * rate,\n minor_xtick_num=2, minor_ytick_num=2)\n ax1.plot(cmf_xy[..., 0], cmf_xy[..., 1], '-k', lw=3.5*rate, label=None)\n ax1.plot((cmf_xy[-1, 0], cmf_xy[0, 0]), (cmf_xy[-1, 1], cmf_xy[0, 1]),\n '-k', lw=3.5*rate, label=None)\n ax1.plot(inner_gamut[:, 0], inner_gamut[:, 1],\n c=UNIVERSAL_COLOR_LIST[0], label=inner_name, lw=2.75*rate)\n ax1.plot(outer_gamut[:, 0], outer_gamut[:, 1],\n c=UNIVERSAL_COLOR_LIST[3], label=outer_name, lw=2.75*rate)\n ax1.plot(tpg.D65_WHITE[0], tpg.D65_WHITE[1], 'x', c='k',\n lw=2.75*rate, label='D65', ms=10*rate, mew=2.75*rate)\n ax1.plot(src_xyY[..., 0], src_xyY[..., 1], ls='', marker='o',\n c='#000000', ms=5.5*rate, label=\"Before\")\n ax1.plot(dst_xyY[..., 0], dst_xyY[..., 1], ls='', marker='+',\n c='#808080', ms=10*rate, mew=2.0*rate,\n label=\"After\")\n # annotation\n arrowprops = dict(\n facecolor='#333333', shrink=0.0, headwidth=6, headlength=8,\n width=1)\n src_xyY = src_xyY.reshape((18, 8, 3))\n dst_xyY = dst_xyY.reshape((18, 8, 3))\n for h_idx in range(18):\n for s_idx in range(8):\n if s_idx < 4:\n continue\n ed_pos = (dst_xyY[h_idx][s_idx][0],\n dst_xyY[h_idx][s_idx][1])\n st_pos = (src_xyY[h_idx][s_idx][0],\n src_xyY[h_idx][s_idx][1])\n ax1.annotate(\"\", xy=ed_pos, xytext=st_pos, xycoords='data',\n textcoords='data', ha='left', va='bottom',\n arrowprops=arrowprops)\n\n # for s_idx in range(src_xyY.shape[0]):\n # ed_pos = (dst_xyY[s_idx][0],\n # dst_xyY[s_idx][1])\n # st_pos = (src_xyY[s_idx][0],\n # src_xyY[s_idx][1])\n # ax1.annotate(\"\", xy=ed_pos, xytext=st_pos, xycoords='data',\n # textcoords='data', ha='left', va='bottom',\n # arrowprops=arrowprops)\n\n ax1.imshow(xy_image, extent=(xmin, xmax, ymin, ymax))\n plt.legend(loc='upper right', fontsize=14 * rate)\n png_file_name = \"./blog_img/xyY_plot_hdr_to_sdr.png\"\n plt.savefig(png_file_name, bbox_inches='tight')\n plt.show()\n\n\ndef plot_simple_xy_move(\n src_xyY, dst_xyY, xmin=0.0, xmax=0.8, ymin=0.0, ymax=0.9):\n \"\"\"\n 3x3 の Matrix で単純な色域変換をした場合の xy平面でのズレのプロット。\n \"\"\"\n rgb_2020 = XYZ_to_RGB(xyY_to_XYZ(src_xyY), D65_WHITE, D65_WHITE,\n BT2020_COLOURSPACE.XYZ_to_RGB_matrix)\n rgb_2020[rgb_2020 < 0] = 0\n rgb_pq = tf.oetf(rgb_2020 * 0.1, tf.ST2084)\n rgb_pq = youtube_tonemapping(rgb_pq)\n rgb_2020 = tf.eotf(rgb_pq, tf.ST2084)\n rgb_709 = RGB_to_RGB(rgb_2020, BT2020_COLOURSPACE, BT709_COLOURSPACE)\n rgb_709 = np.clip(rgb_709, 0.0, 1.0)\n dst_xyY = XYZ_to_xyY(RGB_to_XYZ(rgb_709, D65_WHITE, D65_WHITE,\n BT709_COLOURSPACE.RGB_to_XYZ_matrix))\n xy_image = tpg.get_chromaticity_image(\n xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax)\n cmf_xy = tpg._get_cmfs_xy()\n xlim = (min(0, xmin), max(0.8, xmax))\n ylim = (min(0, ymin), max(0.9, ymax))\n figsize_h = 8 * 1.0\n figsize_v = 9 * 1.0\n rate = 1.3\n # gamut の用意\n outer_gamut = np.array(tpg.get_primaries(cs.BT2020)[0])\n inner_gamut = np.array(tpg.get_primaries(cs.BT709)[0])\n outer_name = 'ITR-R BT.2020'\n inner_name = 'ITR-R BT.709'\n ax1 = pu.plot_1_graph(fontsize=20 * rate,\n figsize=(figsize_h, figsize_v),\n graph_title=\"CIE1931 Chromaticity Diagram\",\n xlabel=None, ylabel=None,\n legend_size=18 * rate,\n xlim=xlim, ylim=ylim,\n xtick=[x * 0.1 + xmin for x in\n range(int((xlim[1] - xlim[0])/0.1) + 1)],\n ytick=[x * 0.1 + ymin for x in\n range(int((ylim[1] - ylim[0])/0.1) + 1)],\n xtick_size=17 * rate,\n ytick_size=17 * rate,\n linewidth=4 * rate,\n minor_xtick_num=2, minor_ytick_num=2)\n ax1.plot(cmf_xy[..., 0], cmf_xy[..., 1], '-k', lw=3.5*rate, label=None)\n ax1.plot((cmf_xy[-1, 0], cmf_xy[0, 0]), (cmf_xy[-1, 1], cmf_xy[0, 1]),\n '-k', lw=3.5*rate, label=None)\n ax1.plot(inner_gamut[:, 0], inner_gamut[:, 1],\n c=UNIVERSAL_COLOR_LIST[0], label=inner_name, lw=2.75*rate)\n ax1.plot(outer_gamut[:, 0], outer_gamut[:, 1],\n c=UNIVERSAL_COLOR_LIST[3], label=outer_name, lw=2.75*rate)\n ax1.plot(tpg.D65_WHITE[0], tpg.D65_WHITE[1], 'x', c='k',\n lw=2.75*rate, label='D65', ms=10*rate, mew=2.75*rate)\n ax1.plot(src_xyY[..., 0], src_xyY[..., 1], ls='', marker='o',\n c='#000000', ms=5.5*rate, label=\"Before\")\n ax1.plot(dst_xyY[..., 0], dst_xyY[..., 1], ls='', marker='+',\n c='#808080', ms=10*rate, mew=2.0*rate,\n label=\"After\")\n # annotation\n arrowprops = dict(\n facecolor='#333333', shrink=0.0, headwidth=6, headlength=8,\n width=1)\n src_xyY = src_xyY.reshape((18, 8, 3))\n dst_xyY = dst_xyY.reshape((18, 8, 3))\n for h_idx in range(18):\n for s_idx in range(8):\n if s_idx < 3:\n continue\n ed_pos = (dst_xyY[h_idx][s_idx][0],\n dst_xyY[h_idx][s_idx][1])\n st_pos = (src_xyY[h_idx][s_idx][0],\n src_xyY[h_idx][s_idx][1])\n ax1.annotate(\"\", xy=ed_pos, xytext=st_pos, xycoords='data',\n textcoords='data', ha='left', va='bottom',\n arrowprops=arrowprops)\n\n ax1.imshow(xy_image, extent=(xmin, xmax, ymin, ymax))\n plt.legend(loc='upper right', fontsize=14 * rate)\n png_file_name = \"./blog_img/xyY_plot_simple_mtx_conv.png\"\n plt.savefig(png_file_name, bbox_inches='tight')\n plt.show()\n\n\ndef plot_apply_eetf_code_value():\n \"\"\"\n 推測したEETFを実際に適用して合っているか確認する。\n \"\"\"\n st_h = 115\n st_v = 563\n ed_h = st_h + 2048\n\n img_youtube = cv2.imread(\"./img/youtubed_sdr_tp_all.png\")\n img_src = cv2.imread(\"./img/youtubed_sdr_src.tiff\",\n cv2.IMREAD_ANYDEPTH | cv2.IMREAD_COLOR)[:, :, ::-1]\n x = np.arange(2048) / 2.0 / 1023.0\n x_src = img_src[st_v, st_h:ed_h, 1] / 65535.0\n y_ref = tf.oetf_from_luminance(\n ((img_youtube[st_v, st_h:ed_h, 1] / 255.0) ** 2.4) * 100, tf.ST2084)\n y_formula = youtube_tonemapping(x_src)\n ax1 = pu.plot_1_graph(\n fontsize=20,\n figsize=(10, 8),\n graph_title=\"Tone Mapping Characteristics\",\n graph_title_size=None,\n xlabel=\"ST2084 Code Value\",\n ylabel=\"Luminance [cd/m2]\",\n axis_label_size=None,\n legend_size=17,\n xtick_size=19,\n ytick_size=19,\n xlim=None,\n ylim=None,\n xtick=None,\n ytick=None,\n linewidth=8,\n minor_xtick_num=None,\n minor_ytick_num=None)\n ax1.plot(x, y_ref, label='ref')\n ax1.plot(x, y_formula, label='formula')\n plt.legend(loc='upper left')\n plt.savefig(\n \"./blog_img/check_estimated_formula_code_value.png\",\n bbox_inches='tight', pad_inches=0.1)\n plt.show()\n\n\ndef plot_apply_eetf_luminance():\n \"\"\"\n 推測したEETFを実際に適用して合っているか確認する。\n \"\"\"\n st_h = 115\n st_v = 563\n ed_h = st_h + 2048\n\n img_youtube = cv2.imread(\"./img/youtubed_sdr_tp_all.png\")\n img_src = cv2.imread(\"./img/youtubed_sdr_src.tiff\",\n cv2.IMREAD_ANYDEPTH | cv2.IMREAD_COLOR)[:, :, ::-1]\n x = np.arange(2048) / 2.0\n x_src = img_src[st_v, st_h:ed_h, 1] / 65535.0\n y_ref = img_youtube[st_v, st_h:ed_h, 1] / 255.0\n y_eetf = youtube_tonemapping(x_src)\n y_formula = tf.oetf_from_luminance(\n tf.eotf_to_luminance(y_eetf, tf.ST2084), tf.GAMMA24)\n ax1 = pu.plot_1_graph(\n fontsize=20,\n figsize=(10, 8),\n graph_title=\"Tone Mapping Characteristics\",\n graph_title_size=None,\n xlabel=\"Luminance [cd/m2]\",\n ylabel=\"Luminance [cd/m2]\",\n axis_label_size=None,\n legend_size=17,\n xtick_size=19,\n ytick_size=19,\n xlim=None,\n ylim=None,\n xtick=None,\n ytick=None,\n linewidth=8,\n minor_xtick_num=None,\n minor_ytick_num=None)\n ax1.plot(x, y_ref, label='ref')\n ax1.plot(x, y_formula, label='formula')\n plt.legend(loc='upper left')\n plt.savefig(\n \"./blog_img/check_estimated_formula_luinance.png\",\n bbox_inches='tight', pad_inches=0.1)\n plt.show()\n\n\ndef main_func():\n # correct_pq_exr_gain()\n # check_after_3dlut_exr()\n analyze_eetf()\n # analyze_gamut_mapping()\n # x = np.linspace(0, 1, 1024)\n # plt.plot(x, eotf_BT1886(x, L_B=0.0), label=\"zero\")\n # plt.plot(x, eotf_BT1886(x, L_B=1/1000), label=\"1/1000\")\n # plt.show()\n\n\nif __name__ == '__main__':\n os.chdir(os.path.dirname(os.path.abspath(__file__)))\n main_func()\n"
] |
[
[
"matplotlib.pyplot.legend",
"numpy.linspace",
"numpy.rad2deg",
"numpy.round",
"numpy.max",
"numpy.hstack",
"numpy.ones_like",
"numpy.clip",
"numpy.sin",
"scipy.interpolate.interp1d",
"numpy.argmax",
"matplotlib.pyplot.close",
"numpy.zeros",
"matplotlib.pyplot.savefig",
"numpy.tan",
"numpy.deg2rad",
"numpy.array",
"numpy.sum",
"numpy.cos",
"numpy.dstack",
"numpy.ones",
"numpy.vstack"
],
[
"numpy.linspace",
"numpy.clip",
"numpy.dstack",
"numpy.round",
"numpy.meshgrid"
],
[
"matplotlib.pyplot.legend",
"numpy.linspace",
"numpy.clip",
"numpy.min",
"numpy.arange",
"matplotlib.pyplot.savefig",
"numpy.dstack",
"numpy.round",
"numpy.max",
"numpy.array",
"matplotlib.pyplot.show",
"numpy.zeros",
"numpy.loadtxt"
]
] |
nelimee/qtoolkit
|
[
"1e99bd7d3a143a327c3bb92595ea88ec12dbdb89",
"1e99bd7d3a143a327c3bb92595ea88ec12dbdb89"
] |
[
"tests/maths/matrix/su2/transformations.py",
"qtoolkit/maths/matrix/su2/transformations.py"
] |
[
"# ======================================================================\n# Copyright CERFACS (October 2018)\n# Contributor: Adrien Suau (adrien.suau@cerfacs.fr)\n#\n# This software is governed by the CeCILL-B license under French law and\n# abiding by the rules of distribution of free software. You can use,\n# modify and/or redistribute the software under the terms of the\n# CeCILL-B license as circulated by CEA, CNRS and INRIA at the following\n# URL \"http://www.cecill.info\".\n#\n# As a counterpart to the access to the source code and rights to copy,\n# modify and redistribute granted by the license, users are provided\n# only with a limited warranty and the software's author, the holder of\n# the economic rights, and the successive licensors have only limited\n# liability.\n#\n# In this respect, the user's attention is drawn to the risks associated\n# with loading, using, modifying and/or developing or reproducing the\n# software by the user in light of its specific status of free software,\n# that may mean that it is complicated to manipulate, and that also\n# therefore means that it is reserved for developers and experienced\n# professionals having in-depth computer knowledge. Users are therefore\n# encouraged to load and test the software's suitability as regards\n# their requirements in conditions enabling the security of their\n# systems and/or data to be ensured and, more generally, to use and\n# operate it in the same conditions as regards security.\n#\n# The fact that you are presently reading this means that you have had\n# knowledge of the CeCILL-B license and that you accept its terms.\n# ======================================================================\n\n\"\"\"Tests for the transformation.py file.\"\"\"\n\nimport typing\nimport unittest\n\nimport numpy\nimport scipy\n\nimport qtoolkit.maths.matrix.generation.su2 as gen_su2\nimport qtoolkit.maths.matrix.generation.unitary as gen_unitary\nimport qtoolkit.maths.matrix.su2.transformations as trans\nimport qtoolkit.maths.random as rand\nimport qtoolkit.utils.constants.matrices as mconsts\nimport qtoolkit.utils.constants.others as other_consts\nimport tests.qtestcase as qtest\n\n\nclass TransformationsSU2SO3TestCase(qtest.QTestCase):\n \"\"\"Tests for the transformations between SO(3) and SU(2).\"\"\"\n\n def test_su2_to_so3_identity(self) -> None:\n \"\"\"Tests su2_to_so3 for multiples of the identity matrix.\"\"\"\n # expected_coefficients = numpy.array([2 * numpy.pi, 0.0, 0.0])\n # for coefficient in numpy.linspace(-1, 1, 100):\n # result = trans.su2_to_so3(coefficient * mconsts.IDENTITY_2X2)\n # self.assert2NormClose(expected_coefficients, result)\n pass\n\n def test_su2_to_so3_pauli_x(self) -> None:\n \"\"\"Tests su2_to_so3 for the Pauli X matrix.\"\"\"\n expected_coefficients = numpy.array([1.0, 0.0, 0.0])\n result = trans.su2_to_so3(scipy.linalg.expm(-1.j * mconsts.P_X / 2))\n self.assert2NormClose(expected_coefficients, result)\n\n def test_su2_to_so3_pauli_y(self) -> None:\n \"\"\"Tests su2_to_so3 for the Pauli Y matrix.\"\"\"\n expected_coefficients = numpy.array([0.0, 1.0, 0.0])\n result = trans.su2_to_so3(scipy.linalg.expm(-1.j * mconsts.P_Y / 2))\n self.assert2NormClose(expected_coefficients, result)\n\n def test_su2_to_so3_pauli_z(self) -> None:\n \"\"\"Tests su2_to_so3 for the Pauli Z matrix.\"\"\"\n expected_coefficients = numpy.array([0.0, 0.0, 1.0])\n result = trans.su2_to_so3(scipy.linalg.expm(-1.j * mconsts.P_Z / 2))\n self.assert2NormClose(expected_coefficients, result)\n\n def test_so3_to_su2_all_zero(self) -> None:\n \"\"\"Tests so3_to_su2 for a zero SO(3) vector.\"\"\"\n matrix = trans.so3_to_su2(numpy.array([0.0, 0.0, 0.0]))\n self.assert2NormClose(matrix, matrix[0, 0] * numpy.identity(2))\n\n def test_so3_to_su2_pauli_x(self) -> None:\n \"\"\"Tests so3_to_su2 for a vector representing the Pauli X matrix.\"\"\"\n matrix = trans.so3_to_su2(numpy.array([1.0, 0.0, 0.0]))\n self.assert2NormClose(matrix, scipy.linalg.expm(-1.j * mconsts.P_X / 2))\n\n def test_so3_to_su2_pauli_y(self) -> None:\n \"\"\"Tests so3_to_su2 for a vector representing the Pauli Y matrix.\"\"\"\n matrix = trans.so3_to_su2(numpy.array([0.0, 1.0, 0.0]))\n self.assert2NormClose(matrix, scipy.linalg.expm(-1.j * mconsts.P_Y / 2))\n\n def test_so3_to_su2_pauli_z(self) -> None:\n \"\"\"Tests so3_to_su2 for a vector representing the Pauli Z matrix.\"\"\"\n matrix = trans.so3_to_su2(numpy.array([0.0, 0.0, 1.0]))\n self.assert2NormClose(matrix, scipy.linalg.expm(-1.j * mconsts.P_Z / 2))\n\n def test_so3_to_su2_to_so3_random(self) -> None:\n \"\"\"Tests X == su2_to_so3(so3_to_su2(X)) for random X.\"\"\"\n # Abort if we don't want random tests\n if not other_consts.USE_RANDOM_TESTS:\n return\n for idx in range(other_consts.RANDOM_SAMPLES):\n local_coefficients = numpy.random.rand(3)\n self.assert2NormClose(\n trans.su2_to_so3(trans.so3_to_su2(local_coefficients)),\n local_coefficients)\n\n def test_su2_to_so3_to_su2_random(self) -> None:\n \"\"\"Tests X == so3_to_su2(su2_to_so3(X)) for random X.\"\"\"\n # Abort if we don't want random tests\n if not other_consts.USE_RANDOM_TESTS:\n return\n for idx in range(other_consts.RANDOM_SAMPLES):\n local_su2 = gen_su2.generate_random_SU2_matrix()\n self.assert2NormClose(trans.so3_to_su2(trans.su2_to_so3(local_su2)),\n local_su2)\n\n\nclass TransformationsSU2HTestCase(qtest.QTestCase):\n \"\"\"Tests for the transformations between SU(2) and H (quaternions).\"\"\"\n\n def test_H_to_su2_identity(self) -> None:\n \"\"\"Tests H_to_su2 for the identity matrix.\"\"\"\n mat = trans.H_to_su2(numpy.array([1, 0, 0, 0]))\n self.assertOperatorNormClose(mat, mconsts.ID2_SU2)\n\n def test_H_to_su2_pauli_x(self) -> None:\n \"\"\"Tests H_to_su2 for the Pauli X matrix.\"\"\"\n mat = trans.H_to_su2(numpy.array([0, 1, 0, 0]))\n self.assertOperatorNormClose(mat, mconsts.P_X_SU2)\n\n def test_H_to_su2_pauli_y(self) -> None:\n \"\"\"Tests H_to_su2 for the Pauli Y matrix.\"\"\"\n mat = trans.H_to_su2(numpy.array([0, 0, 1, 0]))\n self.assertOperatorNormClose(mat, mconsts.P_Y_SU2)\n\n def test_H_to_su2_pauli_z(self) -> None:\n \"\"\"Tests H_to_su2 for the Pauli Z matrix.\"\"\"\n mat = trans.H_to_su2(numpy.array([0, 0, 0, 1]))\n self.assertOperatorNormClose(mat, mconsts.P_Z_SU2)\n\n def test_su2_to_H_identity(self) -> None:\n \"\"\"Tests su2_to_H for the identity matrix.\"\"\"\n quaternion = trans.su2_to_H(mconsts.ID2_SU2)\n self.assert2NormClose(quaternion, numpy.array([1, 0, 0, 0]))\n\n def test_su2_to_H_pauli_x(self) -> None:\n \"\"\"Tests su2_to_H for the Pauli X matrix.\"\"\"\n quaternion = trans.su2_to_H(mconsts.P_X_SU2)\n self.assert2NormClose(quaternion, numpy.array([0, 1, 0, 0]))\n\n def test_su2_to_H_pauli_y(self) -> None:\n \"\"\"Tests su2_to_H for the Pauli Y matrix.\"\"\"\n quaternion = trans.su2_to_H(mconsts.P_Y_SU2)\n self.assert2NormClose(quaternion, numpy.array([0, 0, 1, 0]))\n\n def test_su2_to_H_pauli_z(self) -> None:\n \"\"\"Tests su2_to_H for the Pauli Z matrix.\"\"\"\n quaternion = trans.su2_to_H(mconsts.P_Z_SU2)\n self.assert2NormClose(quaternion, numpy.array([0, 0, 0, 1]))\n\n def test_su2_to_H_to_su2_random(self) -> None:\n \"\"\"Tests X == H_to_su2(su2_to_H(X)) for random X.\"\"\"\n # Abort if we don't want random tests\n if not other_consts.USE_RANDOM_TESTS:\n return\n for idx in range(other_consts.RANDOM_SAMPLES):\n local_su2 = gen_su2.generate_random_SU2_matrix()\n self.assertOperatorNormClose(\n trans.H_to_su2(trans.su2_to_H(local_su2)), local_su2)\n\n def test_H_to_su2_to_H_random(self) -> None:\n \"\"\"Tests X == su2_to_H(H_to_su2(X)) for random X.\"\"\"\n # Abort if we don't want random tests\n if not other_consts.USE_RANDOM_TESTS:\n return\n for idx in range(other_consts.RANDOM_SAMPLES):\n quaternion = rand.generate_unit_norm_quaternion()\n self.assert2NormClose(trans.su2_to_H(trans.H_to_su2(quaternion)),\n quaternion)\n\n\nclass TransformationsSU2UnitTestCase(qtest.QTestCase):\n \"\"\"Tests for the transformations between SU(2) and unitary matrices.\"\"\"\n\n def test_unitary_to_su2_identity(self) -> None:\n \"\"\"Test validity of unitary_to_su2 for the identity matrix.\"\"\"\n self.assertOperatorNormClose(mconsts.ID2,\n trans.unitary_to_su2(mconsts.ID2))\n\n def test_unitary_to_su2_pauli_x(self) -> None:\n \"\"\"Test validity of unitary_to_su2 for the Pauli X matrix.\"\"\"\n self.assertOperatorNormClose(mconsts.P_X_SU2,\n trans.unitary_to_su2(mconsts.P_X))\n\n def test_unitary_to_su2_pauli_y(self) -> None:\n \"\"\"Test validity of unitary_to_su2 for the Pauli Y matrix.\"\"\"\n self.assertOperatorNormClose(mconsts.P_Y_SU2,\n trans.unitary_to_su2(mconsts.P_Y))\n\n def test_unitary_to_su2_pauli_z(self) -> None:\n \"\"\"Test validity of unitary_to_su2 for the Pauli Z matrix.\"\"\"\n self.assertOperatorNormClose(mconsts.P_Z_SU2,\n trans.unitary_to_su2(mconsts.P_Z))\n\n def test_unitary_to_su2_repeated_random(self) -> None:\n \"\"\"Test that repetition of unitary_to_su2 has no effect.\"\"\"\n # Abort if we don't want random tests\n if not other_consts.USE_RANDOM_TESTS:\n return\n\n ReturnType = typing.TypeVar(\"ReturnType\")\n\n def repeat_func(f: typing.Callable[[ReturnType], ReturnType], n: int,\n args: ReturnType) -> ReturnType:\n for i in range(n):\n args = f(args)\n return args\n\n for idx in range(other_consts.RANDOM_SAMPLES):\n unitary = gen_unitary.generate_random_unitary_matrix()\n # We will repeat the application of unitary_to_su2 up to 6 times.\n # 6 has been arbitrarily chosen.\n su2_matrix = trans.unitary_to_su2(unitary)\n for i in range(6):\n self.assertOperatorNormClose(\n repeat_func(trans.unitary_to_su2, i, su2_matrix),\n su2_matrix)\n\n def test_unitary_to_su2_random(self) -> None:\n \"\"\"Tests det(unitary_to_su2(X)) == 1 for random unitary X.\"\"\"\n # Abort if we don't want random tests\n if not other_consts.USE_RANDOM_TESTS:\n return\n for idx in range(other_consts.RANDOM_SAMPLES):\n unitary = gen_unitary.generate_random_unitary_matrix()\n self.assertAlmostEqual(\n numpy.linalg.det(trans.unitary_to_su2(unitary)), 1.0)\n\n\nif __name__ == '__main__':\n unittest.main()\n",
"# ======================================================================\n# Copyright CERFACS (October 2018)\n# Contributor: Adrien Suau (adrien.suau@cerfacs.fr)\n#\n# This software is governed by the CeCILL-B license under French law and\n# abiding by the rules of distribution of free software. You can use,\n# modify and/or redistribute the software under the terms of the\n# CeCILL-B license as circulated by CEA, CNRS and INRIA at the following\n# URL \"http://www.cecill.info\".\n#\n# As a counterpart to the access to the source code and rights to copy,\n# modify and redistribute granted by the license, users are provided\n# only with a limited warranty and the software's author, the holder of\n# the economic rights, and the successive licensors have only limited\n# liability.\n#\n# In this respect, the user's attention is drawn to the risks associated\n# with loading, using, modifying and/or developing or reproducing the\n# software by the user in light of its specific status of free software,\n# that may mean that it is complicated to manipulate, and that also\n# therefore means that it is reserved for developers and experienced\n# professionals having in-depth computer knowledge. Users are therefore\n# encouraged to load and test the software's suitability as regards\n# their requirements in conditions enabling the security of their\n# systems and/or data to be ensured and, more generally, to use and\n# operate it in the same conditions as regards security.\n#\n# The fact that you are presently reading this means that you have had\n# knowledge of the CeCILL-B license and that you accept its terms.\n# ======================================================================\n\n\"\"\"Transformations related to :math:`SU(2)` matrices.\"\"\"\n\nimport numpy\n\nimport qtoolkit.utils.constants.matrices as mconsts\nimport qtoolkit.utils.types as qtypes\n\n\ndef su2_to_so3(U: qtypes.SU2Matrix) -> qtypes.SO3Vector:\n \"\"\"Return :math:`x` such that :math:`U = e^{-ix.\\\\sigma/2}`.\n\n This function is based on the formula\n\n .. math::\n\n e^{ia (\\\\hat{n} \\\\dot{} \\\\vec{\\\\sigma})} = \\\\cos(a) I + i(\\\\hat{n}\n \\\\dot{} \\\\vec{\\\\sigma}) \\\\sin(a)\n\n from https://en.wikipedia.org/wiki/Pauli_matrices.\n\n :param U: The :math:`SU(2)` matrix to convert.\n :return: 3 real numbers parametrising entirely the given matrix.\n \"\"\"\n # The coefficients are: $[-\\sin(a) n_1, -\\sin(a) n_2, -\\sin(a) n_3]$.\n # The minus appears because there is a minus in the exponential we\n # convert to, which is not present in the formula given in the link.\n coefficients = numpy.array(\n [\n -numpy.imag(U[0, 1]),\n numpy.real(U[1, 0]),\n numpy.imag((U[1, 1] - U[0, 0]) / 2.0),\n ]\n )\n\n cos_theta_2 = numpy.real((U[0, 0] + U[1, 1]) / 2.0)\n # The vector $\\hat{n}$ is supposed to be of unit-length so its norm\n # is 1. That is why the expression below gives the sinus.\n sin_theta_2 = numpy.linalg.norm(coefficients, 2)\n\n if sin_theta_2 == 0.0:\n coefficients = numpy.array([2 * numpy.arccos(cos_theta_2), 0.0, 0.0])\n else:\n # We return the vector of coefficients, not normalised.\n theta = 2 * numpy.arctan2(sin_theta_2, cos_theta_2)\n coefficients = theta * coefficients / sin_theta_2\n\n return coefficients\n\n\ndef so3_to_su2(coefficients: qtypes.SO3Vector) -> qtypes.SU2Matrix:\n \"\"\"Convert a set of 3 real coefficients to a unique :math:`SU(2)` matrix.\n\n Computes the unitary matrix in SU(2) with the formula\n\n .. math::\n\n e^{ia (\\\\hat{n} \\\\dot{} \\\\vec{\\\\sigma})} = \\\\cos(a) I + i(\\\\hat{n}\n \\\\dot{} \\\\vec{\\\\sigma}) \\\\sin(a)\n\n from https://en.wikipedia.org/wiki/Pauli_matrices.\n\n :param coefficients: 3 real numbers characterising the :math:`SU(2)` matrix.\n :return: the :math:`SU(2)` matrix characterised by the given coefficients.\n \"\"\"\n theta = numpy.linalg.norm(coefficients, 2)\n identity = numpy.identity(2)\n\n if theta == 0.0:\n return identity\n else:\n normalised_coefficients = coefficients / theta\n theta_2 = theta / 2\n sin_theta_2 = numpy.sin(theta_2)\n unitary = numpy.cos(theta_2) * identity - 1.0j * sin_theta_2 * (\n normalised_coefficients[0] * mconsts.P_X\n + normalised_coefficients[1] * mconsts.P_Y\n + normalised_coefficients[2] * mconsts.P_Z\n )\n return unitary\n\n\ndef su2_to_H(unitary: qtypes.SU2Matrix) -> numpy.ndarray:\n \"\"\"Convert a :math:`SU(2)` matrix to a unit-norm quaternion.\n\n Quaternions are composed of 4 real numbers. These numbers corresponds to\n the coefficients :math:`\\\\alpha_i` in the equation\n\n .. math::\n\n e^{ia (\\\\hat{n} \\\\dot{} \\\\vec{\\\\sigma})} = \\\\cos(a) I + i(\\\\hat{n}\n \\\\dot{} \\\\vec{\\\\sigma}) \\\\sin(a)\n\n from https://en.wikipedia.org/wiki/Pauli_matrices.\n\n :param unitary: The unitary matrix to decompose.\n :return: the 4 real coefficients of the unit-norm quaternion representing\n the matrix.\n \"\"\"\n coefficients = numpy.array(\n [\n numpy.real(unitary[0, 0]),\n -numpy.imag(unitary[0, 1]),\n numpy.real(unitary[1, 0]),\n numpy.imag(unitary[1, 1]),\n ]\n )\n return coefficients\n\n\ndef H_to_su2(coefficients: numpy.ndarray) -> qtypes.SU2Matrix:\n \"\"\"Convert a unit-norm quaternion to a :math:`SU(2)` matrix.\n\n Quaternions are composed of 4 real numbers. These numbers corresponds to\n the coefficients :math:`\\\\alpha_i` in the equation\n\n .. math::\n\n e^{ia (\\\\hat{n} \\\\dot{} \\\\vec{\\\\sigma})} = \\\\cos(a) I + i(\\\\hat{n}\n \\\\dot{} \\\\vec{\\\\sigma}) \\\\sin(a)\n\n from https://en.wikipedia.org/wiki/Pauli_matrices.\n\n :param coefficients: The coefficients characterising the :math:`SU(2)`\n matrix.\n :return: the :math:`SU(2)` matrix corresponding to the given coefficients.\n \"\"\"\n return coefficients[0] * mconsts.ID2 - 1.0j * (\n coefficients[1] * mconsts.P_X\n + coefficients[2] * mconsts.P_Y\n + coefficients[3] * mconsts.P_Z\n )\n\n\ndef unitary_to_su2(unitary: qtypes.UnitaryMatrix) -> qtypes.SU2Matrix:\n \"\"\"Project the given unitary matrix in :math:`U(2)` to :math:`SU(2)`.\n\n This routine just scales the given unitary to make its determinant equals to\n 1.\n\n :param unitary: The unitary matrix in :math:`U(2)` to project.\n :return: the corresponding :math:`SU(2)` matrix.\n \"\"\"\n det = unitary[0, 0] * unitary[1, 1] - unitary[0, 1] * unitary[1, 0]\n return unitary / numpy.lib.scimath.sqrt(det)\n"
] |
[
[
"numpy.array",
"numpy.identity",
"numpy.random.rand",
"scipy.linalg.expm"
],
[
"numpy.imag",
"numpy.linalg.norm",
"numpy.cos",
"numpy.sin",
"numpy.arctan2",
"numpy.arccos",
"numpy.real",
"numpy.identity",
"numpy.lib.scimath.sqrt"
]
] |
mimoralea/king-pong
|
[
"c0ec61f60de64293d00a48d1b7724a24d2b6602a"
] |
[
"agent.py"
] |
[
"#!/usr/bin/python\nfrom __future__ import print_function\nimport logging as log\nimport argparse\nimport time\nimport king_pong as env\nimport multicnet as percept\nimport random\nimport numpy as np\nfrom collections import deque\nimport os\n\n\nclass DeepLearningAgent:\n \"\"\"\n Agent class that uses a deep network\n and a game and learns how to play it\n \"\"\"\n\n def __init__(self, input_width, input_height, nactions, nimages, reset=False, train=False):\n \"\"\"\n Sets up the variables, initializes the game\n and the convolutional network\n recreates the files if needed\n \"\"\"\n self.train = train\n self.memory = deque()\n self.environment = env.GameState()\n self.environment.print_scores = not train\n self.step = 0\n self.perception = percept.MultilayerConvolutionalNetwork(\n input_width, input_height, nimages, nactions)\n\n self.logs_directory = 'logs'\n self.percepts_directory = 'percepts'\n self.networks_directory = 'networks'\n\n if reset:\n log.info('cleaning up directories')\n import shutil\n shutil.rmtree(self.logs_directory)\n shutil.rmtree(self.percepts_directory)\n shutil.rmtree(self.networks_directory)\n\n if not os.path.exists(self.logs_directory): os.makedirs(self.logs_directory)\n if not os.path.exists(self.percepts_directory): os.makedirs(self.percepts_directory)\n if not os.path.exists(self.networks_directory): os.makedirs(self.networks_directory)\n\n self.memory_max_len = 50000\n self.save_interval = 100000\n self.nactions = nactions\n self.gamma = 0.99\n self.observe = int(self.memory_max_len * 1.25)\n self.initial_epsilon = 0.60 if self.train else 0.00\n self.final_epsilon = 0.01 if self.train else 0.00\n self.epsilon = self.initial_epsilon\n self.explore = self.observe * 10 # step when epsilon reaches final epsilon value\n self.batch_size = 60\n\n log.debug(vars(self))\n\n def save_progress(self, stack):\n \"\"\"\n Save the current progress of the agent,\n that is the readout values, the hidden layer values,\n the images in the current stack of the agent\n and the current neural network\n \"\"\"\n log.info('saving current stack')\n for i in range(stack.shape[2]):\n current_percept_path = self.percepts_directory + '/frame' + \\\n str(self.step) + '-' + str(i) +'.png'\n self.perception.save_percepts(current_percept_path, stack[:,:,i])\n\n if not self.train:\n log.debug('no need to save network - we are not training')\n return\n\n log.info('saving percepts')\n with open(self.logs_directory + '/readout.txt', 'w+') as a_file:\n with open(self.logs_directory + '/hidden.txt', 'w+') as h_file:\n self.perception.save_variables(a_file, h_file, stack)\n\n log.info('saving current network')\n self.perception.save_network(self.networks_directory, self.step)\n\n def load_progress(self):\n \"\"\"\n Loads the progress from the agent deep network\n \"\"\"\n file_loaded = self.perception.attempt_restore(self.networks_directory)\n if file_loaded:\n log.info('loaded successfully => ' + str(file_loaded))\n else:\n log.info(\"didn't find any saved network\")\n\n def select_action(self, x_t = None):\n \"\"\"\n Selects either an epsilon random action\n or just the best action according to the\n current state of the neural network\n \"\"\"\n a_t = np.zeros([self.nactions])\n do_action = 0\n if x_t is None or random.random() <= self.epsilon:\n log.debug('random action selected with epsilon ' + str(self.epsilon))\n do_action = random.randrange(self.nactions)\n else:\n log.debug('greedy action selected with epsilon ' + str(self.epsilon))\n do_action = self.perception.select_best_action(x_t)\n\n if self.epsilon > self.final_epsilon and self.step > self.observe:\n self.epsilon -= (self.initial_epsilon - self.final_epsilon) / self.explore\n log.debug('epsilon was updated to ' + str(self.epsilon))\n\n a_t[do_action] = 1\n log.debug('action distribution looks like ' + str(a_t))\n return a_t\n\n def remember(self, sars):\n \"\"\"\n Inserts a state action reward new_state\n observation into the memory bank\n and pops the oldest memory if limit was\n a limit reached\n \"\"\"\n\n self.memory.append(sars)\n log.debug('new sars observation inserted')\n log.debug('before memory size ' + str(len(self.memory)))\n\n if len(self.memory) > self.memory_max_len:\n log.debug('memory reached the max size. Removing oldest memory')\n self.memory.popleft()\n\n log.debug('after memory size ' + str(len(self.memory)))\n\n def learn_maybe(self):\n \"\"\"\n This is the main training loop.\n The agent would leave early if the train\n attribute is not set to True and if the\n observe period hasn't been completed.\n\n It basically grabs a self.batch_size sample from the\n memory bank, extrans the sars observations and it\n batch trains the deep neural network\n \"\"\"\n\n if not self.train or self.step <= self.observe:\n log.debug('No training the network. Train is set to ' + str(self.train) +\n '. Current step is ' + str(self.step) +\n ' and observation period will end after ' + str(self.observe))\n return\n\n minibatch = random.sample(self.memory, self.batch_size)\n log.debug('minibatch created. Total sample of ' + str(len(minibatch)))\n\n state_batch = [m[0] for m in minibatch]\n action_batch = [m[1] for m in minibatch]\n rewards_batch = [m[2] for m in minibatch]\n state_prime_batch = [m[3] for m in minibatch]\n log.debug('sars have been separated and extracted')\n\n value_batch = []\n readout_batch = self.perception.readout_act(state_prime_batch)\n log.debug('values of the next state have been queried')\n\n for i in range(len(minibatch)):\n if abs(rewards_batch[i]) == 1.0:\n value_batch.append(rewards_batch[i])\n log.debug('current memory was calculated as a terminal observation')\n else:\n value_batch.append(rewards_batch[i] + self.gamma * np.max(readout_batch[i]))\n log.debug('current memory was calculated as a non-terminal observation')\n log.debug('calculated value of ' + str(value_batch[i]))\n\n log.debug('training network with ' + str(len(value_batch)) + ' samples')\n self.perception.train(value_batch, action_batch, state_batch)\n log.debug('end of training')\n\n def act_and_perceive(self, action_selected, percept_stack):\n \"\"\"\n Acts in the environment. That is, it moves the game\n one step further by passing the selected action,\n it then reads what the environment had to say about that\n and finally preprocesses the image into the format and\n size used by the network and appends the new image into the front\n of the image stack\n \"\"\"\n log.debug('acting with ' + str(action_selected))\n new_percept, reward = self.environment.frame_step(action_selected)\n log.debug('got reward of ' + str(reward))\n\n new_percept = self.perception.preprocess_percepts(new_percept)\n log.debug('got the new image')\n\n new_percept_stack = np.append(new_percept, percept_stack[:, :, :3], axis=2)\n log.debug('modified the stack to include the new image')\n return new_percept_stack, reward\n\n def exist(self, percept_stack):\n \"\"\"\n Main agent loop that selects and action, acts, remembers\n what happen, learns, updates, saves the progress and\n decides if it should die\n \"\"\"\n log.debug('entering main agent loop')\n while True:\n\n start = time.time()\n action_selected = self.select_action(percept_stack)\n new_percept_stack, reward = self.act_and_perceive(action_selected, percept_stack)\n log.debug(\"act and percieve took \" + str(time.time() - start))\n\n start = time.time()\n self.remember((percept_stack, action_selected, reward, new_percept_stack))\n log.debug(\"remembering took \" + str(time.time() - start))\n\n start = time.time()\n self.learn_maybe()\n log.debug(\"learning took \" + str(time.time() - start))\n\n log.debug('updating the image stack')\n percept_stack = new_percept_stack\n self.step += 1\n\n start = time.time()\n if self.step % self.save_interval == 0:\n self.save_progress(percept_stack)\n log.debug(\"save progress took \" + str(time.time() - start))\n\n timestep_info = \"timestep\", self.step, \"epsilon\", self.epsilon, \\\n \"action_selected\", action_selected, \"reward\", reward\n if reward != 0:\n log.info(timestep_info)\n else:\n log.debug(timestep_info)\n\n if self.environment.score_last_changed() and not self.train:\n best_of, matches_per_game = self.environment.first_to\n cpu_games, agent_games = self.environment.games\n cpu_score, agent_score = self.environment.score\n current_game = cpu_games + agent_games\n title = ' SCOREBOARD '\n\n log.info('=' * 20 + title + '=' * 20)\n log.info('best of ' + str(best_of) + ' games')\n log.info('each game goes to ' +\n str(matches_per_game) +\n ' points')\n log.info('-' * (40 + len(title)))\n log.info('game # ' + str(current_game) + ' score:')\n log.info('-' * (40 + len(title)))\n log.info('cpu ' + str(cpu_score))\n log.info('agent ' + str(agent_score))\n log.info('-' * (40 + len(title)))\n log.info('overall score:')\n log.info('-' * (40 + len(title)))\n log.info('cpu ' + str(cpu_games))\n log.info('agent ' + str(agent_games))\n log.info('=' * (40 + len(title)))\n\n if not self.train and self.environment.game_over():\n log.info('killing the agent. Train was ' +\n str(self.train) +\n ' and game over was ' +\n str(self.environment.game_over()))\n cpu_games, agent_games = self.environment.games\n won = agent_games > cpu_games\n log.info(('agent won ' if won else 'cpu won ') +\n '... final score ' + str(cpu_games) +\n ' to ' + str(agent_games))\n break\n\n\ndef main(args):\n \"\"\"\n Sets up the environment, loads the agent, prepares the\n first action and moves the game a single frame\n and then enters the agents main loop\n \"\"\"\n log.info('Verbose output enabled ' + str(log.getLogger().getEffectiveLevel()))\n log.debug(args)\n\n npixels, nactions, nimages = 80, 3, 4\n agent = DeepLearningAgent(npixels, npixels, nactions, nimages, args.reset, args.train)\n log.info('agent loaded successfully')\n\n agent.environment.first_to = [args.ngames, args.nmatches]\n log.info('we are playing ' + str(args.ngames) +\n ' games of ' + str(args.nmatches) +\n ' matches each - Good luck!!!')\n\n noop = np.zeros(nactions)\n noop[0] = 1 # 0 action is do nothing, 1 is up, 2 is down\n raw_percept, _ = agent.environment.frame_step(noop)\n log.info('pumping first frame on the game state')\n\n x_t = agent.perception.preprocess_percepts(raw_percept, False)\n first_percept_stack = np.stack((x_t, x_t, x_t, x_t), axis = 2)\n log.info('first stack created successfully')\n\n agent.load_progress()\n log.info('agent load progress completed')\n\n agent.exist(first_percept_stack)\n log.info('agent dies')\n\n\nif __name__ == '__main__':\n \"\"\"\n Loads the script and parses the arguments\n \"\"\"\n from sys import argv\n parser = argparse.ArgumentParser(\n description='A Deep Reinforcement Learning agent that plays pong like a King.'\n )\n parser.add_argument(\n '-v',\n help='logging level set to ERROR',\n action='store_const', dest='loglevel', const=log.ERROR,\n )\n parser.add_argument(\n '-vv',\n help='logging level set to INFO',\n action='store_const', dest='loglevel', const=log.INFO,\n )\n parser.add_argument(\n '-vvv',\n help='logging level set to DEBUG',\n action='store_const', dest='loglevel', const=log.DEBUG,\n )\n parser.add_argument(\n '-g', '--games',\n help='number of games for the agent to play. (default: 100) '\n 'NOTE: if you enable training, this variable will not be used',\n dest='ngames', type=int, default=100,\n )\n # TODO: Enable players to be set left or right\n \"\"\"\n parser.add_argument(\n '-l', '--left-player',\n help='agent to play on left. (default: CPU) '\n 'OPTIONS: CPU, AGENT, HUMAN',\n dest='lplayer', type=str, default='CPU',\n )\n parser.add_argument(\n '-r', '--right-player',\n help='agent to play on left. (default: AGENT) '\n 'OPTIONS: CPU, AGENT, HUMAN',\n dest='rplayer', type=str, default='AGENT',\n )\n \"\"\"\n parser.add_argument(\n '-m', '--matches',\n help='number of matches for each game. (default: 5) '\n 'NOTE: if you enable training, this variable will not be used',\n dest='nmatches', type=int, default=5,\n )\n parser.add_argument(\n '-t', '--train',\n help='allows the training of the deep neural network. '\n 'NOTE: leave disabled to only see the current agent behave',\n dest='train', action='store_true')\n parser.add_argument(\n '-c', '--clear',\n help='clears the folders where the state of the agent is saves. '\n 'NOTE: use this to retrain the agent from scratch',\n dest='reset', action='store_true')\n\n args = parser.parse_args()\n if args.loglevel:\n log.basicConfig(format='%(asctime)s - %(levelname)s: %(message)s',\n datefmt='%m/%d/%Y %I:%M:%S %p', level=args.loglevel)\n else:\n log.basicConfig(format='%(asctime)s - %(levelname)s: %(message)s',\n datefmt='%m/%d/%Y %I:%M:%S %p', level=log.CRITICAL)\n\n main(args)\n"
] |
[
[
"numpy.max",
"numpy.append",
"numpy.zeros",
"numpy.stack"
]
] |
codelibs/recotem
|
[
"383ccdd6e1e9feb59bc3adb2543c00b08277317a"
] |
[
"backend/recotem/recotem/api/tasks.py"
] |
[
"import json\nimport pickle\nimport random\nimport re\nimport tempfile\nfrom logging import Logger\nfrom pathlib import Path\nfrom typing import Dict, List, Optional\n\nimport pandas as pd\nimport scipy.sparse as sps\nfrom billiard.connection import Pipe\nfrom billiard.context import Process\nfrom celery import chain, group\nfrom django.conf import settings\nfrom django.core.files.storage import default_storage\nfrom django_celery_results.models import TaskResult\nfrom irspack import Evaluator, IDMappedRecommender, InteractionMatrix\nfrom irspack import __version__ as irspack_version\nfrom irspack import autopilot, get_optimizer_class, split_dataframe_partial_user_holdout\nfrom irspack.optimizers.autopilot import DEFAULT_SEARCHNAMES, TaskBackend, search_one\nfrom irspack.parameter_tuning import Suggestion\nfrom irspack.parameter_tuning.parameter_range import is_valid_param_name\nfrom irspack.recommenders.base import get_recommender_class\nfrom irspack.utils import df_to_sparse\nfrom optuna.storages import RDBStorage\n\nfrom recotem.api.models import (\n EvaluationConfig,\n ModelConfiguration,\n ParameterTuningJob,\n Project,\n SplitConfig,\n TaskAndParameterJobLink,\n TaskAndTrainedModelLink,\n TaskLog,\n TrainedModel,\n TrainingData,\n)\nfrom recotem.api.utils import read_dataframe\nfrom recotem.celery import app\n\n\nclass BilliardBackend(TaskBackend):\n def __init__(\n self,\n X: InteractionMatrix,\n evaluator: Evaluator,\n optimizer_names: List[str],\n suggest_overwrites: Dict[str, List[Suggestion]],\n db_url: str,\n study_name: str,\n random_seed: int,\n logger: Logger,\n ):\n self.pipe_parent, pipe_child = Pipe()\n self._p = Process(\n target=search_one,\n args=(\n pipe_child,\n X,\n evaluator,\n optimizer_names,\n suggest_overwrites,\n db_url,\n study_name,\n random_seed,\n logger,\n ),\n )\n\n def _exit_code(self) -> Optional[int]:\n return self._p.exitcode\n\n def receive_trial_number(self) -> int:\n result: int = self.pipe_parent.recv()\n return result\n\n def start(self) -> None:\n self._p.start()\n\n def join(self, timeout: Optional[int]) -> None:\n self._p.join(timeout=timeout)\n\n def terminate(self) -> None:\n self._p.terminate()\n\n\ndef train_recommender_func(\n task_result, model_id: int, parameter_tuning_job_id: Optional[int] = None\n):\n model: TrainedModel = TrainedModel.objects.get(id=model_id)\n\n model_config: ModelConfiguration = model.configuration\n data: TrainingData = model.data_loc\n\n TaskAndTrainedModelLink.objects.create(model=model, task=task_result)\n assert model_config.project.id == data.project.id\n project: Project = data.project\n user_column = project.user_column\n item_column = project.item_column\n recommender_class = get_recommender_class(model_config.recommender_class_name)\n\n X, uids, iids = df_to_sparse(data.validate_return_df(), user_column, item_column)\n uids = [str(uid) for uid in uids]\n iids = [str(iid) for iid in iids]\n\n model.irspack_version = irspack_version\n\n param = json.loads(model_config.parameters_json)\n rec = recommender_class(X, **param).learn()\n with tempfile.TemporaryFile() as temp_fs:\n mapped_rec = IDMappedRecommender(rec, uids, iids)\n pickle.dump(\n dict(\n id_mapped_recommender=mapped_rec,\n irspack_version=irspack_version,\n recotem_trained_model_id=model_id,\n ),\n temp_fs,\n )\n temp_fs.seek(0)\n file_ = default_storage.save(f\"trained_models/model-{model.id}.pkl\", temp_fs)\n model.file = file_\n model.save()\n\n model.filesize = model.file.size\n model.save()\n\n if parameter_tuning_job_id is not None:\n job: ParameterTuningJob = ParameterTuningJob.objects.get(\n id=parameter_tuning_job_id\n )\n job.tuned_model = model\n job.save()\n\n\n@app.task(bind=True)\ndef task_train_recommender(self, model_id: int) -> None:\n task_result, _ = TaskResult.objects.get_or_create(task_id=self.request.id)\n self.update_state(state=\"STARTED\", meta=[])\n train_recommender_func(task_result, model_id)\n\n\ndef create_best_config_fun(task_result, parameter_tuning_job_id: int) -> int:\n job: ParameterTuningJob = ParameterTuningJob.objects.get(id=parameter_tuning_job_id)\n evaluation: EvaluationConfig = job.evaluation\n\n TaskAndParameterJobLink.objects.create(job=job, task=task_result)\n\n data: TrainingData = job.data\n project: TrainingData = data.project\n\n optuna_storage = RDBStorage(settings.DATABASE_URL)\n study_name = job.study_name()\n study_id = optuna_storage.get_study_id_from_name(study_name)\n best_trial = optuna_storage.get_best_trial(study_id)\n best_params_with_prefix = dict(\n **best_trial.params,\n **{\n key: val\n for key, val in best_trial.user_attrs.items()\n if is_valid_param_name(key)\n },\n )\n best_params = {\n re.sub(r\"^([^\\.]*\\.)\", \"\", key): value\n for key, value in best_params_with_prefix.items()\n }\n optimizer_name: str = best_params.pop(\"optimizer_name\")\n recommender_class_name = get_optimizer_class(\n optimizer_name\n ).recommender_class.__name__\n config_name = f\"Tuning Result of job {job.id}\"\n config = ModelConfiguration.objects.create(\n name=config_name,\n project=project,\n parameters_json=json.dumps(best_params),\n recommender_class_name=recommender_class_name,\n )\n\n job.best_config = config\n job.irspack_version = irspack_version\n job.best_score = -best_trial.value\n job.save()\n\n if best_trial.value == 0.0:\n raise RuntimeError(\n f\"This settings resulted in {evaluation.target_metric} == 0.0.\\n\"\n \"This might be caused by too short timeout or too small validation set.\"\n )\n\n TaskLog.objects.create(\n task=task_result,\n contents=f\"\"\"Job {parameter_tuning_job_id} complete.\"\"\",\n )\n TaskLog.objects.create(\n task=task_result,\n contents=f\"\"\"Found best configuration: {recommender_class_name} / {best_params} with {evaluation.target_metric}@{evaluation.cutoff} = {-best_trial.value}\"\"\",\n )\n\n return config.id\n\n\n@app.task(bind=True)\ndef task_create_best_config(self, parameter_tuning_job_id: int, *args) -> int:\n task_result, _ = TaskResult.objects.get_or_create(task_id=self.request.id)\n self.update_state(state=\"STARTED\", meta=[])\n return create_best_config_fun(task_result, parameter_tuning_job_id)\n\n\n@app.task(bind=True)\ndef task_create_best_config_train_rec(self, parameter_tuning_job_id: int, *args) -> int:\n task_result, _ = TaskResult.objects.get_or_create(task_id=self.request.id)\n self.update_state(state=\"STARTED\", meta=[])\n config_id = create_best_config_fun(task_result, parameter_tuning_job_id)\n job: ParameterTuningJob = ParameterTuningJob.objects.get(id=parameter_tuning_job_id)\n config: ModelConfiguration = ModelConfiguration.objects.get(id=config_id)\n model = TrainedModel.objects.create(configuration=config, data_loc=job.data)\n\n train_recommender_func(task_result, model.id, parameter_tuning_job_id)\n\n\n@app.task(bind=True)\ndef run_search(self, parameter_tuning_job_id: int, index: int) -> None:\n\n task_result, _ = TaskResult.objects.get_or_create(task_id=self.request.id)\n logs = [\n dict(message=f\"Started the parameter tuning jog {parameter_tuning_job_id} \")\n ]\n self.update_state(state=\"STARTED\", meta=logs)\n job: ParameterTuningJob = ParameterTuningJob.objects.get(id=parameter_tuning_job_id)\n\n n_trials: int = job.n_trials // job.n_tasks_parallel\n\n if index < (job.n_trials % job.n_tasks_parallel):\n n_trials += 1\n\n TaskAndParameterJobLink.objects.create(job=job, task=task_result)\n data: TrainingData = job.data\n project: Project = data.project\n split: SplitConfig = job.split\n evaluation: EvaluationConfig = job.evaluation\n df: pd.DataFrame = read_dataframe(Path(data.file.name), data.file)\n tried_algorithms: List[str] = DEFAULT_SEARCHNAMES\n if job.tried_algorithms_json is not None:\n tried_algorithms: List[str] = json.loads(job.tried_algorithms_json)\n user_column = project.user_column\n item_column = project.item_column\n\n TaskLog.objects.create(\n task=task_result,\n contents=f\"\"\"Start job {parameter_tuning_job_id} / worker {index}.\"\"\",\n )\n\n dataset, _ = split_dataframe_partial_user_holdout(\n df,\n user_column=user_column,\n item_column=item_column,\n time_column=project.time_column,\n n_val_user=split.n_test_users,\n val_user_ratio=split.test_user_ratio,\n test_user_ratio=0.0,\n heldout_ratio_val=split.heldout_ratio,\n n_heldout_val=split.n_heldout,\n )\n train = dataset[\"train\"]\n val = dataset[\"val\"]\n X_tv_train = sps.vstack([train.X_train, val.X_train])\n evaluator = Evaluator(\n val.X_test,\n offset=train.n_users,\n target_metric=evaluation.target_metric.lower(),\n cutoff=evaluation.cutoff,\n )\n\n optuna_storage = RDBStorage(settings.DATABASE_URL)\n study_name = job.study_name()\n study_id = optuna_storage.get_study_id_from_name(study_name)\n\n def callback(i: int, df: pd.DataFrame) -> None:\n trial_id = optuna_storage.get_trial_id_from_study_id_trial_number(study_id, i)\n trial = optuna_storage.get_trial(trial_id)\n params = trial.params.copy()\n algo: str = params.pop(\"optimizer_name\")\n if trial.value is None or trial.value == 0.0:\n message = f\"Trial {i} with {algo} / {params}: timeout.\"\n else:\n message = f\"\"\"Trial {i} with {algo} / {params}: {trial.state.name}.\n{evaluator.target_metric.name}@{evaluator.cutoff}={-trial.value}\"\"\"\n TaskLog.objects.create(task=task_result, contents=message)\n\n if job.random_seed is None:\n random_seed = random.randint(0, 2 ** 16)\n else:\n random_seed: int = job.random_seed\n autopilot(\n X_tv_train,\n evaluator,\n n_trials=n_trials,\n memory_budget=job.memory_budget,\n timeout_overall=job.timeout_overall,\n timeout_singlestep=job.timeout_singlestep,\n random_seed=random_seed + index,\n callback=callback,\n storage=optuna_storage,\n study_name=study_name,\n task_resource_provider=BilliardBackend,\n algorithms=tried_algorithms,\n )\n\n\ndef start_tuning_job(job: ParameterTuningJob) -> None:\n optuna_storage = RDBStorage(settings.DATABASE_URL)\n study_name = job.study_name()\n optuna_storage.create_new_study(study_name)\n\n if job.train_after_tuning:\n chain(\n group(\n run_search.si(job.id, i) for i in range(max(1, job.n_tasks_parallel))\n ),\n task_create_best_config_train_rec.si(job.id),\n ).delay()\n else:\n chain(\n group(\n run_search.si(job.id, i) for i in range(max(1, job.n_tasks_parallel))\n ),\n task_create_best_config.si(job.id),\n ).delay()\n"
] |
[
[
"scipy.sparse.vstack"
]
] |
ReyesDeJong/AnomalyDetectionTransformations
|
[
"c60b1adaf0065b684d76ecacabed1eae39a4e3a9"
] |
[
"modules/geometric_transform/transformations_tf.py"
] |
[
"import abc\r\nimport itertools\r\n\r\nimport numpy as np\r\nimport tensorflow as tf\r\n\r\n\"\"\"There is a small discrepancy between original and his transformer, \r\ndue the fact that padding reflects wiithouy copying the edge pixels\"\"\"\r\n\r\n\r\ndef cnn2d_depthwise_tf(image_batch, filters):\r\n features_tf = tf.nn.depthwise_conv2d(image_batch, filters,\r\n strides=[1, 1, 1, 1],\r\n padding='SAME')\r\n\r\n return features_tf\r\n\r\n\r\ndef makeGaussian(size, sigma=3, center=None):\r\n \"\"\" Make a square gaussian kernel.\r\n\r\n size is the length of a side of the square\r\n fwhm is full-width-half-maximum, which\r\n can be thought of as an effective radius.\r\n \"\"\"\r\n\r\n x = np.arange(0, size, 1, float)\r\n y = x[:, np.newaxis]\r\n\r\n if center is None:\r\n x0 = y0 = size // 2\r\n else:\r\n x0 = center[0]\r\n y0 = center[1]\r\n\r\n return np.exp(-((x - x0) ** 2 + (y - y0) ** 2) / (2.0 * sigma ** 2))\r\n\r\n\r\ndef makeLoG(size, sigma=3, center=None):\r\n \"\"\" Make a square LoG kernel.\r\n\r\n size is the length of a side of the square\r\n fwhm is full-width-half-maximum, which\r\n can be thought of as an effective radius.\r\n \"\"\"\r\n\r\n x = np.arange(0, size, 1, float)\r\n y = x[:, np.newaxis]\r\n\r\n if center is None:\r\n x0 = y0 = size // 2\r\n else:\r\n x0 = center[0]\r\n y0 = center[1]\r\n\r\n return (-1 / (np.pi * sigma ** 4)) * (\r\n 1 - (((x - x0) ** 2 + (y - y0) ** 2) / (2 * sigma ** 2))) * np.exp(\r\n -((x - x0) ** 2 + (y - y0) ** 2) / (2.0 * sigma ** 2))\r\n\r\n\r\ndef apply_affine_transform(res_x, t_x, t_y):\r\n # this are inverted, because to perform as train_step_tf2, we need to invert them\r\n tx = t_y\r\n ty = t_x\r\n res_x_padded = tf.pad(res_x,\r\n [[0, 0], [tf.abs(ty), tf.abs(ty)],\r\n [tf.abs(tx), tf.abs(tx)],\r\n [0, 0]], \"REFLECT\")\r\n res_x_translated = res_x_padded\r\n res_x = res_x_translated[:,\r\n tf.abs(ty) + ty:tf.abs(ty) + ty +\r\n res_x.shape[1],\r\n tf.abs(tx) + tx:tf.abs(tx) + tx +\r\n res_x.shape[2], :]\r\n return res_x\r\n\r\n\r\n# TODO: check if avoid doing this and include channel as\r\n# a transformator parameter speed ups things\r\ndef check_shape_kernel(kernel, x):\r\n if len(kernel.shape) == 2:\r\n kernel = tf.stack([kernel] * x.shape[-1], axis=-1)\r\n return tf.expand_dims(kernel, axis=-1)\r\n elif len(kernel.shape) == 3:\r\n return tf.expand_dims(kernel, axis=-1)\r\n return kernel\r\n\r\n\r\nclass KernelTransformation(object):\r\n def __init__(self, flip, tx, ty, k_90_rotate, gauss, log):\r\n self.flip = flip\r\n self.tx = tx\r\n self.ty = ty\r\n self.k_90_rotate = k_90_rotate\r\n self.gauss = gauss\r\n self.log = log\r\n self.gauss_kernel = makeGaussian(5, 1).astype(np.float32)\r\n self.log_kernel = makeLoG(5, 0.5).astype(np.float32)\r\n\r\n def __call__(self, x):\r\n res_x = x\r\n if self.gauss:\r\n res_x = cnn2d_depthwise_tf(\r\n res_x, check_shape_kernel(self.gauss_kernel, res_x))\r\n if self.log:\r\n res_x = cnn2d_depthwise_tf(\r\n res_x, check_shape_kernel(self.log_kernel, res_x))\r\n if self.flip:\r\n with tf.name_scope(\"flip\"):\r\n res_x = tf.image.flip_left_right(res_x)\r\n if self.tx != 0 or self.ty != 0:\r\n res_x = apply_affine_transform(res_x, self.tx, self.ty)\r\n if self.k_90_rotate != 0:\r\n with tf.name_scope(\"rotation\"):\r\n res_x = tf.image.rot90(res_x, k=self.k_90_rotate)\r\n\r\n return res_x\r\n\r\n\r\n# TODO: refactor translation, but test if its correctly done and speed up things or not, test tf.function\r\nclass AffineTransformation(object):\r\n def __init__(self, flip, tx, ty, k_90_rotate):\r\n \"\"\"tx and ty are inverted to match original transformer\"\"\"\r\n self.flip = flip\r\n self.tx = ty\r\n self.ty = tx\r\n self.k_90_rotate = k_90_rotate\r\n\r\n def __call__(self, x):\r\n res_x = x\r\n if self.flip:\r\n with tf.name_scope(\"flip\"):\r\n res_x = tf.image.flip_left_right(res_x)\r\n if self.tx != 0 or self.ty != 0:\r\n with tf.name_scope(\"translation\"):\r\n res_x_padded = tf.pad(res_x,\r\n [[0, 0], [np.abs(self.ty), np.abs(self.ty)],\r\n [np.abs(self.tx), np.abs(self.tx)],\r\n [0, 0]], \"REFLECT\")\r\n res_x_translated = res_x_padded\r\n res_x = res_x_translated[:,\r\n np.abs(self.ty) + self.ty:np.abs(self.ty) + self.ty +\r\n res_x.shape[1],\r\n np.abs(self.tx) + self.tx:np.abs(self.tx) + self.tx +\r\n res_x.shape[2], :]\r\n if self.k_90_rotate != 0:\r\n with tf.name_scope(\"rotation\"):\r\n res_x = tf.image.rot90(res_x, k=self.k_90_rotate)\r\n return res_x\r\n\r\n\r\nclass AbstractTransformer(abc.ABC):\r\n def __init__(self, transform_batch_size=512, name='Abstract_Transformer'):\r\n self.name = name\r\n self._transform_batch_size = transform_batch_size\r\n self._transformation_list = None\r\n self._create_transformation_list()\r\n self.verbose = 1\r\n\r\n @property\r\n def n_transforms(self):\r\n return len(self._transformation_list)\r\n\r\n @abc.abstractmethod\r\n def _create_transformation_list(self):\r\n return\r\n\r\n def set_verbose(self, verbose_value):\r\n self.verbose=verbose_value\r\n\r\n # This must be included within preprocessing mapping(?)\r\n # TODO: refactor transform batch to avoid appending\r\n def transform_batch(self, x, t_inds):\r\n transformed_batch = []\r\n with tf.name_scope(\"transformations\"):\r\n for i, t_ind in enumerate(t_inds):\r\n transformed_batch.append(self._transformation_list[t_ind](x))\r\n concatenated_transformations = tf.concat(transformed_batch, axis=0)\r\n return tf.identity(concatenated_transformations, 'concat_transforms')\r\n\r\n def apply_all_transformsv0(self, x, batch_size=None):\r\n \"\"\"generate transform inds, that are the labels of each transform and\r\n its respective transformed data. It generates labels along with images\"\"\"\r\n if batch_size is not None:\r\n self._transform_batch_size = batch_size\r\n train_ds = tf.data.Dataset.from_tensor_slices((x)).batch(\r\n self._transform_batch_size)\r\n transformations_inds = np.arange(self.n_transforms)\r\n x_transform = []\r\n y_transform = []\r\n for images in train_ds:\r\n transformed_batch = transformer.transform_batch(images,\r\n transformations_inds)\r\n y_transform_batch = np.repeat(\r\n transformations_inds, transformed_batch.shape[0] // self.n_transforms)\r\n x_transform.append(transformed_batch)\r\n y_transform.append(y_transform_batch)\r\n x_transform = np.concatenate(\r\n [tensor.numpy() for tensor in x_transform])\r\n y_transform = np.concatenate(y_transform)\r\n return x_transform, y_transform\r\n\r\n def apply_all_transforms(self, x, batch_size=None):\r\n \"\"\"generate transform inds, that are the labels of each transform and\r\n its respective transformed data. It generates labels after images\"\"\"\r\n if self.verbose:\r\n print('Appliying all %i transforms to set of shape %s' % (\r\n self.n_transforms, str(x.shape)))\r\n transformations_inds = np.arange(self.n_transforms)\r\n return self.apply_transforms(x, transformations_inds, batch_size)\r\n\r\n def apply_transforms(self, x, transformations_inds, batch_size=None):\r\n \"\"\"generate transform inds, that are the labels of each transform and\r\n its respective transformed data. It generates labels after images\"\"\"\r\n if batch_size is not None:\r\n self._transform_batch_size = batch_size\r\n train_ds = tf.data.Dataset.from_tensor_slices((x)).batch(\r\n self._transform_batch_size)\r\n # Todo: check which case is faste, if same, keep second way, it uses less memory\r\n # if x.shape[1] != 63: # or self.n_transforms>90:\r\n # x_transform = []\r\n # for images in train_ds:\r\n # transformed_batch = self.transform_batch(images, transformations_inds)\r\n # x_transform.append(transformed_batch)\r\n # x_transform = np.concatenate(\r\n # [tensor.numpy() for tensor in x_transform])\r\n # else:\r\n x_transform = np.empty(\r\n (x.shape[0] * len(transformations_inds), x.shape[1], x.shape[2],\r\n x.shape[3]),\r\n dtype=np.float32)\r\n i = 0\r\n for images in train_ds:\r\n transformed_batch = self.transform_batch(images, transformations_inds)\r\n x_transform[\r\n i:i + self._transform_batch_size * len(transformations_inds)] = \\\r\n transformed_batch.numpy()\r\n i += self._transform_batch_size * len(transformations_inds)\r\n y_transform_fixed_batch_size = np.repeat(transformations_inds,\r\n self._transform_batch_size)\r\n y_transform_fixed_batch_size = np.tile(y_transform_fixed_batch_size,\r\n len(x) // self._transform_batch_size)\r\n y_transform_leftover_batch_size = np.repeat(\r\n transformations_inds, len(x) % self._transform_batch_size)\r\n y_transform = np.concatenate(\r\n [y_transform_fixed_batch_size, y_transform_leftover_batch_size])\r\n del train_ds\r\n return x_transform, y_transform\r\n\r\n\r\n# ToDO: be more consistent on the usage of transform_batch_size\r\nclass Transformer(AbstractTransformer):\r\n def __init__(self, translation_x=8, translation_y=8,\r\n transform_batch_size=512, name='Transformer'):\r\n self.max_tx = translation_x\r\n self.max_ty = translation_y\r\n super().__init__(transform_batch_size, name)\r\n\r\n def _create_transformation_list(self):\r\n transformation_list = []\r\n self.tranformation_to_perform = list(itertools.product((False, True),\r\n (0, -self.max_tx,\r\n self.max_tx),\r\n (0, -self.max_ty,\r\n self.max_ty),\r\n range(4)))\r\n for is_flip, tx, ty, k_rotate in self.tranformation_to_perform:\r\n transformation = AffineTransformation(is_flip, tx, ty, k_rotate)\r\n transformation_list.append(transformation)\r\n\r\n self._transformation_list = transformation_list\r\n\r\n\r\nclass SimpleTransformer(AbstractTransformer):\r\n def __init__(self, transform_batch_size=512, name='Simple_Transformer'):\r\n super().__init__(transform_batch_size, name)\r\n\r\n def _create_transformation_list(self):\r\n transformation_list = []\r\n self.tranformation_to_perform = list(itertools.product((False, True),\r\n range(4)))\r\n for is_flip, k_rotate in self.tranformation_to_perform:\r\n transformation = AffineTransformation(is_flip, 0, 0, k_rotate)\r\n transformation_list.append(transformation)\r\n\r\n self._transformation_list = transformation_list\r\n\r\n\r\nclass TransTransformer(AbstractTransformer):\r\n def __init__(self, translation_x=8, translation_y=8,\r\n transform_batch_size=512, name='Trans_Transformer'):\r\n self.max_tx = translation_x\r\n self.max_ty = translation_y\r\n super().__init__(transform_batch_size, name)\r\n\r\n def _create_transformation_list(self):\r\n transformation_list = []\r\n self.tranformation_to_perform = list(itertools.product(\r\n (0, -self.max_tx, self.max_tx),\r\n (0, -self.max_ty, self.max_ty),\r\n ))\r\n for tx, ty in self.tranformation_to_perform:\r\n transformation = AffineTransformation(False, tx, ty, 0)\r\n transformation_list.append(transformation)\r\n\r\n self._transformation_list = transformation_list\r\n\r\n\r\nclass KernelTransformer(AbstractTransformer):\r\n def __init__(self, translation_x=8, translation_y=8, rotations=False,\r\n flips=False, gauss=True, log=True, transform_batch_size=512,\r\n name='Kernel_Transformer'):\r\n self.iterable_tx = self.get_translation_iterable(translation_x)\r\n self.iterable_ty = self.get_translation_iterable(translation_y)\r\n self.iterable_rot = self.get_rotation_iterable(rotations)\r\n self.iterable_flips = self.get_bool_iterable(flips)\r\n self.iterable_gauss = self.get_bool_iterable(gauss)\r\n self.iterable_log = self.get_bool_iterable(log)\r\n super().__init__(transform_batch_size, name)\r\n\r\n def get_translation_iterable(self, translation):\r\n if translation:\r\n return (0, -translation, translation)\r\n return range(1)\r\n\r\n def get_rotation_iterable(self, rotations):\r\n if rotations:\r\n return range(4)\r\n return range(1)\r\n\r\n def get_bool_iterable(self, bool_variable):\r\n if bool_variable:\r\n return range(2)\r\n return range(1)\r\n\r\n def _create_transformation_list(self):\r\n transformation_list = []\r\n self.tranformation_to_perform = list(itertools.product(\r\n self.iterable_flips,\r\n self.iterable_tx,\r\n self.iterable_ty,\r\n self.iterable_rot,\r\n self.iterable_gauss,\r\n self.iterable_log))\r\n for is_flip, tx, ty, k_rotate, is_gauss, is_log in self.tranformation_to_perform:\r\n transformation = KernelTransformation(is_flip, tx, ty, k_rotate, is_gauss,\r\n is_log)\r\n transformation_list.append(transformation)\r\n\r\n self._transformation_list = transformation_list\r\n\r\n\r\n# TODO: see if can do some refactoring here\r\nclass PlusKernelTransformer(KernelTransformer):\r\n def __init__(self, translation_x=8, translation_y=8, rotations=True,\r\n flips=True, gauss=True, log=True, transform_batch_size=512,\r\n name='PlusKernel_Transformer'):\r\n super().__init__(translation_x, translation_y, rotations,\r\n flips, gauss, log, transform_batch_size, name)\r\n\r\n def _create_transformation_list(self):\r\n transformation_list = []\r\n for is_flip, tx, ty, k_rotate, is_gauss, is_log in itertools.product(\r\n self.iterable_flips,\r\n self.iterable_tx,\r\n self.iterable_ty,\r\n self.iterable_rot,\r\n [0],\r\n [0]):\r\n transformation = KernelTransformation(is_flip, tx, ty, k_rotate, is_gauss,\r\n is_log)\r\n transformation_list.append(transformation)\r\n\r\n for is_flip, tx, ty, k_rotate, is_gauss, is_log in itertools.product(\r\n [0],\r\n self.iterable_tx,\r\n self.iterable_ty,\r\n [0],\r\n [1],\r\n [0]):\r\n transformation = KernelTransformation(is_flip, tx, ty, k_rotate, is_gauss,\r\n is_log)\r\n transformation_list.append(transformation)\r\n\r\n for is_flip, tx, ty, k_rotate, is_gauss, is_log in itertools.product(\r\n [0],\r\n self.iterable_tx,\r\n self.iterable_ty,\r\n [0],\r\n [0],\r\n [1]):\r\n transformation = KernelTransformation(is_flip, tx, ty, k_rotate,\r\n is_gauss,\r\n is_log)\r\n transformation_list.append(transformation)\r\n\r\n for is_flip, tx, ty, k_rotate, is_gauss, is_log in itertools.product(\r\n [0],\r\n self.iterable_tx,\r\n self.iterable_ty,\r\n [0],\r\n [1],\r\n [1]):\r\n transformation = KernelTransformation(is_flip, tx, ty, k_rotate,\r\n is_gauss,\r\n is_log)\r\n transformation_list.append(transformation)\r\n\r\n self._transformation_list = transformation_list\r\n\r\n\r\ndef test_visualize_transforms():\r\n import imageio\r\n import glob\r\n import os, sys\r\n import matplotlib.pyplot as plt\r\n\r\n PROJECT_PATH = os.path.abspath(\r\n os.path.join(os.path.dirname(__file__), '..', '..'))\r\n sys.path.append(PROJECT_PATH)\r\n\r\n im_path = os.path.join(PROJECT_PATH, 'extra_files', 'dragon.png')\r\n\r\n for im_path in glob.glob(im_path):\r\n im = imageio.imread(im_path)\r\n\r\n im = im[np.newaxis, :150, :150, :]\r\n im = im / np.max(im)\r\n print(im.shape)\r\n plt.imshow(im[0])\r\n plt.show()\r\n\r\n transformer = Transformer(16, 16)\r\n transformations_inds = np.arange(transformer.n_transforms)\r\n\r\n transformed_batch = transformer.transform_batch(im,\r\n transformations_inds)\r\n\r\n print(transformed_batch.shape)\r\n\r\n for i in range(72):\r\n transform_indx = i\r\n if (i % 4) == 0:\r\n plt.imshow(transformed_batch[transform_indx])\r\n plt.title(str(transformer.tranformation_to_perform[i]))\r\n plt.show()\r\n\r\n\r\ndef plot_img(transformed_batch, transformer, indx, batch_size=8):\r\n plt.imshow(transformed_batch.numpy()[indx])\r\n transform_indx = indx // batch_size\r\n plt.title(str(transformer.tranformation_to_perform[transform_indx]))\r\n plt.show()\r\n\r\n\r\ndef test_dataset_generation():\r\n import imageio\r\n import glob\r\n import os, sys\r\n import datetime\r\n import time\r\n\r\n gpus = tf.config.experimental.list_physical_devices('GPU')\r\n for gpu in gpus:\r\n tf.config.experimental.set_memory_growth(gpu, True)\r\n\r\n PROJECT_PATH = os.path.abspath(\r\n os.path.join(os.path.dirname(__file__), '..', '..'))\r\n sys.path.append(PROJECT_PATH)\r\n\r\n im_path = os.path.join(PROJECT_PATH, 'extra_files', 'dragon.png')\r\n\r\n for im_path in glob.glob(im_path):\r\n im = imageio.imread(im_path)\r\n\r\n im = im[np.newaxis, 5:68, 5:68, :]\r\n im = im / np.max(im)\r\n print(im.shape)\r\n # plt.imshow(im[0])\r\n # plt.show()\r\n\r\n dataset_size = 1000\r\n batch_size = 32\r\n x_test = np.repeat(im, dataset_size, axis=0)\r\n test_ds = tf.data.Dataset.from_tensor_slices((x_test)).batch(batch_size)\r\n transformer = Transformer(8, 8)\r\n transformations_inds = np.arange(transformer.n_transforms)\r\n\r\n EPOCHS = 1\r\n\r\n start_time = time.time()\r\n for epoch in range(EPOCHS):\r\n transformed_dataset = []\r\n for images in test_ds:\r\n transformed_batch = transformer.transform_batch(images,\r\n transformations_inds)\r\n transformed_dataset.append(transformed_batch)\r\n # print(transformed_batch.shape)\r\n transformed_dataset = np.concatenate(\r\n [tensor.numpy() for tensor in transformed_dataset])\r\n print(transformed_dataset.shape)\r\n\r\n time_usage = str(datetime.timedelta(\r\n seconds=int(round(time.time() - start_time))))\r\n print(\"Time usage %s: %s\" % (transformer.name, str(time_usage)), flush=True)\r\n\r\n last_batch_size = dataset_size % batch_size\r\n indx_to_plot = np.arange(transformer.n_transforms) * last_batch_size\r\n for i in indx_to_plot:\r\n plot_img(transformed_batch, transformer, i)\r\n\r\n\r\ndef plot_astro_img(x, transform):\r\n plt.imshow(x[..., 0])\r\n plt.title(str(transform))\r\n plt.show()\r\n\r\n\r\nif __name__ == \"__main__\":\r\n import imageio\r\n import glob\r\n import os, sys\r\n import matplotlib.pyplot as plt\r\n import datetime\r\n import time\r\n\r\n PROJECT_PATH = os.path.abspath(\r\n os.path.join(os.path.dirname(__file__), '..', '..'))\r\n sys.path.append(PROJECT_PATH)\r\n\r\n from modules.utils import set_soft_gpu_memory_growth\r\n from parameters import loader_keys, general_keys\r\n from modules.data_loaders.ztf_outlier_loader import ZTFOutlierLoader\r\n\r\n set_soft_gpu_memory_growth()\r\n\r\n params = {\r\n loader_keys.DATA_PATH: os.path.join(\r\n PROJECT_PATH, '../datasets/ztf_v1_bogus_added.pkl'),\r\n loader_keys.VAL_SET_INLIER_PERCENTAGE: 0.1,\r\n loader_keys.USED_CHANNELS: [0, 1, 2],\r\n loader_keys.CROP_SIZE: 21,\r\n general_keys.RANDOM_SEED: 42,\r\n loader_keys.TRANSFORMATION_INLIER_CLASS_VALUE: 1\r\n }\r\n transformer = Transformer()\r\n batch_size = 512\r\n ztf_outlier_dataset = ZTFOutlierLoader(params)\r\n (X_train, y_train), (X_val, y_val), (\r\n X_test, y_test) = ztf_outlier_dataset.get_outlier_detection_datasets()\r\n\r\n train_ds = tf.data.Dataset.from_tensor_slices((X_train)).batch(batch_size)\r\n transformations_inds = np.arange(transformer.n_transforms)\r\n\r\n EPOCHS = 1\r\n\r\n # # no labels\r\n # train_ds = tf.data.Dataset.from_tensor_slices((X_train)).batch(batch_size)\r\n # transformations_inds = np.arange(transformer.n_transforms)\r\n # start_time = time.time()\r\n # for epoch in range(EPOCHS):\r\n # transformed_dataset_v0 = []\r\n # for images in train_ds:\r\n # transformed_batch = transformer.transform_batch(images,\r\n # transformations_inds)\r\n # transformed_dataset_v0.append(transformed_batch)\r\n # transformed_dataset_v0 = np.concatenate(\r\n # [tensor.numpy() for tensor in transformed_dataset_v0])\r\n # print(transformed_dataset_v0.shape)\r\n # time_usage = str(datetime.timedelta(\r\n # seconds=int(round(time.time() - start_time))))\r\n # print(\"Time usage No Labels %s: %s\" % (transformer.name, str(time_usage)),\r\n # flush=True)\r\n #\r\n # retrieving labels along side batch generationg\r\n start_time = time.time()\r\n for epoch in range(EPOCHS):\r\n transformed_dataset_v0 = transformer.apply_all_transformsv0(X_train,\r\n batch_size)\r\n print(transformed_dataset_v0[0].shape)\r\n time_usage = str(datetime.timedelta(\r\n seconds=int(round(time.time() - start_time))))\r\n print(\"Time usage Images along labels v0 %s: %s\" % (\r\n transformer.name, str(time_usage)), flush=True)\r\n\r\n # retrieving labels after batch generationg\r\n start_time = time.time()\r\n for epoch in range(EPOCHS):\r\n transformed_dataset_v1 = transformer.apply_all_transforms(X_train,\r\n batch_size)\r\n print(transformed_dataset_v1[0].shape)\r\n time_usage = str(datetime.timedelta(\r\n seconds=int(round(time.time() - start_time))))\r\n print(\"Time usage Images along labels v1 %s: %s\" % (\r\n transformer.name, str(time_usage)), flush=True)\r\n\r\n start_time = time.time()\r\n (X_train, y_train), (X_val, y_val), (\r\n X_test, y_test) = ztf_outlier_dataset.get_transformed_datasets(\r\n transformer)\r\n print(\"Time usage Loading Pickle %s: %s\" % (\r\n transformer.name, str(time_usage)), flush=True)\r\n\r\n # from transformations import Transformer as slow_Transformer\r\n #\r\n # slow_transformer = slow_Transformer()\r\n # (X_train, y_train), (X_val, y_val), (\r\n # X_test, y_test) = ztf_outlier_dataset.get_transformed_datasets(\r\n # slow_transformer)\r\n #\r\n # # tranform + n_transforms * sample_i_in_one_batch\r\n # sample_i_in_one_batch = 158\r\n # transform_i = 60\r\n # plot_astro_img(X_train[transform_i + 72 * sample_i_in_one_batch],\r\n # transformer.tranformation_to_perform[\r\n # y_train[transform_i + 72 * sample_i_in_one_batch]])\r\n # # sample_i_in_one_batch + tranform * batch_size\r\n # plot_astro_img(transformed_dataset_v1[0][\r\n # sample_i_in_one_batch + transform_i * batch_size],\r\n # transformer.tranformation_to_perform[\r\n # transformed_dataset_v1[1][\r\n # sample_i_in_one_batch + transform_i * batch_size]])\r\n"
] |
[
[
"matplotlib.pyplot.imshow",
"tensorflow.concat",
"tensorflow.stack",
"numpy.concatenate",
"numpy.max",
"tensorflow.image.rot90",
"numpy.exp",
"tensorflow.nn.depthwise_conv2d",
"tensorflow.config.experimental.set_memory_growth",
"numpy.arange",
"tensorflow.name_scope",
"numpy.repeat",
"tensorflow.config.experimental.list_physical_devices",
"tensorflow.identity",
"matplotlib.pyplot.show",
"numpy.abs",
"tensorflow.data.Dataset.from_tensor_slices",
"tensorflow.expand_dims",
"tensorflow.image.flip_left_right",
"tensorflow.abs"
]
] |
bharats97/ddna-toolbox
|
[
"1856d130c14bab094297b1371c7bde3d78d057db"
] |
[
"examples/plot_sequence_color.py"
] |
[
"\"\"\"\n==================\nSequences by Color\n==================\n\nAn example plot of :class:`digitaldna.TwitterDDNASequencer`\n\"\"\"\nfrom digitaldna import TwitterDDNASequencer\nfrom digitaldna import SequencePlots\nimport numpy as np\n\n# Generate DDNA from Twitter\nmodel = TwitterDDNASequencer(input_file='timelines.json', alphabet='b3_type')\narr = model.fit_transform()\n\n# Simulate bots by repeating 10 times the first timeline\nnrep_arr = [10 if i == 0 else 1 for i in range(len(arr))]\narr = np.repeat(arr, nrep_arr, axis=0)\narr[:, 0] = np.random.randint(0, high=10100, size=len(arr))\n\n# Plot results\nplotter = SequencePlots(alphabet='b3_type')\nplotter.plot_sequences_color(arr[:, 1])\n"
] |
[
[
"numpy.repeat"
]
] |
benbuleong/mmfeat
|
[
"c8d40f2e0bc5385b6978599fac5e46683336ade8"
] |
[
"mmfeat/bow/vw.py"
] |
[
"'''\nBag of Visual Words (BoVW)\n'''\n\nfrom ..base import DataObject\n\nfrom .bow import BoW\nfrom .dsift import DsiftExtractor\n\nimport os\n\nimport numpy as np\n\nfrom scipy.misc import imread\nfrom scipy.io import loadmat\n\nclass BoVW(BoW):\n def loadFile(self, fname):\n '''\n fname: filename of the sound file we want to load\n '''\n if self.verbose: print('Loading %s' % fname)\n\n if self.cached:\n if not os.path.exists(fname + '-dsift.npy'):\n img = imread(fname)\n data = self.dsift.process_image(img)\n np.save(fname + '-dsift.npy', data)\n else:\n try:\n data = np.load(fname + '-dsift.npy')\n except:\n return None\n else:\n img = imread(fname)\n data = self.dsift.process_image(img)\n\n return data\n\n def loadMatlabFile(self, fname):\n '''\n fname: filename of the sound file we want to load\n '''\n if not self.cached: raise ValueError('Can only read cached Matlab files')\n\n if self.verbose: print('Loading %s' % fname)\n\n try:\n data = loadmat(fname + '-dsift.mat')['descrs'].T\n except:\n return None\n\n return data\n\n def load(self, data_dir, cached=True):\n '''\n data_dir: data directory containing an index.pkl file\n cached: determines whether we cache MFCC descriptors to disk\n '''\n self.data_dir = data_dir\n self.cached = cached\n self.dsift = DsiftExtractor()\n self.data = DataObject(data_dir, self.loadFile)\n self.idx = self.data.idx\n"
] |
[
[
"numpy.load",
"scipy.io.loadmat",
"scipy.misc.imread",
"numpy.save"
]
] |
aaronenyeshi/benchmark
|
[
"f12d634ef7d86e457131998f7b641d3b046bc040"
] |
[
"torchbenchmark/models/resnext50_32x4d/__init__.py"
] |
[
"\n# Generated by gen_torchvision_benchmark.py\nimport torch\nimport torch.optim as optim\nimport torchvision.models as models\nfrom ...util.model import BenchmarkModel\nfrom torchbenchmark.tasks import COMPUTER_VISION\n\n#######################################################\n#\n# DO NOT MODIFY THESE FILES DIRECTLY!!!\n# USE `gen_torchvision_benchmarks.py`\n#\n#######################################################\nclass Model(BenchmarkModel):\n task = COMPUTER_VISION.CLASSIFICATION\n optimized_for_inference = True\n def __init__(self, device=None, jit=False):\n super().__init__()\n self.device = device\n self.jit = jit\n self.model = models.resnext50_32x4d().to(self.device)\n self.eval_model = models.resnext50_32x4d().to(self.device)\n self.example_inputs = (torch.randn((32, 3, 224, 224)).to(self.device),)\n\n if self.jit:\n self.model = torch.jit.script(self.model, example_inputs=[self.example_inputs, ])\n self.eval_model = torch.jit.script(self.eval_model)\n # model needs to in `eval`\n # in order to be optimized for inference\n self.eval_model.eval()\n self.eval_model = torch.jit.optimize_for_inference(self.eval_model)\n\n\n def get_module(self):\n return self.model, self.example_inputs\n\n # vision models have another model\n # instance for inference that has\n # already been optimized for inference\n def set_eval(self):\n pass\n\n def train(self, niter=3):\n optimizer = optim.Adam(self.model.parameters())\n loss = torch.nn.CrossEntropyLoss()\n for _ in range(niter):\n optimizer.zero_grad()\n pred = self.model(*self.example_inputs)\n y = torch.empty(pred.shape[0], dtype=torch.long, device=self.device).random_(pred.shape[1])\n loss(pred, y).backward()\n optimizer.step()\n\n def eval(self, niter=1):\n model = self.eval_model\n example_inputs = self.example_inputs\n example_inputs = example_inputs[0]\n for i in range(niter):\n model(example_inputs)\n\n\nif __name__ == \"__main__\":\n m = Model(device=\"cuda\", jit=True)\n module, example_inputs = m.get_module()\n module(*example_inputs)\n m.train(niter=1)\n m.eval(niter=1)\n"
] |
[
[
"torch.jit.script",
"torch.nn.CrossEntropyLoss",
"torch.jit.optimize_for_inference",
"torch.empty",
"torch.randn"
]
] |
khansamad47/statsmodels
|
[
"e1ebcacf92aa9c99aaca5b62a2155d7e061772f1"
] |
[
"statsmodels/tsa/ardl/model.py"
] |
[
"from __future__ import annotations\n\nfrom statsmodels.compat.pandas import Appender, Substitution\nfrom statsmodels.compat.python import Literal\n\nfrom collections import defaultdict\nimport datetime as dt\nfrom itertools import combinations, product\nimport textwrap\nfrom types import SimpleNamespace\nfrom typing import (\n TYPE_CHECKING,\n Any,\n Dict,\n Hashable,\n List,\n Mapping,\n NamedTuple,\n Optional,\n Sequence,\n Tuple,\n Union,\n)\nimport warnings\n\nimport numpy as np\nimport pandas as pd\nfrom scipy import stats\n\nfrom statsmodels.base.data import PandasData\nimport statsmodels.base.wrapper as wrap\nfrom statsmodels.iolib.summary import Summary, summary_params\nfrom statsmodels.regression.linear_model import OLS\nfrom statsmodels.tools.decorators import cache_readonly\nfrom statsmodels.tools.docstring import Docstring, Parameter, remove_parameters\nfrom statsmodels.tools.sm_exceptions import SpecificationWarning\nfrom statsmodels.tools.validation import (\n array_like,\n bool_like,\n float_like,\n int_like,\n)\nfrom statsmodels.tsa.ar_model import (\n AROrderSelectionResults,\n AutoReg,\n AutoRegResults,\n sumofsq,\n)\nfrom statsmodels.tsa.ardl import pss_critical_values\nfrom statsmodels.tsa.arima_process import arma2ma\nfrom statsmodels.tsa.base import tsa_model\nfrom statsmodels.tsa.base.prediction import PredictionResults\nfrom statsmodels.tsa.deterministic import DeterministicProcess\nfrom statsmodels.tsa.tsatools import lagmat\n\nif TYPE_CHECKING:\n import matplotlib.figure\n\n__all__ = [\n \"ARDL\",\n \"ARDLResults\",\n \"ardl_select_order\",\n \"ARDLOrderSelectionResults\",\n \"UECM\",\n \"UECMResults\",\n \"BoundsTestResult\",\n]\n\n\nclass BoundsTestResult(NamedTuple):\n stat: float\n crit_vals: pd.DataFrame\n p_values: pd.Series\n null: str\n alternative: str\n\n def __repr__(self):\n return f\"\"\"\\\n{self.__class__.__name__}\nStat: {self.stat:0.5f}\nUpper P-value: {self.p_values[\"upper\"]:0.3g}\nLower P-value: {self.p_values[\"lower\"]:0.3g}\nNull: {self.null}\nAlternative: {self.alternative}\n\"\"\"\n\n\n_UECMOrder = Union[None, int, Dict[Hashable, Optional[int]]]\n\n_ARDLOrder = Union[\n _UECMOrder,\n Sequence[int],\n Dict[Hashable, Union[None, int, Sequence[int]]],\n]\n\n_ArrayLike1D = Union[Sequence[float], np.ndarray, pd.Series]\n_ArrayLike2D = Union[Sequence[Sequence[float]], np.ndarray, pd.DataFrame]\n_INT_TYPES = (int, np.integer)\n\n\ndef _check_order(order: Union[int, Sequence[int]], causal: bool) -> bool:\n if order is None:\n return True\n if isinstance(order, (int, np.integer)):\n if int(order) < int(causal):\n raise ValueError(\n f\"integer orders must be at least {int(causal)} when causal \"\n f\"is {causal}.\"\n )\n return True\n for v in order:\n if not isinstance(v, (int, np.integer)):\n raise TypeError(\n \"sequence orders must contain non-negative integer values\"\n )\n order = [int(v) for v in order]\n if len(set(order)) != len(order) or min(order) < 0:\n raise ValueError(\n \"sequence orders must contain distinct non-negative values\"\n )\n if int(causal) and min(order) < 1:\n raise ValueError(\n \"sequence orders must be strictly positive when causal is True\"\n )\n return True\n\n\ndef _format_order(\n exog: _ArrayLike2D, order: _ARDLOrder, causal: bool\n) -> Dict[Hashable, List[int]]:\n if exog is None and order in (0, None):\n return {}\n if not isinstance(exog, pd.DataFrame):\n exog = array_like(exog, \"exog\", ndim=2, maxdim=2)\n keys = list(range(exog.shape[1]))\n else:\n keys = exog.columns\n if order is None:\n exog_order = {k: None for k in keys}\n elif isinstance(order, Mapping):\n exog_order = order\n missing = set(keys).difference(order.keys())\n extra = set(order.keys()).difference(keys)\n if extra:\n msg = (\n \"order dictionary contains keys for exogenous \"\n \"variable(s) that are not contained in exog\"\n )\n msg += \" Extra keys: \"\n msg += \", \".join([str(k) for k in sorted(extra)]) + \".\"\n raise ValueError(msg)\n if missing:\n msg = (\n \"exog contains variables that are missing from the order \"\n \"dictionary. Missing keys: \"\n )\n msg += \", \".join([str(k) for k in sorted(missing)]) + \".\"\n warnings.warn(msg, SpecificationWarning)\n\n for key in exog_order:\n _check_order(exog_order[key], causal)\n elif isinstance(order, _INT_TYPES):\n _check_order(order, causal)\n exog_order = {k: int(order) for k in keys}\n else:\n _check_order(order, causal)\n exog_order = {k: list(order) for k in keys}\n final_order: Dict[Hashable, List[int]] = {}\n for key in exog_order:\n if exog_order[key] is None:\n continue\n if isinstance(exog_order[key], int):\n final_order[key] = list(range(int(causal), exog_order[key] + 1))\n else:\n final_order[key] = [int(lag) for lag in exog_order[key]]\n\n return final_order\n\n\nclass ARDL(AutoReg):\n r\"\"\"\n Autoregressive Distributed Lag (ARDL) Model\n\n Parameters\n ----------\n endog : array_like\n A 1-d endogenous response variable. The dependent variable.\n lags : {int, list[int]}\n The number of lags to include in the model if an integer or the\n list of lag indices to include. For example, [1, 4] will only\n include lags 1 and 4 while lags=4 will include lags 1, 2, 3, and 4.\n exog : array_like\n Exogenous variables to include in the model. Either a DataFrame or\n an 2-d array-like structure that can be converted to a NumPy array.\n order : {int, sequence[int], dict}\n If int, uses lags 0, 1, ..., order for all exog variables. If\n sequence[int], uses the ``order`` for all variables. If a dict,\n applies the lags series by series. If ``exog`` is anything other\n than a DataFrame, the keys are the column index of exog (e.g., 0,\n 1, ...). If a DataFrame, keys are column names.\n fixed : array_like\n Additional fixed regressors that are not lagged.\n causal : bool, optional\n Whether to include lag 0 of exog variables. If True, only includes\n lags 1, 2, ...\n trend : {'n', 'c', 't', 'ct'}, optional\n The trend to include in the model:\n\n * 'n' - No trend.\n * 'c' - Constant only.\n * 't' - Time trend only.\n * 'ct' - Constant and time trend.\n\n The default is 'c'.\n\n seasonal : bool, optional\n Flag indicating whether to include seasonal dummies in the model. If\n seasonal is True and trend includes 'c', then the first period\n is excluded from the seasonal terms.\n deterministic : DeterministicProcess, optional\n A deterministic process. If provided, trend and seasonal are ignored.\n A warning is raised if trend is not \"n\" and seasonal is not False.\n hold_back : {None, int}, optional\n Initial observations to exclude from the estimation sample. If None,\n then hold_back is equal to the maximum lag in the model. Set to a\n non-zero value to produce comparable models with different lag\n length. For example, to compare the fit of a model with lags=3 and\n lags=1, set hold_back=3 which ensures that both models are estimated\n using observations 3,...,nobs. hold_back must be >= the maximum lag in\n the model.\n period : {None, int}, optional\n The period of the data. Only used if seasonal is True. This parameter\n can be omitted if using a pandas object for endog that contains a\n recognized frequency.\n missing : {\"none\", \"drop\", \"raise\"}, optional\n Available options are 'none', 'drop', and 'raise'. If 'none', no nan\n checking is done. If 'drop', any observations with nans are dropped.\n If 'raise', an error is raised. Default is 'none'.\n\n Notes\n -----\n The full specification of an ARDL is\n\n .. math ::\n\n Y_t = \\delta_0 + \\delta_1 t + \\delta_2 t^2\n + \\sum_{i=1}^{s-1} \\gamma_i I_{[(\\mod(t,s) + 1) = i]}\n + \\sum_{j=1}^p \\phi_j Y_{t-j}\n + \\sum_{l=1}^k \\sum_{m=0}^{o_l} \\beta_{l,m} X_{l, t-m}\n + Z_t \\lambda\n + \\epsilon_t\n\n where :math:`\\delta_\\bullet` capture trends, :math:`\\gamma_\\bullet`\n capture seasonal shifts, s is the period of the seasonality, p is the\n lag length of the endogenous variable, k is the number of exogenous\n variables :math:`X_{l}`, :math:`o_l` is included the lag length of\n :math:`X_{l}`, :math:`Z_t` are ``r`` included fixed regressors and\n :math:`\\epsilon_t` is a white noise shock. If ``causal`` is ``True``,\n then the 0-th lag of the exogenous variables is not included and the\n sum starts at ``m=1``.\n\n See Also\n --------\n statsmodels.tsa.ar_model.AutoReg\n Autoregressive model estimation with optional exogenous regressors\n statsmodels.tsa.ardl.UECM\n Unconstrained Error Correction Model estimation\n statsmodels.tsa.statespace.sarimax.SARIMAX\n Seasonal ARIMA model estimation with optional exogenous regressors\n statsmodels.tsa.arima.model.ARIMA\n ARIMA model estimation\n\n Examples\n --------\n >>> from statsmodels.tsa.api import ARDL\n >>> from statsmodels.datasets import danish_data\n >>> data = danish_data.load_pandas().data\n >>> lrm = data.lrm\n >>> exog = data[[\"lry\", \"ibo\", \"ide\"]]\n\n A basic model where all variables have 3 lags included\n\n >>> ARDL(data.lrm, 3, data[[\"lry\", \"ibo\", \"ide\"]], 3)\n\n A dictionary can be used to pass custom lag orders\n\n >>> ARDL(data.lrm, [1, 3], exog, {\"lry\": 1, \"ibo\": 3, \"ide\": 2})\n\n Setting causal removes the 0-th lag from the exogenous variables\n\n >>> exog_lags = {\"lry\": 1, \"ibo\": 3, \"ide\": 2}\n >>> ARDL(data.lrm, [1, 3], exog, exog_lags, causal=True)\n\n A dictionary can also be used to pass specific lags to include.\n Sequences hold the specific lags to include, while integers are expanded\n to include [0, 1, ..., lag]. If causal is False, then the 0-th lag is\n excluded.\n\n >>> ARDL(lrm, [1, 3], exog, {\"lry\": [0, 1], \"ibo\": [0, 1, 3], \"ide\": 2})\n\n When using NumPy arrays, the dictionary keys are the column index.\n\n >>> import numpy as np\n >>> lrma = np.asarray(lrm)\n >>> exoga = np.asarray(exog)\n >>> ARDL(lrma, 3, exoga, {0: [0, 1], 1: [0, 1, 3], 2: 2})\n \"\"\"\n\n def __init__(\n self,\n endog: Union[Sequence[float], pd.Series, _ArrayLike2D],\n lags: Union[None, int, Sequence[int]],\n exog: Optional[_ArrayLike2D] = None,\n order: _ARDLOrder = 0,\n trend: Literal[\"n\", \"c\", \"ct\", \"ctt\"] = \"c\",\n *,\n fixed: Optional[_ArrayLike2D] = None,\n causal: bool = False,\n seasonal: bool = False,\n deterministic: Optional[DeterministicProcess] = None,\n hold_back: Optional[int] = None,\n period: Optional[int] = None,\n missing: Literal[\"none\", \"drop\", \"raise\"] = \"none\",\n ) -> None:\n self._x = np.empty((0, 0))\n self._y = np.empty((0,))\n\n super().__init__(\n endog,\n lags,\n trend=trend,\n seasonal=seasonal,\n exog=exog,\n hold_back=hold_back,\n period=period,\n missing=missing,\n deterministic=deterministic,\n old_names=False,\n )\n # Reset hold back which was set in AutoReg.__init__\n self._causal = bool_like(causal, \"causal\", strict=True)\n self.data.orig_fixed = fixed\n if fixed is not None:\n fixed_arr = array_like(fixed, \"fixed\", ndim=2, maxdim=2)\n if fixed_arr.shape[0] != self.data.endog.shape[0] or not np.all(\n np.isfinite(fixed_arr)\n ):\n raise ValueError(\n \"fixed must be an (nobs, m) array where nobs matches the \"\n \"number of observations in the endog variable, and all\"\n \"values must be finite\"\n )\n if isinstance(fixed, pd.DataFrame):\n self._fixed_names = list(fixed.columns)\n else:\n self._fixed_names = [\n f\"z.{i}\" for i in range(fixed_arr.shape[1])\n ]\n self._fixed = fixed_arr\n else:\n self._fixed = np.empty((self.data.endog.shape[0], 0))\n self._fixed_names = []\n\n self._blocks: Dict[str, np.ndarray] = {}\n self._names: Dict[str, Sequence[str]] = {}\n\n # 1. Check and update order\n self._order = self._check_order(order)\n # 2. Construct Regressors\n self._y, self._x = self._construct_regressors(hold_back)\n # 3. Construct variable names\n self._endog_name, self._exog_names = self._construct_variable_names()\n self.data.param_names = self.data.xnames = self._exog_names\n self.data.ynames = self._endog_name\n\n self._causal = True\n if self._order:\n min_lags = [min(val) for val in self._order.values()]\n self._causal = min(min_lags) > 0\n self._results_class = ARDLResults\n self._results_wrapper = ARDLResultsWrapper\n\n @property\n def fixed(self) -> Union[None, np.ndarray, pd.DataFrame]:\n \"\"\"The fixed data used to construct the model\"\"\"\n return self.data.orig_fixed\n\n @property\n def causal(self) -> bool:\n \"\"\"Flag indicating that the ARDL is causal\"\"\"\n return self._causal\n\n @property\n def ar_lags(self) -> Optional[List[int]]:\n \"\"\"The autoregressive lags included in the model\"\"\"\n return None if not self._lags else self._lags\n\n @property\n def dl_lags(self) -> Dict[Hashable, List[int]]:\n \"\"\"The lags of exogenous variables included in the model\"\"\"\n return self._order\n\n @property\n def ardl_order(self) -> Tuple[int, ...]:\n \"\"\"The order of the ARDL(p,q)\"\"\"\n ar_order = 0 if not self._lags else int(max(self._lags))\n ardl_order = [ar_order]\n for lags in self._order.values():\n if lags is not None:\n ardl_order.append(int(max(lags)))\n return tuple(ardl_order)\n\n def _setup_regressors(self) -> None:\n \"\"\"Place holder to let AutoReg init complete\"\"\"\n self._y = np.empty((self.endog.shape[0] - self._hold_back, 0))\n\n @staticmethod\n def _format_exog(\n exog: _ArrayLike2D, order: Dict[Hashable, List[int]]\n ) -> Dict[Hashable, np.ndarray]:\n \"\"\"Transform exogenous variables and orders to regressors\"\"\"\n if not order:\n return {}\n max_order = 0\n for val in order.values():\n if val is not None:\n max_order = max(max(val), max_order)\n if not isinstance(exog, pd.DataFrame):\n exog = array_like(exog, \"exog\", ndim=2, maxdim=2)\n exog_lags = {}\n for key in order:\n if order[key] is None:\n continue\n if isinstance(exog, np.ndarray):\n col = exog[:, key]\n else:\n col = exog[key]\n lagged_col = lagmat(col, max_order, original=\"in\")\n lags = order[key]\n exog_lags[key] = lagged_col[:, lags]\n return exog_lags\n\n def _check_order(self, order: _ARDLOrder) -> Dict[Hashable, List[int]]:\n \"\"\"Validate and standardize the model order\"\"\"\n return _format_order(self.data.orig_exog, order, self._causal)\n\n def _fit(\n self,\n cov_type: str = \"nonrobust\",\n cov_kwds: Dict[str, Any] = None,\n use_t: bool = True,\n ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\n if self._x.shape[1] == 0:\n return np.empty((0,)), np.empty((0, 0)), np.empty((0, 0))\n ols_mod = OLS(self._y, self._x)\n ols_res = ols_mod.fit(\n cov_type=cov_type, cov_kwds=cov_kwds, use_t=use_t\n )\n cov_params = ols_res.cov_params()\n use_t = ols_res.use_t\n if cov_type == \"nonrobust\" and not use_t:\n nobs = self._y.shape[0]\n k = self._x.shape[1]\n scale = nobs / (nobs - k)\n cov_params /= scale\n\n return ols_res.params, cov_params, ols_res.normalized_cov_params\n\n def fit(\n self,\n *,\n cov_type: str = \"nonrobust\",\n cov_kwds: Dict[str, Any] = None,\n use_t: bool = True,\n ) -> ARDLResults:\n \"\"\"\n Estimate the model parameters.\n\n Parameters\n ----------\n cov_type : str\n The covariance estimator to use. The most common choices are listed\n below. Supports all covariance estimators that are available\n in ``OLS.fit``.\n\n * 'nonrobust' - The class OLS covariance estimator that assumes\n homoskedasticity.\n * 'HC0', 'HC1', 'HC2', 'HC3' - Variants of White's\n (or Eiker-Huber-White) covariance estimator. `HC0` is the\n standard implementation. The other make corrections to improve\n the finite sample performance of the heteroskedasticity robust\n covariance estimator.\n * 'HAC' - Heteroskedasticity-autocorrelation robust covariance\n estimation. Supports cov_kwds.\n\n - `maxlags` integer (required) : number of lags to use.\n - `kernel` callable or str (optional) : kernel\n currently available kernels are ['bartlett', 'uniform'],\n default is Bartlett.\n - `use_correction` bool (optional) : If true, use small sample\n correction.\n cov_kwds : dict, optional\n A dictionary of keyword arguments to pass to the covariance\n estimator. `nonrobust` and `HC#` do not support cov_kwds.\n use_t : bool, optional\n A flag indicating that inference should use the Student's t\n distribution that accounts for model degree of freedom. If False,\n uses the normal distribution. If None, defers the choice to\n the cov_type. It also removes degree of freedom corrections from\n the covariance estimator when cov_type is 'nonrobust'.\n\n Returns\n -------\n ARDLResults\n Estimation results.\n\n See Also\n --------\n statsmodels.tsa.ar_model.AutoReg\n Ordinary Least Squares estimation.\n statsmodels.regression.linear_model.OLS\n Ordinary Least Squares estimation.\n statsmodels.regression.linear_model.RegressionResults\n See ``get_robustcov_results`` for a detailed list of available\n covariance estimators and options.\n\n Notes\n -----\n Use ``OLS`` to estimate model parameters and to estimate parameter\n covariance.\n \"\"\"\n params, cov_params, norm_cov_params = self._fit(\n cov_type=cov_type, cov_kwds=cov_kwds, use_t=use_t\n )\n res = ARDLResults(\n self, params, cov_params, norm_cov_params, use_t=use_t\n )\n return ARDLResultsWrapper(res)\n\n def _construct_regressors(\n self, hold_back: Optional[int]\n ) -> Tuple[np.ndarray, np.ndarray]:\n \"\"\"Construct and format model regressors\"\"\"\n # TODO: Missing adjustment\n self._maxlag = max(self._lags) if self._lags else 0\n self._endog_reg, self._endog = lagmat(\n self.data.endog, self._maxlag, original=\"sep\"\n )\n if self._endog_reg.shape[1] != len(self._lags):\n lag_locs = [lag - 1 for lag in self._lags]\n self._endog_reg = self._endog_reg[:, lag_locs]\n\n orig_exog = self.data.orig_exog\n self._exog = self._format_exog(orig_exog, self._order)\n\n exog_maxlag = 0\n for val in self._order.values():\n exog_maxlag = max(exog_maxlag, max(val) if val is not None else 0)\n self._maxlag = max(self._maxlag, exog_maxlag)\n\n self._deterministic_reg = self._deterministics.in_sample()\n self._blocks = {\n \"endog\": self._endog_reg,\n \"exog\": self._exog,\n \"deterministic\": self._deterministic_reg,\n \"fixed\": self._fixed,\n }\n x = [self._deterministic_reg, self._endog_reg]\n x += [ex for ex in self._exog.values()] + [self._fixed]\n reg = np.column_stack(x)\n if hold_back is None:\n self._hold_back = int(self._maxlag)\n if self._hold_back < self._maxlag:\n raise ValueError(\n \"hold_back must be >= the maximum lag of the endog and exog \"\n \"variables\"\n )\n reg = reg[self._hold_back :]\n if reg.shape[1] > reg.shape[0]:\n raise ValueError(\n f\"The number of regressors ({reg.shape[1]}) including \"\n \"deterministics, lags of the endog, lags of the exogenous, \"\n \"and fixed regressors is larer than the sample available \"\n f\"for estimation ({reg.shape[0]}).\"\n )\n return self.data.endog[self._hold_back :], reg\n\n def _construct_variable_names(self):\n \"\"\"Construct model variables names\"\"\"\n y_name = self.data.ynames\n endog_lag_names = [f\"{y_name}.L{i}\" for i in self._lags]\n\n exog = self.data.orig_exog\n exog_names = {}\n for key in self._order:\n if isinstance(exog, np.ndarray):\n base = f\"x{key}\"\n else:\n base = str(key)\n lags = self._order[key]\n exog_names[key] = [f\"{base}.L{lag}\" for lag in lags]\n\n self._names = {\n \"endog\": endog_lag_names,\n \"exog\": exog_names,\n \"deterministic\": self._deterministic_reg.columns,\n \"fixed\": self._fixed_names,\n }\n x_names = list(self._deterministic_reg.columns)\n x_names += endog_lag_names\n for key in exog_names:\n x_names += exog_names[key]\n x_names += self._fixed_names\n return y_name, x_names\n\n def _forecasting_x(\n self,\n start: int,\n end: int,\n num_oos: int,\n exog: Optional[_ArrayLike2D],\n exog_oos: Optional[_ArrayLike2D],\n fixed: Optional[_ArrayLike2D],\n fixed_oos: Optional[_ArrayLike2D],\n ) -> np.ndarray:\n \"\"\"Construct exog matrix for forecasts\"\"\"\n\n def pad_x(x: np.ndarray, pad: int) -> np.ndarray:\n if pad == 0:\n return x\n k = x.shape[1]\n return np.vstack([np.full((pad, k), np.nan), x])\n\n pad = 0 if start >= self._hold_back else self._hold_back - start\n # Shortcut if all in-sample and no new data\n\n if (end + 1) < self.endog.shape[0] and exog is None and fixed is None:\n adjusted_start = max(start - self._hold_back, 0)\n return pad_x(\n self._x[adjusted_start : end + 1 - self._hold_back], pad\n )\n\n # If anything changed, rebuild x array\n exog = self.data.exog if exog is None else np.asarray(exog)\n if exog_oos is not None:\n exog = np.vstack([exog, np.asarray(exog_oos)[:num_oos]])\n fixed = self._fixed if fixed is None else np.asarray(fixed)\n if fixed_oos is not None:\n fixed = np.vstack([fixed, np.asarray(fixed_oos)[:num_oos]])\n det = self._deterministics.in_sample()\n if num_oos:\n oos_det = self._deterministics.out_of_sample(num_oos)\n det = pd.concat([det, oos_det], axis=0)\n endog = self.data.endog\n if num_oos:\n endog = np.hstack([endog, np.full(num_oos, np.nan)])\n x = [det]\n if self._lags:\n endog_reg = lagmat(endog, max(self._lags), original=\"ex\")\n x.append(endog_reg[:, [lag - 1 for lag in self._lags]])\n if self.ardl_order[1:]:\n if isinstance(self.data.orig_exog, pd.DataFrame):\n exog = pd.DataFrame(exog, columns=self.data.orig_exog.columns)\n exog = self._format_exog(exog, self._order)\n x.extend([np.asarray(arr) for arr in exog.values()])\n if fixed.shape[1] > 0:\n x.append(fixed)\n _x = np.column_stack(x)\n _x[: self._hold_back] = np.nan\n return _x[start:]\n\n def predict(\n self,\n params: _ArrayLike1D,\n start: Union[None, int, str, dt.datetime, pd.Timestamp] = None,\n end: Union[None, int, str, dt.datetime, pd.Timestamp] = None,\n dynamic: bool = False,\n exog: Union[None, np.ndarray, pd.DataFrame] = None,\n exog_oos: Union[None, np.ndarray, pd.DataFrame] = None,\n fixed: Union[None, np.ndarray, pd.DataFrame] = None,\n fixed_oos: Union[None, np.ndarray, pd.DataFrame] = None,\n ):\n \"\"\"\n In-sample prediction and out-of-sample forecasting.\n\n Parameters\n ----------\n params : array_like\n The fitted model parameters.\n start : int, str, or datetime, optional\n Zero-indexed observation number at which to start forecasting,\n i.e., the first forecast is start. Can also be a date string to\n parse or a datetime type. Default is the the zeroth observation.\n end : int, str, or datetime, optional\n Zero-indexed observation number at which to end forecasting, i.e.,\n the last forecast is end. Can also be a date string to\n parse or a datetime type. However, if the dates index does not\n have a fixed frequency, end must be an integer index if you\n want out-of-sample prediction. Default is the last observation in\n the sample. Unlike standard python slices, end is inclusive so\n that all the predictions [start, start+1, ..., end-1, end] are\n returned.\n dynamic : {bool, int, str, datetime, Timestamp}, optional\n Integer offset relative to `start` at which to begin dynamic\n prediction. Prior to this observation, true endogenous values\n will be used for prediction; starting with this observation and\n continuing through the end of prediction, forecasted endogenous\n values will be used instead. Datetime-like objects are not\n interpreted as offsets. They are instead used to find the index\n location of `dynamic` which is then used to to compute the offset.\n exog : array_like\n A replacement exogenous array. Must have the same shape as the\n exogenous data array used when the model was created.\n exog_oos : array_like\n An array containing out-of-sample values of the exogenous\n variables. Must have the same number of columns as the exog\n used when the model was created, and at least as many rows as\n the number of out-of-sample forecasts.\n fixed : array_like\n A replacement fixed array. Must have the same shape as the\n fixed data array used when the model was created.\n fixed_oos : array_like\n An array containing out-of-sample values of the fixed variables.\n Must have the same number of columns as the fixed used when the\n model was created, and at least as many rows as the number of\n out-of-sample forecasts.\n\n Returns\n -------\n predictions : {ndarray, Series}\n Array of out of in-sample predictions and / or out-of-sample\n forecasts.\n \"\"\"\n params, exog, exog_oos, start, end, num_oos = self._prepare_prediction(\n params, exog, exog_oos, start, end\n )\n\n def check_exog(arr, name, orig, exact):\n if isinstance(orig, pd.DataFrame):\n if not isinstance(arr, pd.DataFrame):\n raise TypeError(\n f\"{name} must be a DataFrame when the original exog \"\n f\"was a DataFrame\"\n )\n if sorted(arr.columns) != sorted(self.data.orig_exog.columns):\n raise ValueError(\n f\"{name} must have the same columns as the original \"\n f\"exog\"\n )\n else:\n arr = array_like(arr, name, ndim=2, optional=False)\n if arr.ndim != 2 or arr.shape[1] != orig.shape[1]:\n raise ValueError(\n f\"{name} must have the same number of columns as the \"\n f\"original data, {orig.shape[1]}\"\n )\n if exact and arr.shape[0] != orig.shape[0]:\n raise ValueError(\n f\"{name} must have the same number of rows as the \"\n f\"original data ({n}).\"\n )\n return arr\n\n n = self.data.endog.shape[0]\n if exog is not None:\n exog = check_exog(exog, \"exog\", self.data.orig_exog, True)\n if exog_oos is not None:\n exog_oos = check_exog(\n exog_oos, \"exog_oos\", self.data.orig_exog, False\n )\n if fixed is not None:\n fixed = check_exog(fixed, \"fixed\", self._fixed, True)\n if fixed_oos is not None:\n fixed_oos = check_exog(\n np.asarray(fixed_oos), \"fixed_oos\", self._fixed, False\n )\n # The maximum number of 1-step predictions that can be made,\n # which depends on the model and lags\n if self._fixed.shape[1] or not self._causal:\n max_1step = 0\n else:\n max_1step = np.inf if not self._lags else min(self._lags)\n if self._order:\n min_exog = min([min(v) for v in self._order.values()])\n max_1step = min(max_1step, min_exog)\n if num_oos > max_1step:\n if self._order and exog_oos is None:\n raise ValueError(\n \"exog_oos must be provided when out-of-sample \"\n \"observations require values of the exog not in the \"\n \"original sample\"\n )\n elif self._order and (exog_oos.shape[0] + max_1step) < num_oos:\n raise ValueError(\n f\"exog_oos must have at least {num_oos - max_1step} \"\n f\"observations to produce {num_oos} forecasts based on \"\n f\"the model specification.\"\n )\n\n if self._fixed.shape[1] and fixed_oos is None:\n raise ValueError(\n \"fixed_oos must be provided when predicting \"\n \"out-of-sample observations\"\n )\n elif self._fixed.shape[1] and fixed_oos.shape[0] < num_oos:\n raise ValueError(\n f\"fixed_oos must have at least {num_oos} observations \"\n f\"to produce {num_oos} forecasts.\"\n )\n # Extend exog_oos if fcast is valid for horizon but no exog_oos given\n if self.exog is not None and exog_oos is None and num_oos:\n exog_oos = np.full((num_oos, self.exog.shape[1]), np.nan)\n if isinstance(self.data.orig_exog, pd.DataFrame):\n exog_oos = pd.DataFrame(\n exog_oos, columns=self.data.orig_exog.columns\n )\n x = self._forecasting_x(\n start, end, num_oos, exog, exog_oos, fixed, fixed_oos\n )\n if dynamic is False:\n dynamic_start = end + 1 - start\n else:\n dynamic_step = self._parse_dynamic(dynamic, start)\n dynamic_start = dynamic_step\n if start < self._hold_back:\n dynamic_start = max(dynamic_start, self._hold_back - start)\n\n fcasts = np.full(x.shape[0], np.nan)\n fcasts[:dynamic_start] = x[:dynamic_start] @ params\n offset = self._deterministic_reg.shape[1]\n for i in range(dynamic_start, fcasts.shape[0]):\n for j, lag in enumerate(self._lags):\n loc = i - lag\n if loc >= dynamic_start:\n val = fcasts[loc]\n else:\n # Actual data\n val = self.endog[start + loc]\n x[i, offset + j] = val\n fcasts[i] = x[i] @ params\n return self._wrap_prediction(fcasts, start, end + 1 + num_oos, 0)\n\n @classmethod\n def from_formula(\n cls,\n formula: str,\n data: pd.DataFrame,\n lags: Union[None, int, Sequence[int]] = 0,\n order: _ARDLOrder = 0,\n trend: Literal[\"n\", \"c\", \"ct\", \"ctt\"] = \"n\",\n *,\n causal: bool = False,\n seasonal: bool = False,\n deterministic: Optional[DeterministicProcess] = None,\n hold_back: Optional[int] = None,\n period: Optional[int] = None,\n missing: Literal[\"none\", \"raise\"] = \"none\",\n ) -> ARDL:\n \"\"\"\n Construct an ARDL from a formula\n\n Parameters\n ----------\n formula : str\n Formula with form dependent ~ independent | fixed. See Examples\n below.\n data : DataFrame\n DataFrame containing the variables in the formula.\n lags : {int, list[int]}\n The number of lags to include in the model if an integer or the\n list of lag indices to include. For example, [1, 4] will only\n include lags 1 and 4 while lags=4 will include lags 1, 2, 3,\n and 4.\n order : {int, sequence[int], dict}\n If int, uses lags 0, 1, ..., order for all exog variables. If\n sequence[int], uses the ``order`` for all variables. If a dict,\n applies the lags series by series. If ``exog`` is anything other\n than a DataFrame, the keys are the column index of exog (e.g., 0,\n 1, ...). If a DataFrame, keys are column names.\n causal : bool, optional\n Whether to include lag 0 of exog variables. If True, only\n includes lags 1, 2, ...\n trend : {'n', 'c', 't', 'ct'}, optional\n The trend to include in the model:\n\n * 'n' - No trend.\n * 'c' - Constant only.\n * 't' - Time trend only.\n * 'ct' - Constant and time trend.\n\n The default is 'c'.\n\n seasonal : bool, optional\n Flag indicating whether to include seasonal dummies in the model.\n If seasonal is True and trend includes 'c', then the first period\n is excluded from the seasonal terms.\n deterministic : DeterministicProcess, optional\n A deterministic process. If provided, trend and seasonal are\n ignored. A warning is raised if trend is not \"n\" and seasonal\n is not False.\n hold_back : {None, int}, optional\n Initial observations to exclude from the estimation sample. If\n None, then hold_back is equal to the maximum lag in the model.\n Set to a non-zero value to produce comparable models with\n different lag length. For example, to compare the fit of a model\n with lags=3 and lags=1, set hold_back=3 which ensures that both\n models are estimated using observations 3,...,nobs. hold_back\n must be >= the maximum lag in the model.\n period : {None, int}, optional\n The period of the data. Only used if seasonal is True. This\n parameter can be omitted if using a pandas object for endog\n that contains a recognized frequency.\n missing : {\"none\", \"drop\", \"raise\"}, optional\n Available options are 'none', 'drop', and 'raise'. If 'none', no\n nan checking is done. If 'drop', any observations with nans are\n dropped. If 'raise', an error is raised. Default is 'none'.\n\n Returns\n -------\n ARDL\n The ARDL model instance\n\n Examples\n --------\n A simple ARDL using the Danish data\n\n >>> from statsmodels.datasets.danish_data import load\n >>> from statsmodels.tsa.api import ARDL\n >>> data = load().data\n >>> mod = ARDL.from_formula(\"lrm ~ ibo\", data, 2, 2)\n\n Fixed regressors can be specified using a |\n\n >>> mod = ARDL.from_formula(\"lrm ~ ibo | ide\", data, 2, 2)\n \"\"\"\n index = data.index\n fixed_formula = None\n if \"|\" in formula:\n formula, fixed_formula = formula.split(\"|\")\n fixed_formula = fixed_formula.strip()\n mod = OLS.from_formula(formula + \" -1\", data)\n exog = mod.data.orig_exog\n exog.index = index\n endog = mod.data.orig_endog\n endog.index = index\n if fixed_formula is not None:\n endog_name = formula.split(\"~\")[0].strip()\n fixed_formula = f\"{endog_name} ~ {fixed_formula} - 1\"\n mod = OLS.from_formula(fixed_formula, data)\n fixed: Optional[pd.DataFrame] = mod.data.orig_exog\n fixed.index = index\n else:\n fixed = None\n return cls(\n endog,\n lags,\n exog,\n order,\n trend=trend,\n fixed=fixed,\n causal=causal,\n seasonal=seasonal,\n deterministic=deterministic,\n hold_back=hold_back,\n period=period,\n missing=missing,\n )\n\n\ndoc = Docstring(ARDL.predict.__doc__)\n_predict_params = doc.extract_parameters(\n [\"start\", \"end\", \"dynamic\", \"exog\", \"exog_oos\", \"fixed\", \"fixed_oos\"], 8\n)\n\n\nclass ARDLResults(AutoRegResults):\n \"\"\"\n Class to hold results from fitting an ARDL model.\n\n Parameters\n ----------\n model : ARDL\n Reference to the model that is fit.\n params : ndarray\n The fitted parameters from the AR Model.\n cov_params : ndarray\n The estimated covariance matrix of the model parameters.\n normalized_cov_params : ndarray\n The array inv(dot(x.T,x)) where x contains the regressors in the\n model.\n scale : float, optional\n An estimate of the scale of the model.\n use_t : bool\n Whether use_t was set in fit\n \"\"\"\n\n _cache = {} # for scale setter\n\n def __init__(\n self,\n model: ARDL,\n params: np.ndarray,\n cov_params: np.ndarray,\n normalized_cov_params: Optional[np.ndarray] = None,\n scale: float = 1.0,\n use_t: bool = False,\n ):\n super().__init__(\n model, params, normalized_cov_params, scale, use_t=use_t\n )\n self._cache = {}\n self._params = params\n self._nobs = model.nobs\n self._n_totobs = model.endog.shape[0]\n self._df_model = model.df_model\n self._ar_lags = model.ar_lags\n self._max_lag = 0\n if self._ar_lags:\n self._max_lag = max(self._ar_lags)\n self._hold_back = self.model.hold_back\n self.cov_params_default = cov_params\n\n @Appender(remove_parameters(ARDL.predict.__doc__, \"params\"))\n def predict(\n self,\n start: Union[None, int, str, dt.datetime, pd.Timestamp] = None,\n end: Union[None, int, str, dt.datetime, pd.Timestamp] = None,\n dynamic: bool = False,\n exog: Union[None, np.ndarray, pd.DataFrame] = None,\n exog_oos: Union[None, np.ndarray, pd.DataFrame] = None,\n fixed: Union[None, np.ndarray, pd.DataFrame] = None,\n fixed_oos: Union[None, np.ndarray, pd.DataFrame] = None,\n ):\n return self.model.predict(\n self._params,\n start=start,\n end=end,\n dynamic=dynamic,\n exog=exog,\n exog_oos=exog_oos,\n fixed=fixed,\n fixed_oos=fixed_oos,\n )\n\n def forecast(\n self,\n steps: int = 1,\n exog: Union[None, np.ndarray, pd.DataFrame] = None,\n fixed: Union[None, np.ndarray, pd.DataFrame] = None,\n ) -> Union[np.ndarray, pd.Series]:\n \"\"\"\n Out-of-sample forecasts\n\n Parameters\n ----------\n steps : {int, str, datetime}, default 1\n If an integer, the number of steps to forecast from the end of the\n sample. Can also be a date string to parse or a datetime type.\n However, if the dates index does not have a fixed frequency,\n steps must be an integer.\n exog : array_like, optional\n Exogenous values to use out-of-sample. Must have same number of\n columns as original exog data and at least `steps` rows\n fixed : array_like, optional\n Fixed values to use out-of-sample. Must have same number of\n columns as original fixed data and at least `steps` rows\n\n Returns\n -------\n array_like\n Array of out of in-sample predictions and / or out-of-sample\n forecasts.\n\n See Also\n --------\n ARDLResults.predict\n In- and out-of-sample predictions\n ARDLResults.get_prediction\n In- and out-of-sample predictions and confidence intervals\n \"\"\"\n start = self.model.data.orig_endog.shape[0]\n if isinstance(steps, (int, np.integer)):\n end = start + steps - 1\n else:\n end = steps\n return self.predict(\n start=start, end=end, dynamic=False, exog_oos=exog, fixed_oos=fixed\n )\n\n def _lag_repr(self) -> np.ndarray:\n \"\"\"Returns poly repr of an AR, (1 -phi1 L -phi2 L^2-...)\"\"\"\n ar_lags = self._ar_lags if self._ar_lags is not None else []\n k_ar = len(ar_lags)\n ar_params = np.zeros(self._max_lag + 1)\n ar_params[0] = 1\n offset = self.model._deterministic_reg.shape[1]\n params = self._params[offset : offset + k_ar]\n for i, lag in enumerate(ar_lags):\n ar_params[lag] = -params[i]\n return ar_params\n\n def get_prediction(\n self,\n start: Union[None, int, str, dt.datetime, pd.Timestamp] = None,\n end: Union[None, int, str, dt.datetime, pd.Timestamp] = None,\n dynamic: bool = False,\n exog: Union[None, np.ndarray, pd.DataFrame] = None,\n exog_oos: Union[None, np.ndarray, pd.DataFrame] = None,\n fixed: Union[None, np.ndarray, pd.DataFrame] = None,\n fixed_oos: Union[None, np.ndarray, pd.DataFrame] = None,\n ) -> Union[np.ndarray, pd.Series]:\n \"\"\"\n Predictions and prediction intervals\n\n Parameters\n ----------\n start : int, str, or datetime, optional\n Zero-indexed observation number at which to start forecasting,\n i.e., the first forecast is start. Can also be a date string to\n parse or a datetime type. Default is the the zeroth observation.\n end : int, str, or datetime, optional\n Zero-indexed observation number at which to end forecasting, i.e.,\n the last forecast is end. Can also be a date string to\n parse or a datetime type. However, if the dates index does not\n have a fixed frequency, end must be an integer index if you\n want out-of-sample prediction. Default is the last observation in\n the sample. Unlike standard python slices, end is inclusive so\n that all the predictions [start, start+1, ..., end-1, end] are\n returned.\n dynamic : {bool, int, str, datetime, Timestamp}, optional\n Integer offset relative to `start` at which to begin dynamic\n prediction. Prior to this observation, true endogenous values\n will be used for prediction; starting with this observation and\n continuing through the end of prediction, forecasted endogenous\n values will be used instead. Datetime-like objects are not\n interpreted as offsets. They are instead used to find the index\n location of `dynamic` which is then used to to compute the offset.\n exog : array_like\n A replacement exogenous array. Must have the same shape as the\n exogenous data array used when the model was created.\n exog_oos : array_like\n An array containing out-of-sample values of the exogenous variable.\n Must has the same number of columns as the exog used when the\n model was created, and at least as many rows as the number of\n out-of-sample forecasts.\n fixed : array_like\n A replacement fixed array. Must have the same shape as the\n fixed data array used when the model was created.\n fixed_oos : array_like\n An array containing out-of-sample values of the fixed variables.\n Must have the same number of columns as the fixed used when the\n model was created, and at least as many rows as the number of\n out-of-sample forecasts.\n\n Returns\n -------\n PredictionResults\n Prediction results with mean and prediction intervals\n \"\"\"\n mean = self.predict(\n start=start,\n end=end,\n dynamic=dynamic,\n exog=exog,\n exog_oos=exog_oos,\n fixed=fixed,\n fixed_oos=fixed_oos,\n )\n mean_var = np.full_like(mean, fill_value=self.sigma2)\n mean_var[np.isnan(mean)] = np.nan\n start = 0 if start is None else start\n end = self.model._index[-1] if end is None else end\n _, _, oos, _ = self.model._get_prediction_index(start, end)\n if oos > 0:\n ar_params = self._lag_repr()\n ma = arma2ma(ar_params, np.ones(1), lags=oos)\n mean_var[-oos:] = self.sigma2 * np.cumsum(ma ** 2)\n if isinstance(mean, pd.Series):\n mean_var = pd.Series(mean_var, index=mean.index)\n\n return PredictionResults(mean, mean_var)\n\n @Substitution(predict_params=_predict_params)\n def plot_predict(\n self,\n start: Union[None, int, str, dt.datetime, pd.Timestamp] = None,\n end: Union[None, int, str, dt.datetime, pd.Timestamp] = None,\n dynamic: bool = False,\n exog: Union[None, np.ndarray, pd.DataFrame] = None,\n exog_oos: Union[None, np.ndarray, pd.DataFrame] = None,\n fixed: Union[None, np.ndarray, pd.DataFrame] = None,\n fixed_oos: Union[None, np.ndarray, pd.DataFrame] = None,\n alpha: float = 0.05,\n in_sample: bool = True,\n fig: \"matplotlib.figure.Figure\" = None,\n figsize: Optional[Tuple[int, int]] = None,\n ) -> \"matplotlib.figure.Figure\":\n \"\"\"\n Plot in- and out-of-sample predictions\n\n Parameters\n ----------\\n%(predict_params)s\n alpha : {float, None}\n The tail probability not covered by the confidence interval. Must\n be in (0, 1). Confidence interval is constructed assuming normally\n distributed shocks. If None, figure will not show the confidence\n interval.\n in_sample : bool\n Flag indicating whether to include the in-sample period in the\n plot.\n fig : Figure\n An existing figure handle. If not provided, a new figure is\n created.\n figsize: tuple[float, float]\n Tuple containing the figure size values.\n\n Returns\n -------\n Figure\n Figure handle containing the plot.\n \"\"\"\n predictions = self.get_prediction(\n start=start,\n end=end,\n dynamic=dynamic,\n exog=exog,\n exog_oos=exog_oos,\n fixed=fixed,\n fixed_oos=fixed_oos,\n )\n return self._plot_predictions(\n predictions, start, end, alpha, in_sample, fig, figsize\n )\n\n def summary(self, alpha: float = 0.05) -> Summary:\n \"\"\"\n Summarize the Model\n\n Parameters\n ----------\n alpha : float, optional\n Significance level for the confidence intervals.\n\n Returns\n -------\n smry : Summary instance\n This holds the summary table and text, which can be printed or\n converted to various output formats.\n\n See Also\n --------\n statsmodels.iolib.summary.Summary\n \"\"\"\n model = self.model\n\n title = model.__class__.__name__ + \" Model Results\"\n method = \"Conditional MLE\"\n # get sample\n start = self._hold_back\n if self.data.dates is not None:\n dates = self.data.dates\n sample = [dates[start].strftime(\"%m-%d-%Y\")]\n sample += [\"- \" + dates[-1].strftime(\"%m-%d-%Y\")]\n else:\n sample = [str(start), str(len(self.data.orig_endog))]\n model = self.model.__class__.__name__ + str(self.model.ardl_order)\n if self.model.seasonal:\n model = \"Seas. \" + model\n\n dep_name = str(self.model.endog_names)\n top_left = [\n (\"Dep. Variable:\", [dep_name]),\n (\"Model:\", [model]),\n (\"Method:\", [method]),\n (\"Date:\", None),\n (\"Time:\", None),\n (\"Sample:\", [sample[0]]),\n (\"\", [sample[1]]),\n ]\n\n top_right = [\n (\"No. Observations:\", [str(len(self.model.endog))]),\n (\"Log Likelihood\", [\"%#5.3f\" % self.llf]),\n (\"S.D. of innovations\", [\"%#5.3f\" % self.sigma2 ** 0.5]),\n (\"AIC\", [\"%#5.3f\" % self.aic]),\n (\"BIC\", [\"%#5.3f\" % self.bic]),\n (\"HQIC\", [\"%#5.3f\" % self.hqic]),\n ]\n\n smry = Summary()\n smry.add_table_2cols(\n self, gleft=top_left, gright=top_right, title=title\n )\n smry.add_table_params(self, alpha=alpha, use_t=False)\n\n return smry\n\n\nclass ARDLResultsWrapper(wrap.ResultsWrapper):\n _attrs = {}\n _wrap_attrs = wrap.union_dicts(\n tsa_model.TimeSeriesResultsWrapper._wrap_attrs, _attrs\n )\n _methods = {}\n _wrap_methods = wrap.union_dicts(\n tsa_model.TimeSeriesResultsWrapper._wrap_methods, _methods\n )\n\n\nwrap.populate_wrapper(ARDLResultsWrapper, ARDLResults)\n\n\nclass ARDLOrderSelectionResults(AROrderSelectionResults):\n \"\"\"\n Results from an ARDL order selection\n\n Contains the information criteria for all fitted model orders.\n \"\"\"\n\n def __init__(self, model, ics, trend, seasonal, period):\n _ics = (((0,), (0, 0, 0)),)\n super().__init__(model, _ics, trend, seasonal, period)\n\n def _to_dict(d):\n return d[0], dict(d[1:])\n\n self._aic = pd.Series(\n {v[0]: _to_dict(k) for k, v in ics.items()}, dtype=object\n )\n self._aic.index.name = self._aic.name = \"AIC\"\n self._aic = self._aic.sort_index()\n\n self._bic = pd.Series(\n {v[1]: _to_dict(k) for k, v in ics.items()}, dtype=object\n )\n self._bic.index.name = self._bic.name = \"BIC\"\n self._bic = self._bic.sort_index()\n\n self._hqic = pd.Series(\n {v[2]: _to_dict(k) for k, v in ics.items()}, dtype=object\n )\n self._hqic.index.name = self._hqic.name = \"HQIC\"\n self._hqic = self._hqic.sort_index()\n\n @property\n def dl_lags(self) -> Dict[Hashable, List[int]]:\n \"\"\"The lags of exogenous variables in the selected model\"\"\"\n return self._model.dl_lags\n\n\ndef ardl_select_order(\n endog: Union[Sequence[float], pd.Series, _ArrayLike2D],\n maxlag: int,\n exog: _ArrayLike2D,\n maxorder: Union[int, Dict[Hashable, int]],\n trend: Literal[\"n\", \"c\", \"ct\", \"ctt\"] = \"c\",\n *,\n fixed: Optional[_ArrayLike2D] = None,\n causal: bool = False,\n ic: Literal[\"aic\", \"bic\"] = \"bic\",\n glob: bool = False,\n seasonal: bool = False,\n deterministic: Optional[DeterministicProcess] = None,\n hold_back: Optional[int] = None,\n period: Optional[int] = None,\n missing: Literal[\"none\", \"raise\"] = \"none\",\n) -> ARDLOrderSelectionResults:\n r\"\"\"\n ARDL order selection\n\n Parameters\n ----------\n endog : array_like\n A 1-d endogenous response variable. The dependent variable.\n maxlag : int\n The maximum lag to consider for the endogenous variable.\n exog : array_like\n Exogenous variables to include in the model. Either a DataFrame or\n an 2-d array-like structure that can be converted to a NumPy array.\n maxorder : {int, dict}\n If int, sets a common max lag length for all exog variables. If\n a dict, then sets individual lag length. They keys are column names\n if exog is a DataFrame or column indices otherwise.\n trend : {'n', 'c', 't', 'ct'}, optional\n The trend to include in the model:\n\n * 'n' - No trend.\n * 'c' - Constant only.\n * 't' - Time trend only.\n * 'ct' - Constant and time trend.\n\n The default is 'c'.\n fixed : array_like\n Additional fixed regressors that are not lagged.\n causal : bool, optional\n Whether to include lag 0 of exog variables. If True, only includes\n lags 1, 2, ...\n ic : {\"aic\", \"bic\", \"hqic\"}\n The information criterion to use in model selection.\n glob : bool\n Whether to consider all possible submodels of the largest model\n or only if smaller order lags must be included if larger order\n lags are. If ``True``, the number of model considered is of the\n order 2**(maxlag + k * maxorder) assuming maxorder is an int. This\n can be very large unless k and maxorder are bot relatively small.\n If False, the number of model considered is of the order\n maxlag*maxorder**k which may also be substantial when k and maxorder\n are large.\n seasonal : bool, optional\n Flag indicating whether to include seasonal dummies in the model. If\n seasonal is True and trend includes 'c', then the first period\n is excluded from the seasonal terms.\n deterministic : DeterministicProcess, optional\n A deterministic process. If provided, trend and seasonal are ignored.\n A warning is raised if trend is not \"n\" and seasonal is not False.\n hold_back : {None, int}, optional\n Initial observations to exclude from the estimation sample. If None,\n then hold_back is equal to the maximum lag in the model. Set to a\n non-zero value to produce comparable models with different lag\n length. For example, to compare the fit of a model with lags=3 and\n lags=1, set hold_back=3 which ensures that both models are estimated\n using observations 3,...,nobs. hold_back must be >= the maximum lag in\n the model.\n period : {None, int}, optional\n The period of the data. Only used if seasonal is True. This parameter\n can be omitted if using a pandas object for endog that contains a\n recognized frequency.\n missing : {\"none\", \"drop\", \"raise\"}, optional\n Available options are 'none', 'drop', and 'raise'. If 'none', no nan\n checking is done. If 'drop', any observations with nans are dropped.\n If 'raise', an error is raised. Default is 'none'.\n\n Returns\n -------\n ARDLSelectionResults\n A results holder containing the selected model and the complete set\n of information criteria for all models fit.\n \"\"\"\n orig_hold_back = int_like(hold_back, \"hold_back\", optional=True)\n\n def compute_ics(y, x, df):\n if x.shape[1]:\n resid = y - x @ np.linalg.lstsq(x, y, rcond=None)[0]\n else:\n resid = y\n nobs = resid.shape[0]\n sigma2 = 1.0 / nobs * sumofsq(resid)\n llf = -nobs * (np.log(2 * np.pi * sigma2) + 1) / 2\n res = SimpleNamespace(\n nobs=nobs, df_model=df + x.shape[1], sigma2=sigma2, llf=llf\n )\n\n aic = ARDLResults.aic.func(res)\n bic = ARDLResults.bic.func(res)\n hqic = ARDLResults.hqic.func(res)\n\n return aic, bic, hqic\n\n base = ARDL(\n endog,\n maxlag,\n exog,\n maxorder,\n trend,\n fixed=fixed,\n causal=causal,\n seasonal=seasonal,\n deterministic=deterministic,\n hold_back=hold_back,\n period=period,\n missing=missing,\n )\n hold_back = base.hold_back\n blocks = base._blocks\n always = np.column_stack([blocks[\"deterministic\"], blocks[\"fixed\"]])\n always = always[hold_back:]\n select = []\n iter_orders = []\n select.append(blocks[\"endog\"][hold_back:])\n iter_orders.append(list(range(blocks[\"endog\"].shape[1] + 1)))\n var_names = []\n for var in blocks[\"exog\"]:\n block = blocks[\"exog\"][var][hold_back:]\n select.append(block)\n iter_orders.append(list(range(block.shape[1] + 1)))\n var_names.append(var)\n y = base._y\n if always.shape[1]:\n pinv_always = np.linalg.pinv(always)\n for i in range(len(select)):\n x = select[i]\n select[i] = x - always @ (pinv_always @ x)\n y = y - always @ (pinv_always @ y)\n\n def perm_to_tuple(keys, perm):\n if perm == ():\n d = {k: 0 for k, _ in keys if k is not None}\n return (0,) + tuple((k, v) for k, v in d.items())\n d = defaultdict(list)\n y_lags = []\n for v in perm:\n key = keys[v]\n if key[0] is None:\n y_lags.append(key[1])\n else:\n d[key[0]].append(key[1])\n d = dict(d)\n if not y_lags or y_lags == [0]:\n y_lags = 0\n else:\n y_lags = tuple(y_lags)\n for key in keys:\n if key[0] not in d and key[0] is not None:\n d[key[0]] = None\n for key in d:\n if d[key] is not None:\n d[key] = tuple(d[key])\n return (y_lags,) + tuple((k, v) for k, v in d.items())\n\n always_df = always.shape[1]\n ics = {}\n if glob:\n ar_lags = base.ar_lags if base.ar_lags is not None else []\n keys = [(None, i) for i in ar_lags]\n for k, v in base._order.items():\n keys += [(k, i) for i in v]\n x = np.column_stack([a for a in select])\n all_columns = list(range(x.shape[1]))\n for i in range(x.shape[1]):\n for perm in combinations(all_columns, i):\n key = perm_to_tuple(keys, perm)\n ics[key] = compute_ics(y, x[:, perm], always_df)\n else:\n for io in product(*iter_orders):\n x = np.column_stack([a[:, : io[i]] for i, a in enumerate(select)])\n key = [io[0] if io[0] else None]\n for j, val in enumerate(io[1:]):\n var = var_names[j]\n if causal:\n key.append((var, None if val == 0 else val))\n else:\n key.append((var, val - 1 if val - 1 >= 0 else None))\n key = tuple(key)\n ics[key] = compute_ics(y, x, always_df)\n index = {\"aic\": 0, \"bic\": 1, \"hqic\": 2}[ic]\n lowest = np.inf\n for key in ics:\n val = ics[key][index]\n if val < lowest:\n lowest = val\n selected_order = key\n exog_order = {k: v for k, v in selected_order[1:]}\n model = ARDL(\n endog,\n selected_order[0],\n exog,\n exog_order,\n trend,\n fixed=fixed,\n causal=causal,\n seasonal=seasonal,\n deterministic=deterministic,\n hold_back=orig_hold_back,\n period=period,\n missing=missing,\n )\n\n return ARDLOrderSelectionResults(model, ics, trend, seasonal, period)\n\n\nlags_descr = textwrap.wrap(\n \"The number of lags of the endogenous variable to include in the model. \"\n \"Must be at least 1.\",\n 71,\n)\nlags_param = Parameter(name=\"lags\", type=\"int\", desc=lags_descr)\norder_descr = textwrap.wrap(\n \"If int, uses lags 0, 1, ..., order for all exog variables. If a dict, \"\n \"applies the lags series by series. If ``exog`` is anything other than a \"\n \"DataFrame, the keys are the column index of exog (e.g., 0, 1, ...). If \"\n \"a DataFrame, keys are column names.\",\n 71,\n)\norder_param = Parameter(name=\"order\", type=\"int, dict\", desc=order_descr)\n\nfrom_formula_doc = Docstring(ARDL.from_formula.__doc__)\nfrom_formula_doc.replace_block(\"Summary\", \"Construct an UECM from a formula\")\nfrom_formula_doc.remove_parameters(\"lags\")\nfrom_formula_doc.remove_parameters(\"order\")\nfrom_formula_doc.insert_parameters(\"data\", lags_param)\nfrom_formula_doc.insert_parameters(\"lags\", order_param)\n\n\nfit_doc = Docstring(ARDL.fit.__doc__)\nfit_doc.replace_block(\n \"Returns\", [Parameter(\"\", \"UECMResults\", [\"Estimation results.\"])]\n)\n\nif fit_doc._ds is not None:\n see_also = fit_doc._ds[\"See Also\"]\n see_also.insert(\n 0,\n (\n [(\"statsmodels.tsa.ardl.ARDL\", None)],\n [\"Autoregressive distributed lag model estimation\"],\n ),\n )\n fit_doc.replace_block(\"See Also\", see_also)\n\n\nclass UECM(ARDL):\n r\"\"\"\n Unconstrained Error Correlation Model(UECM)\n\n Parameters\n ----------\n endog : array_like\n A 1-d endogenous response variable. The dependent variable.\n lags : {int, list[int]}\n The number of lags of the endogenous variable to include in the\n model. Must be at least 1.\n exog : array_like\n Exogenous variables to include in the model. Either a DataFrame or\n an 2-d array-like structure that can be converted to a NumPy array.\n order : {int, sequence[int], dict}\n If int, uses lags 0, 1, ..., order for all exog variables. If a\n dict, applies the lags series by series. If ``exog`` is anything\n other than a DataFrame, the keys are the column index of exog\n (e.g., 0, 1, ...). If a DataFrame, keys are column names.\n fixed : array_like\n Additional fixed regressors that are not lagged.\n causal : bool, optional\n Whether to include lag 0 of exog variables. If True, only includes\n lags 1, 2, ...\n trend : {'n', 'c', 't', 'ct'}, optional\n The trend to include in the model:\n\n * 'n' - No trend.\n * 'c' - Constant only.\n * 't' - Time trend only.\n * 'ct' - Constant and time trend.\n\n The default is 'c'.\n\n seasonal : bool, optional\n Flag indicating whether to include seasonal dummies in the model. If\n seasonal is True and trend includes 'c', then the first period\n is excluded from the seasonal terms.\n deterministic : DeterministicProcess, optional\n A deterministic process. If provided, trend and seasonal are ignored.\n A warning is raised if trend is not \"n\" and seasonal is not False.\n hold_back : {None, int}, optional\n Initial observations to exclude from the estimation sample. If None,\n then hold_back is equal to the maximum lag in the model. Set to a\n non-zero value to produce comparable models with different lag\n length. For example, to compare the fit of a model with lags=3 and\n lags=1, set hold_back=3 which ensures that both models are estimated\n using observations 3,...,nobs. hold_back must be >= the maximum lag in\n the model.\n period : {None, int}, optional\n The period of the data. Only used if seasonal is True. This parameter\n can be omitted if using a pandas object for endog that contains a\n recognized frequency.\n missing : {\"none\", \"drop\", \"raise\"}, optional\n Available options are 'none', 'drop', and 'raise'. If 'none', no nan\n checking is done. If 'drop', any observations with nans are dropped.\n If 'raise', an error is raised. Default is 'none'.\n\n Notes\n -----\n The full specification of an UECM is\n\n .. math ::\n\n \\Delta Y_t = \\delta_0 + \\delta_1 t + \\delta_2 t^2\n + \\sum_{i=1}^{s-1} \\gamma_i I_{[(\\mod(t,s) + 1) = i]}\n + \\lambda_0 Y_{t-1} + \\lambda_1 X_{1,t-1} + \\ldots\n + \\lambda_{k} X_{k,t-1}\n + \\sum_{j=1}^{p-1} \\phi_j \\Delta Y_{t-j}\n + \\sum_{l=1}^k \\sum_{m=0}^{o_l-1} \\beta_{l,m} \\Delta X_{l, t-m}\n + Z_t \\lambda\n + \\epsilon_t\n\n where :math:`\\delta_\\bullet` capture trends, :math:`\\gamma_\\bullet`\n capture seasonal shifts, s is the period of the seasonality, p is the\n lag length of the endogenous variable, k is the number of exogenous\n variables :math:`X_{l}`, :math:`o_l` is included the lag length of\n :math:`X_{l}`, :math:`Z_t` are ``r`` included fixed regressors and\n :math:`\\epsilon_t` is a white noise shock. If ``causal`` is ``True``,\n then the 0-th lag of the exogenous variables is not included and the\n sum starts at ``m=1``.\n\n See Also\n --------\n statsmodels.tsa.ardl.ARDL\n Autoregressive distributed lag model estimation\n statsmodels.tsa.ar_model.AutoReg\n Autoregressive model estimation with optional exogenous regressors\n statsmodels.tsa.statespace.sarimax.SARIMAX\n Seasonal ARIMA model estimation with optional exogenous regressors\n statsmodels.tsa.arima.model.ARIMA\n ARIMA model estimation\n\n Examples\n --------\n >>> from statsmodels.tsa.api import UECM\n >>> from statsmodels.datasets import danish_data\n >>> data = danish_data.load_pandas().data\n >>> lrm = data.lrm\n >>> exog = data[[\"lry\", \"ibo\", \"ide\"]]\n\n A basic model where all variables have 3 lags included\n\n >>> UECM(data.lrm, 3, data[[\"lry\", \"ibo\", \"ide\"]], 3)\n\n A dictionary can be used to pass custom lag orders\n\n >>> UECM(data.lrm, [1, 3], exog, {\"lry\": 1, \"ibo\": 3, \"ide\": 2})\n\n Setting causal removes the 0-th lag from the exogenous variables\n\n >>> exog_lags = {\"lry\": 1, \"ibo\": 3, \"ide\": 2}\n >>> UECM(data.lrm, 3, exog, exog_lags, causal=True)\n\n When using NumPy arrays, the dictionary keys are the column index.\n\n >>> import numpy as np\n >>> lrma = np.asarray(lrm)\n >>> exoga = np.asarray(exog)\n >>> UECM(lrma, 3, exoga, {0: 1, 1: 3, 2: 2})\n \"\"\"\n\n def __init__(\n self,\n endog: Union[Sequence[float], pd.Series, _ArrayLike2D],\n lags: Union[None, int],\n exog: Optional[_ArrayLike2D] = None,\n order: _UECMOrder = 0,\n trend: Literal[\"n\", \"c\", \"ct\", \"ctt\"] = \"c\",\n *,\n fixed: Optional[_ArrayLike2D] = None,\n causal: bool = False,\n seasonal: bool = False,\n deterministic: Optional[DeterministicProcess] = None,\n hold_back: Optional[int] = None,\n period: Optional[int] = None,\n missing: Literal[\"none\", \"drop\", \"raise\"] = \"none\",\n ) -> None:\n super().__init__(\n endog,\n lags,\n exog,\n order,\n trend=trend,\n fixed=fixed,\n seasonal=seasonal,\n causal=causal,\n hold_back=hold_back,\n period=period,\n missing=missing,\n deterministic=deterministic,\n )\n self._results_class = UECMResults\n self._results_wrapper = UECMResultsWrapper\n\n def _check_lags(self) -> Tuple[List[int], int]:\n \"\"\"Check lags value conforms to requirement\"\"\"\n if not (isinstance(self._lags, _INT_TYPES) or self._lags is None):\n raise TypeError(\"lags must be an integer or None\")\n return super()._check_lags()\n\n def _check_order(self, order: _ARDLOrder):\n \"\"\"Check order conforms to requirement\"\"\"\n if isinstance(order, Mapping):\n for k, v in order.items():\n if not isinstance(v, _INT_TYPES) and v is not None:\n raise TypeError(\n \"order values must be positive integers or None\"\n )\n elif not (isinstance(order, _INT_TYPES) or order is None):\n raise TypeError(\n \"order must be None, a positive integer, or a dict \"\n \"containing positive integers or None\"\n )\n # TODO: Check order is >= 1\n order = super()._check_order(order)\n if not order:\n raise ValueError(\n \"Model must contain at least one exogenous variable\"\n )\n for key, val in order.items():\n if val == [0]:\n raise ValueError(\n \"All included exog variables must have a lag length >= 1\"\n )\n return order\n\n def _construct_variable_names(self):\n \"\"\"Construct model variables names\"\"\"\n endog = self.data.orig_endog\n if isinstance(endog, pd.Series):\n y_base = endog.name or \"y\"\n elif isinstance(endog, pd.DataFrame):\n y_base = endog.squeeze().name or \"y\"\n else:\n y_base = \"y\"\n y_name = f\"D.{y_base}\"\n # 1. Deterministics\n x_names = list(self._deterministic_reg.columns)\n # 2. Levels\n x_names.append(f\"{y_base}.L1\")\n orig_exog = self.data.orig_exog\n exog_pandas = isinstance(orig_exog, pd.DataFrame)\n dexog_names = []\n for key, val in self._order.items():\n if val is not None:\n if exog_pandas:\n x_name = f\"{key}.L1\"\n else:\n x_name = f\"x{key}.L1\"\n x_names.append(x_name)\n lag_base = x_name[:-1]\n for lag in val[:-1]:\n dexog_names.append(f\"D.{lag_base}{lag}\")\n # 3. Lagged endog\n y_lags = max(self._lags) if self._lags else 0\n dendog_names = [f\"{y_name}.L{lag}\" for lag in range(1, y_lags)]\n x_names.extend(dendog_names)\n x_names.extend(dexog_names)\n x_names.extend(self._fixed_names)\n return y_name, x_names\n\n def _construct_regressors(\n self, hold_back: Optional[int]\n ) -> Tuple[np.ndarray, np.ndarray]:\n \"\"\"Construct and format model regressors\"\"\"\n # 1. Endogenous and endogenous lags\n self._maxlag = max(self._lags) if self._lags else 0\n dendog = np.full_like(self.data.endog, np.nan)\n dendog[1:] = np.diff(self.data.endog, axis=0)\n dlag = max(0, self._maxlag - 1)\n self._endog_reg, self._endog = lagmat(dendog, dlag, original=\"sep\")\n # 2. Deterministics\n self._deterministic_reg = self._deterministics.in_sample()\n # 3. Levels\n orig_exog = self.data.orig_exog\n exog_pandas = isinstance(orig_exog, pd.DataFrame)\n lvl = np.full_like(self.data.endog, np.nan)\n lvl[1:] = self.data.endog[:-1]\n lvls = [lvl.copy()]\n for key, val in self._order.items():\n if val is not None:\n if exog_pandas:\n loc = orig_exog.columns.get_loc(key)\n else:\n loc = key\n lvl[1:] = self.data.exog[:-1, loc]\n lvls.append(lvl.copy())\n self._levels = np.column_stack(lvls)\n\n # 4. exog Lags\n if exog_pandas:\n dexog = orig_exog.diff()\n else:\n dexog = np.full_like(self.data.exog, np.nan)\n dexog[1:] = np.diff(orig_exog, axis=0)\n adj_order = {}\n for key, val in self._order.items():\n val = None if (val is None or val == [1]) else val[:-1]\n adj_order[key] = val\n self._exog = self._format_exog(dexog, adj_order)\n\n self._blocks = {\n \"deterministic\": self._deterministic_reg,\n \"levels\": self._levels,\n \"endog\": self._endog_reg,\n \"exog\": self._exog,\n \"fixed\": self._fixed,\n }\n blocks = [self._endog]\n for key, val in self._blocks.items():\n if key != \"exog\":\n blocks.append(np.asarray(val))\n else:\n for subval in val.values():\n blocks.append(np.asarray(subval))\n y = blocks[0]\n reg = np.column_stack(blocks[1:])\n exog_maxlag = 0\n for val in self._order.values():\n exog_maxlag = max(exog_maxlag, max(val) if val is not None else 0)\n self._maxlag = max(self._maxlag, exog_maxlag)\n # Must be at least 1 since the endog is differenced\n self._maxlag = max(self._maxlag, 1)\n if hold_back is None:\n self._hold_back = int(self._maxlag)\n if self._hold_back < self._maxlag:\n raise ValueError(\n \"hold_back must be >= the maximum lag of the endog and exog \"\n \"variables\"\n )\n reg = reg[self._hold_back :]\n if reg.shape[1] > reg.shape[0]:\n raise ValueError(\n f\"The number of regressors ({reg.shape[1]}) including \"\n \"deterministics, lags of the endog, lags of the exogenous, \"\n \"and fixed regressors is larer than the sample available \"\n f\"for estimation ({reg.shape[0]}).\"\n )\n return np.squeeze(y)[self._hold_back :], reg\n\n @Appender(str(fit_doc))\n def fit(\n self,\n *,\n cov_type: str = \"nonrobust\",\n cov_kwds: Dict[str, Any] = None,\n use_t: bool = True,\n ) -> UECMResults:\n params, cov_params, norm_cov_params = self._fit(\n cov_type=cov_type, cov_kwds=cov_kwds, use_t=use_t\n )\n res = UECMResults(\n self, params, cov_params, norm_cov_params, use_t=use_t\n )\n return UECMResultsWrapper(res)\n\n @classmethod\n def from_ardl(\n cls, ardl: ARDL, missing: Literal[\"none\", \"drop\", \"raise\"] = \"none\"\n ):\n \"\"\"\n Construct a UECM from an ARDL model\n\n Parameters\n ----------\n ardl : ARDL\n The ARDL model instance\n missing : {\"none\", \"drop\", \"raise\"}, default \"none\"\n How to treat missing observations.\n\n Returns\n -------\n UECM\n The UECM model instance\n\n Notes\n -----\n The lag requirements for a UECM are stricter than for an ARDL.\n Any variable that is included in the UECM must have a lag length\n of at least 1. Additionally, the included lags must be contiguous\n starting at 0 if non-causal or 1 if causal.\n \"\"\"\n err = (\n \"UECM can only be created from ARDL models that include all \"\n \"{var_typ} lags up to the maximum lag in the model.\"\n )\n uecm_lags = {}\n dl_lags = ardl.dl_lags\n for key, val in dl_lags.items():\n max_val = max(val)\n if len(dl_lags[key]) < (max_val + int(not ardl.causal)):\n raise ValueError(err.format(var_typ=\"exogenous\"))\n uecm_lags[key] = max_val\n if ardl.ar_lags is None:\n ar_lags = None\n else:\n max_val = max(ardl.ar_lags)\n if len(ardl.ar_lags) != max_val:\n raise ValueError(err.format(var_typ=\"endogenous\"))\n ar_lags = max_val\n\n return cls(\n ardl.data.orig_endog,\n ar_lags,\n ardl.data.orig_exog,\n uecm_lags,\n trend=ardl.trend,\n fixed=ardl.fixed,\n seasonal=ardl.seasonal,\n hold_back=ardl.hold_back,\n period=ardl.period,\n causal=ardl.causal,\n missing=missing,\n deterministic=ardl.deterministic,\n )\n\n def predict(\n self,\n params: Union[np.ndarray, pd.DataFrame],\n start: Union[None, int, str, dt.datetime, pd.Timestamp] = None,\n end: Union[None, int, str, dt.datetime, pd.Timestamp] = None,\n dynamic: bool = False,\n exog: Union[None, np.ndarray, pd.DataFrame] = None,\n exog_oos: Union[None, np.ndarray, pd.DataFrame] = None,\n fixed: Union[None, np.ndarray, pd.DataFrame] = None,\n fixed_oos: Union[None, np.ndarray, pd.DataFrame] = None,\n ) -> np.ndarray:\n \"\"\"\n In-sample prediction and out-of-sample forecasting.\n\n Parameters\n ----------\n params : array_like\n The fitted model parameters.\n start : int, str, or datetime, optional\n Zero-indexed observation number at which to start forecasting,\n i.e., the first forecast is start. Can also be a date string to\n parse or a datetime type. Default is the the zeroth observation.\n end : int, str, or datetime, optional\n Zero-indexed observation number at which to end forecasting, i.e.,\n the last forecast is end. Can also be a date string to\n parse or a datetime type. However, if the dates index does not\n have a fixed frequency, end must be an integer index if you\n want out-of-sample prediction. Default is the last observation in\n the sample. Unlike standard python slices, end is inclusive so\n that all the predictions [start, start+1, ..., end-1, end] are\n returned.\n dynamic : {bool, int, str, datetime, Timestamp}, optional\n Integer offset relative to `start` at which to begin dynamic\n prediction. Prior to this observation, true endogenous values\n will be used for prediction; starting with this observation and\n continuing through the end of prediction, forecasted endogenous\n values will be used instead. Datetime-like objects are not\n interpreted as offsets. They are instead used to find the index\n location of `dynamic` which is then used to to compute the offset.\n exog : array_like\n A replacement exogenous array. Must have the same shape as the\n exogenous data array used when the model was created.\n exog_oos : array_like\n An array containing out-of-sample values of the exogenous\n variables. Must have the same number of columns as the exog\n used when the model was created, and at least as many rows as\n the number of out-of-sample forecasts.\n fixed : array_like\n A replacement fixed array. Must have the same shape as the\n fixed data array used when the model was created.\n fixed_oos : array_like\n An array containing out-of-sample values of the fixed variables.\n Must have the same number of columns as the fixed used when the\n model was created, and at least as many rows as the number of\n out-of-sample forecasts.\n\n Returns\n -------\n predictions : {ndarray, Series}\n Array of out of in-sample predictions and / or out-of-sample\n forecasts.\n \"\"\"\n if dynamic is not False:\n raise NotImplementedError(\"dynamic forecasts are not supported\")\n params, exog, exog_oos, start, end, num_oos = self._prepare_prediction(\n params, exog, exog_oos, start, end\n )\n if num_oos != 0:\n raise NotImplementedError(\n \"Out-of-sample forecasts are not supported\"\n )\n pred = np.full(self.endog.shape[0], np.nan)\n pred[-self._x.shape[0] :] = self._x @ params\n return pred[start : end + 1]\n\n @classmethod\n @Appender(from_formula_doc.__str__().replace(\"ARDL\", \"UECM\"))\n def from_formula(\n cls,\n formula: str,\n data: pd.DataFrame,\n lags: Union[None, int, Sequence[int]] = 0,\n order: _ARDLOrder = 0,\n trend: Literal[\"n\", \"c\", \"ct\", \"ctt\"] = \"n\",\n *,\n causal: bool = False,\n seasonal: bool = False,\n deterministic: Optional[DeterministicProcess] = None,\n hold_back: Optional[int] = None,\n period: Optional[int] = None,\n missing: Literal[\"none\", \"raise\"] = \"none\",\n ) -> UECM:\n return super().from_formula(\n formula,\n data,\n lags,\n order,\n trend,\n causal=causal,\n seasonal=seasonal,\n deterministic=deterministic,\n hold_back=hold_back,\n period=period,\n missing=missing,\n )\n\n\nclass UECMResults(ARDLResults):\n \"\"\"\n Class to hold results from fitting an UECM model.\n\n Parameters\n ----------\n model : UECM\n Reference to the model that is fit.\n params : ndarray\n The fitted parameters from the AR Model.\n cov_params : ndarray\n The estimated covariance matrix of the model parameters.\n normalized_cov_params : ndarray\n The array inv(dot(x.T,x)) where x contains the regressors in the\n model.\n scale : float, optional\n An estimate of the scale of the model.\n \"\"\"\n\n _cache = {} # for scale setter\n\n def _ci_wrap(\n self, val: np.ndarray, name: str = \"\"\n ) -> Union[np.ndarray, pd.Series, pd.DataFrame]:\n if not isinstance(self.model.data, PandasData):\n return val\n ndet = self.model._blocks[\"deterministic\"].shape[1]\n nlvl = self.model._blocks[\"levels\"].shape[1]\n lbls = self.model.exog_names[: (ndet + nlvl)]\n for i in range(ndet, ndet + nlvl):\n lbl = lbls[i]\n if lbl.endswith(\".L1\"):\n lbls[i] = lbl[:-3]\n if val.ndim == 2:\n return pd.DataFrame(val, columns=lbls, index=lbls)\n return pd.Series(val, index=lbls, name=name)\n\n @cache_readonly\n def ci_params(self) -> Union[np.ndarray, pd.Series]:\n \"\"\"Parameters of normalized cointegrating relationship\"\"\"\n ndet = self.model._blocks[\"deterministic\"].shape[1]\n nlvl = self.model._blocks[\"levels\"].shape[1]\n base = np.asarray(self.params)[ndet]\n return self._ci_wrap(self.params[: ndet + nlvl] / base, \"ci_params\")\n\n @cache_readonly\n def ci_bse(self) -> Union[np.ndarray, pd.Series]:\n \"\"\"Standard Errors of normalized cointegrating relationship\"\"\"\n bse = np.sqrt(np.diag(self.ci_cov_params()))\n return self._ci_wrap(bse, \"ci_bse\")\n\n @cache_readonly\n def ci_tvalues(self) -> Union[np.ndarray, pd.Series]:\n \"\"\"T-values of normalized cointegrating relationship\"\"\"\n ndet = self.model._blocks[\"deterministic\"].shape[1]\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n tvalues = np.asarray(self.ci_params) / np.asarray(self.ci_bse)\n tvalues[ndet] = np.nan\n return self._ci_wrap(tvalues, \"ci_tvalues\")\n\n @cache_readonly\n def ci_pvalues(self) -> Union[np.ndarray, pd.Series]:\n \"\"\"P-values of normalized cointegrating relationship\"\"\"\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n pvalues = 2 * (1 - stats.norm.cdf(np.abs(self.ci_tvalues)))\n return self._ci_wrap(pvalues, \"ci_pvalues\")\n\n def ci_conf_int(\n self, alpha: float = 0.05\n ) -> Union[np.ndarray, pd.DataFrame]:\n alpha = float_like(alpha, \"alpha\")\n\n if self.use_t:\n q = stats.t(self.df_resid).ppf(1 - alpha / 2)\n else:\n q = stats.norm().ppf(1 - alpha / 2)\n p = self.ci_params\n se = self.ci_bse\n out = [p - q * se, p + q * se]\n if not isinstance(p, pd.Series):\n return np.column_stack(out)\n\n df = pd.concat(out, axis=1)\n df.columns = [\"lower\", \"upper\"]\n\n return df\n\n def ci_summary(self, alpha: float = 0.05) -> Summary:\n def _ci(alpha=alpha):\n return np.asarray(self.ci_conf_int(alpha))\n\n smry = Summary()\n ndet = self.model._blocks[\"deterministic\"].shape[1]\n nlvl = self.model._blocks[\"levels\"].shape[1]\n exog_names = list(self.model.exog_names)[: (ndet + nlvl)]\n\n model = SimpleNamespace(\n endog_names=self.model.endog_names, exog_names=exog_names\n )\n data = SimpleNamespace(\n params=self.ci_params,\n bse=self.ci_bse,\n tvalues=self.ci_tvalues,\n pvalues=self.ci_pvalues,\n conf_int=_ci,\n model=model,\n )\n tab = summary_params(data)\n tab.title = \"Cointegrating Vector\"\n smry.tables.append(tab)\n\n return smry\n\n @cache_readonly\n def ci_resids(self) -> Union[np.ndarray, pd.Series]:\n d = self.model._blocks[\"deterministic\"]\n exog = self.model.data.orig_exog\n is_pandas = isinstance(exog, pd.DataFrame)\n exog = exog if is_pandas else self.model.exog\n cols = [np.asarray(d), self.model.endog]\n for key, value in self.model.dl_lags.items():\n if value is not None:\n if is_pandas:\n cols.append(np.asarray(exog[key]))\n else:\n cols.append(exog[:, key])\n ci_x = np.column_stack(cols)\n resids = ci_x @ self.ci_params\n if not isinstance(self.model.data, PandasData):\n return resids\n index = self.model.data.orig_endog.index\n return pd.Series(resids, index=index, name=\"ci_resids\")\n\n def ci_cov_params(self) -> Union[np.ndarray, pd.DataFrame]:\n \"\"\"Covariance of normalized of cointegrating relationship\"\"\"\n ndet = self.model._blocks[\"deterministic\"].shape[1]\n nlvl = self.model._blocks[\"levels\"].shape[1]\n loc = list(range(ndet + nlvl))\n cov = self.cov_params()\n cov_a = np.asarray(cov)\n ci_cov = cov_a[np.ix_(loc, loc)]\n m = ci_cov.shape[0]\n params = np.asarray(self.params)[: ndet + nlvl]\n base = params[ndet]\n d = np.zeros((m, m))\n for i in range(m):\n if i == ndet:\n continue\n d[i, i] = 1 / base\n d[i, ndet] = -params[i] / (base ** 2)\n ci_cov = d @ ci_cov @ d.T\n return self._ci_wrap(ci_cov)\n\n def _lag_repr(self):\n \"\"\"Returns poly repr of an AR, (1 -phi1 L -phi2 L^2-...)\"\"\"\n # TODO\n\n def bounds_test(\n self,\n case: Literal[1, 2, 3, 4, 5],\n cov_type: str = \"nonrobust\",\n cov_kwds: Dict[str, Any] = None,\n use_t: bool = True,\n asymptotic: bool = True,\n nsim: int = 100_000,\n seed: Optional[\n int, Sequence[int], np.random.RandomState, np.random.Generator\n ] = None,\n ):\n r\"\"\"\n Cointegration bounds test of Pesaran, Shin, and Smith\n\n Parameters\n ----------\n case : {1, 2, 3, 4, 5}\n One of the cases covered in the PSS test.\n cov_type : str\n The covariance estimator to use. The asymptotic distribution of\n the PSS test has only been established in the homoskedastic case,\n which is the default.\n\n The most common choices are listed below. Supports all covariance\n estimators that are available in ``OLS.fit``.\n\n * 'nonrobust' - The class OLS covariance estimator that assumes\n homoskedasticity.\n * 'HC0', 'HC1', 'HC2', 'HC3' - Variants of White's\n (or Eiker-Huber-White) covariance estimator. `HC0` is the\n standard implementation. The other make corrections to improve\n the finite sample performance of the heteroskedasticity robust\n covariance estimator.\n * 'HAC' - Heteroskedasticity-autocorrelation robust covariance\n estimation. Supports cov_kwds.\n\n - `maxlags` integer (required) : number of lags to use.\n - `kernel` callable or str (optional) : kernel\n currently available kernels are ['bartlett', 'uniform'],\n default is Bartlett.\n - `use_correction` bool (optional) : If true, use small sample\n correction.\n cov_kwds : dict, optional\n A dictionary of keyword arguments to pass to the covariance\n estimator. `nonrobust` and `HC#` do not support cov_kwds.\n use_t : bool, optional\n A flag indicating that small-sample corrections should be applied\n to the covariance estimator.\n asymptotic : bool\n Flag indicating whether to use asymptotic critical values which\n were computed by simulation (True, default) or to simulate a\n sample-size specific set of critical values. Tables are only\n available for up to 10 components in the cointegrating\n relationship, so if more variables are included then simulation\n is always used. The simulation computed the test statistic under\n and assumption that the residuals are homoskedastic.\n nsim : int\n Number of simulations to run when computing exact critical values.\n Only used if ``asymptotic`` is ``True``.\n seed : {None, int, sequence[int], RandomState, Generator}, optional\n Seed to use when simulating critical values. Must be provided if\n reproducible critical value and p-values are required when\n ``asymptotic`` is ``False``.\n\n Returns\n -------\n BoundsTestResult\n Named tuple containing ``stat``, ``crit_vals``, ``p_values``,\n ``null` and ``alternative``. The statistic is the F-type\n test statistic favored in PSS.\n\n Notes\n -----\n The PSS bounds test has 5 cases which test the coefficients on the\n level terms in the model\n\n .. math::\n\n \\Delta Y_{t}=\\delta_{0} + \\delta_{1}t + Z_{t-1}\\beta\n + \\sum_{j=0}^{P}\\Delta X_{t-j}\\Gamma + \\epsilon_{t}\n\n where :math:`Z_{t-1}` contains both :math:`Y_{t-1}` and\n :math:`X_{t-1}`.\n\n The cases determine which deterministic terms are included in the\n model and which are tested as part of the test.\n\n Cases:\n\n 1. No deterministic terms\n 2. Constant included in both the model and the test\n 3. Constant included in the model but not in the test\n 4. Constant and trend included in the model, only trend included in\n the test\n 5. Constant and trend included in the model, neither included in the\n test\n\n The test statistic is a Wald-type quadratic form test that all of the\n coefficients in :math:`\\beta` are 0 along with any included\n deterministic terms, which depends on the case. The statistic returned\n is an F-type test statistic which is the standard quadratic form test\n statistic divided by the number of restrictions.\n\n References\n ----------\n .. [*] Pesaran, M. H., Shin, Y., & Smith, R. J. (2001). Bounds testing\n approaches to the analysis of level relationships. Journal of\n applied econometrics, 16(3), 289-326.\n \"\"\"\n model = self.model\n trend: Literal[\"n\", \"c\", \"ct\"]\n if case == 1:\n trend = \"n\"\n elif case in (2, 3):\n trend = \"c\"\n else:\n trend = \"ct\"\n order = {key: max(val) for key, val in model._order.items()}\n uecm = UECM(\n model.data.endog,\n max(model.ar_lags),\n model.data.orig_exog,\n order=order,\n causal=model.causal,\n trend=trend,\n )\n res = uecm.fit(cov_type=cov_type, cov_kwds=cov_kwds, use_t=use_t)\n cov = res.cov_params()\n nvar = len(res.model.ardl_order)\n if case == 1:\n rest = np.arange(nvar)\n elif case == 2:\n rest = np.arange(nvar + 1)\n elif case == 3:\n rest = np.arange(1, nvar + 1)\n elif case == 4:\n rest = np.arange(1, nvar + 2)\n elif case == 5:\n rest = np.arange(2, nvar + 2)\n r = np.zeros((rest.shape[0], cov.shape[1]))\n for i, loc in enumerate(rest):\n r[i, loc] = 1\n vcv = r @ cov @ r.T\n coef = r @ res.params\n stat = coef.T @ np.linalg.inv(vcv) @ coef / r.shape[0]\n k = nvar\n if asymptotic and k <= 10:\n cv = pss_critical_values.crit_vals\n key = (k, case)\n upper = cv[key + (True,)]\n lower = cv[key + (False,)]\n crit_vals = pd.DataFrame(\n {\"lower\": lower, \"upper\": upper},\n index=pss_critical_values.crit_percentiles,\n )\n crit_vals.index.name = \"percentile\"\n p_values = pd.Series(\n {\n \"lower\": _pss_pvalue(stat, k, case, False),\n \"upper\": _pss_pvalue(stat, k, case, True),\n }\n )\n else:\n nobs = res.resid.shape[0]\n crit_vals, p_values = _pss_simulate(\n stat, k, case, nobs=nobs, nsim=nsim, seed=seed\n )\n\n return BoundsTestResult(\n stat,\n crit_vals,\n p_values,\n \"No Cointegration\",\n \"Possible Cointegration\",\n )\n\n\ndef _pss_pvalue(stat: float, k: int, case: int, i1: bool) -> float:\n key = (k, case, i1)\n large_p = pss_critical_values.large_p[key]\n small_p = pss_critical_values.small_p[key]\n threshold = pss_critical_values.stat_star[key]\n log_stat = np.log(stat)\n p = small_p if stat > threshold else large_p\n x = [log_stat ** i for i in range(len(p))]\n return 1 - stats.norm.cdf(x @ np.array(p))\n\n\ndef _pss_simulate(\n stat: float,\n k: int,\n case: Literal[1, 2, 3, 4, 5],\n nobs: int,\n nsim: int,\n seed: Union[\n int, Sequence[int], np.random.RandomState, np.random.Generator\n ],\n) -> Tuple[pd.DataFrame, pd.Series]:\n if not isinstance(seed, np.random.RandomState):\n rs: Union[\n np.random.RandomState, np.random.Generator\n ] = np.random.default_rng(seed)\n else:\n assert isinstance(seed, np.random.RandomState)\n rs = seed\n\n def _vectorized_ols_resid(rhs, lhs):\n rhs_t = np.transpose(rhs, [0, 2, 1])\n xpx = np.matmul(rhs_t, rhs)\n xpy = np.matmul(rhs_t, lhs)\n b = np.linalg.solve(xpx, xpy)\n return np.squeeze(lhs - np.matmul(rhs, b))\n\n block_size = 100_000_000 // (8 * nobs * k)\n remaining = nsim\n loc = 0\n f_upper = np.empty(nsim)\n f_lower = np.empty(nsim)\n while remaining > 0:\n to_do = min(remaining, block_size)\n e = rs.standard_normal((to_do, nobs + 1, k))\n\n y = np.cumsum(e[:, :, :1], axis=1)\n x_upper = np.cumsum(e[:, :, 1:], axis=1)\n x_lower = e[:, :, 1:]\n lhs = np.diff(y, axis=1)\n if case in (2, 3):\n rhs = np.empty((to_do, nobs, k + 1))\n rhs[:, :, -1] = 1\n elif case in (4, 5):\n rhs = np.empty((to_do, nobs, k + 2))\n rhs[:, :, -2] = np.arange(nobs, dtype=float)\n rhs[:, :, -1] = 1\n else:\n rhs = np.empty((to_do, nobs, k))\n rhs[:, :, :1] = y[:, :-1]\n rhs[:, :, 1:k] = x_upper[:, :-1]\n\n u = _vectorized_ols_resid(rhs, lhs)\n df = rhs.shape[1] - rhs.shape[2]\n s2 = (u ** 2).sum(1) / df\n\n if case in (3, 4):\n rhs_r = rhs[:, :, -1:]\n elif case == 5: # case 5\n rhs_r = rhs[:, :, -2:]\n if case in (3, 4, 5):\n ur = _vectorized_ols_resid(rhs_r, lhs)\n nrest = rhs.shape[-1] - rhs_r.shape[-1]\n else:\n ur = np.squeeze(lhs)\n nrest = rhs.shape[-1]\n\n f = ((ur ** 2).sum(1) - (u ** 2).sum(1)) / nrest\n f /= s2\n f_upper[loc : loc + to_do] = f\n\n # Lower\n rhs[:, :, 1:k] = x_lower[:, :-1]\n u = _vectorized_ols_resid(rhs, lhs)\n s2 = (u ** 2).sum(1) / df\n\n if case in (3, 4):\n rhs_r = rhs[:, :, -1:]\n elif case == 5: # case 5\n rhs_r = rhs[:, :, -2:]\n if case in (3, 4, 5):\n ur = _vectorized_ols_resid(rhs_r, lhs)\n nrest = rhs.shape[-1] - rhs_r.shape[-1]\n else:\n ur = np.squeeze(lhs)\n nrest = rhs.shape[-1]\n\n f = ((ur ** 2).sum(1) - (u ** 2).sum(1)) / nrest\n f /= s2\n f_lower[loc : loc + to_do] = f\n\n loc += to_do\n remaining -= to_do\n\n crit_percentiles = pss_critical_values.crit_percentiles\n crit_vals = pd.DataFrame(\n {\n \"lower\": np.percentile(f_lower, crit_percentiles),\n \"upper\": np.percentile(f_upper, crit_percentiles),\n },\n index=crit_percentiles,\n )\n crit_vals.index.name = \"percentile\"\n p_values = pd.Series(\n {\"lower\": (stat < f_lower).mean(), \"upper\": (stat < f_upper).mean()}\n )\n return crit_vals, p_values\n\n\nclass UECMResultsWrapper(wrap.ResultsWrapper):\n _attrs = {}\n _wrap_attrs = wrap.union_dicts(\n tsa_model.TimeSeriesResultsWrapper._wrap_attrs, _attrs\n )\n _methods = {}\n _wrap_methods = wrap.union_dicts(\n tsa_model.TimeSeriesResultsWrapper._wrap_methods, _methods\n )\n\n\nwrap.populate_wrapper(UECMResultsWrapper, UECMResults)\n"
] |
[
[
"pandas.Series",
"numpy.asarray",
"numpy.squeeze",
"numpy.cumsum",
"pandas.DataFrame",
"numpy.random.default_rng",
"numpy.ix_",
"numpy.arange",
"numpy.matmul",
"numpy.full",
"numpy.diff",
"numpy.column_stack",
"scipy.stats.t",
"numpy.zeros",
"numpy.log",
"pandas.concat",
"numpy.isnan",
"numpy.linalg.inv",
"numpy.full_like",
"numpy.linalg.lstsq",
"numpy.transpose",
"numpy.array",
"numpy.linalg.solve",
"numpy.abs",
"numpy.isfinite",
"numpy.percentile",
"numpy.ones",
"numpy.linalg.pinv",
"scipy.stats.norm",
"numpy.empty"
]
] |
WorldEditors/Knover
|
[
"e4664e8eabe598d8203a5ffc8445b79de2fc9191",
"e4664e8eabe598d8203a5ffc8445b79de2fc9191"
] |
[
"knover/utils/tensor_utils.py",
"knover/data/dialog_reader.py"
] |
[
"# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"Tensor utility.\"\"\"\n\nfrom itertools import chain\n\nimport numpy as np\nimport paddle.fluid as fluid\nimport paddle.fluid.core as core\n\n\ndef get_tensor(tensor_name, to_np=True):\n \"\"\"Get tensor by name.\"\"\"\n var = fluid.global_scope().find_var(tensor_name)\n if var is None:\n return None\n tensor = var.get_tensor()\n if tensor is None:\n return None\n if to_np:\n return np.array(tensor)\n else:\n return tensor\n\n\ndef to_lodtensor(data, place, dtype=None):\n \"\"\"Convert data to LoDTensor.\"\"\"\n if place is None:\n return data\n lengths = []\n while isinstance(data[0], list):\n lengths.append(list(map(len, data)))\n data = [x for xs in data for x in xs]\n if dtype is None:\n if isinstance(data[0], float):\n dtype = \"float32\"\n else:\n dtype = \"int64\"\n data = np.array(data, dtype=dtype)\n data_tensor = fluid.LoDTensor()\n data_tensor.set(data, place)\n data_tensor.set_recursive_sequence_lengths(lengths)\n return data_tensor\n\n\ndef pad_batch_data(insts, pad_id=0):\n \"\"\"Pad the instances to the max sequence length in batch. \"\"\"\n max_len = max(map(len, insts))\n inst_data = np.array([list(inst) + [pad_id] * (max_len - len(inst)) for inst in insts])\n return inst_data.astype(\"int64\").reshape([-1, max_len, 1])\n\n\ndef convert_lodtensor_to_list(tensor):\n data = np.array(tensor)\n recursive_sequence_lengths = tensor.recursive_sequence_lengths()\n recursive_sequence_lengths.reverse()\n for i, lengths in enumerate(recursive_sequence_lengths):\n offset = 0\n new_data = []\n for j, l in enumerate(lengths):\n new_data.append(list(data[offset:offset + l]))\n offset += l\n data = new_data\n return data\n\n\ndef concatenate_lodtensors(tensors, place):\n \"\"\"Concatenate LoD tensors.\"\"\"\n data = []\n recursive_sequence_lengths = []\n for tensor in tensors:\n data.append(np.array(tensor))\n recursive_sequence_lengths.append(tensor.recursive_sequence_lengths())\n data = np.concatenate(data, axis=0)\n recursive_sequence_lengths = [sum(lens, []) for lens in zip(*recursive_sequence_lengths)]\n data_tensor = fluid.LoDTensor()\n data_tensor.set(data, place)\n data_tensor.set_recursive_sequence_lengths(recursive_sequence_lengths)\n assert data_tensor.has_valid_recursive_sequence_lengths()\n return data_tensor\n\n\ndef repeat_array_or_tensor(array_or_tensor, place, times):\n \"\"\"Repeate numpy array or LoD tensor.\"\"\"\n if isinstance(array_or_tensor, fluid.LoDTensor):\n data = [np.array(array_or_tensor)] * times\n recursive_sequence_lengths = [array_or_tensor.recursive_sequence_lengths()] * times\n data = np.concatenate(data, axis=0)\n recursive_sequence_lengths = [sum(lens, []) for lens in zip(*recursive_sequence_lengths)]\n data_tensor = fluid.LoDTensor()\n data_tensor.set(data, place)\n data_tensor.set_recursive_sequence_lengths(recursive_sequence_lengths)\n assert data_tensor.has_valid_recursive_sequence_lengths()\n return data_tensor\n elif isinstance(array_or_tensor, list):\n return list(chain(*([array_or_tensor] * times)))\n else:\n return np.concatenate([array_or_tensor] * times, axis=0)\n\n\ndef slice_array_or_tensor(array_or_tensor, place, begin, end):\n \"\"\"Repeate numpy array or LoD tensor.\"\"\"\n if isinstance(array_or_tensor, fluid.LoDTensor):\n data = convert_lodtensor_to_list(array_or_tensor)\n data = data[begin:end]\n if array_or_tensor._dtype() == core.VarDesc.VarType.FP32:\n dtype=\"float32\"\n else:\n dtype=\"int64\"\n return to_lodtensor(data, place, dtype)\n else:\n return array_or_tensor[begin:end]\n",
"# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"Dialogue Reader.\"\"\"\n\nfrom collections import namedtuple\nimport os\n\nimport numpy as np \nimport paddle.fluid as fluid\nfrom paddle.fluid.incubate.fleet.collective import fleet\n\nfrom knover.utils import mask, open_file, pad_batch_data, str2bool\nimport knover.utils.tokenization as tokenization\n\n\nclass DialogReader(object):\n \"\"\"The implement of DialogReader.\"\"\"\n\n @classmethod\n def add_cmdline_args(cls, parser):\n \"\"\"Add cmdline arguments.\"\"\"\n group = parser.add_argument_group(\"Reader\")\n group.add_argument(\"--max_src_len\", type=int, default=128,\n help=\"The maximum length of source sequence (context in dialogue generation task).\")\n group.add_argument(\"--max_tgt_len\", type=int, default=128,\n help=\"The maximum length of target sequence (response in dialogue generation task).\")\n group.add_argument(\"--max_seq_len\", type=int, default=256,\n help=\"The maximum length of sequence.\")\n group.add_argument(\"--max_knowledge_len\", type=int, default=0,\n help=\"The maximum length of knowledge sequence.\")\n group.add_argument(\"--knowledge_position\", type=str, default=\"post_src\",\n choices=[\"post_src\", \"pre_src\"],\n help=\"How to concatenate source sequence and knowledge sequence. \"\n \"`post_src` means concatenate knowledge sequence after source sequence, \"\n \"and `pre_src` means concatenate knowledge sequence before source sequence.\")\n group.add_argument(\"--knowledge_style\", type=str, default=\"original\",\n choices=[\"original\", \"reversed\"],\n help=\"How to concatenate multipe knowledges. `original` concatenate knowledges in \"\n \"original order, and `reversed` means concatenate knowledges in reversed order.\")\n group.add_argument(\"--truncate_first_turn\", type=str2bool, default=False,\n help=\"Whether truncate the first turn.\")\n group.add_argument(\"--file_format\", type=str, default=\"file\",\n choices=[\"file\", \"filelist\"],\n help=\"The input file format.\")\n group.add_argument(\"--data_format\", type=str, default=\"raw\",\n choices=[\"raw\", \"tokenized\", \"numerical\"],\n help=\"The data format of each file.\")\n group.add_argument(\"--in_tokens\", type=str2bool, default=False,\n help=\"Whether batchify examples by the number of tokens.\")\n group.add_argument(\"--batch_size\", type=int, default=16,\n help=\"The size of batches. If `in_tokens` is false, then batchify every X examples.\"\n \"If `in_tokens` is true, then batchify examples which contains nearly X tokens.\")\n group.add_argument(\"--position_style\", type=str, default=\"continuous\",\n choices=[\"continuous\", \"relative\"],\n help=\"The position encoding style.\")\n group.add_argument(\"--random_seed\", type=int, default=11,\n help=\"The seed to control the data generation.\")\n group.add_argument(\"--shuffle_pool_size\", type=int, default=0,\n help=\"The size of shuffle pool.\"\n \"If it is positive, we will shuffle each X examples and then batchify them.\")\n group.add_argument(\"--sort_pool_size\", type=int, default=2 ** 16,\n help=\"The size of sorting pool. If it is positive, we will generate batches from sorted \"\n \"example pool (containing X examples).\")\n\n tokenizer_group = parser.add_argument_group(\"Tokenizer\")\n tokenizer_group.add_argument(\"--tokenizer\", type=str, default=\"SentencePieceTokenizer\")\n args, _ = parser.parse_known_args()\n tokenizer_cls = getattr(tokenization, args.tokenizer)\n tokenizer_cls.add_cmdline_args(parser)\n return group\n\n def __init__(self, args):\n tokenizer_cls = getattr(tokenization, args.tokenizer)\n self.tokenizer = tokenizer_cls(args)\n self.vocab = self.tokenizer.vocab\n self.pad_id = args.pad_id = self.tokenizer.pad_id\n self.bos_id = args.bos_id = self.tokenizer.bos_id\n self.eos_id = args.eos_id = self.tokenizer.eos_id\n self.unk_id = args.unk_id = self.tokenizer.unk_id\n self.mask_id = args.mask_id = self.tokenizer.mask_id\n self.vocab_size = args.get(\"vocab_size\", self.tokenizer.vocab_size)\n self.max_src_len = args.max_src_len\n self.max_tgt_len = args.max_tgt_len\n self.max_knowledge_len = args.max_knowledge_len\n self.knowledge_position = args.knowledge_position\n self.knowledge_style = args.knowledge_style\n self.truncate_first_turn = args.truncate_first_turn\n self.file_format = args.file_format\n self.data_format = args.data_format\n self.in_tokens = args.in_tokens\n self.batch_size = args.batch_size\n self.position_style = args.position_style\n self.sort_pool_size = args.sort_pool_size\n self.shuffle_pool_size = args.shuffle_pool_size\n\n self.reserve_example = args.get(\"reserve_example\", False)\n\n if self.shuffle_pool_size > 0 and self.sort_pool_size > 0:\n raise ValueError(f\"Cannot set `shuffle_pool_size = {self.shuffle_pool_size}`\"\n f\" and `sort_pool_size = ${self.sort_pool_size}` both positive.\")\n\n assert args.max_knowledge_len + args.max_src_len + args.max_tgt_len <= args.max_seq_len, \\\n \"args.max_knowledge_len + args.max_src_len + args.max_tgt_len > args.max_seq_len\"\n\n # random_seed must be set for data slicing when using multi-gpu\n self.global_rng = np.random.RandomState(args.random_seed)\n\n # training progress\n self.current_example = 0\n self.current_epoch = 0\n self.num_examples = 0\n\n # model related\n self.use_role = args.use_role\n\n self.fields = [\"token_ids\", \"type_ids\", \"pos_ids\"]\n if args.use_role:\n self.fields.append(\"role_ids\")\n self.num_numerical_fields = len(self.fields)\n self.fields += [\"tgt_start_idx\", \"data_id\"]\n self.sort_key = lambda record: [len(record.token_ids)]\n\n self.Record = namedtuple(\"Record\", self.fields, defaults=(None,) * len(self.fields))\n\n if self.reserve_example:\n self.features = {}\n return\n\n def get_train_progress(self):\n \"\"\"Gets progress for training phase.\"\"\"\n return self.current_epoch, self.current_file_index, self.total_file\n\n def _parse_src(self, src):\n \"\"\"Parse source sequence and return corresponding fields.\"\"\"\n # process src\n src_token_ids = []\n src_pos_ids = []\n if self.use_role:\n src_role_ids = []\n role_id_list = []\n\n # tokenize src\n s_token_ids_list = []\n for s in src.split(\"[SEP]\"):\n s = s.strip()\n if self.use_role and \"\\1\" in s:\n s, role_id = s.split(\"\\1\")\n role_id = int(role_id)\n role_id_list.append(role_id)\n\n if self.data_format == \"tokenized\":\n s_tokens = s.split(\" \")\n else:\n s_tokens = self.tokenizer.tokenize(s)\n\n s_token_ids = self.tokenizer.convert_tokens_to_ids(s_tokens) + [self.eos_id]\n s_token_ids_list.append(s_token_ids)\n\n # trim src\n idx = len(s_token_ids_list) - 1\n total_token_num = 1\n while idx >= 0:\n total_token_num += len(s_token_ids_list[idx])\n if total_token_num > self.max_src_len:\n if self.truncate_first_turn and idx == 0:\n truncated_ids = s_token_ids_list[idx][:self.max_src_len - total_token_num]\n if len(truncated_ids) > 1:\n s_token_ids_list[idx] = truncated_ids[:-1] + [self.eos_id]\n idx -= 1\n break\n idx -= 1\n\n if self.use_role and len(role_id_list) == 0:\n for i in range(len(s_token_ids_list)):\n role_id_list.append((len(s_token_ids_list) - i) % 2)\n for i, s_token_ids in enumerate(s_token_ids_list[idx + 1:], idx + 1):\n src_token_ids += s_token_ids\n src_pos_ids += list(range(1, len(s_token_ids) + 1))\n if self.use_role:\n src_role_ids += [role_id_list[i]] * len(s_token_ids)\n\n field_values = {\n \"token_ids\": [self.bos_id] + src_token_ids,\n \"type_ids\": [0] * (len(src_token_ids) + 1),\n \"pos_ids\": [0] + src_pos_ids\n }\n if self.use_role:\n field_values[\"role_ids\"] = [0] + src_role_ids\n\n for k in field_values:\n assert len(field_values[k]) == len(field_values[\"token_ids\"]), \\\n f\"len(field_values[{k}]) != len(field_values['token_ids'])\"\n return field_values\n\n def _parse_knowledge(self, knowledge):\n \"\"\"Parse knowledge sequence and return corresponding fields.\"\"\"\n ks_token_ids = [self.bos_id]\n ks_pos_ids = [0]\n if self.knowledge_style == \"original\":\n ks = knowledge.split(\"[SEP]\")\n elif self.knowledge_style == \"reversed\":\n ks = reversed(knowledge.split(\"[SEP]\"))\n for k in ks:\n k = k.strip()\n if self.data_format == \"tokenized\":\n k_tokens = k.split(\" \")\n else:\n k_tokens = self.tokenizer.tokenize(k)\n\n k_token_ids = self.tokenizer.convert_tokens_to_ids(k_tokens) + [self.eos_id]\n ks_token_ids += k_token_ids\n ks_pos_ids += list(range(1, len(k_token_ids) + 1))\n\n if len(ks_token_ids) > self.max_knowledge_len:\n if self.knowledge_style == \"original\":\n ks_token_ids = ks_token_ids[:self.max_knowledge_len]\n ks_pos_ids = ks_pos_ids[:self.max_knowledge_len]\n else:\n ks_token_ids = ks_token_ids[-self.max_knowledge_len:]\n ks_pos_ids = ks_pos_ids[-self.max_knowledge_len:]\n\n field_values = {\n \"token_ids\": ks_token_ids,\n \"type_ids\": [2] * len(ks_token_ids),\n \"pos_ids\": ks_pos_ids\n }\n if self.use_role:\n field_values[\"role_ids\"] = [0] * len(ks_token_ids)\n\n return field_values\n\n def _parse_tgt(self, tgt):\n \"\"\"Parse target sequence and return corresponding fields.\"\"\"\n # process tgt\n tgt = tgt.strip()\n if self.use_role:\n if \"\\1\" in tgt:\n tgt, role_id = tgt.split(\"\\1\")\n role_id = int(role_id)\n else:\n role_id = 0\n if self.data_format == \"tokenized\":\n tgt_tokens = tgt.split(\" \")\n else:\n tgt_tokens = self.tokenizer.tokenize(tgt)\n\n tgt_token_ids = self.tokenizer.convert_tokens_to_ids(tgt_tokens)\n tgt_token_ids.append(self.eos_id)\n\n # trim tgt\n tgt_token_ids = tgt_token_ids[:self.max_tgt_len - 1]\n\n tgt_token_ids = [self.bos_id] + tgt_token_ids\n\n field_values = {\n \"token_ids\": tgt_token_ids,\n \"type_ids\": [1] * len(tgt_token_ids),\n \"pos_ids\": list(range(len(tgt_token_ids)))\n }\n if self.use_role:\n field_values[\"role_ids\"] = [role_id] * len(tgt_token_ids)\n\n return field_values\n\n def _convert_example_to_record(self, example, is_infer):\n \"\"\"Convert an example to a record which can be used as the model's input.\"\"\"\n field_values = self._parse_src(example.src)\n\n if self.max_knowledge_len > 0:\n # add knowledge\n knowledge_field_values = self._parse_knowledge(example.knowledge)\n if self.knowledge_position == \"pre_src\":\n field_values = {\n k: knowledge_field_values[k] + field_values[k]\n for k in field_values\n }\n else:\n field_values = {\n k: field_values[k] + knowledge_field_values[k]\n for k in field_values\n }\n\n tgt_start_idx = len(field_values[\"token_ids\"])\n\n if self.position_style == \"relative\":\n ctx_len = len(field_values[\"token_ids\"])\n field_values[\"pos_ids\"] = [\n self.max_tgt_len + ctx_len - i - 1\n for i in range(ctx_len)\n ]\n\n if not is_infer:\n tgt_field_values = self._parse_tgt(example.tgt)\n field_values = {\n k: field_values[k] + tgt_field_values[k]\n for k in field_values\n }\n\n if self.position_style == \"continuous\":\n field_values[\"pos_ids\"] = list(range(len(field_values[\"token_ids\"])))\n\n field_values[\"tgt_start_idx\"] = tgt_start_idx\n field_values[\"data_id\"] = example.data_id\n\n record = self.Record(**field_values)\n return record\n\n def _read_tsv(self, fp, phase, is_infer, delimiter=\"\\t\", quotechar=None):\n \"\"\"Read a tab separated value file and yield records.\"\"\"\n headers = next(fp).rstrip(\"\\n\").split(delimiter)\n headers.append(\"data_id\")\n Example = namedtuple(\"Example\", headers)\n\n for i, line in enumerate(fp):\n line = line.rstrip(\"\\n\").split(delimiter)\n example = Example(*line, data_id=i)\n if self.reserve_example and (is_infer or phase.endswith(\"test\")):\n self.features[i] = example\n record = self._convert_example_to_record(example, is_infer)\n yield record\n\n def _read_numerical_file(self, fp, phase, is_infer, delimiter=\";\"):\n \"\"\"Read a file which contains numerical data and yield records.\"\"\"\n for i, line in enumerate(fp):\n cols = line.strip().split(delimiter)\n cols = list(map(lambda x: list(map(int, x.split(\" \"))), cols))\n if len(cols) > self.num_numerical_fields:\n cols = cols[:self.num_numerical_fields]\n if is_infer:\n tgt_start_idx = len(cols[0])\n else:\n # get the start position of target sequence\n # if you change the numerical data format, you must to make sure the last part of\n # numerical sequence is the target sequence\n def rindex(lst, elem):\n try:\n return len(lst) - lst[::-1].index(elem) - 1\n except:\n return 0\n tgt_start_idx = rindex(cols[0], self.bos_id)\n record = self.Record(*cols, tgt_start_idx=tgt_start_idx, data_id=i)\n yield record\n\n def _read_file(self, input_file, phase, is_infer):\n \"\"\"Read a data file and yield records.\"\"\"\n def __wrapper__():\n with open_file(input_file) as fp:\n if self.data_format == \"numerical\":\n records = self._read_numerical_file(fp, phase, is_infer)\n else:\n records = self._read_tsv(fp, phase, is_infer)\n for record in records:\n yield record\n\n return __wrapper__\n\n def _read_files(self, filelist, phase, is_infer, shuffle_files):\n \"\"\"Read multiply files and yield records.\"\"\"\n input_files = open(filelist).readlines()\n def __wrapper__():\n if shuffle_files:\n self.global_rng.shuffle(input_files)\n\n if phase == \"train\":\n self.total_file = len(input_files)\n for file_index, input_file in enumerate(input_files, 1):\n if phase == \"train\":\n self.current_file_index = file_index\n self.current_file = input_file\n file_reader = self._read_file(input_file.strip(), phase, is_infer)\n for record in file_reader():\n yield record\n\n return __wrapper__\n\n def _shuffle_reader(self, reader, shuffle_pool_size):\n \"\"\"Shuffle examples.\"\"\"\n def get_batch(pool):\n self.global_rng.shuffle(pool)\n for record in pool:\n yield record\n\n def __wrapper__():\n pool = []\n for record in reader():\n pool.append(record)\n if len(pool) == shuffle_pool_size:\n yield from get_batch(pool)\n pool = []\n if len(pool) > 0:\n yield from get_batch(pool)\n\n return __wrapper__\n\n def _update_max_lens(self, max_lens, record):\n \"\"\"Update max_lens.\"\"\"\n if max_lens is None:\n return self.sort_key(record)\n else:\n return [max(max_len, l) for max_len, l in zip(max_lens, self.sort_key(record))]\n\n def _get_batch(self, reader):\n \"\"\"Yield batches from record reader.\"\"\"\n def __wrapper__():\n batch, max_lens = [], None\n for record in reader():\n if record is None:\n yield batch\n batch, max_lens = [], None\n continue\n\n self.current_example += 1\n max_lens = self._update_max_lens(max_lens, record)\n if self.in_tokens:\n to_append = (len(batch) + 1) * sum(max_lens) <= self.batch_size\n else:\n to_append = len(batch) < self.batch_size\n if to_append:\n batch.append(record)\n else:\n yield batch\n batch, max_lens = [record], self.sort_key(record)\n\n if len(batch) > 0:\n yield batch\n return __wrapper__\n\n def _get_sorted_batch(self, reader):\n \"\"\"Yield sorted batches from record reader.\"\"\"\n def _get_sorted_batch_from_pool(pool):\n \"\"\"Generate sorted batches from pool.\"\"\"\n pool = sorted(pool, key=self.sort_key)\n batches = []\n batch, max_lens = [], None\n for record in pool:\n self.current_example += 1\n max_lens = self._update_max_lens(max_lens, record)\n if self.in_tokens:\n to_append = (len(batch) + 1) * sum(max_lens) <= self.batch_size\n else:\n to_append = len(batch) < self.batch_size\n if to_append:\n batch.append(record)\n else:\n batches.append(batch)\n batch, max_lens = [record], self.sort_key(record)\n\n if len(batch) > 0:\n batches.append(batch)\n self.global_rng.shuffle(batches)\n\n for batch in batches:\n yield batch\n\n def __wrapper__():\n pool = []\n for record in reader():\n pool.append(record)\n if len(pool) == self.sort_pool_size:\n yield from _get_sorted_batch_from_pool(pool)\n pool = []\n if len(pool) > 0:\n yield from _get_sorted_batch_from_pool(pool)\n\n return __wrapper__\n\n def _batch_reader(self, reader, phase=None, is_infer=False):\n \"\"\"Construct a batch reader from a record reader.\"\"\"\n if self.sort_pool_size > 0 and not is_infer:\n return self._get_sorted_batch(reader)\n else:\n return self._get_batch(reader)\n\n def _distributed_batch_reader(self, batch_reader, num_part, part_id, is_test=False):\n \"\"\"Distributed batch reader.\n\n Slice dataset and feed batches to different devices.\n\n Args:\n batch_reader: A batch reader.\n num_part: The number of devices.\n part_id: The id of current device.\n is_test: Whether slice dataset in testing phase. When it sets false, we will drop the last batches\n if the number of remainder batches is less than the number of devices.\n\n Returns:\n reader: A distributed Reader.\n \"\"\"\n def __wrapper__():\n batches = []\n for batch in batch_reader():\n batches.append(batch)\n if len(batches) == num_part:\n yield batches[part_id]\n batches = []\n if is_test and 0 <= part_id < len(batches):\n yield batches[part_id]\n return\n\n return __wrapper__\n\n def data_generator(self,\n input_file=None,\n reader=None,\n num_epochs=1,\n num_part=1,\n part_id=0,\n phase=None,\n is_infer=False):\n \"\"\"Yield batches from a file or a record reader.\n\n If `reader` is set, it will yield batches from the record reader, otherwise yield batches from the given\n `input_file`.\n\n Args:\n input_file: The path of input file. The format of this file is controlled by Reader.file_format and\n Reader.data_format.\n reader: The record reader.\n num_epochs: The number of times the learning algorithm will work through the entire training dataset.\n num_part: The number of devices.\n part_id: The id of current device.\n phase: The type of dataset, which can be one of 'train' / 'valid' / 'test'.\n is_infer: Whether to run inference on this dataset.\n \"\"\"\n def __wrapper__():\n nonlocal reader\n if reader is None:\n if self.file_format == \"filelist\":\n reader = self._read_files(input_file, phase, is_infer, not phase.endswith(\"test\"))\n else:\n if phase == \"train\":\n self.total_file = 1\n self.current_file_index = 1\n self.current_file = input_file\n reader = self._read_file(input_file, phase, is_infer)\n\n if self.shuffle_pool_size > 0:\n reader = self._shuffle_reader(reader, self.shuffle_pool_size)\n\n batch_reader = self._batch_reader(reader, phase, is_infer)\n if phase == \"train\":\n batch_reader = self._distributed_batch_reader(batch_reader, num_part, part_id)\n elif phase.startswith(\"distributed\"):\n batch_reader = self._distributed_batch_reader(batch_reader, num_part, part_id, is_test=True)\n\n for epoch_index in range(num_epochs):\n if phase == \"train\":\n self.current_example = 0\n self.current_epoch = epoch_index + 1\n for batch in batch_reader():\n yield self._pad_batch_records(batch, is_infer, phase=phase)\n\n return __wrapper__\n\n def _gen_self_attn_mask(self, batch_token_ids, batch_tgt_start_idx=None, is_unidirectional=True, num_aux_token=0):\n \"\"\"Generate self attention masking matrix.\n\n This is a helpful function to generate different types of attention masking matrix.\n 1. Bi-directional: all tokens can attent to all other tokens.\n 2. Uni-directional: all tokens can only attent to their former tokens.\n 3. Seq2seq: tokens in source sequence can attent each other, tokens in target sequence can only attent the\n tokens in source sequence and the former token in target sequence.\n\n Args:\n batch_token_ids: A batch of token ids.\n batch_tgt_start_idx: A batch of indices which represent the starting index of target sequence.\n is_unidirectional: Whether generate uni-directional masking matrix. When `batch_tgt_start_idx` is not\n `None` and `is_unidirectional` is True, then it will generate seq2seq masking matrix (source sequence\n is bi-directional attention and target sequence is uni-directional attention).\n num_aux_token: The number of auxiliary tokens. The auxiliary tokens will concatenate to the begin of\n sequence. They are considered as a part of source sequence.\n \"\"\"\n max_len = max(map(len, batch_token_ids))\n input_mask_data = np.zeros((len(batch_token_ids), max_len + num_aux_token, max_len + num_aux_token))\n if is_unidirectional:\n for index, mask_data in enumerate(input_mask_data):\n start = 0 if batch_tgt_start_idx is None else batch_tgt_start_idx[index]\n end = len(batch_token_ids[index])\n mask_data[:end + num_aux_token, :start + num_aux_token] = 1.0\n # Generate the lower triangular matrix using the slice of matrix\n b = np.tril(np.ones([end - start, end - start]), 0)\n mask_data[start + num_aux_token:end + num_aux_token, start + num_aux_token:end + num_aux_token] = b\n else:\n for index, token_ids in enumerate(batch_token_ids):\n input_mask_data[index, :len(token_ids) + num_aux_token, :len(token_ids) + num_aux_token] = 1.0\n return input_mask_data.astype(\"float32\")\n\n def _pad_batch_records(self, batch_records, is_infer, phase=None):\n \"\"\"Padding a batch of records and construct model's inputs.\n\n This function can be override by its subclass if necessary.\n \"\"\"\n batch_size = len(batch_records)\n batch = {}\n batch_token_ids = [record.token_ids for record in batch_records]\n batch_type_ids = [record.type_ids for record in batch_records]\n batch_pos_ids = [record.pos_ids for record in batch_records]\n if self.use_role:\n batch_role_ids = [record.role_ids for record in batch_records]\n batch[\"token_ids\"] = pad_batch_data(batch_token_ids, pad_id=self.pad_id)\n batch[\"type_ids\"] = pad_batch_data(batch_type_ids, pad_id=0)\n batch[\"pos_ids\"] = pad_batch_data(batch_pos_ids, pad_id=0)\n if self.use_role:\n batch[\"role_ids\"] = pad_batch_data(batch_role_ids, pad_id=0)\n\n batch_tgt_start_idx = [record.tgt_start_idx for record in batch_records]\n batch[\"generation_mask\"] = self._gen_self_attn_mask(\n batch_token_ids,\n batch_tgt_start_idx=batch_tgt_start_idx)\n\n if is_infer:\n tgt_ids = np.array([[[self.bos_id]]] * len(batch_token_ids), dtype=\"int64\")\n if self.position_style == \"continuous\":\n tgt_pos = np.array(batch_tgt_start_idx, dtype=\"int64\")\n else:\n tgt_pos = np.zeros_like(batch_tgt_start_idx, dtype=\"int64\")\n tgt_pos = tgt_pos.reshape(-1, 1, 1)\n batch[\"init_score\"] = np.zeros_like(tgt_ids, dtype=\"float32\").reshape(-1, 1).tolist()\n batch[\"tgt_ids\"] = tgt_ids.tolist()\n batch[\"tgt_pos\"] = tgt_pos.tolist()\n batch[\"parent_idx\"] = np.array(range(batch_size), dtype=\"int32\")\n\n batch[\"tgt_generation_mask\"] = batch[\"generation_mask\"][:, 0:1, :].astype(\"float32\")\n\n batch_data_id = [record.data_id for record in batch_records]\n batch[\"data_id\"] = np.array(batch_data_id).astype(\"int64\").reshape([-1, 1])\n else:\n batch[\"tgt_label\"], batch[\"tgt_idx\"] = mask(\n batch_tokens=batch_token_ids,\n vocab_size=self.vocab_size,\n tgt_starts=batch_tgt_start_idx,\n bos_id=self.bos_id,\n eos_id=self.eos_id,\n mask_id=self.mask_id,\n is_unidirectional=True)\n\n return batch\n"
] |
[
[
"numpy.concatenate",
"numpy.array"
],
[
"numpy.array",
"numpy.random.RandomState",
"numpy.zeros_like",
"numpy.ones"
]
] |
vinisalazar/vamb
|
[
"3ba78e0d5a1a30cfdefb20c373c7df5494437a60"
] |
[
"vamb/vambtools.py"
] |
[
"__doc__ = \"Various classes and functions Vamb uses internally.\"\n\nimport os as _os\nimport gzip as _gzip\nimport bz2 as _bz2\nimport lzma as _lzma\nimport numpy as _np\nfrom vamb._vambtools import _kmercounts, _overwrite_matrix\nimport collections as _collections\nfrom hashlib import md5 as _md5\n\nclass PushArray:\n \"\"\"Data structure that allows efficient appending and extending a 1D Numpy array.\n Intended to strike a balance between not resizing too often (which is slow), and\n not allocating too much at a time (which is memory inefficient).\n\n Usage:\n >>> arr = PushArray(numpy.float64)\n >>> arr.append(5.0)\n >>> arr.extend(numpy.linspace(4, 3, 3))\n >>> arr.take() # return underlying Numpy array\n array([5. , 4. , 3.5, 3. ])\n \"\"\"\n\n __slots__ = ['data', 'capacity', 'length']\n\n def __init__(self, dtype, start_capacity=1<<16):\n self.capacity = start_capacity\n self.data = _np.empty(self.capacity, dtype=dtype)\n self.length = 0\n\n def __len__(self):\n return self.length\n\n def _setcapacity(self, n):\n self.data.resize(n, refcheck=False)\n self.capacity = n\n\n def _grow(self, mingrowth):\n \"\"\"Grow capacity by power of two between 1/8 and 1/4 of current capacity, though at\n least mingrowth\"\"\"\n growth = max(int(self.capacity * 0.125), mingrowth)\n nextpow2 = 1 << (growth - 1).bit_length()\n self._setcapacity(self.capacity + nextpow2)\n\n def append(self, value):\n if self.length == self.capacity:\n self._grow(64)\n\n self.data[self.length] = value\n self.length += 1\n\n def extend(self, values):\n lenv = len(values)\n if self.length + lenv > self.capacity:\n self._grow(lenv)\n\n self.data[self.length:self.length+lenv] = values\n self.length += lenv\n\n def take(self):\n \"Return the underlying array\"\n self._setcapacity(self.length)\n return self.data\n\n def clear(self, force=False):\n \"Empties the PushArray. If force is true, also truncates the underlying memory.\"\n self.length = 0\n if force:\n self._setcapacity(0)\n\ndef zscore(array, axis=None, inplace=False):\n \"\"\"Calculates zscore for an array. A cheap copy of scipy.stats.zscore.\n\n Inputs:\n array: Numpy array to be normalized\n axis: Axis to operate across [None = entrie array]\n inplace: Do not create new array, change input array [False]\n\n Output:\n If inplace is True: None\n else: New normalized Numpy-array\"\"\"\n\n if axis is not None and axis >= array.ndim:\n raise _np.AxisError('array only has {} axes'.format(array.ndim))\n\n if inplace and not _np.issubdtype(array.dtype, _np.floating):\n raise TypeError('Cannot convert a non-float array to zscores')\n\n mean = array.mean(axis=axis)\n std = array.std(axis=axis)\n\n if axis is None:\n if std == 0:\n std = 1 # prevent divide by zero\n\n else:\n std[std == 0.0] = 1 # prevent divide by zero\n shape = tuple(dim if ax != axis else 1 for ax, dim in enumerate(array.shape))\n mean.shape, std.shape = shape, shape\n\n if inplace:\n array -= mean\n array /= std\n return None\n else:\n return (array - mean) / std\n\ndef numpy_inplace_maskarray(array, mask):\n \"\"\"In-place masking of a Numpy array, i.e. if `mask` is a boolean mask of same\n length as `array`, then array[mask] == numpy_inplace_maskarray(array, mask),\n but does not allocate a new array.\n \"\"\"\n\n if len(mask) != len(array):\n raise ValueError('Lengths of array and mask must match')\n elif len(array.shape) != 2:\n raise ValueError('Can only take a 2 dimensional-array.')\n\n uints = _np.frombuffer(mask, dtype=_np.uint8)\n index = _overwrite_matrix(array, uints)\n array.resize((index, array.shape[1]), refcheck=False)\n return array\n\ndef torch_inplace_maskarray(array, mask):\n \"\"\"In-place masking of a Tensor, i.e. if `mask` is a boolean mask of same\n length as `array`, then array[mask] == torch_inplace_maskarray(array, mask),\n but does not allocate a new tensor.\n \"\"\"\n\n if len(mask) != len(array):\n raise ValueError('Lengths of array and mask must match')\n elif array.dim() != 2:\n raise ValueError('Can only take a 2 dimensional-array.')\n\n np_array = array.numpy()\n np_mask = _np.frombuffer(mask.numpy(), dtype=_np.uint8)\n index = _overwrite_matrix(np_array, np_mask)\n array.resize_((index, array.shape[1]))\n return array\n\nclass Reader:\n \"\"\"Use this instead of `open` to open files which are either plain text,\n gzipped, bzip2'd or zipped with LZMA.\n\n Usage:\n >>> with Reader(file, readmode) as file: # by default textmode\n >>> print(next(file))\n TEST LINE\n \"\"\"\n\n def __init__(self, filename, readmode='r'):\n if readmode not in ('r', 'rt', 'rb'):\n raise ValueError(\"the Reader cannot write, set mode to 'r' or 'rb'\")\n if readmode == 'r':\n self.readmode = 'rt'\n else:\n self.readmode = readmode\n\n self.filename = filename\n\n with open(self.filename, 'rb') as f:\n signature = f.peek(8)[:8]\n\n # Gzipped files begin with the two bytes 0x1F8B\n if tuple(signature[:2]) == (0x1F, 0x8B):\n self.filehandle = _gzip.open(self.filename, self.readmode)\n\n # bzip2 files begin with the signature BZ\n elif signature[:2] == b'BZ':\n self.filehandle = _bz2.open(self.filename, self.readmode)\n\n # .XZ files begins with 0xFD377A585A0000\n elif tuple(signature[:7]) == (0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00, 0x00):\n self.filehandle = _lzma.open(self.filename, self.readmode)\n\n # Else we assume it's a text file.\n else:\n self.filehandle = open(self.filename, self.readmode)\n\n def close(self):\n self.filehandle.close()\n\n def __enter__(self):\n return self\n\n def __exit__(self, type, value, traceback):\n self.close()\n\n def __iter__(self):\n return self.filehandle\n\nclass FastaEntry:\n \"\"\"One single FASTA entry. Instantiate with string header and bytearray\n sequence.\"\"\"\n\n basemask = bytearray.maketrans(b'acgtuUswkmyrbdhvnSWKMYRBDHV',\n b'ACGTTTNNNNNNNNNNNNNNNNNNNNN')\n __slots__ = ['header', 'sequence']\n\n def __init__(self, header, sequence):\n if len(header) > 0 and (header[0] in ('>', '#') or header[0].isspace()):\n raise ValueError('Header cannot begin with #, > or whitespace')\n if '\\t' in header:\n raise ValueError('Header cannot contain a tab')\n\n masked = sequence.translate(self.basemask, b' \\t\\n\\r')\n stripped = masked.translate(None, b'ACGTN')\n if len(stripped) > 0:\n bad_character = chr(stripped[0])\n msg = \"Non-IUPAC DNA byte in sequence {}: '{}'\"\n raise ValueError(msg.format(header, bad_character))\n\n self.header = header\n self.sequence = masked\n\n def __len__(self):\n return len(self.sequence)\n\n def __str__(self):\n return '>{}\\n{}'.format(self.header, self.sequence.decode())\n\n def format(self, width=60):\n sixtymers = range(0, len(self.sequence), width)\n spacedseq = '\\n'.join([self.sequence[i: i+width].decode() for i in sixtymers])\n return '>{}\\n{}'.format(self.header, spacedseq)\n\n def __getitem__(self, index):\n return self.sequence[index]\n\n def __repr__(self):\n return '<FastaEntry {}>'.format(self.header)\n\n def kmercounts(self, k):\n if k < 1 or k > 10:\n raise ValueError('k must be between 1 and 10 inclusive')\n\n counts = _np.zeros(1 << (2*k), dtype=_np.int32)\n _kmercounts(self.sequence, k, counts)\n return counts\n\ndef byte_iterfasta(filehandle, comment=b'#'):\n \"\"\"Yields FastaEntries from a binary opened fasta file.\n\n Usage:\n >>> with Reader('/dir/fasta.fna', 'rb') as filehandle:\n ... entries = byte_iterfasta(filehandle) # a generator\n\n Inputs:\n filehandle: Any iterator of binary lines of a FASTA file\n comment: Ignore lines beginning with any whitespace + comment\n\n Output: Generator of FastaEntry-objects from file\n \"\"\"\n\n # Make it work for persistent iterators, e.g. lists\n line_iterator = iter(filehandle)\n # Skip to first header\n try:\n for probeline in line_iterator:\n stripped = probeline.lstrip()\n if stripped.startswith(comment):\n pass\n\n elif probeline[0:1] == b'>':\n break\n\n else:\n raise ValueError('First non-comment line is not a Fasta header')\n\n else: # no break\n raise ValueError('Empty or outcommented file')\n\n except TypeError:\n errormsg = 'First line does not contain bytes. Are you reading file in binary mode?'\n raise TypeError(errormsg) from None\n\n header = probeline[1:-1].decode()\n buffer = list()\n\n # Iterate over lines\n for line in line_iterator:\n if line.startswith(comment):\n pass\n\n elif line.startswith(b'>'):\n yield FastaEntry(header, bytearray().join(buffer))\n buffer.clear()\n header = line[1:-1].decode()\n\n else:\n buffer.append(line)\n\n yield FastaEntry(header, bytearray().join(buffer))\n\ndef write_clusters(filehandle, clusters, max_clusters=None, min_size=1,\n header=None, rename=True):\n \"\"\"Writes clusters to an open filehandle.\n Inputs:\n filehandle: An open filehandle that can be written to\n clusters: An iterator generated by function `clusters` or a dict\n max_clusters: Stop printing after this many clusters [None]\n min_size: Don't output clusters smaller than N contigs\n header: Commented one-line header to add\n rename: Rename clusters to \"cluster_1\", \"cluster_2\" etc.\n\n Outputs:\n clusternumber: Number of clusters written\n ncontigs: Number of contigs written\n \"\"\"\n\n if not hasattr(filehandle, 'writable') or not filehandle.writable():\n raise ValueError('Filehandle must be a writable file')\n\n # Special case to allows dicts even though they are not iterators of\n # clustername, {cluster}\n if isinstance(clusters, dict):\n clusters = clusters.items()\n\n if max_clusters is not None and max_clusters < 1:\n raise ValueError('max_clusters must None or at least 1, not {}'.format(max_clusters))\n\n if header is not None and len(header) > 0:\n if '\\n' in header:\n raise ValueError('Header cannot contain newline')\n\n if header[0] != '#':\n header = '# ' + header\n\n print(header, file=filehandle)\n\n clusternumber = 0\n ncontigs = 0\n\n for clustername, contigs in clusters:\n if len(contigs) < min_size:\n continue\n\n if rename:\n clustername = 'cluster_' + str(clusternumber + 1)\n\n for contig in contigs:\n print(clustername, contig, sep='\\t', file=filehandle)\n filehandle.flush()\n\n clusternumber += 1\n ncontigs += len(contigs)\n\n if clusternumber == max_clusters:\n break\n\n return clusternumber, ncontigs\n\ndef read_clusters(filehandle, min_size=1):\n \"\"\"Read clusters from a file as created by function `writeclusters`.\n\n Inputs:\n filehandle: An open filehandle that can be read from\n min_size: Minimum number of contigs in cluster to be kept\n\n Output: A {clustername: set(contigs)} dict\"\"\"\n\n contigsof = _collections.defaultdict(set)\n\n for line in filehandle:\n stripped = line.strip()\n\n if not stripped or stripped[0] == '#':\n continue\n\n clustername, contigname = stripped.split('\\t')\n contigsof[clustername].add(contigname)\n\n contigsof = {cl: co for cl, co in contigsof.items() if len(co) >= min_size}\n\n return contigsof\n\n\ndef loadfasta(byte_iterator, keep=None, comment=b'#', compress=False):\n \"\"\"Loads a FASTA file into a dictionary.\n\n Usage:\n >>> with Reader('/dir/fasta.fna', 'rb') as filehandle:\n ... fastadict = loadfasta(filehandle)\n\n Input:\n byte_iterator: Iterator of binary lines of FASTA file\n keep: Keep entries with headers in `keep`. If None, keep all entries\n comment: Ignore lines beginning with any whitespace + comment\n compress: Keep sequences compressed [False]\n\n Output: {header: FastaEntry} dict\n \"\"\"\n\n entries = dict()\n\n for entry in byte_iterfasta(byte_iterator, comment=comment):\n if keep is None or entry.header in keep:\n if compress:\n entry.sequence = bytearray(_gzip.compress(entry.sequence, compresslevel=2))\n\n entries[entry.header] = entry\n\n return entries\n\ndef write_bins(directory, bins, fastadict, compressed=False, maxbins=250, minsize=0):\n \"\"\"Writes bins as FASTA files in a directory, one file per bin.\n\n Inputs:\n directory: Directory to create or put files in\n bins: {'name': {set of contignames}} dictionary (can be loaded from\n clusters.tsv using vamb.cluster.read_clusters)\n fastadict: {contigname: FastaEntry} dict as made by `loadfasta`\n compressed: Sequences in dict are compressed [False]\n maxbins: None or else raise an error if trying to make more bins than this [250]\n minsize: Minimum number of nucleotides in cluster to be output [0]\n\n Output: None\n \"\"\"\n\n # Safety measure so someone doesn't accidentally make 50000 tiny bins\n # If you do this on a compute cluster it can grind the entire cluster to\n # a halt and piss people off like you wouldn't believe.\n if maxbins is not None and len(bins) > maxbins:\n raise ValueError('{} bins exceed maxbins of {}'.format(len(bins), maxbins))\n\n # Check that the directory is not a non-directory file,\n # and that its parent directory indeed exists\n abspath = _os.path.abspath(directory)\n parentdir = _os.path.dirname(abspath)\n\n if parentdir != '' and not _os.path.isdir(parentdir):\n raise NotADirectoryError(parentdir)\n\n if _os.path.isfile(abspath):\n raise NotADirectoryError(abspath)\n\n if minsize < 0:\n raise ValueError(\"Minsize must be nonnegative\")\n\n # Check that all contigs in all bins are in the fastadict\n allcontigs = set()\n\n for contigs in bins.values():\n allcontigs.update(set(contigs))\n\n allcontigs -= fastadict.keys()\n if allcontigs:\n nmissing = len(allcontigs)\n raise IndexError('{} contigs in bins missing from fastadict'.format(nmissing))\n\n # Make the directory if it does not exist - if it does, do nothing\n try:\n _os.mkdir(directory)\n except FileExistsError:\n pass\n except:\n raise\n\n # Now actually print all the contigs to files\n for binname, contigs in bins.items():\n # Load bin into a list, decompress that bin if necessary\n bin = []\n for contig in contigs:\n entry = fastadict[contig]\n if compressed:\n uncompressed = bytearray(_gzip.decompress(entry.sequence))\n entry = FastaEntry(entry.header, uncompressed)\n bin.append(entry)\n\n # Skip bin if it's too small\n if minsize > 0 and sum(len(entry) for entry in bin) < minsize:\n continue\n\n # Print bin to file\n filename = _os.path.join(directory, binname + '.fna')\n with open(filename, 'w') as file:\n for entry in bin:\n print(entry.format(), file=file)\n\ndef validate_input_array(array):\n \"Returns array similar to input array but C-contiguous and with own data.\"\n if not array.flags['C_CONTIGUOUS']:\n array = _np.ascontiguousarray(array)\n if not array.flags['OWNDATA']:\n array = array.copy()\n\n assert (array.flags['C_CONTIGUOUS'] and array.flags['OWNDATA'])\n return array\n\ndef read_npz(file):\n \"\"\"Loads array in .npz-format\n\n Input: Open file or path to file with npz-formatted array\n\n Output: A Numpy array\n \"\"\"\n\n npz = _np.load(file)\n array = validate_input_array(npz['arr_0'])\n npz.close()\n\n return array\n\ndef write_npz(file, array):\n \"\"\"Writes a Numpy array to an open file or path in .npz format\n\n Inputs:\n file: Open file or path to file\n array: Numpy array\n\n Output: None\n \"\"\"\n _np.savez_compressed(file, array)\n\ndef filtercontigs(infile, outfile, minlength=2000):\n \"\"\"Creates new FASTA file with filtered contigs\n\n Inputs:\n infile: Binary opened input FASTA file\n outfile: Write-opened output FASTA file\n minlength: Minimum contig length to keep [2000]\n\n Output: None\n \"\"\"\n\n fasta_entries = byte_iterfasta(infile)\n\n for entry in fasta_entries:\n if len(entry) > minlength:\n print(entry.format(), file=outfile)\n\ndef concatenate_fasta(outfile, inpaths, minlength=2000, rename=True):\n \"\"\"Creates a new FASTA file from input paths, and optionally rename contig headers\n to the pattern \"S{sample number}C{contig identifier}\".\n\n Inputs:\n outpath: Open filehandle for output file\n inpaths: Iterable of paths to FASTA files to read from\n minlength: Minimum contig length to keep [2000]\n rename: Rename headers\n\n Output: None\n \"\"\"\n\n headers = set()\n for (inpathno, inpath) in enumerate(inpaths):\n with Reader(inpath, \"rb\") as infile:\n\n # If we rename, seq headers only have to be unique for each sample\n if rename:\n headers.clear()\n entries = byte_iterfasta(infile)\n\n for entry in entries:\n if len(entry) < minlength:\n continue\n\n header = entry.header\n identifier = header.split()[0]\n\n if rename:\n newheader = \"S{}C{}\".format(inpathno + 1, identifier)\n else:\n newheader = identifier\n\n if newheader in headers:\n raise ValueError(\"Multiple sequences would be given \"\n \"header {}.\".format(newheader))\n headers.add(newheader)\n\n entry.header = newheader\n print(entry.format(), file=outfile)\n\ndef _hash_refnames(refnames):\n \"Hashes an iterable of strings of reference names using MD5.\"\n hasher = _md5()\n for refname in refnames:\n hasher.update(refname.encode().rstrip())\n\n return hasher.digest()\n\ndef _load_jgi(filehandle, minlength, refhash):\n \"This function can be merged with load_jgi below in the next breaking release (post 3.0)\"\n header = next(filehandle)\n fields = header.strip().split('\\t')\n if not fields[:3] == [\"contigName\", \"contigLen\", \"totalAvgDepth\"]:\n raise ValueError('Input file format error: First columns should be \"contigName,\"'\n '\"contigLen\" and \"totalAvgDepth\"')\n\n columns = tuple([i for i in range(3, len(fields)) if not fields[i].endswith(\"-var\")])\n array = PushArray(_np.float32)\n identifiers = list()\n\n for row in filehandle:\n fields = row.split('\\t')\n # We use float because very large numbers will be printed in scientific notation\n if float(fields[1]) < minlength:\n continue\n\n for col in columns:\n array.append(float(fields[col]))\n \n identifiers.append(fields[0])\n \n if refhash is not None:\n hash = _hash_refnames(identifiers)\n if hash != refhash:\n errormsg = ('JGI file has reference hash {}, expected {}. '\n 'Verify that all BAM headers and FASTA headers are '\n 'identical and in the same order.')\n raise ValueError(errormsg.format(hash.hex(), refhash.hex()))\n\n result = array.take()\n result.shape = (len(result) // len(columns), len(columns))\n return validate_input_array(result)\n\ndef load_jgi(filehandle):\n \"\"\"Load depths from the --outputDepth of jgi_summarize_bam_contig_depths.\n See https://bitbucket.org/berkeleylab/metabat for more info on that program.\n\n Usage:\n with open('/path/to/jgi_depths.tsv') as file:\n depths = load_jgi(file)\n Input:\n File handle of open output depth file\n Output:\n N_contigs x N_samples Numpy matrix of dtype float32\n \"\"\"\n return _load_jgi(filehandle, 0, None)\n\ndef _split_bin(binname, headers, separator, bysample=_collections.defaultdict(set)):\n \"Split a single bin by the prefix of the headers\"\n\n bysample.clear()\n for header in headers:\n if not isinstance(header, str):\n raise TypeError('Can only split named sequences, not of type {}'.format(type(header)))\n\n sample, _sep, identifier = header.partition(separator)\n\n if not identifier:\n raise KeyError(\"Separator '{}' not in sequence label: '{}'\".format(separator, header))\n\n bysample[sample].add(header)\n\n for sample, splitheaders in bysample.items():\n newbinname = \"{}{}{}\".format(sample, separator, binname)\n yield newbinname, splitheaders\n\ndef _binsplit_generator(cluster_iterator, separator):\n \"Return a generator over split bins with the function above.\"\n for binname, headers in cluster_iterator:\n for newbinname, splitheaders in _split_bin(binname, headers, separator):\n yield newbinname, splitheaders\n\ndef binsplit(clusters, separator):\n \"\"\"Splits a set of clusters by the prefix of their names.\n The separator is a string which separated prefix from postfix of contignames. The\n resulting split clusters have the prefix and separator prepended to them.\n\n clusters can be an iterator, in which case this function returns an iterator, or a dict\n with contignames: set_of_contignames pair, in which case a dict is returned.\n\n Example:\n >>> clusters = {\"bin1\": {\"s1-c1\", \"s1-c5\", \"s2-c1\", \"s2-c3\", \"s5-c8\"}}\n >>> binsplit(clusters, \"-\")\n {'s2-bin1': {'s1-c1', 's1-c3'}, 's1-bin1': {'s1-c1', 's1-c5'}, 's5-bin1': {'s1-c8'}}\n \"\"\"\n if iter(clusters) is clusters: # clusters is an iterator\n return _binsplit_generator(clusters, separator)\n\n elif isinstance(clusters, dict):\n return dict(_binsplit_generator(clusters.items(), separator))\n\n else:\n raise TypeError(\"clusters must be iterator of pairs or dict\")\n"
] |
[
[
"numpy.ascontiguousarray",
"numpy.issubdtype",
"numpy.frombuffer",
"numpy.savez_compressed",
"numpy.load",
"numpy.zeros",
"numpy.empty"
]
] |
gghatano/PPMTF-1
|
[
"670bff7e58150418f9e7b75e6367f0f069c454b5"
] |
[
"python/EvalUtilPriv.py"
] |
[
"#!/usr/bin/env python3\nimport numpy as np\nfrom scipy.sparse import lil_matrix\nfrom scipy.stats import wasserstein_distance\nimport math\nimport csv\nimport sys\nimport glob\nimport os\n\n################################# Parameters ##################################\n#sys.argv = [\"EvalUtilPriv.py\", \"PF\", \"TK\", \"PPMTF\"]\n#sys.argv = [\"EvalUtilPriv.py\", \"PF\", \"TK\", \"PPITF\"]\n#sys.argv = [\"EvalUtilPriv.py\", \"PF\", \"TK\", \"SGD\"]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"TK\", \"SGLT\"]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"IS\", \"PPMTF\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"JK\", \"PPMTF\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"KL\", \"PPMTF\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"NY\", \"PPMTF\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"TK\", \"PPMTF\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"SP\", \"PPMTF\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"IS\", \"PPITF\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"JK\", \"PPITF\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"KL\", \"PPITF\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"NY\", \"PPITF\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"TK\", \"PPITF\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"SP\", \"PPITF\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"IS\", \"SGD\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"JK\", \"SGD\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"KL\", \"SGD\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"NY\", \"SGD\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"TK\", \"SGD\", 1]\n#sys.argv = [\"EvalUtilPriv.py\", \"FS\", \"SP\", \"SGD\", 1]\n\nif len(sys.argv) < 4:\n print(\"Usage:\",sys.argv[0],\"[Dataset] [City] [SynAlg (PPMTF/PPITF/SGD/SGLT)] ([TraceNum (default:10)] [ItrNum (default:100)] [PDTest (default:1)] [Reqk (default:10)])\")\n sys.exit(0)\n\n# Dataset (PF/FS)\nDataSet = sys.argv[1]\n# City\nCity = sys.argv[2]\n\n# Synthesizing algorithm\nSynAlg = sys.argv[3]\n\n# Number of traces per user\nTraceNum = 10\nif len(sys.argv) >= 5:\n TraceNum = int(sys.argv[4])\n\n# Number of iterations in Gibbs sampling (SynAlg = \"PPMTF\")\nItrNum = 100\nif len(sys.argv) >= 6:\n ItrNum = int(sys.argv[5])\n\n# Perform the PD test (1: yes, 0: no)\nPDTest = 1\nif len(sys.argv) >= 7:\n PDTest = int(sys.argv[6])\n\n# Required k in plausible deniability\nReqk = 10\nif len(sys.argv) >= 8:\n Reqk = int(sys.argv[7])\n\n# Data directory\nDataDir = \"../data/\" + DataSet + \"/\"\n\n# Training user index file (input)\nTUserIndexFile = DataDir + \"tuserindex_XX.csv\"\n# Testing user index file (output)\nEUserIndexFile = DataDir + \"euserindex_XX.csv\"\n# POI file (input)\nPOIFile = DataDir + \"POI_XX.csv\"\n# POI index file (input)\nPOIIndexFile = DataDir + \"POIindex_XX.csv\"\n# Training trace file (input)\nTrainTraceFile = DataDir + \"traintraces_XX.csv\"\n# Testing trace file (input)\nTestTraceFile = DataDir + \"testtraces_XX.csv\"\n\n# Type of time slots (1: 9-19h, 20min, 2: 2 hours)\nif DataSet == \"PF\":\n TimeType = 1\nelif DataSet[0:2] == \"FS\":\n TimeType = 2\nelse:\n print(\"Wrong Dataset\")\n sys.exit(-1)\n\n# Maximum time interval between two temporally-continuous locations (sec) (-1: none)\nif DataSet == \"PF\":\n MaxTimInt = -1\nelif DataSet[0:2] == \"FS\":\n MaxTimInt = 7200\n\n# Number of columns in model parameters (A, B, C)\nK = 16\n\n# Minimum probability\nDeltaProb = 0.00000001\n# Top-L POIs (Time-specific)\nL1 = 50\n# Number of bins in the visit-fraction distribution\nif DataSet == \"PF\":\n B = 30\nelif DataSet[0:2] == \"FS\":\n B = 24\nelse:\n print(\"Wrong Dataset\")\n sys.exit(-1)\n\n# Minimum/maximum of y/x\nif DataSet == \"PF\" and City == \"TK\":\n MIN_Y = 35.65\n MAX_Y = 35.75\n MIN_X = 139.68\n MAX_X = 139.8\nelif DataSet[0:2] == \"FS\" and City == \"IS\":\n MIN_Y = 40.8\n MAX_Y = 41.2\n MIN_X = 28.5\n MAX_X = 29.5\nelif DataSet[0:2] == \"FS\" and City == \"JK\":\n MIN_Y = -6.4\n MAX_Y = -6.1\n MIN_X = 106.7\n MAX_X = 107.0\nelif DataSet[0:2] == \"FS\" and City == \"KL\":\n MIN_Y = 3.0\n MAX_Y = 3.3\n MIN_X = 101.6\n MAX_X = 101.8\nelif DataSet[0:2] == \"FS\" and City == \"NY\":\n MIN_Y = 40.5\n MAX_Y = 41.0\n MIN_X = -74.28\n MAX_X = -73.68\nelif DataSet[0:2] == \"FS\" and City == \"TK\":\n MIN_Y = 35.5\n MAX_Y = 35.9\n MIN_X = 139.5\n MAX_X = 140.0\nelif DataSet[0:2] == \"FS\" and City == \"SP\":\n MIN_Y = -24.0\n MAX_Y = -23.4\n MIN_X = -46.8\n MAX_X = -46.3\nelse:\n print(\"Wrong Dataset\")\n sys.exit(-1)\n# Number of regions on the x-axis\nNumRegX = 20\n# Number of regions on the y-axis\nNumRegY = 20\n\nif SynAlg == \"PPMTF\":\n # Prefix of the synthesized trace directory\n SynTraceDirPre = DataDir + \"PPMTF_\" + City\n # Synthesized trace directory\n SynTraceDir = SynTraceDirPre + \"*/\"\n # Synthesized trace file (with asterisk)\n SynTraceFileAst = SynTraceDir + \"syntraces_Itr\" + str(ItrNum) + \".csv\"\n # Result file (output)\n ResFile = DataDir + \"utilpriv_PPMTF_\" + City + \".csv\"\nelif SynAlg == \"PPITF\":\n # Prefix of the synthesized trace directory\n SynTraceDirPre = DataDir + \"PPITF_\" + City\n # Synthesized trace directory\n SynTraceDir = SynTraceDirPre + \"*/\"\n # Synthesized trace file (with asterisk)\n SynTraceFileAst = SynTraceDir + \"syntraces_Itr\" + str(ItrNum) + \".csv\"\n # Result file (output)\n ResFile = DataDir + \"utilpriv_PPITF_\" + City + \".csv\"\nelif SynAlg == \"SGD\":\n # Prefix of the synthesized trace directory \n SynTraceDirPre = DataDir + \"SGD_\" + City\n # Synthesized trace directory\n SynTraceDir = SynTraceDirPre + \"/\"\n # Synthesized trace file (with asterisk)\n SynTraceFileAst = SynTraceDir + \"syntraces_cn*.csv\"\n # Result file (output)\n ResFile = DataDir + \"utilpriv_SGD_\" + City + \".csv\"\nelif SynAlg == \"SGLT\":\n # Prefix of the synthesized trace directory \n SynTraceDirPre = DataDir + \"SGLT_\" + City\n # Synthesized trace directory\n SynTraceDir = SynTraceDirPre + \"/\"\n # Synthesized trace file (with asterisk)\n SynTraceFileAst = SynTraceDir + \"*_syntraces.csv\"\n # Result file (output)\n ResFile = DataDir + \"utilpriv_SGLT_\" + City + \".csv\"\nelse:\n print(\"Wrong SynAlg\")\n sys.exit(-1)\n\n# Prefix of the model parameter file (input)\nModelParameterDir = DataDir + \"PPMTF_\" + City + \"_alp200_mnt100_mnv100/\"\nModelParameterFile = ModelParameterDir + \"modelparameter\"\n\n######################### Read a training trace file ##########################\n# [output1]: ttrans_count ({(user_index, poi_index_from, poi_index_to): counts})\n# [output2]: ttrans_prob ({(user_index, poi_index_from, poi_index_to): probability})\n# [output3]: tcount_sum (N x M matrix)\ndef ReadTrainTraceFile():\n # Initialization\n ttrans_count = {}\n ttrans_prob = {}\n tcount_sum = np.zeros((N, M))\n user_index_prev = -1\n poi_index_prev = 0\n\n # Read a training trace file\n f = open(TrainTraceFile, \"r\")\n reader = csv.reader(f)\n next(reader)\n for lst in reader:\n user_index = int(lst[0])\n poi_index = int(lst[1])\n # Update a transition matrix if the event and the previous event are from the same user\n if user_index == user_index_prev:\n ttrans_count[(user_index, poi_index_prev, poi_index)] = ttrans_count.get((user_index, poi_index_prev, poi_index), 0) + 1\n user_index_prev = user_index\n poi_index_prev = poi_index\n f.close()\n\n # Make a count sum matrix --> tcount_sum\n for (user_index, poi_index_prev, poi_index), counts in sorted(ttrans_count.items()):\n tcount_sum[user_index, poi_index_prev] += counts\n\n # Make a transition probability tensor --> ttrans_prob\n for (user_index, poi_index_prev, poi_index), counts in sorted(ttrans_count.items()):\n ttrans_prob[(user_index, poi_index_prev, poi_index)] = counts / tcount_sum[user_index, poi_index_prev]\n\n return ttrans_count, ttrans_prob, tcount_sum\n\n######################### Read a testing trace file ##########################\n# [output1]: etrans_count ({(user_index, poi_index_from, poi_index_to): counts})\n# [output2]: etrans_prob ({(user_index, poi_index_from, poi_index_to): probability})\n# [output3]: ecount_sum (N x M matrix)\ndef ReadTestTraceFile():\n # Initialization\n etrans_count = {}\n etrans_prob = {}\n ecount_sum = np.zeros((N, M))\n user_index_prev = -1\n poi_index_prev = 0\n\n # Read a testing trace file\n f = open(TestTraceFile, \"r\")\n reader = csv.reader(f)\n next(reader)\n for lst in reader:\n user_index = int(lst[0]) - N\n poi_index = int(lst[1])\n # Update a transition matrix if the event and the previous event are from the same user\n if user_index == user_index_prev:\n etrans_count[(user_index, poi_index_prev, poi_index)] = etrans_count.get((user_index, poi_index_prev, poi_index), 0) + 1\n user_index_prev = user_index\n poi_index_prev = poi_index\n f.close()\n\n # Make a count sum matrix --> ecount_sum\n for (user_index, poi_index_prev, poi_index), counts in sorted(etrans_count.items()):\n ecount_sum[user_index, poi_index_prev] += counts\n\n # Make a transition probability tensor --> etrans_prob\n for (user_index, poi_index_prev, poi_index), counts in sorted(etrans_count.items()):\n etrans_prob[(user_index, poi_index_prev, poi_index)] = counts / ecount_sum[user_index, poi_index_prev]\n\n return etrans_count, etrans_prob, ecount_sum\n\n######################## MAP re-identification attack #########################\n# [input1]: ttrans_prob ({(user_index, poi_index_from, poi_index_to): probability})\n# [input2]: tcount_sum (N x M matrix)\n# [input3]: syn_trace_file\ndef MAPReidentify(ttrans_prob, tcount_sum, syn_trace_file):\n # Initialization\n log_post = np.zeros(N)\n reid_res = np.zeros(N*TraceNum)\n user_index_prev = 0\n poi_index_prev = 0\n\n # Read a synthesized trace file\n f = open(syn_trace_file, \"r\")\n reader = csv.reader(f)\n next(reader)\n user_no = 0\n time_slot = 0\n for lst in reader:\n user_index = int(lst[0])\n\n trace_index = int(lst[1])\n user_index = user_index * TraceNum + trace_index\n\n poi_index = int(lst[4])\n\n if user_index != user_index_prev:\n time_slot = 0\n\n # Update the log-posterior if the event and the previous event are from the same user\n if user_index == user_index_prev and time_slot >= 1:\n # For each user\n for n in range(N):\n if tcount_sum[n,poi_index_prev] > 0:\n if (n, poi_index_prev, poi_index) in ttrans_prob:\n log_post[n] += math.log(ttrans_prob[n,poi_index_prev,poi_index])\n else:\n log_post[n] += math.log(DeltaProb)\n else:\n log_post[n] += math.log(DeltaProb)\n # Update the re-identification result if a new user appears --> reid_res\n elif user_index != user_index_prev:\n reid_res[user_no] = np.argmax(log_post)\n log_post = np.zeros(N)\n user_no += 1\n\n user_index_prev = user_index\n poi_index_prev = poi_index\n time_slot += 1\n f.close()\n\n # Update the re-identification result for the last user\n reid_res[user_no] = np.argmax(log_post)\n\n return log_post, reid_res\n\n############# Likelihood-ratio-based membership inference attack ##############\n# [input1]: ttrans_prob ({(user_index, poi_index_from, poi_index_to): probability})\n# [input2]: etrans_prob ({(user_index, poi_index_from, poi_index_to): probability})\n# [input3]: syn_trace_file\n# [output1]: llr_per_trace ((TraceNum x (N+N2) matrix)\n# [output2]: trace_thr (1000-dim vector)\n# [output3]: trace_true_pos (1000-dim vector)\n# [output4]: trace_true_neg (1000-dim vector)\n# [output5]: trace_max_acc\n# [output6]: trace_max_adv\ndef LRMIA(ttrans_prob, etrans_prob, syn_trace_file):\n # Initialization\n llr_per_trace = np.full((TraceNum, N+N2), -sys.float_info.max)\n\n # Membership inference for each training/testing user n\n for n in range(N+N2):\n # Population transition probability matrix --> pop_trans_prob\n pop_trans_prob = np.zeros((M, M))\n # Population transition matrix except for training user n\n for (user_index, poi_index_prev, poi_index), prob in sorted(ttrans_prob.items()):\n if n < N and user_index == n:\n continue\n pop_trans_prob[poi_index_prev, poi_index] += prob\n # Population transition matrix except for testing user n-N\n for (user_index, poi_index_prev, poi_index), prob in sorted(etrans_prob.items()):\n if n >= N and user_index == n-N:\n continue\n pop_trans_prob[poi_index_prev, poi_index] += prob\n pop_trans_prob /= (N+N2-1)\n\n # Read a synthesized trace file\n f = open(syn_trace_file, \"r\")\n reader = csv.reader(f)\n next(reader)\n \n # Initialization\n user_index_prev = 0\n poi_index_prev = 0\n time_slot = 0\n llr_trace = np.zeros(TraceNum)\n\n for lst in reader:\n user_index = int(lst[0])\n trace_index = int(lst[1])\n# user_index = user_index * TraceNum + trace_index\n \n poi_index = int(lst[4])\n \n if user_index != user_index_prev:\n time_slot = 0\n \n # Update the log-likelihood ratio if the event and the previous event are from the same user\n if user_index == user_index_prev and time_slot >= 1:\n # Update the log-likelihood ratio for the user --> llr_trace[trace_index]\n # Membership inference for training user n\n if n < N:\n # Add the log-likelihood using the transition matrix of training user n\n if (n, poi_index_prev, poi_index) in ttrans_prob:\n llr_trace[trace_index] += math.log(ttrans_prob[n,poi_index_prev,poi_index])\n else:\n llr_trace[trace_index] += math.log(DeltaProb)\n # Membership inference for testing user n-N\n else:\n # Add the log-likelihood using the transition matrix of testing user n-N\n if (n-N, poi_index_prev, poi_index) in etrans_prob:\n llr_trace[trace_index] += math.log(etrans_prob[n-N,poi_index_prev,poi_index])\n else:\n llr_trace[trace_index] += math.log(DeltaProb)\n # Subtract the log-likelihood using the population matrix\n if pop_trans_prob[poi_index_prev, poi_index] > 0:\n llr_trace[trace_index] -= math.log(pop_trans_prob[poi_index_prev, poi_index])\n else:\n llr_trace[trace_index] -= math.log(DeltaProb)\n\n # Update llr_per_trace if a new user appears\n elif user_index != user_index_prev:\n for tr in range(TraceNum):\n if llr_per_trace[tr,n] < llr_trace[tr]:\n llr_per_trace[tr,n] = llr_trace[tr]\n# print(\"Update llr_per_trace.\", user_index_prev, int(lst[0]), int(lst[1]), llr_trans, llr_trace)\n llr_trace = np.zeros(TraceNum)\n \n user_index_prev = user_index\n poi_index_prev = poi_index\n time_slot += 1\n f.close()\n\n # Update the log-likelihood ratio for the last user\n for tr in range(TraceNum):\n if llr_per_trace[tr,n] < llr_trace[tr]:\n llr_per_trace[tr,n] = llr_trace[tr]\n# print(n, llr_per_trace[0,n], llr_per_trace[1,n], llr_per_trace[2,n])\n\n # Calculate #true positive/negative using llr_per_trace --> trace_true_pos, trace_true_neg\n MIA_thr = np.zeros(1000)\n max_llr_per_trace = -sys.float_info.max\n min_llr_per_trace = -sys.float_info.max\n for tr in range(TraceNum):\n if max_llr_per_trace < max(llr_per_trace[tr]):\n max_llr_per_trace = max(llr_per_trace[tr])\n if min_llr_per_trace < min(llr_per_trace[tr]):\n min_llr_per_trace = min(llr_per_trace[tr])\n MIA_true_pos = np.zeros(1000)\n MIA_true_neg = np.zeros(1000)\n # For each threshold\n for i in range(1000):\n # Threshold --> thr\n MIA_thr[i] = min_llr_per_trace + (max_llr_per_trace - min_llr_per_trace) * i / 1000\n # True positive --> true_pos\n for tr in range(TraceNum):\n for n in range(N):\n if llr_per_trace[tr,n] > MIA_thr[i]:\n MIA_true_pos[i] += 1\n # True negative --> true_neg\n for n in range(N2):\n if llr_per_trace[tr,N+n] <= MIA_thr[i]:\n MIA_true_neg[i] += 1\n # Calculate the maximum accuracy using llr_per_trace --> MIA_max_acc\n MIA_max_acc = 0\n for i in range(1000):\n if MIA_max_acc < MIA_true_pos[i] + MIA_true_neg[i]:\n MIA_max_acc = MIA_true_pos[i] + MIA_true_neg[i]\n MIA_max_acc /= (TraceNum*(N+N2))\n\n # Calculate the maximum membership advantage using llr_per_trace --> MIA_max_adv\n MIA_max_adv = -sys.float_info.max\n for i in range(1000):\n if MIA_max_adv < MIA_true_pos[i]/(TraceNum*N) - 1 + MIA_true_neg[i]/(TraceNum*N2):\n MIA_max_adv = MIA_true_pos[i]/(TraceNum*N) - 1 + MIA_true_neg[i]/(TraceNum*N2)\n\n return llr_per_trace, MIA_thr, MIA_true_pos, MIA_true_neg, MIA_max_acc, MIA_max_adv\n\n############################### Read POI files ################################\n# [output1]: poi_dic ({poi_index: [y, x, y_id, x_id, category]})\ndef ReadPOI():\n # Initialization\n poi_dic = {}\n poi_file_dic = {}\n\n # Calculate the boundaries of the regions (NumRegX x NumRegY) --> xb, yb\n xb = np.zeros(NumRegX)\n yb = np.zeros(NumRegY)\n for i in range(NumRegX):\n xb[i] = MIN_X + (MAX_X - MIN_X) * i / NumRegX\n for i in range(NumRegY):\n yb[i] = MIN_Y + (MAX_Y - MIN_Y) * i / NumRegY\n \n # Read a POI file --> poi_file_dic ({poi_id: [y, x, y_id, x_id]})\n f = open(POIFile, \"r\")\n reader = csv.reader(f)\n next(reader)\n for lst in reader:\n y = float(lst[1])\n x = float(lst[2])\n\n x_id = NumRegX-1\n for i in range(NumRegX-1):\n if xb[i] <= x < xb[i+1]:\n x_id = i\n break\n y_id = NumRegY-1\n for i in range(NumRegY-1):\n if yb[i] <= y < yb[i+1]:\n y_id = i\n break\n\n poi_file_dic[lst[0]] = [y, x, y_id, x_id]\n f.close()\n\n # Read a POI index file --> poi_dic ({poi_index: [y, x, y_id, x_id, category]})\n f = open(POIIndexFile, \"r\")\n reader = csv.reader(f)\n next(reader)\n for lst in reader:\n y = poi_file_dic[lst[0]][0]\n x = poi_file_dic[lst[0]][1]\n y_id = poi_file_dic[lst[0]][2]\n x_id = poi_file_dic[lst[0]][3]\n poi_dic[int(lst[1])] = [y, x, y_id, x_id, lst[2]]\n f.close()\n\n return poi_dic\n\n########################### Read model parameters #############################\n# [output1]: ParamA (N x K matrix)\n# [output2]: ParamB (M x K matrix)\n# [output3]: ParamC (M x K matrix)\n# [output4]: ParamD (T x K matrix)\ndef ReadModelParameters():\n # Read model parameter A\n infile = ModelParameterFile + \"_Itr\" + str(ItrNum) + \"_A.csv\"\n f = open(infile, \"r\")\n ParamA = np.loadtxt(infile, delimiter=\",\")\n f.close()\n\n # Read model parameter B\n infile = ModelParameterFile + \"_Itr\" + str(ItrNum) + \"_B.csv\"\n f = open(infile, \"r\")\n ParamB = np.loadtxt(infile, delimiter=\",\")\n f.close()\n\n # Read model parameter C\n infile = ModelParameterFile + \"_Itr\" + str(ItrNum) + \"_C.csv\"\n f = open(infile, \"r\")\n ParamC = np.loadtxt(infile, delimiter=\",\")\n f.close()\n\n # Read model parameter D\n infile = ModelParameterFile + \"_Itr\" + str(ItrNum) + \"_D.csv\"\n f = open(infile, \"r\")\n ParamD = np.loadtxt(infile, delimiter=\",\")\n f.close()\n\n return ParamA, ParamB, ParamC, ParamD\n\n############################## Read real traces ###############################\n# [input1]: st_user_index -- Start user index\n# [input2]: user_num -- Number of users\n# [input3]: M -- Number of POIs\n# [input4]: T -- Number of time slots\n# [input5]: A_bin (N x K matrix)\n# [input6]: trace_file -- Trace file\n# [output1]: treal_dist (T x M matrix)\n# [output2]: treal_count (T-dim vector)\n# [output3]: real_trans (M x M matrix)\n# [output4]: vf_dist (M x B matrix)\n# [output5]: kreal_dist (K x (1 x M matrix))\n# [output6]: ktreal_dist (K x (T x M matrix))\ndef ReadRealTraces(st_user_index, user_num, M, T, A_bin, trace_file):\n # Initialization\n ureal_visit = lil_matrix((user_num, M))\n# visitor_real_rate = np.zeros(M)\n vf = np.zeros(M)\n vf_dist = np.zeros((M, B))\n ureal_count = np.zeros(user_num)\n treal_dist = np.zeros((T, M))\n treal_count = np.zeros(T)\n real_trans = np.zeros((M, M))\n user_index_prev = -1\n poi_index_prev = 0\n unixtime_prev = 0\n time_ins_prev = 0\n kreal_dist = [0] * K\n for k in range(K):\n kreal_dist[k] = np.zeros((1, M))\n ktreal_dist = [0] * K\n for k in range(K):\n ktreal_dist[k] = np.zeros((T, M))\n\n # Read a real trace file\n f = open(trace_file, \"r\")\n reader = csv.reader(f)\n next(reader)\n for lst in reader:\n user_index = int(lst[0]) - st_user_index\n poi_index = int(lst[1])\n unixtime = float(lst[3])\n ho = int(lst[5])\n if TimeType == 1:\n if int(lst[6]) >= 40:\n mi = 2\n elif int(lst[6]) >= 20:\n mi = 1\n else:\n mi = 0\n time_slot = 3 * (ho - 9) + mi\n time_ins = time_slot\n elif TimeType == 2:\n time_slot = int(ho/2)\n time_ins = ho\n else:\n print(\"Wrong TimeType.\\n\")\n sys.exit(-1)\n\n # New user\n if user_index != user_index_prev and user_index_prev != -1:\n if ureal_count[user_index_prev] >= 5:\n # Normalize vf\n vf /= ureal_count[user_index_prev]\n # Update vf_dist\n for i in range(M):\n # Continue if the visit-count is zero or one\n if vf[i] == 0 or vf[i] == 1:\n continue\n vf_bin = math.ceil(vf[i] * B) - 1\n vf_dist[i,vf_bin] += 1\n # Initialization\n vf = np.zeros(M)\n\n # Update the user-specific visit matrix --> ureal_visit\n ureal_visit[user_index, poi_index] = 1\n # Update the visit-fraction\n vf[poi_index] += 1\n\n # Update visit counts for the user --> ureal_count\n ureal_count[user_index] += 1\n # Update the time-specific real distribution --> treal_dist\n treal_dist[time_slot, poi_index] += 1\n\n # Update the time-specific real distribution for each basis --> kreal_dist, ktreal_dist\n for k in range(K):\n if A_bin[user_index, k] == True:\n kreal_dist[k][0, poi_index] += 1\n ktreal_dist[k][time_slot, poi_index] += 1\n\n # Update visit counts for the time instance --> treal_count\n treal_count[time_slot] += 1\n # Update a transition matrix if the event and the previous event are from the same user\n if user_index == user_index_prev and (MaxTimInt == -1 or unixtime - unixtime_prev <= MaxTimInt) and time_ins - time_ins_prev == 1:\n real_trans[poi_index_prev, poi_index] += 1\n user_index_prev = user_index\n poi_index_prev = poi_index\n unixtime_prev = unixtime\n time_ins_prev = time_ins\n f.close()\n\n # Last user\n if ureal_count[user_index_prev] >= 5:\n # Normalize the visit-fraction\n vf /= ureal_count[user_index_prev]\n # Update vf_dist\n for i in range(M):\n # Continue if the visit-count is zero or one\n if vf[i] == 0 or vf[i] == 1:\n continue\n vf_bin = math.ceil(vf[i] * B) - 1\n vf_dist[i,vf_bin] += 1\n\n # Normalize vf_dist\n for i in range(M):\n if np.sum(vf_dist[i]) > 0:\n vf_dist[i] /= np.sum(vf_dist[i])\n\n # Normalize treal_dist\n for t in range(T):\n if np.sum(treal_dist[t]) > 0:\n treal_dist[t] /= np.sum(treal_dist[t])\n else:\n treal_dist[t] = np.full(M, 1.0/float(M))\n\n # Normalize kreal_dist\n for k in range(K):\n if np.sum(kreal_dist[k][0]) > 0:\n kreal_dist[k][0] /= np.sum(kreal_dist[k][0])\n else:\n kreal_dist[k][0] = np.full(M, 1.0/float(M))\n\n # Normalize ktreal_dist\n for k in range(K):\n for t in range(T):\n if np.sum(ktreal_dist[k][t]) > 0:\n ktreal_dist[k][t] /= np.sum(ktreal_dist[k][t])\n else:\n ktreal_dist[k][t] = np.full(M, 1.0/float(M))\n\n # Normalize real_trans\n for i in range(M):\n if np.sum(real_trans[i]) > 0:\n real_trans[i] /= np.sum(real_trans[i])\n else:\n real_trans[i,i] = 1.0\n\n return treal_dist, treal_count, real_trans, vf_dist, kreal_dist, ktreal_dist\n\n########################### Read synthesized traces ###########################\n# [input1]: N -- Number of users\n# [input2]: M -- Number of POIs\n# [input3]: T -- Number of time slots\n# [input4]: A_bin (N x K matrix)\n# [input5]: syn_trace_file -- Synthesized trace file\n# [input6]: pdtest_file -- PD test result file\n# [input7]: req_k -- Required k\n# [input8]: trace_no -- Trace no.\n# [output1]: tsyn_dist (T x M matrix)\n# [output2]: syn_trans (M x M matrix)\n# [output3]: pass_test (N-dim vector)\n# [output4]: vf_dist (M x B matrix)\n# [output5]: ksyn_dist (K x (1 x M matrix))\n# [output6]: ktsyn_dist (K x (T x M matrix))\ndef ReadSynTraces(N, M, T, A_bin, syn_trace_file, pdtest_file, req_k, trace_no):\n # Initialization\n usyn_visit = lil_matrix((N, M))\n vf = np.zeros(M)\n vf_dist = np.zeros((M, B))\n usyn_count = np.zeros(N)\n tsyn_dist = np.zeros((T, M))\n syn_trans = np.zeros((M, M))\n pass_test = np.ones(N)\n user_index_prev = -1\n poi_index_prev = 0\n ksyn_dist = [0] * K\n for k in range(K):\n ksyn_dist[k] = np.zeros((1, M))\n ktsyn_dist = [0] * K\n for k in range(K):\n ktsyn_dist[k] = np.zeros((T, M))\n\n # Read a PD test result file --> pass_test\n if pdtest_file != \"none\":\n infile = pdtest_file + \"_Itr\" + str(ItrNum) + \".csv\"\n i = 0\n f = open(infile, \"r\")\n reader = csv.reader(f)\n for lst in reader:\n if lst[0] == \"-\":\n break\n k = float(lst[0])\n if k < req_k:\n pass_test[i] = 0\n i += 1\n print(\"Fraction of passing the PD test:\", float(np.sum(pass_test)) / float(N), \"(\", np.sum(pass_test), \"/\", N, \")\")\n\n # Read a real trace file\n f = open(syn_trace_file, \"r\")\n reader = csv.reader(f)\n next(reader)\n for lst in reader:\n user_index = int(lst[0])\n trace_no_cur = int(lst[1])\n time_slot = int(lst[2])\n poi_index = int(lst[4])\n\n if trace_no_cur != trace_no and trace_no != -1:\n continue\n\n if pass_test[user_index] == 1:\n # New user\n if user_index != user_index_prev and user_index_prev != -1:\n if usyn_count[user_index_prev] >= 5:\n # Normalize vf\n vf /= usyn_count[user_index_prev]\n # Update vf_dist\n for i in range(M):\n # Continue if the visit-count is zero or one\n if vf[i] == 0 or vf[i] == 1:\n continue\n vf_bin = math.ceil(vf[i] * B) - 1\n vf_dist[i,vf_bin] += 1\n # Initialization\n vf = np.zeros(M)\n\n # Update the user-specific visit matrix --> usyn_visit\n usyn_visit[user_index, poi_index] = 1\n # Update the visit-fraction\n vf[poi_index] += 1\n # Update visit counts for the user --> usyn_count\n usyn_count[user_index] += 1\n # Update the time-specific synthesized distribution --> tsyn_dist\n tsyn_dist[time_slot, poi_index] += 1\n\n # Update the real distribution & time-specific real distribution for each basis --> ksyn_dist, ktsyn_dist\n for k in range(K):\n if A_bin[user_index, k] == True:\n ksyn_dist[k][0, poi_index] += 1\n ktsyn_dist[k][time_slot, poi_index] += 1\n\n # Update a transition matrix if the event and the previous event are from the same user\n if user_index == user_index_prev:\n syn_trans[poi_index_prev, poi_index] += 1\n user_index_prev = user_index\n poi_index_prev = poi_index\n f.close()\n\n # Last user\n if usyn_count[user_index_prev] >= 5:\n # Normalize the visit-fraction\n vf /= usyn_count[user_index_prev]\n # Update vf_dist\n for i in range(M):\n # Continue if the visit-count is zero or one\n if vf[i] == 0 or vf[i] == 1:\n continue\n vf_bin = math.ceil(vf[i] * B) - 1\n vf_dist[i,vf_bin] += 1\n\n # Normalize vf_dist\n for i in range(M):\n if np.sum(vf_dist[i]) > 0:\n vf_dist[i] /= np.sum(vf_dist[i])\n else:\n vf_dist[i,0] = 1.0\n\n # Normalize tsyn_dist\n for t in range(T):\n if np.sum(tsyn_dist[t]) > 0:\n tsyn_dist[t] /= np.sum(tsyn_dist[t])\n else:\n tsyn_dist[t] = np.full(M, 1.0/float(M))\n\n # Normalize ksyn_dist\n for k in range(K):\n if np.sum(ksyn_dist[k][0]) > 0:\n ksyn_dist[k][0] /= np.sum(ksyn_dist[k][0])\n else:\n ksyn_dist[k][0] = np.full(M, 1.0/float(M))\n\n # Normalize ktsyn_dist\n for k in range(K):\n for t in range(T):\n if np.sum(ktsyn_dist[k][t]) > 0:\n ktsyn_dist[k][t] /= np.sum(ktsyn_dist[k][t])\n else:\n ktsyn_dist[k][t] = np.full(M, 1.0/float(M))\n\n # Normalize syn_trans\n for i in range(M):\n if np.sum(syn_trans[i]) > 0:\n syn_trans[i] /= np.sum(syn_trans[i])\n else:\n syn_trans[i,i] = 1.0\n\n return tsyn_dist, syn_trans, pass_test, vf_dist, ksyn_dist, ktsyn_dist\n\n#################### Calculate the average l1 & l2 losses #####################\n# [input1]: dist1 (Z x M matrix)\n# [input2]: dist2 (Z x M matrix)\n# [input3]: pass_test (Z-dim vector)\n# [input4]: Z -- Number of distributions\n# [input5]: M -- Number of POIs\n# [input6]: L -- Number of top POIs in dist1\n# [output1]: l1_loss\n# [output2]: l2_loss\ndef CalcL1L2(dist1, dist2, pass_test, Z, M, L):\n l1_loss = 0.0\n l2_loss = 0.0\n z_num = 0\n\n # l1 & l2 losses for all POIs\n if L == M:\n for z in range(Z):\n if pass_test[z] == 1:\n # Update the l1-loss & l2-loss\n for i in range(M):\n l1_loss += np.abs(dist1[z,i] - dist2[z,i])\n l2_loss += (dist1[z,i] - dist2[z,i])**2\n z_num += 1\n # l1 & l2 losses for the top L POIs\n else:\n for z in range(Z):\n if pass_test[z] == 1:\n # Sort indexes in descending order of dist1\n sortindex = np.argsort(dist1[z])[::-1]\n\n # Update the l1-loss & l2-loss\n for i in range(L):\n j = sortindex[i]\n l1_loss += np.abs(dist1[z,j] - dist2[z,j])\n l2_loss += (dist1[z,j] - dist2[z,j])**2\n z_num += 1\n \n # Normalize l1_loss and l2_loss\n l1_loss /= z_num\n l2_loss /= z_num\n\n return l1_loss, l2_loss\n\n##################### Calculate the average JS-divergence #####################\n# [input1]: dist1 (Z x M matrix)\n# [input2]: dist2 (Z x M matrix)\n# [input3]: pass_test (Z-dim vector)\n# [input4]: Z -- Number of distributions\n# [input5]: M -- Number of POIs\n# [input6]: L -- Number of top POIs in dist1\n# [output1]: js\ndef CalcJS(dist1, dist2, pass_test, Z, M, L):\n # Initialization\n m_dist = np.zeros((Z, M))\n js = 0.0\n\n for z in range(Z):\n for i in range(M):\n m_dist[z,i] = (dist1[z,i] + dist2[z,i]) / 2.0\n\n # JS-divergence for all POIs\n if L == M:\n for z in range(Z):\n if pass_test[z] == 1:\n for i in range(M):\n if dist1[z,i] > 0.0:\n js += dist1[z,i] * math.log(dist1[z,i]/m_dist[z,i]) / 2\n if dist2[z,i] > 0.0:\n js += dist2[z,i] * math.log(dist2[z,i]/m_dist[z,i]) / 2\n # JS-divergence for all POIs\n else:\n for z in range(Z):\n if pass_test[z] == 1:\n sortindex = np.argsort(dist1[z])[::-1]\n for i in range(L):\n j = sortindex[i]\n if dist1[z,j] > 0.0:\n js += dist1[z,j] * math.log(dist1[z,j]/m_dist[z,j]) / 2\n if dist2[z,j] > 0.0:\n js += dist2[z,j] * math.log(dist2[z,j]/m_dist[z,j]) / 2\n\n # Normalize js\n js /= np.sum(pass_test)\n\n return js\n\n####### Calculate the l1-loss using visit-fraction distributions ########\n# [input1]: vf_dist1 (M x B matrix)\n# [input2]: vf_dist2 (M x B matrix)\n# [input3]: vf_exist (M-dim vector)\n# [input4]: M -- Number of POIs\n# [input5]: B -- Number of bins\n# [output1]: l1_loss\ndef CalcL1VfDist(vf_dist1, vf_dist2, vf_exist, M, B):\n # Initialization\n l1_loss = 0\n x = 0\n\n # For each POI\n for i in range(M):\n # i-th row (visit-fraction for the i-th POI) in vf_dist1 --> p1\n p1 = vf_dist1[i,:]\n # i-th row (visit-fraction for the i-th POI) in vf_dist2 --> p2\n p2 = vf_dist2[i,:]\n # Continue if either testing vf or training vf doesn't exist\n if vf_exist[i] == 0:\n continue\n # l1-loss between p1 & p2 --> l1_loss\n for j in range(B):\n l1_loss += np.abs(p1[j] - p2[j])\n x += 1\n\n # Calculate the average l1-loss\n l1_loss /= x\n\n return l1_loss\n\n######### Calculate the EMD on the y/x-axis using transition matrices #########\n# [input1]: trans1 (M x M matrix)\n# [input2]: trans2 (M x M matrix)\n# [input3]: poi_dic ({poi_index: [y, x, y_id, x_id]})\n# [input4]: M -- Number of POIs\n# [output1]: weight_avg_emd -- Weighted average EMD\ndef CalcEMDTransMat(trans1, trans2, poi_dic, M):\n # Initializaion\n avg_emd_y = 0\n avg_emd_x = 0\n y_axis_ids = np.arange(NumRegY)\n x_axis_ids = np.arange(NumRegX)\n\n # For each POI\n for i in range(M):\n # Initialization\n p1_y = np.zeros(NumRegY)\n p1_x = np.zeros(NumRegX)\n p2_y = np.zeros(NumRegY)\n p2_x = np.zeros(NumRegX)\n\n # i-th row (conditional probability from the i-th POI) in trans1 --> p1\n p1 = trans1[i,:]\n # p1 on the y-axis --> p1_y\n for j in range(M):\n y_id = poi_dic[j][2]\n p1_y[y_id] += p1[j]\n # p1 on the x-axis --> p1_x\n for j in range(M):\n x_id = poi_dic[j][3]\n p1_x[x_id] += p1[j]\n\n # i-th row (conditional probability from the i-th POI) in trans2 --> p2\n p2 = trans2[i,:]\n # p2 on the y-axis --> p2_y\n for j in range(M):\n y_id = poi_dic[j][2]\n p2_y[y_id] += p2[j]\n # p2 on the x-axis --> p2_x\n for j in range(M):\n x_id = poi_dic[j][3]\n p2_x[x_id] += p2[j]\n\n # EMD between p1_y & p2_y --> avg_emd_y\n emd_y = wasserstein_distance(y_axis_ids, y_axis_ids, p1_y, p2_y)\n avg_emd_y += emd_y\n\n # EMD between p1_x & p2_x --> avg_emd_x\n emd_x = wasserstein_distance(x_axis_ids, x_axis_ids, p1_x, p2_x)\n avg_emd_x += emd_x\n\n # Calculate the average EMD\n avg_emd_y /= M\n avg_emd_x /= M\n\n return avg_emd_y, avg_emd_x\n\n########### Calculate the l1 & l2 losses using transition matrices ############\n# [input1]: trans1 (M x M matrix)\n# [input2]: trans2 (M x M matrix)\n# [input3]: M -- Number of POIs\n# [output1]: l1_loss\n# [output2]: l2_loss\ndef CalcL1L2TransMat(trans1, trans2, M):\n # Initializaion\n l1_loss = 0.0\n l2_loss = 0.0\n m_num = 0\n\n # For each POI\n for i in range(M):\n l1_loss_row = 0.0\n l2_loss_row = 0.0\n # i-th row (conditional probability from the i-th POI) in trans1 --> p1\n p1 = trans1[i,:]\n # i-th row (conditional probability from the i-th POI) in trans2 --> p2\n p2 = trans2[i,:]\n\n if np.sum(p1) > 0:\n # L1 & L2 losses for the row\n for j in range(M):\n l1_loss_row += np.abs(p1[j] - p2[j])\n l2_loss_row += (p1[j] - p2[j])**2\n\n # Update the average L1 & L2 losses\n l1_loss += l1_loss_row\n l2_loss += l2_loss_row\n m_num += 1\n\n# print(i, l1_loss_row, l2_loss_row, l1_loss, l2_loss)\n l1_loss /= m_num\n l2_loss /= m_num\n\n return l1_loss, l2_loss\n\n#################################### Main #####################################\n# Replace XX with City\nTUserIndexFile = TUserIndexFile.replace(\"XX\", City)\nEUserIndexFile = EUserIndexFile.replace(\"XX\", City)\nPOIFile = POIFile.replace(\"XX\", City)\nPOIIndexFile = POIIndexFile.replace(\"XX\", City)\nTrainTraceFile = TrainTraceFile.replace(\"XX\", City)\nTestTraceFile = TestTraceFile.replace(\"XX\", City)\nResFile = ResFile.replace(\"XX\", City)\n\n# Number of training users --> N\nN = len(open(TUserIndexFile).readlines()) - 1\n# Number of testing users --> N2\nN2 = len(open(EUserIndexFile).readlines()) - 1\n# Number of POIs --> M\nM = len(open(POIIndexFile).readlines()) - 1\n# Number of time slots --> T\nif TimeType == 1:\n T = 30\nelif TimeType == 2:\n T = 12\nelse:\n print(\"Wrong TimeType.\\n\")\n sys.exit(-1)\n\n# Read a training/testing trace file for the MAP re-identification attack (DataSet = PF)\nif DataSet == \"PF\":\n ttrans_count, ttrans_prob, tcount_sum = ReadTrainTraceFile()\n etrans_count, etrans_prob, ecount_sum = ReadTestTraceFile()\n\n# Read POI files\npoi_dic = ReadPOI()\n\n# Read model parameters\nParamA_bin = np.zeros((N,K))\nif os.path.exists(ModelParameterDir):\n ParamA, ParamB, ParamC, ParamD = ReadModelParameters()\n\n # Normalize model parameters\n for k in range(K):\n l2_norm = np.linalg.norm(ParamA[:,k])\n ParamA[:,k] /= l2_norm\n l2_norm = np.linalg.norm(ParamB[:,k])\n ParamB[:,k] /= l2_norm\n l2_norm = np.linalg.norm(ParamC[:,k])\n ParamC[:,k] /= l2_norm\n l2_norm = np.linalg.norm(ParamD[:,k])\n ParamD[:,k] /= l2_norm\n\n for k in range(K):\n # Set the 90th percentile of ParamA as ParamAThr\n ParamAThr = np.percentile(ParamA[:,k], 90)\n # Binarize model parameter A using ParamAThr\n ParamA_bin[:,k] = ParamA[:,k] > ParamAThr\n\n# Read training traces\nttrain_dist, ttrain_count, atrain_trans, vf_train_dist, ktrain_dist, kttrain_dist = ReadRealTraces(0, N, M, T, ParamA_bin, TrainTraceFile)\n\n# Read testing traces\nttest_dist, ttest_count, atest_trans, vf_test_dist, ktest_dist, kttest_dist = ReadRealTraces(N, N2, M, T, ParamA_bin, TestTraceFile)\n\n# Set vf_exist\nvf_exist = np.ones(M)\nfor i in range(M):\n if np.sum(vf_train_dist[i]) == 0 or np.sum(vf_test_dist[i]) == 0:\n vf_exist[i] = 0\n\nSynTraceFileLst = glob.glob(SynTraceFileAst)\n\nf = open(ResFile, \"w\")\n#print(\"tracedir, tracefile, reid_rate, MIA_acc, MIA_adv, -, TP-TV_syn, TP-MSE_syn, TP-JS_syn, TP-TV_tra, TP-MSE_tra, TP-JS_tra, TP-TV_uni, TP-MSE_uni, TP-JS_uni, -, TP-TV-Top50_syn, TP-MSE-Top50_syn, TP-JS-Top50_syn, TP-TV-Top50_tra, TP-MSE-Top50_tra, TP-JS-Top50_tra, TP-TV-Top50_uni, TP-MSE-Top50_uni, TP-JS-Top50_uni, -, VF-TV_syn, VF-TV_tra, VF-TV_uni, -, TM-EMD-Y_syn, TM-EMD-X_syn, TM-EMD-Y_tra, TM-EMD-X_tra, TM-EMD-Y_uni, TM-EMD-X_uni, -, CP-TV_syn, CP-MSE_syn, CP-JS_syn, CP-TV_uni, CP-MSE_uni, CP-JS_uni\", file=f)\nprint(\"tracedir, tracefile, reid_rate, MIA_acc, MIA_adv, -, TP-TV_syn, TP-TV_tra, TP-TV_uni, -, TP-TV-Top50_syn, TP-TV-Top50_tra, TP-TV-Top50_uni, -, VF-TV_syn, VF-TV_tra, VF-TV_uni, -, TM-EMD-Y_syn, TM-EMD-X_syn, TM-EMD-Y_tra, TM-EMD-X_tra, TM-EMD-Y_uni, TM-EMD-X_uni\", file=f)\n\n######################### Utiility of the benchmark ##########################\n################### Time-specific Geo-distribution ####################\n# Uniform distribution --> uni_dist\ntuni_dist = np.full((T, M), 1.0/float(M))\ntones = np.ones(T)\n\n# Calculate the l1 & l2 losses between ttest_dist & ttrain_dist\nttra_l1_loss, ttra_l2_loss = CalcL1L2(ttest_dist, ttrain_dist, tones, T, M, M)\n# Calculate the JS divergence between ttest_dist & ttrain_dist\nttra_js = CalcJS(ttest_dist, ttrain_dist, tones, T, M, M)\n\n# Calculate the l1 & l2 losses between ttest_dist & tuni_dist\ntuni_l1_loss, tuni_l2_loss = CalcL1L2(ttest_dist, tuni_dist, tones, T, M, M)\n# Calculate the JS divergence between ttest_dist & tuni_dist\ntuni_js = CalcJS(ttest_dist, tuni_dist, tones, T, M, M)\n\n####################### Time-specific Top-L POIs ######################\n# Calculate the l1 & l2 losses between test_dist & train_dist\nttral_l1_loss, ttral_l2_loss = CalcL1L2(ttest_dist, ttrain_dist, tones, T, M, L1)\n# Calculate the JS divergence between test_dist & syn_dist\nttral_js = CalcJS(ttest_dist, ttrain_dist, tones, T, M, L1)\n\n# Calculate the l1 & l2 losses between test_dist & uni_dist\ntunil_l1_loss, tunil_l2_loss = CalcL1L2(ttest_dist, tuni_dist, tones, T, M, L1)\n# Calculate the JS divergence between test_dist & uni_dist\ntunil_js = CalcJS(ttest_dist, tuni_dist, tones, T, M, L1)\n\n######### Visit-fraction distribution [Ye+,KDD11][Do+,TMC13] ##########\nvtra_l1 = 0\nvuni_l1 = 0\nif DataSet == \"FS\":\n # Uniform distribution --> vf_uni_dist\n #vf_uni_dist = np.full((M, B), 1.0/float(B))\n vf_uni_dist = np.zeros((M, B))\n vf_bin = math.ceil(1.0*B/M) - 1\n for i in range(M):\n vf_uni_dist[i,vf_bin] = 1\n \n # Calculate the average EMD between vf_test_dist & vf_train_dist\n vtra_l1 = CalcL1VfDist(vf_test_dist, vf_train_dist, vf_exist, M, B)\n # Calculate the average EMD between vf_test_dist & vf_uni_dist\n vuni_l1 = CalcL1VfDist(vf_test_dist, vf_uni_dist, vf_exist, M, B)\n\n################### Basis-specific Geo-distribution ###################\natrain_dist = np.zeros((1, M))\nauni_dist = np.zeros((1, M))\naones = np.ones(1)\nfor t in range(T):\n atrain_dist += ttrain_dist[t] / T\nfor t in range(T):\n auni_dist += tuni_dist[t] / T\n\nktra_l1_loss = np.zeros(K)\nktra_l2_loss = np.zeros(K)\nfor k in range(K):\n # Calculate the l1 & l2 losses between ktrain_dist & atrain_dist\n ktra_l1_loss[k], ktra_l2_loss[k] = CalcL1L2(ktrain_dist[k], atrain_dist, aones, 1, M, M)\n # Sort indices in descending order of ktra_l1_loss --> ktra_l1_loss_index\n ktra_l1_loss_index = np.argsort(-ktra_l1_loss)\n\nkuni_l1_loss = np.zeros(K)\nkuni_l2_loss = np.zeros(K)\nkuni_js = np.zeros(K)\nfor k in range(K):\n # Calculate the l1 & l2 losses between ktrain_dist & auni_dist\n kuni_l1_loss[k], kuni_l2_loss[k] = CalcL1L2(ktrain_dist[k], auni_dist, aones, 1, M, M)\n # Calculate the JS divergence between ktrain_dist & auni_dist\n kuni_js[k] = CalcJS(ktrain_dist[k], auni_dist, aones, 1, M, M)\n\nkuni_l1_loss_max = np.max(kuni_l1_loss)\nkuni_l2_loss_max = np.max(kuni_l2_loss)\nkuni_js_max = np.max(kuni_js)\n\n########################## Mobility features ##########################\n# Uniform transition matrix --> uni_trans\nauni_trans = np.full((M, M), 1.0/float(M))\n\n# Calculate the average EMD on the y/x-axis between atest_trans & atrain_trans\natra_trans_emd_y, atra_trans_emd_x = CalcEMDTransMat(atest_trans, atrain_trans, poi_dic, M)\n# Calculate the average EMD on the y/x-axis between atest_trans & auni_trans\nauni_trans_emd_y, auni_trans_emd_x = CalcEMDTransMat(atest_trans, auni_trans, poi_dic, M)\n\n# For each synthesized trace file\nfor SynTraceFile in SynTraceFileLst:\n SynTraceFile = SynTraceFile.replace(\"\\\\\", \"/\")\n print(\"Evaluating\", os.path.split(SynTraceFile)[0].split(\"/\")[-1] + \"/\" + os.path.split(SynTraceFile)[1])\n\n if DataSet == \"PF\":\n # MAP (Maximum a Posteriori) re-identification attack --> reid_res\n log_post, reid_res = MAPReidentify(ttrans_prob, tcount_sum, SynTraceFile)\n reid_num = 0\n for i in range(N*TraceNum):\n if reid_res[i] == int(i / TraceNum):\n reid_num += 1\n reid_rate = reid_num / (N*TraceNum)\n\n # Likelihood-ratio-based MIA (Membership Inference Attack) --> mia_res\n llr_per_trace, MIA_thr, MIA_true_pos, MIA_true_neg, MIA_max_acc, MIA_max_adv = LRMIA(ttrans_prob, etrans_prob, SynTraceFile)\n# # Output the detailed results of MIA\n# outfile = DataDir + \"utilpriv_MIA_\" + os.path.split(SynTraceFile)[0].split(\"/\")[-1] + \"_\" + os.path.split(SynTraceFile)[1]\n# f2 = open(outfile, \"w\")\n# print(\"thr, #true_pos, #true_neg, accuracy, advantage\", file=f2)\n# writer = csv.writer(f2, lineterminator=\"\\n\")\n# for i in range(1000):\n# s = [MIA_thr[i], MIA_true_pos[i], MIA_true_neg[i], \n# (MIA_true_pos[i]+MIA_true_neg[i])/(TraceNum*(N+N2)),\n# MIA_true_pos[i]/(TraceNum*N) - 1 + MIA_true_neg[i]/(TraceNum*N2)] \n# writer.writerow(s)\n# f2.close()\n else:\n reid_rate = 0\n MIA_max_acc = 0\n MIA_max_adv = 0\n\n # Initialization\n tsyn_l1_loss_avg = 0\n tsyn_l2_loss_avg = 0\n tsyn_js_avg = 0\n\n tsynl_l1_loss_avg = 0\n tsynl_l2_loss_avg = 0\n tsynl_js_avg = 0\n\n vsyn_l1_avg = 0\n\n ksyn_l1_loss = np.zeros(K)\n ksyn_l2_loss = np.zeros(K)\n ksyn_js = np.zeros(K)\n\n asyn_trans_emd_y_avg = 0\n asyn_trans_emd_x_avg = 0\n\n # PD test result file --> PDTestResFile\n if DataSet == \"FS\" and PDTest == 1 and (SynAlg == \"PPMTF\" or SynAlg == \"PPITF\"):\n PDTestResFile = DataDir + os.path.split(SynTraceFile)[0].split(\"/\")[-1] + \"/\" + \"pdtest_res\"\n else:\n PDTestResFile = \"none\"\n\n # For each trace no.\n for trace_no in range(TraceNum):\n # Read synthesized traces\n tsyn_dist, asyn_trans, pass_test, vf_syn_dist, ksyn_dist, ktsyn_dist = ReadSynTraces(N, M, T, ParamA_bin, SynTraceFile, PDTestResFile, Reqk, trace_no)\n\n ################### Time-specific Geo-distribution ####################\n # Calculate the l1 & l2 losses between ttest_dist & tsyn_dist\n tsyn_l1_loss, tsyn_l2_loss = CalcL1L2(ttest_dist, tsyn_dist, tones, T, M, M)\n tsyn_l1_loss_avg += tsyn_l1_loss\n tsyn_l2_loss_avg += tsyn_l2_loss\n # Calculate the JS divergence between ttest_dist & tsyn_dist\n tsyn_js = CalcJS(ttest_dist, tsyn_dist, tones, T, M, M)\n tsyn_js_avg += tsyn_js\n\n ####################### Time-specific Top-L POIs ######################\n # Calculate the l1 & l2 losses between ttest_dist & tsyn_dist\n tsynl_l1_loss, tsynl_l2_loss = CalcL1L2(ttest_dist, tsyn_dist, tones, T, M, L1)\n tsynl_l1_loss_avg += tsynl_l1_loss\n tsynl_l2_loss_avg += tsynl_l2_loss\n # Calculate the JS divergence between ttest_dist & tsyn_dist\n tsynl_js = CalcJS(ttest_dist, tsyn_dist, tones, T, M, L1)\n tsynl_js_avg += tsynl_js\n \n ######### Visit-fraction distribution [Ye+,KDD11][Do+,TMC13] ##########\n if DataSet == \"FS\":\n # Calculate the average EMD between vf_test_dist & vf_syn_dist\n vsyn_l1 = CalcL1VfDist(vf_test_dist, vf_syn_dist, vf_exist, M, B)\n vsyn_l1_avg += vsyn_l1\n \n ################### Basis-specific Geo-distribution ###################\n for k in range(K):\n # Calculate the l1 & l2 losses between ktrain_dist & ksyn_dist\n l1_loss, l2_loss = CalcL1L2(ktrain_dist[k], ksyn_dist[k], aones, 1, M, M)\n ksyn_l1_loss[k] += l1_loss\n ksyn_l2_loss[k] += l2_loss\n # Calculate the JS divergence between ktrain_dist & ksyn_dist\n js = CalcJS(ktrain_dist[k], ksyn_dist[k], aones, 1, M, M)\n ksyn_js[k] += js\n\n ########################## Mobility features ##########################\n # Calculate the average EMD on the y/x-axis between atest_trans & asyn_trans\n asyn_trans_emd_y, asyn_trans_emd_x = CalcEMDTransMat(atest_trans, asyn_trans, poi_dic, M)\n asyn_trans_emd_y_avg += asyn_trans_emd_y\n asyn_trans_emd_x_avg += asyn_trans_emd_x\n\n # Normalization\n tsyn_l1_loss_avg /= TraceNum\n tsyn_l2_loss_avg /= TraceNum\n tsyn_js_avg /= TraceNum\n\n tsynl_l1_loss_avg /= TraceNum\n tsynl_l2_loss_avg /= TraceNum\n tsynl_js_avg /= TraceNum\n\n vsyn_l1_avg /= TraceNum\n\n ksyn_l1_loss /= TraceNum\n ksyn_l2_loss /= TraceNum\n ksyn_js /= TraceNum\n\n ksyn_l1_loss_max= np.max(ksyn_l1_loss)\n ksyn_l2_loss_max = np.max(ksyn_l2_loss)\n ksyn_js_max = np.max(ksyn_js)\n\n asyn_trans_emd_y_avg /= TraceNum\n asyn_trans_emd_x_avg /= TraceNum\n\n # Output the results\n writer = csv.writer(f, lineterminator=\"\\n\")\n if DataSet == \"PF\":\n# s = [os.path.split(SynTraceFile)[0].split(\"/\")[-1], os.path.split(SynTraceFile)[1], reid_rate, MIA_max_acc, MIA_max_adv, \"-\", \n# tsyn_l1_loss_avg/2.0, tsyn_l2_loss_avg, tsyn_js_avg, ttra_l1_loss/2.0, ttra_l2_loss, ttra_js, tuni_l1_loss/2.0, tuni_l2_loss, tuni_js, \"-\", \n# tsynl_l1_loss_avg/2.0, tsynl_l2_loss_avg, tsynl_js_avg, ttral_l1_loss/2.0, ttral_l2_loss, ttral_js, tunil_l1_loss/2.0, tunil_l2_loss, tunil_js, \"-\", \n# \"-\", \"-\", \"-\", \"-\", \n# asyn_trans_emd_y_avg, asyn_trans_emd_x_avg, atra_trans_emd_y, atra_trans_emd_x, auni_trans_emd_y, auni_trans_emd_x, \"-\", \n# ksyn_l1_loss_max/2.0, ksyn_l2_loss_max, ksyn_js_max, kuni_l1_loss_max/2.0, kuni_l2_loss_max, kuni_js_max, \"-\"]\n s = [os.path.split(SynTraceFile)[0].split(\"/\")[-1], os.path.split(SynTraceFile)[1], reid_rate, MIA_max_acc, MIA_max_adv, \"-\", \n tsyn_l1_loss_avg/2.0, ttra_l1_loss/2.0, tuni_l1_loss/2.0, \"-\", \n tsynl_l1_loss_avg/2.0, ttral_l1_loss/2.0, tunil_l1_loss/2.0, \"-\", \n \"-\", \"-\", \"-\", \"-\", \n asyn_trans_emd_y_avg, asyn_trans_emd_x_avg, atra_trans_emd_y, atra_trans_emd_x, auni_trans_emd_y, auni_trans_emd_x]\n else:\n# s = [os.path.split(SynTraceFile)[0].split(\"/\")[-1], os.path.split(SynTraceFile)[1], reid_rate, MIA_max_acc, MIA_max_adv, \"-\", \n# tsyn_l1_loss_avg/2.0, tsyn_l2_loss_avg, tsyn_js_avg, ttra_l1_loss/2.0, ttra_l2_loss, ttra_js, tuni_l1_loss/2.0, tuni_l2_loss, tuni_js, \"-\", \n# tsynl_l1_loss_avg/2.0, tsynl_l2_loss_avg, tsynl_js_avg, ttral_l1_loss/2.0, ttral_l2_loss, ttral_js, tunil_l1_loss/2.0, tunil_l2_loss, tunil_js, \"-\", \n# vsyn_l1_avg/2.0, vtra_l1/2.0, vuni_l1/2.0, \"-\", \n# asyn_trans_emd_y_avg, asyn_trans_emd_x_avg, atra_trans_emd_y, atra_trans_emd_x, auni_trans_emd_y, auni_trans_emd_x, \"-\", \n# ksyn_l1_loss_max/2.0, ksyn_l2_loss_max, ksyn_js_max, kuni_l1_loss_max/2.0, kuni_l2_loss_max, kuni_js_max, \"-\"] \n s = [os.path.split(SynTraceFile)[0].split(\"/\")[-1], os.path.split(SynTraceFile)[1], \"-\", \"-\", \"-\", \"-\", \n tsyn_l1_loss_avg/2.0, ttra_l1_loss/2.0, tuni_l1_loss/2.0, \"-\", \n tsynl_l1_loss_avg/2.0, ttral_l1_loss/2.0, tunil_l1_loss/2.0, \"-\", \n vsyn_l1_avg/2.0, vtra_l1/2.0, vuni_l1/2.0, \"-\", \n asyn_trans_emd_y_avg, asyn_trans_emd_x_avg, atra_trans_emd_y, atra_trans_emd_x, auni_trans_emd_y, auni_trans_emd_x] \n writer.writerow(s)\n\nf.close()\n"
] |
[
[
"scipy.stats.wasserstein_distance",
"numpy.abs",
"numpy.arange",
"numpy.linalg.norm",
"numpy.percentile",
"numpy.full",
"numpy.ones",
"numpy.max",
"numpy.argmax",
"numpy.argsort",
"numpy.zeros",
"numpy.sum",
"numpy.loadtxt",
"scipy.sparse.lil_matrix"
]
] |
oatsu-gh/nnsvs
|
[
"510f37bc1d1f15282646e4d34435b5d63686cf40"
] |
[
"egs/jsut-song/svs-world-conv/local/data_prep.py"
] |
[
"# coding: utf-8\nimport os\n\nimport argparse\nfrom glob import glob\nfrom os.path import join, basename, splitext, exists, expanduser\nfrom nnmnkwii.io import hts\nfrom scipy.io import wavfile\nimport librosa\nimport soundfile as sf\nimport sys\nimport numpy as np\n\nfrom nnsvs.io.hts import get_note_indices\n\n\ndef _is_silence(l):\n is_full_context = \"@\" in l\n if is_full_context:\n is_silence = (\"-sil\" in l or \"-pau\" in l)\n else:\n is_silence = (l == \"sil\" or l == \"pau\")\n return is_silence\n\n\ndef remove_sil_and_pau(lab):\n newlab = hts.HTSLabelFile()\n for l in lab:\n if \"-sil\" not in l[-1] and \"-pau\" not in l[-1]:\n newlab.append(l, strict=False)\n\n return newlab\n\n\ndef get_parser():\n parser = argparse.ArgumentParser(\n description=\"Data preparation for NIT-SONG070\",\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\n )\n parser.add_argument(\"jsut_song_root\", type=str, help=\"JSUT song dir\")\n parser.add_argument(\"jsut_lab_root\", type=str, help=\"JSUT lab dir\")\n parser.add_argument(\"hts_demo_root\", type=str, help=\"HTS demo root\")\n parser.add_argument(\"out_dir\", type=str, help=\"Output directory\")\n parser.add_argument(\"--gain-normalize\", action='store_true')\n return parser\n\nargs = get_parser().parse_args(sys.argv[1:])\n\nout_dir = args.out_dir\nnit_song080_label_root = join(args.hts_demo_root, \"data/labels/full\")\njsut_song_root = join(args.jsut_song_root, \"child_song\")\ngain_normalize = args.gain_normalize\n\n# Time-lag constraints to filter outliers\ntimelag_allowed_range = (-20, 19)\ntimelag_allowed_range_rest = (-40, 39)\n\noffset_correction_threshold = 0.005\n\n\n### Make aligned full context labels\n\nfull_align_dir = join(args.jsut_lab_root)\n# Note: this will be saved under jsut_song_root directory\nfull_align_new_dir = join(jsut_song_root, \"label_phone_align\")\n\nos.makedirs(full_align_new_dir, exist_ok=True)\n\n# replace contexts with HTS demo's one\n# this is needed because nnmnkwii assumes that pitch is represented by midi note (e.g. E4),\n# while jsut-song's label uses numbers (e.g. 87) to represent pitch.\nfull_lab_files = sorted(glob(join(full_align_dir, \"*.lab\")))\nnames = list(map(lambda s: basename(s), full_lab_files))\nnit_lab_files = list(map(lambda s: join(nit_song080_label_root, f\"nitech_jp_song070_f001_{s}\"), names))\nfor jsut, nit in zip(full_lab_files, nit_lab_files):\n assert exists(jsut) and exists(nit)\n jsut_lab = hts.load(jsut)\n nit_lab = hts.load(nit)\n assert len(jsut_lab) == len(nit_lab)\n\n # make sure that each label represents the same\n for a, b in zip(jsut_lab, nit_lab):\n assert a[-1].split(\"/A\")[0] == b[-1].split(\"/A\")[0]\n\n jsut_lab.contexts = nit_lab.contexts\n name = basename(jsut)\n dst_path = join(full_align_new_dir, name)\n with open(dst_path, \"w\") as of:\n of.write(str(jsut_lab))\n\n\n### Prepare data for time-lag models\n\ndst_dir = join(out_dir, \"timelag\")\nlab_align_dst_dir = join(dst_dir, \"label_phone_align\")\nlab_score_dst_dir = join(dst_dir, \"label_phone_score\")\n\nfor d in [lab_align_dst_dir, lab_score_dst_dir]:\n os.makedirs(d, exist_ok=True)\n\nprint(\"Prepare data for time-lag models\")\nfull_lab_align_files = sorted(glob(join(full_align_new_dir, \"*.lab\")))\nfor lab_align_path in full_lab_align_files:\n name = basename(lab_align_path)\n lab_score_path = join(nit_song080_label_root, f\"nitech_jp_song070_f001_{name}\")\n assert exists(lab_score_path)\n\n lab_align = hts.load(lab_align_path)\n lab_score = hts.load(lab_score_path)\n\n # Extract note onsets and let's compute a offset\n note_indices = get_note_indices(lab_score)\n\n onset_align = np.asarray(lab_align[note_indices].start_times)\n onset_score = np.asarray(lab_score[note_indices].start_times)\n\n global_offset = (onset_align - onset_score).mean()\n global_offset = int(round(global_offset / 50000) * 50000)\n\n # Apply offset correction only when there is a big gap\n apply_offset_correction = np.abs(global_offset * 1e-7) > offset_correction_threshold\n if apply_offset_correction:\n print(f\"{name}: Global offset (in sec): {global_offset * 1e-7}\")\n lab_score.start_times = list(np.asarray(lab_score.start_times) + global_offset)\n lab_score.end_times = list(np.asarray(lab_score.end_times) + global_offset)\n onset_score += global_offset\n\n # Exclude large diff parts (probably a bug of musicxml or alignment though)\n valid_note_indices = []\n for idx, (a, b) in enumerate(zip(onset_align, onset_score)):\n note_idx = note_indices[idx]\n lag = np.abs(a - b) / 50000\n if _is_silence(lab_score.contexts[note_idx]):\n if lag >= timelag_allowed_range_rest[0] and lag <= timelag_allowed_range_rest[1]:\n valid_note_indices.append(note_idx)\n else:\n if lag >= timelag_allowed_range[0] and lag <= timelag_allowed_range[1]:\n valid_note_indices.append(note_idx)\n\n if len(valid_note_indices) < len(note_indices):\n D = len(note_indices) - len(valid_note_indices)\n print(f\"{name}: {D}/{len(note_indices)} time-lags are excluded.\")\n\n # Note onsets as labels\n lab_align = lab_align[valid_note_indices]\n lab_score = lab_score[valid_note_indices]\n\n # Save lab files\n lab_align_dst_path = join(lab_align_dst_dir, name)\n with open(lab_align_dst_path, \"w\") as of:\n of.write(str(lab_align))\n\n lab_score_dst_path = join(lab_score_dst_dir, name)\n with open(lab_score_dst_path, \"w\") as of:\n of.write(str(lab_score))\n\n### Prepare data for duration models\n\ndst_dir = join(out_dir, \"duration\")\nlab_align_dst_dir = join(dst_dir, \"label_phone_align\")\n\nfor d in [lab_align_dst_dir]:\n os.makedirs(d, exist_ok=True)\n\nprint(\"Prepare data for duration models\")\nfull_lab_align_files = sorted(glob(join(full_align_new_dir, \"*.lab\")))\nfor lab_align_path in full_lab_align_files:\n name = basename(lab_align_path)\n\n lab_align = hts.load(lab_align_path)\n\n # Save lab file\n lab_align_dst_path = join(lab_align_dst_dir, name)\n with open(lab_align_dst_path, \"w\") as of:\n of.write(str(lab_align))\n\n\n### Prepare data for acoustic models\n\ndst_dir = join(out_dir, \"acoustic\")\nwav_dst_dir = join(dst_dir, \"wav\")\nlab_align_dst_dir = join(dst_dir, \"label_phone_align\")\nlab_score_dst_dir = join(dst_dir, \"label_phone_score\")\n\nfor d in [wav_dst_dir, lab_align_dst_dir, lab_score_dst_dir]:\n os.makedirs(d, exist_ok=True)\n\nprint(\"Prepare data for acoustic models\")\nfull_lab_align_files = sorted(glob(join(full_align_new_dir, \"*.lab\")))\nfor lab_align_path in full_lab_align_files:\n name = splitext(basename(lab_align_path))[0]\n lab_score_path = join(nit_song080_label_root, f\"nitech_jp_song070_f001_{name}.lab\")\n assert exists(lab_score_path)\n wav_path = join(jsut_song_root, \"wav\", name + \".wav\")\n\n assert wav_path\n # sr, wave = wavfile.read(wav_path)\n wav, sr = librosa.load(wav_path, sr=48000)\n\n if gain_normalize:\n wav = wav / wav.max() * 0.99\n\n lab_align = hts.load(lab_align_path)\n lab_score = hts.load(lab_score_path)\n\n # Save caudio\n wav_dst_path = join(wav_dst_dir, name + \".wav\")\n # TODO: consider explicit subtype\n sf.write(wav_dst_path, wav, sr)\n\n # Save label\n lab_align_dst_path = join(lab_align_dst_dir, name + \".lab\")\n with open(lab_align_dst_path, \"w\") as of:\n of.write(str(lab_align))\n\n lab_score_dst_path = join(lab_score_dst_dir, name + \".lab\")\n with open(lab_score_dst_path, \"w\") as of:\n of.write(str(lab_score))\n\nsys.exit(0)"
] |
[
[
"numpy.asarray",
"numpy.abs"
]
] |
yaozhang2016/deepwater
|
[
"861a2dbeffeafab83dd53956deeb4f8193b9cb2e"
] |
[
"tensorflow/src/main/resources/deepwater/models/alexnet.py"
] |
[
"import tensorflow as tf\n\nfrom deepwater.models import BaseImageClassificationModel\nfrom deepwater.models.nn import fc, conv3x3, conv5x5, conv11x11, max_pool_3x3\n\n\nclass AlexNet(BaseImageClassificationModel):\n def __init__(self, width, height, channels, classes):\n super(AlexNet, self).__init__()\n\n size = width * height * channels\n\n x = tf.placeholder(tf.float32, [None, size], name=\"x\")\n self._inputs = x\n\n with tf.variable_scope(\"reshape1\"):\n x = tf.reshape(self._inputs, [-1, width, height, channels])\n\n self._number_of_classes = classes\n\n with tf.variable_scope(\"resize1\"):\n if width < 224:\n x = tf.image.resize_images(x, [48, 48])\n else:\n x = tf.image.resize_images(x, [224, 224])\n\n with tf.variable_scope(\"conv1\"):\n conv1 = conv11x11(x, 96, stride=4, padding='VALID')\n pool1 = max_pool_3x3(conv1, padding='VALID')\n lrn1 = tf.nn.lrn(pool1, 5, bias=1.0, alpha=0.0001, beta=0.75)\n\n with tf.variable_scope(\"conv2\"):\n conv2 = conv5x5(lrn1, 256)\n pool2 = max_pool_3x3(conv2, padding='VALID')\n lrn2 = tf.nn.lrn(pool2, 5, bias=1.0, alpha=0.0001, beta=0.75)\n\n with tf.variable_scope(\"conv3\"):\n conv3 = conv3x3(lrn2, 384)\n with tf.variable_scope(\"conv4\"):\n conv4 = conv3x3(conv3, 384)\n with tf.variable_scope(\"conv5\"):\n conv5 = conv3x3(conv4, 256)\n pool3 = max_pool_3x3(conv5)\n lrn3 = tf.nn.lrn(pool3, 5, bias=1.0, alpha=0.001 / 9.0, beta=0.75)\n\n dims = lrn3.get_shape().as_list()\n flatten_size = 1\n for d in dims[1:]:\n flatten_size *= d\n\n with tf.variable_scope(\"reshape2\"):\n flatten = tf.reshape(lrn3, [-1, int(flatten_size)])\n\n with tf.variable_scope(\"fc1\"):\n fc1 = fc(flatten, 4096)\n relu1 = tf.nn.relu(fc1)\n\n with tf.variable_scope(\"fc2\"):\n fc2 = fc(relu1, 4096)\n relu2 = tf.nn.relu(fc2)\n\n with tf.variable_scope(\"fc3\"):\n y = fc(relu2, classes)\n\n self._logits = y\n\n if classes > 1:\n self._predictions = tf.nn.softmax(y)\n else:\n self._predictions = self._logits\n\n @property\n def train_dict(self):\n return {}\n\n @property\n def name(self):\n return \"AlexNet\"\n\n @property\n def number_of_classes(self):\n return self._number_of_classes\n\n @property\n def inputs(self):\n return self._inputs\n\n @property\n def logits(self):\n return self._logits\n\n @property\n def predictions(self):\n return self._predictions\n"
] |
[
[
"tensorflow.nn.relu",
"tensorflow.nn.softmax",
"tensorflow.image.resize_images",
"tensorflow.reshape",
"tensorflow.placeholder",
"tensorflow.nn.lrn",
"tensorflow.variable_scope"
]
] |
donghaozhang/Pytorch_Geometric
|
[
"bbe2f21e5208d30636c22c40f55a1d17e18ca9b4"
] |
[
"test/nn/dense/test_dense_gcn_conv.py"
] |
[
"import torch\nfrom torch_geometric.nn import GCNConv, DenseGCNConv\n\n\ndef test_dense_gcn_conv():\n channels = 16\n sparse_conv = GCNConv(channels, channels)\n dense_conv = DenseGCNConv(channels, channels)\n assert dense_conv.__repr__() == 'DenseGCNConv(16, 16)'\n\n # Ensure same weights and bias.\n dense_conv.weight = sparse_conv.weight\n dense_conv.bias = sparse_conv.bias\n\n x = torch.randn((5, channels))\n edge_index = torch.tensor([[0, 0, 1, 1, 2, 2, 3, 4],\n [1, 2, 0, 2, 0, 1, 4, 3]])\n\n sparse_out = sparse_conv(x, edge_index)\n assert sparse_out.size() == (5, channels)\n\n x = torch.cat([x, x.new_zeros(1, channels)], dim=0).view(2, 3, channels)\n adj = torch.Tensor([\n [\n [0, 1, 1],\n [1, 0, 1],\n [1, 1, 0],\n ],\n [\n [0, 1, 0],\n [1, 0, 0],\n [0, 0, 0],\n ],\n ])\n mask = torch.tensor([[1, 1, 1], [1, 1, 0]], dtype=torch.uint8)\n\n dense_out = dense_conv(x, adj, mask)\n assert dense_out.size() == (2, 3, channels)\n\n assert dense_out[1, 2].abs().sum().item() == 0\n dense_out = dense_out.view(6, channels)[:-1]\n assert torch.allclose(sparse_out, dense_out, atol=1e-04)\n\n\ndef test_dense_gcn_conv_with_broadcasting():\n batch_size, num_nodes, channels = 8, 3, 16\n conv = DenseGCNConv(channels, channels)\n\n x = torch.randn(batch_size, num_nodes, channels)\n adj = torch.Tensor([\n [0, 1, 1],\n [1, 0, 1],\n [1, 1, 0],\n ])\n\n assert conv(x, adj).size() == (batch_size, num_nodes, channels)\n mask = torch.tensor([1, 1, 1], dtype=torch.uint8)\n assert conv(x, adj, mask).size() == (batch_size, num_nodes, channels)\n"
] |
[
[
"torch.randn",
"torch.allclose",
"torch.Tensor",
"torch.tensor"
]
] |
wudbug/RoboND-Rover-Project
|
[
"09dbc392fc75afdfab645be290e9450f64784f11"
] |
[
"code/perception.py"
] |
[
"import numpy as np\nimport cv2\n\n# Identify pixels above the threshold\n# Threshold of RGB > 160 does a nice job of identifying ground pixels only\ndef color_thresh(img, rgb_thresh=(160, 160, 160)):\n # Create an array of zeros same xy size as img, but single channel\n color_select = np.zeros_like(img[:,:,0])\n # Require that each pixel be above all three threshold values in RGB\n # above_thresh will now contain a boolean array with \"True\"\n # where threshold was met\n above_thresh = (img[:,:,0] > rgb_thresh[0]) \\\n & (img[:,:,1] > rgb_thresh[1]) \\\n & (img[:,:,2] > rgb_thresh[2])\n # Index the array of zeros with the boolean array and set to 1\n color_select[above_thresh] = 1\n # Return the binary image\n return color_select\n\n\ndef find_rocks(img, levels=(110, 110, 50)):\n rock = ((img[:, :, 0] > levels[0]) \\\n & (img[:, :, 1] > levels[1]) \\\n & (img[:, :, 2] < levels[2]))\n\n color_select = np.zeros_like(img[:, :, 0])\n color_select[rock] = 1\n\n return color_select\n\n# Define a function to convert from image coords to rover coords\ndef rover_coords(binary_img):\n # Identify nonzero pixels\n ypos, xpos = binary_img.nonzero()\n # Calculate pixel positions with reference to the rover position being at the \n # center bottom of the image. \n x_pixel = -(ypos - binary_img.shape[0]).astype(np.float)\n y_pixel = -(xpos - binary_img.shape[1]/2 ).astype(np.float)\n return x_pixel, y_pixel\n\n\n# Define a function to convert to radial coords in rover space\ndef to_polar_coords(x_pixel, y_pixel):\n # Convert (x_pixel, y_pixel) to (distance, angle) \n # in polar coordinates in rover space\n # Calculate distance to each pixel\n dist = np.sqrt(x_pixel**2 + y_pixel**2)\n # Calculate angle away from vertical for each pixel\n angles = np.arctan2(y_pixel, x_pixel)\n return dist, angles\n\n# Define a function to map rover space pixels to world space\ndef rotate_pix(xpix, ypix, yaw):\n # Convert yaw to radians\n yaw_rad = yaw * np.pi / 180\n xpix_rotated = (xpix * np.cos(yaw_rad)) - (ypix * np.sin(yaw_rad))\n \n ypix_rotated = (xpix * np.sin(yaw_rad)) + (ypix * np.cos(yaw_rad))\n # Return the result \n return xpix_rotated, ypix_rotated\n\ndef translate_pix(xpix_rot, ypix_rot, xpos, ypos, scale): \n # Apply a scaling and a translation\n xpix_translated = (xpix_rot / scale) + xpos\n ypix_translated = (ypix_rot / scale) + ypos\n # Return the result \n return xpix_translated, ypix_translated\n\n\n# Define a function to apply rotation and translation (and clipping)\n# Once you define the two functions above this function should work\ndef pix_to_world(xpix, ypix, xpos, ypos, yaw, world_size, scale):\n # Apply rotation\n xpix_rot, ypix_rot = rotate_pix(xpix, ypix, yaw)\n # Apply translation\n xpix_tran, ypix_tran = translate_pix(xpix_rot, ypix_rot, xpos, ypos, scale)\n # Perform rotation, translation and clipping all at once\n x_pix_world = np.clip(np.int_(xpix_tran), 0, world_size - 1)\n y_pix_world = np.clip(np.int_(ypix_tran), 0, world_size - 1)\n # Return the result\n return x_pix_world, y_pix_world\n\n# Define a function to perform a perspective transform\ndef perspect_transform(img, src, dst):\n \n M = cv2.getPerspectiveTransform(src, dst)\n warped = cv2.warpPerspective(img, M, (img.shape[1], img.shape[0]))# keep same size as input image\n mask = cv2.warpPerspective(np.ones_like(img[:, :, 0]), M,\n (img.shape[1], img.shape[0])) # keep same size as input image\n\n return warped, mask\n\n\n# Apply the above functions in succession and update the Rover state accordingly\ndef perception_step(Rover):\n\n # Perform perception steps to update Rover()\n # TODO: \n # NOTE: camera image is coming to you in Rover.img\n\n # 1) Define source and destination points for perspective transform\n dst_size = 5\n bottom_offset = 6\n source = np.float32([[14, 140], [301, 140], [200, 96], [118, 96]])\n destination = np.float32([[Rover.img.shape[1] / 2 - dst_size, Rover.img.shape[0] - bottom_offset],\n [Rover.img.shape[1] / 2 + dst_size, Rover.img.shape[0] - bottom_offset],\n [Rover.img.shape[1] / 2 + dst_size, Rover.img.shape[0] - 2 * dst_size - bottom_offset],\n [Rover.img.shape[1] / 2 - dst_size, Rover.img.shape[0] - 2 * dst_size - bottom_offset],\n ])\n # 2) Apply perspective transform\n warped, mask = perspect_transform(Rover.img, source, destination)\n # warped_binary = color_thresh(warped, [0,0,0])\n\n # 3) Apply color threshold to identify navigable terrain/obstacles/rock samples\n #look for navigable terrain in the warped image\n navigable_terrain = color_thresh(warped)\n\n # obstacles are the opposite of navigable terrain\n obstacles = np.copy(navigable_terrain)\n obstacles = np.absolute(np.float32(obstacles) - 1) * mask # add the mask to account for camera fov\n\n #Look for rocks in the camera image\n rock_samples = find_rocks(warped)\n\n # 4) Update Rover.vision_image (this will be displayed on left side of screen)\n # Example: Rover.vision_image[:,:,0] = obstacle color-thresholded binary image\n # Rover.vision_image[:,:,1] = rock_sample color-thresholded binary image\n # Rover.vision_image[:,:,2] = navigable terrain color-thresholded binary image\n\n Rover.vision_image[:, :, 0] = obstacles * 255\n Rover.vision_image[:, :, 1] = rock_samples * 255\n Rover.vision_image[:, :, 2] = navigable_terrain * 255\n #\n # 5) Convert map image pixel values to rover-centric coords\n navigable_x_pixel, navigable_y_pixel = rover_coords(navigable_terrain)\n obstacles_x_pixel, obstacles_y_pixel = rover_coords(obstacles)\n rocks_x_pixel, rocks_y_pixel = rover_coords(rock_samples)\n\n # 6) Convert rover-centric pixel values to world coordinates\n world_size = Rover.worldmap.shape[0]\n scale = 2 * dst_size\n navigable_x_world, navigable_y_world = pix_to_world(navigable_x_pixel, navigable_y_pixel, Rover.pos[0], Rover.pos[1],Rover.yaw, world_size, scale)\n obstacles_x_world, obstacles_y_world = pix_to_world(obstacles_x_pixel, obstacles_y_pixel, Rover.pos[0], Rover.pos[1], Rover.yaw, world_size, scale)\n rock_x_world, rock_y_world = pix_to_world(rocks_x_pixel, rocks_y_pixel, Rover.pos[0], Rover.pos[1], Rover.yaw, world_size, scale)\n\n # 7) Update Rover worldmap (to be displayed on right side of screen)\n # Example: Rover.worldmap[obstacle_y_world, obstacle_x_world, 0] += 1\n # Rover.worldmap[rock_y_world, rock_x_world, 1] += 1\n # Rover.worldmap[navigable_y_world, navigable_x_world, 2] += 1\n\n\n # Only map to the world if the angles are fairly close to 0. The perspective transform is designed for when the angles are 0\n\n if Rover.pitch < 0.5 or Rover.pitch > 359.5 and Rover.roll < 0.5 or Rover.roll > 359.5:\n Rover.worldmap[obstacles_y_world, obstacles_x_world, 0] += 1\n Rover.worldmap[navigable_y_world, navigable_x_world, 2] += 1\n Rover.worldmap[rock_y_world, rock_x_world, 1] += 1\n\n # 8) Convert rover-centric pixel positions to polar coordinates\n # Update Rover pixel distances and angles\n # Rover.nav_dists = rover_centric_pixel_distances\n # Rover.nav_angles = rover_centric_angles\n distance, angles = to_polar_coords(navigable_x_pixel, navigable_y_pixel)\n\n # TODO: This needs improving to move the Rover towards the rocks\n # if rock_samples.any():\n # distance, angles = to_polar_coords(rocks_x_pixel, rocks_y_pixel)\n\n Rover.nav_dists = distance\n Rover.nav_angles = angles\n\n\n return Rover"
] |
[
[
"numpy.ones_like",
"numpy.sqrt",
"numpy.cos",
"numpy.int_",
"numpy.arctan2",
"numpy.sin",
"numpy.copy",
"numpy.zeros_like",
"numpy.float32"
]
] |
BeatHubmann/19H-AdvNCSE
|
[
"3979f768da933de82bd6ab29bbf31ea9fc31e501"
] |
[
"series2_handout/hyp_sys_1d/plot_euler.py"
] |
[
"import json\nimport glob\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom matplotlib.ticker import LogLocator\nfrom matplotlib import rc\nfrom matplotlib import rcParams\nfont = {'family' : 'Dejavu Sans',\n 'weight' : 'normal',\n 'size' : 22}\nrc('font', **font)\nrcParams['lines.linewidth'] = 4\nrcParams['lines.markersize'] = 12\nrcParams['markers.fillstyle'] = 'none'\n\ndef load_json(filename):\n with open(filename, \"r\") as f:\n return json.load(f)\n\ndef load_snapshot(filename):\n j = load_json(filename)\n return j[\"time\"], np.array(j[\"cell_centers\"]), np.array(j[\"density\"]), np.array(j[\"velocity\"]), np.array(j[\"pressure\"])\n\ndef plot_snapshot(t, x, u):\n plt.plot(x, u)\n plt.title(f\"t = {t:0.6f}\")\n plt.show()\n\nif __name__ == \"__main__\":\n\n files = sorted(glob.glob(\"output/euler_fvm_sod_shock_tube*.json\"))\n\n for fn in files:\n t, x, rho, v, p = load_snapshot(fn)\n plot_snapshot(t, x, rho)\n"
] |
[
[
"matplotlib.pyplot.title",
"matplotlib.rc",
"matplotlib.pyplot.plot",
"numpy.array",
"matplotlib.pyplot.show"
]
] |
jhartika/audioapinat
|
[
"f14809f8573a54cd5a2a384f3ca9d75cc754e17b"
] |
[
"NN.py"
] |
[
"import numpy as np\n\ndef main():\n \n \n train_data_file = \"data/mel/train_data.npy\"\n train_labels_file = \"data/mel/train_labels.npy\"\n test_data_file = \"data/mel/test_data.npy\"\n test_labels_file = \"data/mel/test_labels.npy\"\n \n train_data = np.load(train_data_file)\n train_labels = np.load(train_labels_file)\n test_data = np.load(test_data_file)\n test_labels = np.load(test_labels_file)\n\n from keras.layers import Flatten, Dense, Dropout, GRU, Conv2D, MaxPool2D, Reshape, BatchNormalization\n from keras.optimizers import Adam, SGD\n from keras.models import Sequential\n from keras.utils import np_utils\n \n train_labels = np_utils.to_categorical(train_labels, 34)\n test_labels = np_utils.to_categorical(test_labels, 34)\n \n## Best model yet. Stabilises in the 80-85% range. 300 epochs is enough to \n## reach that point\n model = Sequential()\n \n model.add(GRU(128, return_sequences=True, activation='relu',\n dropout=0.5, recurrent_dropout=0.5,input_shape=(40,44)))\n model.add(BatchNormalization())\n \n model.add(GRU(64, return_sequences=True, activation='relu',\n dropout=0.5, recurrent_dropout=0.5))\n model.add(BatchNormalization())\n \n model.add(Flatten())\n model.add(Dense(256, activation='relu'))\n model.add(Dropout(0.5))\n model.add(Dense(128, activation='relu'))\n model.add(Dropout(0.5))\n model.add(Dense(34, activation='softmax'))\n\n model.summary()\n \n optim = Adam()\n model.compile(loss='categorical_crossentropy',\n optimizer=optim,\n metrics=['accuracy'])\n \n model.fit(train_data, train_labels, epochs = 300, batch_size=5, validation_data = [test_data, test_labels])\n score = model.evaluate(test_data, test_labels, batch_size=128)\n print(score[1])\n \n \nif __name__ == '__main__':\n main()\n"
] |
[
[
"numpy.load"
]
] |
smearle/gym-micropolis
|
[
"42b338ee050fb654e1c74dfe59bf5f03f03d39a4",
"42b338ee050fb654e1c74dfe59bf5f03f03d39a4"
] |
[
"poet_distributed/optimizers.py",
"extinction_eval.py"
] |
[
"# The following code is modified from openai/evolution-strategies-starter\n# (https://github.com/openai/evolution-strategies-starter)\n# under the MIT License.\n\n# Modifications Copyright (c) 2019 Uber Technologies, Inc.\n\n\nimport numpy as np\n#from algo import A2C_ACKTR_NOREWARD\n\n\nclass Optimizer(object):\n def __init__(self, theta):\n self.dim = len(theta)\n self.t = 0\n\n def update(self, theta, globalg):\n self.t += 1\n step = self._compute_step(globalg)\n ratio = np.linalg.norm(step) / np.linalg.norm(theta)\n return ratio, theta + step\n\n def _compute_step(self, globalg):\n raise NotImplementedError\n\n\nclass SimpleSGD(Optimizer):\n def __init__(self, stepsize):\n self.stepsize = stepsize\n\n def compute(self, theta, globalg):\n step = -self.stepsize * globalg\n ratio = np.linalg.norm(step) / np.linalg.norm(theta)\n return ratio, theta + step\n\n\nclass SGD(Optimizer):\n def __init__(self, theta, stepsize, momentum=0.9):\n Optimizer.__init__(self, theta)\n self.v = np.zeros(self.dim, dtype=np.float32)\n self.stepsize, self.momentum = stepsize, momentum\n\n def _compute_step(self, globalg):\n self.v = self.momentum * self.v + (1. - self.momentum) * globalg\n step = -self.stepsize * self.v\n return step\n\n\nclass Adam(Optimizer):\n def __init__(self, theta, stepsize, beta1=0.9, beta2=0.999, epsilon=1e-08):\n Optimizer.__init__(self, theta)\n self.stepsize = stepsize\n self.init_stepsize = stepsize\n self.beta1 = beta1\n self.beta2 = beta2\n self.epsilon = epsilon\n self.m = np.zeros(self.dim, dtype=np.float32)\n self.v = np.zeros(self.dim, dtype=np.float32)\n\n def reset(self):\n self.m = np.zeros(self.dim, dtype=np.float32)\n self.v = np.zeros(self.dim, dtype=np.float32)\n self.t = 0\n self.stepsize = self.init_stepsize\n\n def _compute_step(self, globalg):\n print('COMPUTIN')\n a = self.stepsize * \\\n np.sqrt(1 - self.beta2 ** self.t) / (1 - self.beta1 ** self.t)\n self.m = self.beta1 * self.m + (1 - self.beta1) * globalg\n self.v = self.beta2 * self.v + (1 - self.beta2) * (globalg * globalg)\n step = -a * self.m / (np.sqrt(self.v) + self.epsilon)\n return step\n\n def propose(self, theta, globalg):\n a = self.stepsize * \\\n np.sqrt(1 - self.beta2 ** self.t) / (1 - self.beta1 ** self.t)\n m = self.beta1 * self.m + (1 - self.beta1) * globalg\n v = self.beta2 * self.v + (1 - self.beta2) * (globalg * globalg)\n step = -a * m / (np.sqrt(v) + self.epsilon)\n ratio = np.linalg.norm(step) / np.linalg.norm(theta)\n return ratio, theta + step\n",
"''' Runs experiments for our alife20 paper, exploring the effect of extinction events on the\ncomplexity of maps generated by a trained RL agent.'''\nimport os\nimport shutil\nimport re\nimport time\n\nimport matplotlib.pyplot as plt\nimport gym\nimport numpy as np\nimport torch\nfrom PIL import Image\n\nimport game_of_life\nimport gym_city\nfrom arguments import get_parser\nfrom envs import VecPyTorch, make_vec_envs\nfrom evaluate import Evaluator\nfrom model import Policy\nfrom utils import get_vec_normalize\n\n#plt.switch_backend('agg')\n\ndef parse_cl_args():\n #TODO: away with this function, in theory.\n '''\n Takes arguments from the command line and ignores as many of them as possible.\n '''\n\n # assume the user passes no args, and these are defaults/dummy\n #TODO: trash all of this\n parser = get_parser()\n\n parser.add_argument('--non-det', action='store_true', default=False,\n help='whether to use a non-deterministic policy')\n parser.add_argument('--active-column', default=None, type=int,\n help='Run only one vertical column of a fractal model to see what it\\\n has learnt independently')\n parser.add_argument('--evaluate', action='store_true', default=False,\n help='record trained network\\'s performance')\n # add any experiment-specific args here\n args = parser.parse_args()\n args.im_render = True\n #args.render = True\n args.random_terrain = False\n args.random_builds = False\n return args\n\n\n\nclass ExtinctionEvaluator():\n '''Run a series of experiments to evaluate the effect of extinction events on the complexity\n of the behaviour of a trained agent.'''\n def __init__(self, args, im_log_dir):\n self.im_log_dir = im_log_dir\n self.log_dir = args.load_dir\n env_name = args.env_name\n if torch.cuda.is_available() and not args.no_cuda:\n args.cuda = True\n device = torch.device('cuda')\n map_location = torch.device('cuda')\n else:\n args.cuda = False\n device = torch.device('cpu')\n map_location = torch.device('cpu')\n try:\n checkpoint = torch.load(os.path.join(args.load_dir, env_name + '.tar'),\n map_location=map_location)\n except FileNotFoundError:\n print('load-dir does not start with valid gym environment id, using command line args')\n env_name = args.env_name\n checkpoint = torch.load(os.path.join(args.load_dir, env_name + '.tar'),\n map_location=map_location)\n saved_args = checkpoint['args']\n past_frames = checkpoint['n_frames']\n args.past_frames = past_frames\n env_name = saved_args.env_name\n\n if 'Micropolis' in env_name:\n args.power_puzzle = saved_args.power_puzzle\n\n if not args.evaluate and not 'GoLMulti' in env_name:\n # assume we just want to observe/interact w/ a single env.\n args.num_proc = 1\n dummy_args = args\n envs = make_vec_envs(env_name, args.seed + 1000, args.num_processes,\n None, args.load_dir, args.add_timestep, device=device,\n allow_early_resets=False,\n args=dummy_args)\n print(args.load_dir)\n\n if isinstance(envs.observation_space, gym.spaces.Discrete):\n in_width = 1\n num_inputs = envs.observation_space.n\n elif isinstance(envs.observation_space, gym.spaces.Box):\n if len(envs.observation_space.shape) == 3:\n in_w = envs.observation_space.shape[1]\n in_h = envs.observation_space.shape[2]\n else:\n in_w = 1\n in_h = 1\n num_inputs = envs.observation_space.shape[0]\n\n if isinstance(envs.action_space, gym.spaces.Discrete):\n out_w = 1\n out_h = 1\n num_actions = int(envs.action_space.n // (in_w * in_h))\n #if 'Micropolis' in env_name:\n # num_actions = env.venv.venv.envs[0].num_tools\n #elif 'GameOfLife' in env_name:\n # num_actions = 1\n #else:\n # num_actions = env.action_space.n\n elif isinstance(envs.action_space, gym.spaces.Box):\n out_w = envs.action_space.shape[0]\n out_h = envs.action_space.shape[1]\n num_actions = envs.action_space.shape[-1]\n # We need to use the same statistics for normalization as used in training\n #actor_critic, ob_rms = \\\n # torch.load(os.path.join(args.load_dir, args.env_name + \".pt\"))\n\n if saved_args.model == 'fractal':\n saved_args.model = 'FractalNet'\n actor_critic = Policy(envs.observation_space.shape, envs.action_space,\n base_kwargs={'map_width': args.map_width,\n 'recurrent': args.recurrent_policy,\n 'in_w': in_w, 'in_h': in_h, 'num_inputs': num_inputs,\n 'out_w': out_w, 'out_h': out_h },\n curiosity=args.curiosity, algo=saved_args.algo,\n model=saved_args.model, args=saved_args)\n actor_critic.to(device)\n torch.nn.Module.dump_patches = True\n actor_critic.load_state_dict(checkpoint['model_state_dict'])\n ob_rms = checkpoint['ob_rms']\n\n if 'fractal' in args.model.lower():\n new_recs = args.n_recs - saved_args.n_recs\n\n for nr in range(new_recs):\n actor_critic.base.auto_expand()\n print('expanded network:\\n', actor_critic.base)\n\n if args.active_column is not None \\\n and hasattr(actor_critic.base, 'set_active_column'):\n actor_critic.base.set_active_column(args.active_column)\n vec_norm = get_vec_normalize(envs)\n\n if vec_norm is not None:\n vec_norm.eval()\n vec_norm.ob_rms = ob_rms\n self.actor_critic = actor_critic\n self.envs = envs\n self.args = args\n\n def run_experiment(self, n_epis, max_step, map_width, extinction_type, extinction_prob,\n extinction_dels):\n '''Evaluate the effect of a single type of extinction event (or none).'''\n args = self.args\n actor_critic = self.actor_critic\n envs = self.envs\n im_log_dir = '{}/xttyp:{}_stp:{}'.format(\n self.im_log_dir,\n extinction_type,\n #extinction_prob,\n #map_width,\n max_step\n )\n envs.venv.venv.set_log_dir(im_log_dir)\n # adjust envs in general\n envs.venv.venv.setMapSize(map_width, max_step=max_step, render=args.render)\n if extinction_type is not None:\n # adjust extinguisher wrapper\n envs.venv.venv.set_extinction_type(extinction_type, extinction_prob, extinction_dels)\n # adjust image render wrapper\n envs.venv.venv.reset_episodes(im_log_dir)\n envs.venv.venv.init_storage()\n recurrent_hidden_states = torch.zeros(1, actor_critic.recurrent_hidden_state_size)\n masks = torch.zeros(1, 1)\n obs = envs.reset()\n #obs = torch.Tensor(obs)\n player_act = None\n n_episode = 0\n\n while n_episode < n_epis:\n with torch.no_grad():\n value, action, _, recurrent_hidden_states = actor_critic.act(\n obs, recurrent_hidden_states, masks, deterministic=not args.non_det,\n player_act=player_act)\n # Observe reward and next obs\n obs, reward, done, infos = envs.step(action)\n if args.render:\n envs.venv.venv.render()\n\n if done.any():\n n_episode += np.sum(done.astype(int))\n player_act = None\n\n if infos[0]:\n if 'player_move' in infos[0].keys():\n player_act = infos[0]['player_move']\n #masks.fill_(0.0 if done else 1.0)\n envs.reset()\n\n#def run_experiment():\n# '''Measure True under various conditions.'''\n# map_sizes = self.map_sizes\n# extinction_types = self.extinction_types\n# extinction_intervals = self.extinction_intervals\n# evaluator = ExtinctionEvaluator()\n#\n# for map_size in map_sizes:\n# for extinction_type in extinction_types:\n# for extinction_interval in extinction_intervals:\n# evaluator.run_experiment(map_size, extinction_type, extinction_interval)\n\ndef get_xy(exp_dir):\n '''Plot the mean episode by mean size of the functional jpeg in terms of timestep.\n - exp_dir: location of images\n Return xy coordinates of mean episode\n '''\n ims = os.listdir(exp_dir)\n # map timesteps to a tuple (mean_size, num_ims)\n step2size = {}\n\n for im in ims:\n step_search = re.search(r'([\\d]+)\\.jpg', im)\n step = step_search.group(1)\n im_path = os.path.join(exp_dir, im)\n size = os.stat(im_path).st_size\n\n if step in step2size:\n mean_size, num_ims = step2size[step]\n mean_size = (mean_size * num_ims + size) / (num_ims + 1)\n num_ims += 1\n step2size[step] = (mean_size, num_ims)\n else:\n step2size[step] = (size, 1)\n xs = []\n ys = []\n for x, (y, _) in step2size.items():\n xs += [x]\n ys += [y]\n xy = zip(xs, ys)\n xy = sorted(xy, key = lambda x: int(x[0]))\n xs, ys = zip(*xy)\n return xs, ys\n\ndef visualize_experiments(log_dir):\n '''Visualize results from extinction-compressibility experiments.\n - load-dir: stores folder of experiments, within which are compressed images named by rank and\n episode\n '''\n log_dir = log_dir\n xtinct_dirs = os.listdir(log_dir)\n xt_dir_paths = [os.path.join(log_dir, xt_dir) for xt_dir in xtinct_dirs]\n # make sure the order of local and global paths correspond\n dirs_types = zip(xtinct_dirs, xt_dir_paths)\n dirs_types = sorted(dirs_types, key = lambda x: str(x[0]))\n xtinct_dirs, xt_dir_paths = zip(*dirs_types)\n xt_ims = [os.listdir(xt_dir) for xt_dir in xt_dir_paths if not os.path.isfile(xt_dir) ]\n\n for i, trial_name in enumerate(xtinct_dirs):\n print(trial_name)\n srch_xttyp = re.search(r'xttyp\\:([a-zA-Z]+)', trial_name)\n if srch_xttyp is None:\n continue\n xt_type = srch_xttyp.group(1)\n xt_dir = xt_dir_paths[i]\n exp_title = ' '.join(xt_dir.split('/')[-2:])\n if os.path.isfile(xt_dir):\n continue\n x, y = get_xy(xt_dir)\n exp_plot, = plt.plot(x, y)\n print(xt_type)\n exp_plot.set_label(xt_type)\n\n srch_xtprob = re.search(r'xtprob\\:(\\d.[\\d]+)', log_dir)\n xt_prob = srch_xtprob.group(1)\n xt_interval = int(1 / float(xt_prob))\n graph_title = 'extinction interval = {}'.format(xt_interval)\n plt.title(graph_title)\n plt.xlabel('timesteps')\n plt.ylabel('bytes per jpg')\n plt.xticks([25 * i for i in range(5)])\n plt.legend()\n plt.savefig(os.path.join(log_dir, '{}.png'.format(graph_title)), format='png')\n #plt.show()\n\nclass ExtinctionExperimenter():\n '''\n Coordinate between experimentation and visualization.\n '''\n def __init__(self, log_dir):\n args = parse_cl_args()\n env_name = log_dir.split('/')[-1].split('_')[0]\n args.env_name = env_name\n # Experiment global parameters\n self.n_epis = 20\n self.max_step = [1000]\n self.map_sizes = [\n 16,\n #32,\n #64\n ]\n self.xt_types = [\n None,\n 'age',\n 'spatial',\n 'random'\n ]\n # TODO: automate xt_probs\n self.xt_probs = [args.extinction_prob]\n self.xt_dels = [15]\n self.map_sizes = [args.map_width]\n #self.xt_probs = [\n # 0.005,\n # #0.01,\n # #0.05,\n # #0.1\n # ]\n exp_name = 'test_map:{}_xtprob:{}_xtdels:{}'.format(\n self.map_sizes[0],\n float(self.xt_probs[0]),\n self.xt_dels[0])\n self.log_dir = log_dir\n args.load_dir = log_dir\n im_log_dir = os.path.join(log_dir, exp_name)\n try:\n os.mkdir(im_log_dir)\n except FileExistsError:\n #shutil.rmtree(im_log_dir)\n #os.mkdir(im_log_dir)\n pass\n self.im_log_dir = im_log_dir\n self.evaluator = ExtinctionEvaluator(args, im_log_dir)\n\n def run_experiments(self):\n '''Run experiments and produce data.'''\n evaluator = self.evaluator\n for mst in self.max_step:\n for msz in self.map_sizes:\n for xtd in self.xt_dels:\n for xtt in self.xt_types:\n if xtt is None:\n xtp = 0\n evaluator.run_experiment(self.n_epis, mst, msz, xtt, xtp, xtd)\n else:\n for xtp in self.xt_probs:\n evaluator.run_experiment(self.n_epis, mst, msz, xtt, xtp, xtd)\n\n def visualize_experiments(self):\n '''\n Visualize compressibility data stored in subfolders of the current directory.\n '''\n return visualize_experiments(self.im_log_dir)\n\n\nif __name__ == \"__main__\":\n VIS_ONLY = False\n #VIS_ONLY = True\n LOG_DIR = os.path.abspath(os.path.join(\n 'trained_models',\n 'a2c_FractalNet_drop',\n 'MicropolisEnv-v0_w16_1000s_noExtinct.bkp',\n ))\n EXPERIMENTER = ExtinctionExperimenter(LOG_DIR)\n\n #TODO: hacky; detect incomplete folders automatically,\n # should save numpy object w/ stats in folder\n if not VIS_ONLY:\n try:\n EXPERIMENTER.run_experiments()\n # broadcast problem when sizing up map #TODO: adjust vec_envs to prevent this\n except ValueError as ve:\n print(ve)\n EXPERIMENTER.visualize_experiments()\n"
] |
[
[
"numpy.sqrt",
"numpy.zeros",
"numpy.linalg.norm"
],
[
"matplotlib.pyplot.legend",
"matplotlib.pyplot.title",
"torch.zeros",
"matplotlib.pyplot.plot",
"torch.no_grad",
"torch.cuda.is_available",
"torch.device",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.ylabel"
]
] |
terraregina/BalancingControl
|
[
"36330cc0a20ad1f2fbd3a8f87ef8fed98df3fb22"
] |
[
"world.py"
] |
[
"\"\"\"This module contains the World class that defines interactions between\nthe environment and the agent. It also keeps track of all observations and\nactions generated during a single experiment. To initiate it one needs to\nprovide the environment class and the agent class that will be used for the\nexperiment.\n\"\"\"\nimport numpy as np\nfrom misc import ln\n\nclass World(object):\n\n def __init__(self, environment, agent, trials = 1, T = 10):\n #set inital elements of the world to None\n self.environment = environment\n self.agent = agent\n\n self.trials = trials # number of trials in the experiment\n self.T = T # number of time steps in each trial\n\n self.free_parameters = {}\n\n #container for observations\n self.observations = np.zeros((self.trials, self.T), dtype = int)\n\n #container for agents actions\n self.actions = np.zeros((self.trials, self.T), dtype = int)\n\n #container for rewards\n self.rewards = np.zeros((self.trials, self.T), dtype = int)\n\n def simulate_experiment(self, curr_trials=None, print_thoughts=False):\n \"\"\"This methods evolves all the states of the world by iterating\n through all the trials and time steps of each trial.\n \"\"\"\n if curr_trials is not None:\n trials = curr_trials\n else:\n trials = range(self.trials)\n for tau in trials:\n for t in range(self.T):\n if print_thoughts:\n print(\"tau\", tau, \", t\", t)\n self.__update_world(tau, t, print_thoughts=print_thoughts)\n\n\n def estimate_par_evidence(self, params, method='MLE'):\n\n\n val = np.zeros(params.shape[0])\n for i, par in enumerate(params):\n if method == 'MLE':\n val[i] = self.__get_log_likelihood(par)\n else:\n val[i] = self.__get_log_jointprobability(par)\n\n return val\n\n def fit_model(self, bounds, n_pars, method='MLE'):\n \"\"\"This method uses the existing observation and response data to\n determine the set of parameter values that are most likely to cause\n the meassured behavior.\n \"\"\"\n\n inference = Inference(ftol = 1e-4, xtol = 1e-8, bounds = bounds,\n opts = {'np': n_pars})\n\n if method == 'MLE':\n return inference.infer_posterior(self.__get_log_likelihood)\n else:\n return inference.infer_posterior(self.__get_log_jointprobability)\n\n\n #this is a private method do not call it outside of the class\n def __get_log_likelihood(self, params):\n self.agent.set_free_parameters(params)\n self.agent.reset_beliefs(self.actions)\n self.__update_model()\n\n p1 = np.tile(np.arange(self.trials), (self.T, 1)).T\n p2 = np.tile(np.arange(self.T), (self.trials, 1))\n p3 = self.actions.astype(int)\n\n return ln(self.agent.asl.control_probability[p1, p2, p3]).sum()\n\n def __get_log_jointprobability(self, params):\n self.agent.set_free_parameters(params)\n self.agent.reset_beliefs(self.actions)\n self.__update_model()\n\n p1 = np.tile(np.arange(self.trials), (self.T, 1)).T\n p2 = np.tile(np.arange(self.T), (self.trials, 1))\n p3 = self.actions.astype(int)\n\n ll = ln(self.agent.asl.control_probability[p1, p2, p3]).sum()\n\n return ll + self.agent.log_prior()\n\n #this is a private method do not call it outside of the class\n def __update_model(self):\n \"\"\"This private method updates the internal states of the behavioral\n model given the avalible set of observations and actions.\n \"\"\"\n\n for tau in range(self.trials):\n for t in range(self.T):\n\n if t == 0:\n response = None\n else:\n response = self.actions[tau, t-1]\n\n observation = self.observations[tau,t]\n\n self.agent.update_beliefs(tau, t, observation, response)\n self.agent.plan_behavior(tau, t)\n self.agent.estimate_response_probability(tau, t)\n\n #this is a private method do not call it outside of the class\n def __update_world(self, tau, t, print_thoughts = False):\n \"\"\"This private method performs a signel time step update of the\n whole world. Here we update the hidden state(s) of the environment,\n the perceptual and planning states of the agent, and in parallel we\n generate observations and actions.\n \"\"\"\n # if tau%5 == 0:\n # print(tau)\n \n if t==0:\n self.environment.set_initial_states(tau)\n response = None\n if hasattr(self.environment, 'Chi'):\n context = self.environment.generate_context_obs(tau)\n else:\n context = None\n else:\n response = self.actions[tau, t-1]\n self.environment.update_hidden_states(tau, t, response)\n context = None\n\n\n self.observations[tau, t] = \\\n self.environment.generate_observations(tau, t)\n\n if t>0:\n self.rewards[tau, t] = self.environment.generate_rewards(tau, t)\n\n observation = self.observations[tau, t]\n\n reward = self.rewards[tau, t]\n\n self.agent.update_beliefs(tau, t, observation, reward, response, context)\n\n\n if t < self.T-1:\n self.actions[tau, t] = self.agent.generate_response(tau, t)\n else:\n self.actions[tau, t] = -1\n \n if print_thoughts:\n print(\"response\", response)\n if t>0:\n print(\"rewards\", self.rewards[tau, t])\n # print(\"posterior policies: \", self.agent.posterior_policies[tau,t])\n # print(\"posterior context: \", self.agent.posterior_context[tau,t])\n if t<self.T-1:\n print(\"prior actions: \", self.agent.prior_actions)\n print(\"posterior actions: \", self.agent.posterior_actions[tau,t])\n print(\"\\n\")\n\nclass World_old(object):\n\n def __init__(self, environment, agent, trials = 1, T = 10):\n #set inital elements of the world to None\n self.environment = environment\n self.agent = agent\n\n self.trials = trials # number of trials in the experiment\n self.T = T # number of time steps in each trial\n\n self.free_parameters = {}\n\n #container for observations\n self.observations = np.zeros((self.trials, self.T), dtype = int)\n\n #container for agents actions\n self.actions = np.zeros((self.trials, self.T), dtype = int)\n\n #container for rewards\n self.rewards = np.zeros((self.trials, self.T), dtype = int)\n\n def simulate_experiment(self, curr_trials=None):\n \"\"\"This methods evolves all the states of the world by iterating\n through all the trials and time steps of each trial.\n \"\"\"\n if curr_trials is not None:\n trials = curr_trials\n else:\n trials = range(self.trials)\n for tau in trials:\n for t in range(self.T):\n self.__update_world(tau, t)\n\n\n def estimate_par_evidence(self, params, method='MLE'):\n\n\n val = np.zeros(params.shape[0])\n for i, par in enumerate(params):\n if method == 'MLE':\n val[i] = self.__get_log_likelihood(par)\n else:\n val[i] = self.__get_log_jointprobability(par)\n\n return val\n\n def fit_model(self, bounds, n_pars, method='MLE'):\n \"\"\"This method uses the existing observation and response data to\n determine the set of parameter values that are most likely to cause\n the meassured behavior.\n \"\"\"\n\n inference = Inference(ftol = 1e-4, xtol = 1e-8, bounds = bounds,\n opts = {'np': n_pars})\n\n if method == 'MLE':\n return inference.infer_posterior(self.__get_log_likelihood)\n else:\n return inference.infer_posterior(self.__get_log_jointprobability)\n\n\n #this is a private method do not call it outside of the class\n def __get_log_likelihood(self, params):\n self.agent.set_free_parameters(params)\n self.agent.reset_beliefs(self.actions)\n self.__update_model()\n\n p1 = np.tile(np.arange(self.trials), (self.T, 1)).T\n p2 = np.tile(np.arange(self.T), (self.trials, 1))\n p3 = self.actions.astype(int)\n\n return ln(self.agent.asl.control_probability[p1, p2, p3]).sum()\n\n def __get_log_jointprobability(self, params):\n self.agent.set_free_parameters(params)\n self.agent.reset_beliefs(self.actions)\n self.__update_model()\n\n p1 = np.tile(np.arange(self.trials), (self.T, 1)).T\n p2 = np.tile(np.arange(self.T), (self.trials, 1))\n p3 = self.actions.astype(int)\n\n ll = ln(self.agent.asl.control_probability[p1, p2, p3]).sum()\n\n return ll + self.agent.log_prior()\n\n #this is a private method do not call it outside of the class\n def __update_model(self):\n \"\"\"This private method updates the internal states of the behavioral\n model given the avalible set of observations and actions.\n \"\"\"\n\n for tau in range(self.trials):\n for t in range(self.T):\n if t == 0:\n response = None\n else:\n response = self.actions[tau, t-1]\n\n observation = self.observations[tau,t]\n\n self.agent.update_beliefs(tau, t, observation, response)\n self.agent.plan_behavior(tau, t)\n self.agent.estimate_response_probability(tau, t)\n\n #this is a private method do not call it outside of the class\n def __update_world(self, tau, t):\n \"\"\"This private method performs a signel time step update of the\n whole world. Here we update the hidden state(s) of the environment,\n the perceptual and planning states of the agent, and in parallel we\n generate observations and actions.\n \"\"\"\n\n if t==0:\n self.environment.set_initial_states(tau)\n response = None\n else:\n response = self.actions[tau, t-1]\n self.environment.update_hidden_states(tau, t, response)\n\n self.observations[tau, t] = \\\n self.environment.generate_observations(tau, t)\n\n if t>0:\n self.rewards[tau, t] = self.environment.generate_rewards(tau, t)\n\n observation = self.observations[tau, t]\n\n reward = self.rewards[tau, t]\n\n self.agent.update_beliefs(tau, t, observation, reward, response)\n\n\n if t < self.T-1:\n self.actions[tau, t] = self.agent.generate_response(tau, t)\n else:\n self.actions[tau, t] = -1\n\n\n\nclass FakeWorld(object):\n\n def __init__(self, agent, observations, rewards, actions, trials = 1, T = 10, log_prior=0):\n #set inital elements of the world to None\n self.agent = agent\n\n self.trials = trials # number of trials in the experiment\n self.T = T # number of time steps in each trial\n\n self.free_parameters = {}\n\n #container for observations\n self.observations = observations.copy()\n\n #container for agents actions\n self.actions = actions.copy()\n\n #container for rewards\n self.rewards = rewards.copy()\n\n self.log_prior = log_prior\n\n self.like_actions = np.zeros((trials,T-1))\n self.like_rewards = np.zeros((trials,T-1))\n\n def __simulate_agent(self):\n \"\"\"This methods evolves all the states of the world by iterating\n through all the trials and time steps of each trial.\n \"\"\"\n\n for tau in range(self.trials):\n for t in range(self.T):\n self.__update_model(tau, t)\n\n\n def estimate_par_evidence(self, params, fixed):\n\n\n val = self.__get_log_jointprobability(params, fixed)\n\n return val\n\n def fit_model(self, params, fixed, test_trials):\n \"\"\"This method uses the existing observation and response data to\n determine the set of parameter values that are most likely to cause\n the meassured behavior.\n \"\"\"\n self.like_actions = np.zeros((self.trials,self.T-1))\n self.like_rewards = np.zeros((self.trials,self.T-1))\n self.agent.reset(params, fixed)\n\n self.__simulate_agent()\n\n #print(self.like_actions)\n #print(self.like_rewards)\n\n like = self.like_actions[test_trials].prod() * self.like_rewards[test_trials].prod()\n\n return like #self.agent.posterior_actions.squeeze(), self.agent.posterior_rewards[:,1]\n\n def __get_log_jointprobability(self, params, fixed):\n\n self.agent.reset(params, fixed)\n\n self.__simulate_agent()\n\n p1 = np.tile(np.arange(self.trials), (self.T-1, 1)).T\n p2 = np.tile(np.arange(self.T-1), (self.trials, 1))\n p3 = self.actions.astype(int)\n #self.agent.log_probability\n ll = self.agent.log_probability#ln(self.agent.posterior_actions[p1, p2, p3].prod())\n\n return ll + self.log_prior\n\n #this is a private method do not call it outside of the class\n def __update_model(self, tau, t):\n \"\"\"This private method updates the internal states of the behavioral\n model given the avalible set of observations and actions.\n \"\"\"\n if t==0:\n response = None\n else:\n response = self.actions[tau, t-1]\n\n self.like_actions[tau,t-1] = self.agent.posterior_actions[tau, t-1, response]\n\n\n observation = self.observations[tau, t]\n\n reward = self.rewards[tau, t]\n\n self.agent.update_beliefs(tau, t, observation, reward, response)\n\n if t==1:\n self.like_rewards[tau,t-1] = self.agent.posterior_rewards[tau, t-1, reward]\n"
] |
[
[
"numpy.arange",
"numpy.zeros"
]
] |
francesco-mannella/ArmSim
|
[
"897d1797e81c4d65f679f4783f2a9b5e0f6f67f7"
] |
[
"ArmSim/examples/test.py"
] |
[
"import numpy as np\nfrom scipy import interpolate\nimport gym\nimport ArmSim\n\nenv = gym.make(\"ArmSimOneArm-v0\")\n\nstime = 120\nactions = np.pi * np.array(\n [\n [0.00, 0.00, 0.00, 0.00, 0.00],\n [0.20, -0.30, -0.20, 0.50, 0.00],\n [0.20, -0.30, -0.30, 0.50, 0.00],\n [0.10, -0.30, -0.30, 0.20, 0.30],\n [0.00, -0.30, -0.30, 0.20, 0.50],\n [0.00, -0.30, -0.30, 0.20, 0.50],\n [0.00, -0.30, -0.30, 0.20, 0.50],\n ]\n)\n\nactions_interp = np.zeros([stime, 5])\nfor joint_idx, joint_timeline in enumerate(actions.T):\n x0 = np.linspace(0, 1, len(joint_timeline))\n f = interpolate.interp1d(x0, joint_timeline)\n x = np.linspace(0, 1, stime)\n joint_timeline_interp = f(x)\n actions_interp[:, joint_idx] = joint_timeline_interp\n\nfor t in range(stime):\n env.render()\n action = actions_interp[t]\n o, *_ = env.step(action)\n"
] |
[
[
"numpy.array",
"numpy.zeros",
"scipy.interpolate.interp1d",
"numpy.linspace"
]
] |
cybersnus/text-to-text-transfer-transformer
|
[
"da14d97fa7f4be2da6ebb84e5d20ba6a3fd8add2"
] |
[
"t5/scripts/dump_task.py"
] |
[
"# Copyright 2020 The T5 Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# Lint as: python3\nr\"\"\"Utility to print the text or tokens in a task.\n\nExample usage:\npython -m t5.scripts.dump_task \\\n --task=glue_mnli_v002 \\\n --max_examples=100\n\n\n\"\"\"\n\nimport importlib\n\nfrom absl import app\nfrom absl import flags\nfrom absl import logging\n\n# from mesh_tensorflow.transformer import utils\nimport gin\nimport t5\nimport tensorflow.compat.v1 as tf\n\n\n_DEFAULT_MODULE_IMPORTS = [\n]\n\nFLAGS = flags.FLAGS\n\nflags.DEFINE_string(\"task\", None,\n \"A registered Task.\")\nflags.DEFINE_integer(\"max_examples\", -1,\n \"maximum number of examples. -1 for no limit\")\nflags.DEFINE_string(\n \"format_string\",\n \"{inputs}\\t{targets}\", \"format for printing examples\")\nflags.DEFINE_multi_string(\n \"module_import\", _DEFAULT_MODULE_IMPORTS,\n \"Modules to import. Use this when your Task or is defined outside \"\n \"of the T5 codebase so that it is registered.\")\nflags.DEFINE_string(\n \"split\", \"train\", \"which split of the dataset, e.g. train or validation\")\nflags.DEFINE_bool(\n \"tokenize\", False, \"tokenize and print out token ids\")\n\n\n@gin.configurable\ndef sequence_length(value=512):\n \"\"\"Sequence length used when tokenizing.\n\n Args:\n value: an integer or dictionary\n Returns:\n a dictionary\n \"\"\"\n if isinstance(value, int):\n return {\"inputs\": value, \"targets\": value}\n else:\n return value\n\n\ndef import_modules(modules):\n for module in modules:\n importlib.import_module(module)\n\n\ndef main(_):\n flags.mark_flags_as_required([\"task\"])\n\n if FLAGS.module_import:\n import_modules(FLAGS.module_import)\n\n gin.parse_config_files_and_bindings(FLAGS.gin_file, FLAGS.gin_param)\n\n total_examples = 0\n tf.enable_eager_execution()\n task = t5.data.TaskRegistry.get(FLAGS.task)\n files = task.tfds_dataset.files(FLAGS.split)\n def _example_to_string(ex):\n key_to_string = {}\n for k in (\"inputs\", \"targets\"):\n if k in ex:\n v = ex[k].numpy()\n key_to_string[k] = (\n \" \".join(str(i) for i in v) if FLAGS.tokenize\n else v.decode(\"utf-8\"))\n else:\n key_to_string[k] = \"\"\n return FLAGS.format_string.format(**key_to_string)\n\n for shard_path in files:\n logging.info(\"Processing shard: %s\", shard_path)\n ds = task.tfds_dataset.load_shard(shard_path)\n ds = task.preprocess_text(ds)\n if FLAGS.tokenize:\n ds = t5.data.encode_string_features(\n ds, task.output_features, keys=task.output_features,\n copy_plaintext=True)\n ds = task.preprocess_tokens(ds, sequence_length())\n\n for ex in ds:\n print(_example_to_string(ex))\n total_examples += 1\n if total_examples == FLAGS.max_examples:\n return\n\n\nif __name__ == \"__main__\":\n tf.disable_v2_behavior()\n app.run(main)\n"
] |
[
[
"tensorflow.compat.v1.enable_eager_execution",
"tensorflow.compat.v1.disable_v2_behavior"
]
] |
TangYuan-Liu/Paddle-Lite
|
[
"0349642ad19a155f2adb748c5f68a750c786aac2",
"0349642ad19a155f2adb748c5f68a750c786aac2"
] |
[
"lite/tests/unittest_py/op/test_gather_nd_op.py",
"lite/tests/unittest_py/op/test_elementwise_add_op.py"
] |
[
"# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport sys\nsys.path.append('../')\n\nfrom auto_scan_test import AutoScanTest, IgnoreReasons\nfrom program_config import TensorConfig, ProgramConfig, OpConfig, CxxConfig, TargetType, PrecisionType, DataLayoutType, Place\nimport unittest\n\nimport hypothesis\nfrom hypothesis import given, settings, seed, example, assume\n\nimport numpy as np\nfrom functools import partial\nimport hypothesis.strategies as st\n\n\nclass TestGatherNdOp(AutoScanTest):\n def __init__(self, *args, **kwargs):\n AutoScanTest.__init__(self, *args, **kwargs)\n self.enable_testing_on_place(\n TargetType.Host,\n PrecisionType.Any,\n DataLayoutType.Any,\n thread=[1, 4])\n\n def is_program_valid(self,\n program_config: ProgramConfig,\n predictor_config: CxxConfig) -> bool:\n return True\n\n def sample_program_configs(self, draw):\n in_shape = draw(\n st.lists(\n st.integers(\n min_value=4, max_value=8), min_size=3, max_size=4))\n value0 = draw(st.integers(min_value=0, max_value=in_shape[0] - 1))\n value1 = draw(st.integers(min_value=0, max_value=in_shape[1] - 1))\n value2 = draw(st.integers(min_value=0, max_value=in_shape[2] - 1))\n index = draw(\n st.sampled_from([[value0], [value0, value1],\n [value0, value1, value2]]))\n index_type = draw(st.sampled_from([\"int32\", \"int64\"]))\n\n def generate_index(*args, **kwargs):\n if index_type == \"int32\":\n return np.array(index).astype(np.int32)\n else:\n return np.array(index).astype(np.int64)\n\n def generate_input(*args, **kwargs):\n if kwargs[\"type\"] == \"int32\":\n return np.random.randint(kwargs[\"low\"], kwargs[\"high\"],\n kwargs[\"shape\"]).astype(np.int32)\n elif kwargs[\"type\"] == \"int64\":\n return np.random.randint(kwargs[\"low\"], kwargs[\"high\"],\n kwargs[\"shape\"]).astype(np.int64)\n elif kwargs[\"type\"] == \"float32\":\n return (kwargs[\"high\"] - kwargs[\"low\"]) * np.random.random(\n kwargs[\"shape\"]).astype(np.float32) + kwargs[\"low\"]\n\n input_type = draw(st.sampled_from([\"float32\", \"int64\", \"int32\"]))\n\n op_inputs = {\"X\": [\"input_data\"], \"Index\": [\"index_data\"]}\n program_inputs = {\n \"input_data\": TensorConfig(data_gen=partial(\n generate_input,\n type=input_type,\n low=-10,\n high=10,\n shape=in_shape)),\n \"index_data\": TensorConfig(data_gen=partial(generate_index))\n }\n\n gather_nd_op = OpConfig(\n type=\"gather_nd\",\n inputs=op_inputs,\n outputs={\"Out\": [\"output_data\"]},\n attrs={\"axis\": 1})\n program_config = ProgramConfig(\n ops=[gather_nd_op],\n weights={},\n inputs=program_inputs,\n outputs=[\"output_data\"])\n return program_config\n\n def sample_predictor_configs(self):\n return self.get_predictor_configs(), [\"gather_nd\"], (1e-5, 1e-5)\n\n def add_ignore_pass_case(self):\n def _teller1(program_config, predictor_config):\n if predictor_config.target() == TargetType.Host:\n in_dtype = program_config.inputs[\"input_data\"].dtype\n #wait for atuo_scan_base bug fix \n if \"float32\" != in_dtype:\n return True\n\n self.add_ignore_check_case(\n _teller1, IgnoreReasons.PADDLELITE_NOT_SUPPORT,\n \"Lite does not support this op in a specific case on host. We need to fix it as soon as possible.\"\n )\n\n def test(self, *args, **kwargs):\n self.run_and_statis(quant=False, max_examples=300)\n\n\nif __name__ == \"__main__\":\n unittest.main(argv=[''])\n",
"# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\nimport sys\nsys.path.append('../')\n\nfrom auto_scan_test import AutoScanTest, IgnoreReasons\nfrom program_config import TensorConfig, ProgramConfig, OpConfig, CxxConfig, TargetType, PrecisionType, DataLayoutType, Place\nimport unittest\n\nimport hypothesis\nfrom hypothesis import given, settings, seed, example, assume, reproduce_failure\nimport hypothesis.strategies as st\nimport numpy as np\nfrom functools import partial\n\n\ndef check_broadcast(x_shape, y_shape, axis):\n if x_shape == y_shape:\n return True\n else:\n x_dims_size = len(x_shape)\n y_dims_size = len(y_shape)\n max_dims_size = max(x_dims_size, y_dims_size)\n if (x_dims_size == y_dims_size):\n # The axis should be -1 or 0 while the dimension of tensor X is equal to the dimension of tensor Y.\n if not (axis == -1 or axis == 0):\n return False\n # The axis should be met [-max(x_dims_size, y_dims_size), max(x_dims_size, y_dims_size))\n if not (axis >= (-max_dims_size) and axis < max_dims_size):\n return False\n if axis < 0:\n axis = abs(x_dims_size - y_dims_size) + axis + 1\n if not (axis >= 0 and axis < max_dims_size):\n return False\n # The axis should be met axis + min(x_dims_size, y_dims_size) <= max(x_dims_size, y_dims_size)\n if axis + min(x_dims_size, y_dims_size) > max_dims_size:\n return False\n x_dims_array = [1 for i in range(max_dims_size)]\n y_dims_array = [1 for i in range(max_dims_size)]\n if x_dims_size > y_dims_size:\n x_dims_array = x_shape\n for i in range(y_dims_size):\n y_dims_array[axis + i] = y_shape[i]\n else:\n y_dims_array = y_shape\n for i in range(x_dims_size):\n x_dims_array[axis + i] = x_shape[i]\n for i in range(max_dims_size):\n broadcast_flag = (x_dims_array[i] == y_dims_array[i]) or (\n x_dims_array[i] <= 1) or (y_dims_array[i] <= 1)\n if not broadcast_flag:\n return False\n return True\n\n\nclass TestElementwiseAddOp(AutoScanTest):\n def __init__(self, *args, **kwargs):\n AutoScanTest.__init__(self, *args, **kwargs)\n self.enable_testing_on_place(\n TargetType.X86,\n PrecisionType.FP32,\n DataLayoutType.NCHW,\n thread=[1, 4])\n self.enable_testing_on_place(\n TargetType.ARM,\n [PrecisionType.FP32, PrecisionType.INT32, PrecisionType.INT64],\n DataLayoutType.NCHW,\n thread=[1, 4])\n opencl_valid_places = [\n Place(TargetType.OpenCL, PrecisionType.FP16,\n DataLayoutType.ImageDefault), Place(\n TargetType.OpenCL, PrecisionType.FP16,\n DataLayoutType.ImageFolder),\n Place(TargetType.OpenCL, PrecisionType.FP32, DataLayoutType.NCHW),\n Place(TargetType.OpenCL, PrecisionType.Any,\n DataLayoutType.ImageDefault), Place(\n TargetType.OpenCL, PrecisionType.Any,\n DataLayoutType.ImageFolder),\n Place(TargetType.OpenCL, PrecisionType.Any, DataLayoutType.NCHW),\n Place(TargetType.Host, PrecisionType.FP32)\n ]\n self.enable_testing_on_place(places=opencl_valid_places)\n metal_places = [\n Place(TargetType.Metal, PrecisionType.FP32,\n DataLayoutType.MetalTexture2DArray),\n Place(TargetType.Metal, PrecisionType.FP16,\n DataLayoutType.MetalTexture2DArray),\n Place(TargetType.ARM, PrecisionType.FP32),\n Place(TargetType.Host, PrecisionType.FP32)\n ]\n self.enable_testing_on_place(places=metal_places)\n\n def is_program_valid(self,\n program_config: ProgramConfig,\n predictor_config: CxxConfig) -> bool:\n target_type = predictor_config.target()\n input_data_type = program_config.inputs[\"input_data_x\"].dtype\n # Check config\n if target_type in [TargetType.ARM]:\n if predictor_config.precision(\n ) == PrecisionType.INT64 and input_data_type != np.int64:\n return False\n if predictor_config.precision(\n ) == PrecisionType.FP32 and input_data_type != np.float32:\n return False\n if predictor_config.precision(\n ) == PrecisionType.FP16 and input_data_type != np.float16:\n return False\n if predictor_config.precision(\n ) == PrecisionType.INT32 and input_data_type != np.int32:\n return False\n return True\n\n def sample_program_configs(self, draw):\n input_data_x_shape = draw(\n st.lists(\n st.integers(\n min_value=1, max_value=20), min_size=1, max_size=4))\n input_data_y_shape = draw(\n st.lists(\n st.integers(\n min_value=1, max_value=20), min_size=1, max_size=4))\n axis = draw(st.integers(min_value=-1, max_value=4))\n assume(\n check_broadcast(input_data_x_shape, input_data_y_shape, axis) ==\n True)\n if axis < 0:\n axis = abs(len(input_data_x_shape) - len(\n input_data_y_shape)) + axis + 1\n\n if self.get_target().upper() == 'X86':\n input_data_type = draw(\n st.sampled_from([np.float32, np.int32, np.int64]))\n elif self.get_target().upper() == 'ARM':\n input_data_type = draw(\n st.sampled_from([np.float32, np.int32, np.int64]))\n elif self.get_target().upper() == 'OPENCL':\n input_data_type = draw(st.sampled_from([np.float32]))\n elif self.get_target().upper() == 'METAL':\n input_data_type = draw(st.sampled_from([np.float32]))\n\n def gen_input_data(*args, **kwargs):\n return np.random.randint(\n 1, 20, size=(kwargs['shape'])).astype(kwargs['dtype'])\n\n elementwise_add_op = OpConfig(\n type=\"elementwise_add\",\n inputs={\"X\": [\"input_data_x\"],\n \"Y\": [\"input_data_y\"]},\n outputs={\"Out\": [\"output_data\"]},\n attrs={\"axis\": axis})\n program_config = ProgramConfig(\n ops=[elementwise_add_op],\n weights={},\n inputs={\n \"input_data_x\": TensorConfig(data_gen=partial(\n gen_input_data,\n shape=input_data_x_shape,\n dtype=input_data_type)),\n \"input_data_y\": TensorConfig(data_gen=partial(\n gen_input_data,\n shape=input_data_y_shape,\n dtype=input_data_type))\n },\n outputs=[\"output_data\"])\n return program_config\n\n def sample_predictor_configs(self):\n return self.get_predictor_configs(), [\"elementwise_add\"], (1e-5, 1e-5)\n\n def add_ignore_pass_case(self):\n def _teller1(program_config, predictor_config):\n target_type = predictor_config.target()\n input_data_type = program_config.inputs[\"input_data_x\"].dtype\n in_x_shape = list(program_config.inputs[\"input_data_x\"].shape)\n in_y_shape = list(program_config.inputs[\"input_data_y\"].shape)\n if target_type == TargetType.Metal:\n if input_data_type != np.float32 \\\n or in_x_shape != in_y_shape \\\n or len(in_x_shape) == 3 \\\n or in_x_shape[0] != 1:\n return True\n\n def _teller2(program_config, predictor_config):\n target_type = predictor_config.target()\n input_data_type = program_config.inputs[\"input_data_x\"].dtype\n if target_type == TargetType.ARM:\n if input_data_type == np.int64:\n return True\n\n self.add_ignore_check_case(\n _teller1, IgnoreReasons.PADDLELITE_NOT_SUPPORT,\n \"Lite does not support this op in a specific case on metal. We need to fix it as soon as possible.\"\n )\n self.add_ignore_check_case(\n _teller2, IgnoreReasons.PADDLELITE_NOT_SUPPORT,\n \"Elementwise_add op on this backend will crash with int64 dtype, we should fix it as soon as possible!\"\n )\n\n def test(self, *args, **kwargs):\n target_str = self.get_target()\n max_examples = 150\n if target_str == \"OpenCL\":\n # Make sure to generate enough valid cases for OpenCL\n max_examples = 300\n if target_str == \"Metal\":\n # Make sure to generate enough valid cases for Metal\n max_examples = 2000\n self.run_and_statis(quant=False, max_examples=max_examples)\n\n\nif __name__ == \"__main__\":\n unittest.main(argv=[''])\n"
] |
[
[
"numpy.array",
"numpy.random.random",
"numpy.random.randint"
],
[
"numpy.random.randint"
]
] |
yu-efremov/ViscoIndent
|
[
"b9658509fdf9ed232cf682cb554f668572735e4d",
"b9658509fdf9ed232cf682cb554f668572735e4d"
] |
[
"bottom_effect_correction.py",
"selection_windows_common_gui.py"
] |
[
"# -*- coding: utf-8 -*-\r\n\"\"\"\r\n@author: Yuri Efremov\r\nbottom effect correction coefficients\r\n\"\"\"\r\nimport numpy as np\r\nfrom numpy import pi\r\n\r\n\r\ndef bottom_effect_correction(Poisson, Probe_dimension, Height, modelprobe,\r\n indentationfull):\r\n BEC = np.ones(len(indentationfull))\r\n indentationfull[indentationfull < 0] = np.nan # to remove warnings in sqrt\r\n if 0.45 <= Poisson <= 0.5: # coefficients from doi.org/10.1016/j.bpj.2018.05.012\r\n if modelprobe == 'sphere': # sphere\r\n Dpar1 = 1.133\r\n Dpar2 = 1.497\r\n Dpar3 = 1.469\r\n Dpar4 = 0.755\r\n R = Probe_dimension\r\n h = Height\r\n BEC = 1 + (Dpar1*(R*indentationfull)**(0.5)/h) +\\\r\n (Dpar2*((R*indentationfull)**(0.5)/h)**2) +\\\r\n (Dpar3*((R*indentationfull)**(0.5)/h)**3) +\\\r\n (Dpar4*((R*indentationfull)**(0.5)/h)**4)\r\n\r\n BECspeed = 1 + 4/3*(Dpar1*(R*indentationfull)**(0.5)/h) +\\\r\n 5/3*(Dpar2*((R*indentationfull)**(0.5)/h)**2) +\\\r\n 2*(Dpar3*((R*indentationfull)**(0.5)/h)**3) +\\\r\n 7/3*(Dpar4*((R*indentationfull)**(0.5)/h)**4)\r\n\r\n elif modelprobe in ['pyramid', 'cylinder']:\r\n # in the curent version of the script the correction is not yet implemented\r\n BEC = np.ones(len(indentationfull))\r\n BECspeed = np.ones(len(indentationfull))\r\n print('BEC is not yet avilable')\r\n\r\n else:\r\n if modelprobe == 'sphere':\r\n # coefficients are from doi.org/10.1016/S0006-3495(02)75620-8\r\n alpha = -(1.2876-1.4678*Poisson+1.3442*Poisson^2)/(1-Poisson) # bonded case\r\n bettaD = (0.6387-1.0277*Poisson+1.5164*Poisson^2)/(1-Poisson) # bonded case\r\n Dpar1 = 2*alpha/pi\r\n Dpar2 = 4*(alpha/pi)**2\r\n Dpar3 = (8/pi**3)*(alpha**3+(4*(pi**2)*bettaD/15))\r\n Dpar4 = -(16*alpha/pi**4)*(alpha**3+(3*(pi**2)*bettaD/5))\r\n R = Radius\r\n h = Height\r\n BEC = 1 + (Dpar1*(R*indentationfull)**(0.5)/h) +\\\r\n (Dpar2*((R*indentationfull)**(0.5)/h)**2) +\\\r\n (Dpar3*((R*indentationfull)**(0.5)/h)**3) +\\\r\n (Dpar4*((R*indentationfull)**(0.5)/h)**4)\r\n\r\n BECspeed = 1 + 4/3*(Dpar1*(R*indentationfull)**(0.5)/h) +\\\r\n 5/3*(Dpar2*((R*indentationfull)**(0.5)/h)**2) +\\\r\n 2*(Dpar3*((R*indentationfull)**(0.5)/h)**3) +\\\r\n 7/3*(Dpar4*((R*indentationfull)**(0.5)/h)**4)\r\n\r\n elif modelprobe in ['pyramid', 'cylinder']:\r\n # in the curent version of the script the correction is not yet implemented\r\n BEC = np.ones(len(indentationfull))\r\n BECspeed = np.ones(len(indentationfull))\r\n print('BEC is not yet avilable')\r\n\r\n return BEC, BECspeed\r\n\r\n\r\nif __name__ == '__main__':\r\n import matplotlib.pyplot as plt\r\n Poisson = 0.5\r\n Radius = 1000\r\n Height = 1000\r\n modelprobe = 'sphere'\r\n indentationfull = np.linspace(0, 200, 200)\r\n BEC = bottom_effect_correction(Poisson, Radius, Height, modelprobe, indentationfull)[0]\r\n plt.plot(indentationfull, BEC)\r\n",
"# -*- coding: utf-8 -*-\r\n\"\"\"\r\n@author: Yuri\r\n\"\"\"\r\n\r\nimport sys\r\nfrom PyQt5.QtWidgets import QMainWindow, QApplication, QWidget, \\\r\n QVBoxLayout, QHBoxLayout, QLabel,\\\r\n QPushButton, QFileDialog\r\n\r\nimport numpy as np\r\n\r\nfrom Pars_class import Pars_gen\r\nfrom import_AFM_data import Bruker_import\r\nfrom import_ARDF import ARDF_import\r\nfrom make_Results import make_Results\r\nfrom utils_ViscoIndent import load_AFM_data_pickle, load_AFM_data_pickle_short\r\n\r\n\r\nclass selection_win1(QMainWindow):\r\n\r\n def __init__(self, parent=None):\r\n super(selection_win1, self).__init__(parent)\r\n self.selection_win1_gui = parent # share variables\r\n if not hasattr(self.selection_win1_gui, 'commongui'):\r\n self.initUI()\r\n\r\n def initUI(self):\r\n\r\n self.btn_loadSPM = QPushButton(\"Load .spm\", self)\r\n self.btn_loadSPM.clicked.connect(self.load_spm)\r\n \r\n self.btn_loadARDF = QPushButton(\"Load .ARDF\", self)\r\n self.btn_loadARDF.clicked.connect(self.load_ardf)\r\n\r\n self.btn_loadDAT = QPushButton(\"Load .dat\", self)\r\n self.btn_loadDAT.clicked.connect(self.load_dat)\r\n\r\n self.btn_loadWorkspace = QPushButton(\"Load from workspace\", self)\r\n self.btn_loadWorkspace.clicked.connect(self.load_workspace)\r\n\r\n self.btn_Exit = QPushButton(\"Exit\", self)\r\n self.btn_Exit.clicked.connect(self.btn_Exit_pressed)\r\n\r\n if 'Data' in globals() or hasattr(self.selection_win1_gui, 'Data'):\r\n print('Data were found in workspace')\r\n strData = 'Data found in workspace. Reuse or open new?'\r\n # choice = QMessageBox.question(msg_box, \"Choose Data\", strData, QMessageBox.Yes | QMessageBox.Open | QMessageBox.Cancel)\r\n else:\r\n print('no Data were found in workspace')\r\n strData = 'Open data file or exit'\r\n self.btn_loadWorkspace.setEnabled(False)\r\n # choice = QMessageBox.question(msg_box, \"Choose Data\", strData, QMessageBox.Open | QMessageBox.Cancel)\r\n self.label_textabove = QLabel(strData)\r\n\r\n self.setGeometry(300, 300, 900, 100)\r\n self.setWindowTitle('Select data to open')\r\n layoutA = QHBoxLayout()\r\n layoutA.addWidget(self.btn_loadSPM)\r\n layoutA.addWidget(self.btn_loadDAT)\r\n layoutA.addWidget(self.btn_loadARDF)\r\n layoutA.addWidget(self.btn_loadWorkspace)\r\n layoutA.addWidget(self.btn_Exit)\r\n layoutM = QVBoxLayout()\r\n layoutM.addWidget(self.label_textabove)\r\n layoutM.addLayout(layoutA)\r\n\r\n widget = QWidget()\r\n widget.setLayout(layoutM)\r\n self.setCentralWidget(widget)\r\n self.show()\r\n self.activateWindow()\r\n\r\n def load_spm(self):\r\n options = QFileDialog.Options()\r\n self.fileName, _ = QFileDialog.getOpenFileName(self, \"QFileDialog.getOpenFileName()\", \"examples/\", \"All Files (*);;Python Files (*.py)\", options=options)\r\n filedir0 = self.fileName\r\n self.supress_ROIquestion = 0\r\n\r\n # filedir0 = 'D:/MailCloud/AFM_data/BrukerResolve/MISIS/20190928_PC3_MMAE_ACALold2/area1-01.0_00000.spm'\r\n # filedir0 = 'examples/Bruker_forcevolume_cells.spm'\r\n fnameshort = filedir0.split(\"/\")\r\n fnameshort = fnameshort[-1]\r\n Pars = Pars_gen()\r\n Pars.probe_shape = 'sphere'\r\n Pars.probe_dimension = 5000\r\n Pars.Poisson = 0.5 # Poisson's ratio of the sample\r\n Pars.dT = 1e-3 # Sampling time\r\n Pars.height = 0\r\n Pars.HeightfromZ = 0\r\n Pars.viscomodel = 'elastic'\r\n Pars.hydro.corr = 1\r\n Pars.hydro.corr_type = 2\r\n Pars.hydro.speedcoef = 4.0e-7\r\n Pars.cp_adjust = 1\r\n\r\n Pars.filedir = []\r\n Pars.filedir.append(filedir0)\r\n Pars.fnameshort = []\r\n Pars.fnameshort.append(fnameshort)\r\n self.Data = {}\r\n Bruker_data = Bruker_import(Pars)\r\n print('data loaded from file')\r\n self.Data = Bruker_data.Data\r\n self.Pars = Bruker_data.Pars\r\n self.Results = make_Results(np.shape(self.Data)[0])\r\n print(self.Data[0])\r\n self.Results.Pixel = self.Data[:, 0] # remove nans\r\n if hasattr(self.selection_win1_gui, 'commongui'):\r\n self.selection_win1_gui.Pars = self.Pars\r\n self.selection_win1_gui.Data = self.Data\r\n self.selection_win1_gui.Results = self.Results\r\n self.close()\r\n self.selection_win1_gui.initUI2()\r\n \r\n def load_ardf(self):\r\n options = QFileDialog.Options()\r\n self.fileName, _ = QFileDialog.getOpenFileName(self, \"QFileDialog.getOpenFileName()\", \"examples/\", \"All Files (*);;Python Files (*.py)\", options=options)\r\n filedir0 = self.fileName\r\n self.supress_ROIquestion = 0\r\n\r\n # filedir0 = 'D:/MailCloud/AFM_data/BrukerResolve/MISIS/20190928_PC3_MMAE_ACALold2/area1-01.0_00000.spm'\r\n # filedir0 = 'examples/Bruker_forcevolume_cells.spm'\r\n fnameshort = filedir0.split(\"/\")\r\n fnameshort = fnameshort[-1]\r\n Pars = Pars_gen()\r\n Pars.probe_shape = 'sphere'\r\n Pars.probe_dimension = 5000\r\n Pars.Poisson = 0.5 # Poisson's ratio of the sample\r\n Pars.dT = 1e-3 # Sampling time\r\n Pars.height = 0\r\n Pars.HeightfromZ = 0\r\n Pars.viscomodel = 'elastic'\r\n Pars.hydro.corr = 1\r\n Pars.hydro.corr_type = 2\r\n Pars.hydro.speedcoef = 4.0e-7\r\n Pars.cp_adjust = 1\r\n\r\n Pars.filedir = []\r\n Pars.filedir.append(filedir0)\r\n Pars.fnameshort = []\r\n Pars.fnameshort.append(fnameshort)\r\n self.Data = {}\r\n [Pars, Data] = ARDF_import(Pars)\r\n print('data loaded from ARDF file')\r\n self.Data = Data\r\n self.Pars = Pars\r\n self.Results = make_Results(np.shape(self.Data)[0])\r\n print(self.Data[0])\r\n self.Results.Pixel = self.Data[:, 0] # remove nans\r\n if hasattr(self.selection_win1_gui, 'commongui'):\r\n self.selection_win1_gui.Pars = self.Pars\r\n self.selection_win1_gui.Data = self.Data\r\n self.selection_win1_gui.Results = self.Results\r\n self.close()\r\n self.selection_win1_gui.initUI2() \r\n\r\n def load_dat(self):\r\n print('load dat')\r\n options = QFileDialog.Options()\r\n self.fileName, _ = QFileDialog.getOpenFileName(self, \"QFileDialog.getOpenFileName()\", \"examples/\", \"All Files (*.dat);;Python Files (*.py)\", options=options)\r\n\r\n # self.Pars, self.Data, self.Results = load_AFM_data_pickle(self.fileName)\r\n\r\n self.Pars, self.Data, self.Results = load_AFM_data_pickle_short(self.fileName)\r\n # self.supress_ROIquestion = 1\r\n if hasattr(self.selection_win1_gui, 'commongui'):\r\n self.selection_win1_gui.Pars = self.Pars\r\n self.selection_win1_gui.Data = self.Data\r\n self.selection_win1_gui.Results = self.Results\r\n self.selection_win1_gui.supress_ROIquestion = 1\r\n self.close()\r\n self.selection_win1_gui.initUI2()\r\n\r\n def load_workspace(self):\r\n self.supress_ROIquestion = 1\r\n if 'Data' in globals(): # and choice == QMessageBox.Yes:\r\n print('here1')\r\n global Pars, Results, Data\r\n if 'Results' not in globals():\r\n self.Results = make_Results(np.shape(Data)[0])\r\n else:\r\n self.Results = Results\r\n self.Data = Data\r\n self.Pars = Pars\r\n self.close()\r\n elif hasattr(self.selection_win1_gui, 'Data'):\r\n self.Pars = self.selection_win1_gui.Pars\r\n self.Data = self.selection_win1_gui.Data\r\n self.Results = self.selection_win1_gui.Results\r\n self.selection_win1_gui.supress_ROIquestion = 1\r\n self.close()\r\n self.selection_win1_gui.initUI2()\r\n\r\n def btn_Exit_pressed(self):\r\n self.close()\r\n\r\n def closeEvent(self, event):\r\n\r\n if not hasattr(self.selection_win1_gui, 'commongui'):\r\n if hasattr(self, 'Pars'):\r\n global Pars, Data, Results\r\n Pars = self.Pars\r\n Data = self.Data\r\n Results = self.Results\r\n print('module exit')\r\n QApplication.quit()\r\n else:\r\n if hasattr(self, 'Pars'):\r\n self.selection_win1_gui.Pars = self.Pars\r\n self.selection_win1_gui.Data = self.Data\r\n self.selection_win1_gui.Results = self.Results\r\n else:\r\n self.selection_win1_gui.supress_ROIquestion = 1\r\n # self.selection_win1_gui.curveviewer()\r\n # print('module_PLpart_finished')\r\n # self.close()\r\n # self.selection_win1_gui.close() # initUI2\r\n print('module_PLpart_finished')\r\n\r\n\r\nif __name__ == '__main__':\r\n try:\r\n del app\r\n except:\r\n print('noapp')\r\n\r\n app = QApplication(sys.argv)\r\n main = selection_win1()\r\n main.show()\r\n sys.exit(app.exec_())\r\n"
] |
[
[
"matplotlib.pyplot.plot",
"numpy.linspace"
],
[
"numpy.shape"
]
] |
brauliotegui/DEMAND
|
[
"ffe0180a0a45b6a9aa5b800b8d2c43cf45f31997"
] |
[
"linear_model.py"
] |
[
"\"\"\"\nRidge model for predicting bike rental demand for Capital Bike Share\nin Washington D.C.\n\"\"\"\nimport pandas as pd\nfrom scipy import stats\nimport numpy as np\n\nfrom sklearn.pipeline import make_pipeline\nfrom sklearn.preprocessing import PolynomialFeatures\nfrom sklearn.linear_model import Ridge\n\nDF = pd.read_csv('train_dataset.csv')\n\ndef create_timefs(df):\n \"\"\"\n Creates hour and month column in the dataframe\n \"\"\"\n df = df.copy()\n df['hour'] = pd.to_datetime(df['datetime']).dt.hour\n df['month'] = pd.to_datetime(df['datetime']).dt.month\n return df\n\nDF = create_timefs(DF)\nDF = DF.drop(['datetime'], axis=1)\nz = np.abs(stats.zscore(DF))\nDF = DF[(z < 3).all(axis=1)]\n\nfeature_list = ['temp', 'atemp', 'workingday', 'hour', 'month',\n 'weather', 'humidity']\ny = np.log1p(DF[\"count\"])\n\nX_train = (DF[feature_list])\ny_train = y\n\nlinear_m = make_pipeline(PolynomialFeatures(degree=8), Ridge(max_iter=3000, alpha=0.0001, normalize=True))\nlinear_m.fit(X_train, y_train)\n"
] |
[
[
"pandas.read_csv",
"pandas.to_datetime",
"scipy.stats.zscore",
"sklearn.preprocessing.PolynomialFeatures",
"sklearn.linear_model.Ridge",
"numpy.log1p"
]
] |
dashmoment/moxa_ai_training
|
[
"675a6b208ed130e92a0d49be8ad27e4bd1a98813"
] |
[
"CNN_HW_solution/utility/utility.py"
] |
[
"import numpy as np\nimport random\nimport tensorflow as tf\n\ndef ramdom_batch(data_length, batch_size):\n fid_list = list(range(data_length))\n random.shuffle(fid_list) \n datapool = []\n \n for i in range(data_length//batch_size):\n datapool.append(fid_list[i*batch_size:i*batch_size + batch_size])\n \n \n return datapool\n\n\ndef print_operations_in_graph():\n \n graph = tf.get_default_graph()\n \n for op in graph.get_operations(): print(op.name)\n \n \ndef clac_accuracy(logits, labels, eval=False):\n \n with tf.name_scope('accuracy'):\n predict_model = tf.argmax(tf.nn.softmax(logits),1)\n true_label = tf.argmax(labels,1) \n\n if eval == True:\n true_positive = tf.reduce_sum(tf.cast(tf.equal(predict_model, true_label), tf.int32)) \n else:\n true_positive = tf.reduce_mean(tf.cast(tf.equal(predict_model, true_label), tf.float32))\n \n return true_positive"
] |
[
[
"tensorflow.nn.softmax",
"tensorflow.equal",
"tensorflow.name_scope",
"tensorflow.get_default_graph",
"tensorflow.argmax"
]
] |
louay-rouabeh/Energy-Management-Live-Dashboard
|
[
"cf321b99119bef252c6f6dee0f07bb8254a91149"
] |
[
"project/GroundFloor.py"
] |
[
"import dash_core_components as dcc\nimport dash_html_components as html\nimport pandas as pd\nfrom dash.dependencies import Output, Input\nfrom app import app\nfrom dash_extensions import Download\nfrom dash_extensions.snippets import send_data_frame\n\nground = pd.read_excel(\"consumption.xlsx\", \"Sheet1\")\n\ncontent0 = html.Div([html.Button(\"Download\", id=\"btn\"), Download(id=\"download\"), dcc.Graph(\n figure=dict(\n data=[\n dict(\n x=ground['Month'],\n y=ground['consumption'],\n name='2019',\n marker=dict(\n color='rgb(55, 83, 109)'\n )\n ),\n\n ],\n layout=dict(\n title='consumption ',\n showlegend=True,\n legend=dict(\n x=0,\n y=1.0\n ),\n margin=dict(l=40, r=0, t=40, b=30)\n )\n ),\n style={'height': 300},\n id='my-graph'\n)])\n\n\n\n\n@app.callback(Output(\"download\", \"data\"), [Input(\"btn\", \"n_clicks\")])\ndef func(n_clicks):\n return send_data_frame(ground.to_csv, \"groundFloor.csv\", index=False)\n"
] |
[
[
"pandas.read_excel"
]
] |
ivallesp/abs
|
[
"8a250cdab230ec2420e3d22eb3dfae67642430bd"
] |
[
"src/metrics.py"
] |
[
"import numpy as np\nfrom scipy.special import softmax\n\n\ndef accuracy(y_true, y_pred):\n pred_labels = y_pred.argmax(axis=1)\n hits = y_true == pred_labels\n assert len(hits.shape) == 1\n return hits.mean()\n\n\ndef crossentropy(y_true, y_pred, eps=1e-9):\n y_pred = softmax(y_pred, axis=1)\n mask = np.eye(y_pred.shape[1])[y_true]\n p = np.sum(y_pred * mask, axis=1)\n return -np.log(np.clip(p, eps, 1 - eps)).mean()\n"
] |
[
[
"numpy.eye",
"scipy.special.softmax",
"numpy.sum",
"numpy.clip"
]
] |
nishaq503/polus-plugins-dl
|
[
"511689e82eb29a84761538144277d1be1af7aa44"
] |
[
"polus-cell-nuclei-segmentation/src/dsb2018_topcoders/albu/src/pytorch_zoo/inplace_abn/modules/bn.py"
] |
[
"from collections import OrderedDict, Iterable\r\nfrom itertools import repeat\r\n\r\ntry:\r\n # python 3\r\n from queue import Queue\r\nexcept ImportError:\r\n # python 2\r\n from Queue import Queue\r\n\r\nimport torch\r\nimport torch.nn as nn\r\nimport torch.autograd as autograd\r\n\r\ntry:\r\n from .functions import inplace_abn, inplace_abn_sync\r\nexcept ImportError:\r\n print(\"please compile abn\")\r\n\r\n\r\ndef _pair(x):\r\n if isinstance(x, Iterable):\r\n return x\r\n return tuple(repeat(x, 2))\r\n\r\n\r\nclass ABN(nn.Sequential):\r\n \"\"\"Activated Batch Normalization\r\n\r\n This gathers a `BatchNorm2d` and an activation function in a single module\r\n \"\"\"\r\n\r\n def __init__(self, num_features, activation=nn.ReLU(inplace=True), **kwargs):\r\n \"\"\"Creates an Activated Batch Normalization module\r\n\r\n Parameters\r\n ----------\r\n num_features : int\r\n Number of feature channels in the input and output.\r\n activation : nn.Module\r\n Module used as an activation function.\r\n kwargs\r\n All other arguments are forwarded to the `BatchNorm2d` constructor.\r\n \"\"\"\r\n super(ABN, self).__init__(OrderedDict([\r\n (\"bn\", nn.BatchNorm2d(num_features, **kwargs)),\r\n (\"act\", activation)\r\n ]))\r\n\r\n\r\nclass InPlaceABN(nn.Module):\r\n \"\"\"InPlace Activated Batch Normalization\"\"\"\r\n\r\n def __init__(self, num_features, eps=1e-5, momentum=0.1, affine=True, activation=\"leaky_relu\", slope=0.01):\r\n \"\"\"Creates an InPlace Activated Batch Normalization module\r\n\r\n Parameters\r\n ----------\r\n num_features : int\r\n Number of feature channels in the input and output.\r\n eps : float\r\n Small constant to prevent numerical issues.\r\n momentum : float\r\n Momentum factor applied to compute running statistics as.\r\n affine : bool\r\n If `True` apply learned scale and shift transformation after normalization.\r\n activation : str\r\n Name of the activation functions, one of: `leaky_relu`, `elu` or `none`.\r\n slope : float\r\n Negative slope for the `leaky_relu` activation.\r\n \"\"\"\r\n super(InPlaceABN, self).__init__()\r\n self.num_features = num_features\r\n self.affine = affine\r\n self.eps = eps\r\n self.momentum = momentum\r\n self.activation = activation\r\n self.slope = slope\r\n if self.affine:\r\n self.weight = nn.Parameter(torch.Tensor(num_features))\r\n self.bias = nn.Parameter(torch.Tensor(num_features))\r\n else:\r\n self.register_parameter('weight', None)\r\n self.register_parameter('bias', None)\r\n self.register_buffer('running_mean', torch.zeros(num_features))\r\n self.register_buffer('running_var', torch.ones(num_features))\r\n self.reset_parameters()\r\n\r\n def reset_parameters(self):\r\n self.running_mean.zero_()\r\n self.running_var.fill_(1)\r\n if self.affine:\r\n self.weight.data.fill_(1)\r\n self.bias.data.zero_()\r\n\r\n def forward(self, x):\r\n return inplace_abn(x, self.weight, self.bias, autograd.Variable(self.running_mean),\r\n autograd.Variable(self.running_var), self.training, self.momentum, self.eps,\r\n self.activation, self.slope)\r\n\r\n def __repr__(self):\r\n rep = '{name}({num_features}, eps={eps}, momentum={momentum},' \\\r\n ' affine={affine}, activation={activation}'\r\n if self.activation == \"leaky_relu\":\r\n rep += ' slope={slope})'\r\n else:\r\n rep += ')'\r\n return rep.format(name=self.__class__.__name__, **self.__dict__)\r\n\r\n\r\nclass InPlaceABNSync(nn.Module):\r\n \"\"\"InPlace Activated Batch Normalization with cross-GPU synchronization\r\n\r\n This assumes that it will be replicated across GPUs using the same mechanism as in `nn.DataParallel`.\r\n \"\"\"\r\n\r\n def __init__(self, num_features, devices=None, eps=1e-5, momentum=0.1, affine=True, activation=\"leaky_relu\",\r\n slope=0.01):\r\n \"\"\"Creates a synchronized, InPlace Activated Batch Normalization module\r\n\r\n Parameters\r\n ----------\r\n num_features : int\r\n Number of feature channels in the input and output.\r\n devices : list of int or None\r\n IDs of the GPUs that will run the replicas of this module.\r\n eps : float\r\n Small constant to prevent numerical issues.\r\n momentum : float\r\n Momentum factor applied to compute running statistics as.\r\n affine : bool\r\n If `True` apply learned scale and shift transformation after normalization.\r\n activation : str\r\n Name of the activation functions, one of: `leaky_relu`, `elu` or `none`.\r\n slope : float\r\n Negative slope for the `leaky_relu` activation.\r\n \"\"\"\r\n super(InPlaceABNSync, self).__init__()\r\n self.num_features = num_features\r\n self.devices = devices if devices else list(range(torch.cuda.device_count()))\r\n self.affine = affine\r\n self.eps = eps\r\n self.momentum = momentum\r\n self.activation = activation\r\n self.slope = slope\r\n if self.affine:\r\n self.weight = nn.Parameter(torch.Tensor(num_features))\r\n self.bias = nn.Parameter(torch.Tensor(num_features))\r\n else:\r\n self.register_parameter('weight', None)\r\n self.register_parameter('bias', None)\r\n self.register_buffer('running_mean', torch.zeros(num_features))\r\n self.register_buffer('running_var', torch.ones(num_features))\r\n self.reset_parameters()\r\n\r\n # Initialize queues\r\n self.worker_ids = self.devices[1:]\r\n self.master_queue = Queue(len(self.worker_ids))\r\n self.worker_queues = [Queue(1) for _ in self.worker_ids]\r\n\r\n def reset_parameters(self):\r\n self.running_mean.zero_()\r\n self.running_var.fill_(1)\r\n if self.affine:\r\n self.weight.data.fill_(1)\r\n self.bias.data.zero_()\r\n\r\n def forward(self, x):\r\n if x.get_device() == self.devices[0]:\r\n # Master mode\r\n extra = {\r\n \"is_master\": True,\r\n \"master_queue\": self.master_queue,\r\n \"worker_queues\": self.worker_queues,\r\n \"worker_ids\": self.worker_ids\r\n }\r\n else:\r\n # Worker mode\r\n extra = {\r\n \"is_master\": False,\r\n \"master_queue\": self.master_queue,\r\n \"worker_queue\": self.worker_queues[self.worker_ids.index(x.get_device())]\r\n }\r\n\r\n return inplace_abn_sync(x, self.weight, self.bias, autograd.Variable(self.running_mean),\r\n autograd.Variable(self.running_var), extra, self.training, self.momentum, self.eps,\r\n self.activation, self.slope)\r\n\r\n def __repr__(self):\r\n rep = '{name}({num_features}, eps={eps}, momentum={momentum},' \\\r\n ' affine={affine}, devices={devices}, activation={activation}'\r\n if self.activation == \"leaky_relu\":\r\n rep += ' slope={slope})'\r\n else:\r\n rep += ')'\r\n return rep.format(name=self.__class__.__name__, **self.__dict__)\r\n\r\n\r\nclass InPlaceABNWrapper(nn.Module):\r\n \"\"\"Wrapper module to make `InPlaceABN` compatible with `ABN`\"\"\"\r\n\r\n def __init__(self, *args, **kwargs):\r\n super(InPlaceABNWrapper, self).__init__()\r\n self.bn = InPlaceABN(*args, **kwargs)\r\n\r\n def forward(self, input):\r\n return self.bn(input)\r\n\r\n\r\nclass InPlaceABNSyncWrapper(nn.Module):\r\n \"\"\"Wrapper module to make `InPlaceABNSync` compatible with `ABN`\"\"\"\r\n\r\n def __init__(self, *args, **kwargs):\r\n super(InPlaceABNSyncWrapper, self).__init__()\r\n self.bn = InPlaceABNSync(*args, **kwargs)\r\n\r\n def forward(self, input):\r\n return self.bn(input)\r\n"
] |
[
[
"torch.ones",
"torch.Tensor",
"torch.zeros",
"torch.cuda.device_count",
"torch.nn.BatchNorm2d",
"torch.nn.ReLU",
"torch.autograd.Variable"
]
] |
vnpavanelli/SimpleITK
|
[
"63e6dbcf17b0f5233a872cc0d0b778923d9ca365"
] |
[
"Utilities/Statistics/download_stats.py"
] |
[
"#!/usr/bin/env python\n\n\n# /files/some/path/stats/json\n\nfrom __future__ import print_function\nimport requests\nimport json\nimport datetime\n\nimport pandas as pd\nimport numpy as np\n\nimport cartopy.crs as ccrs\nimport cartopy.feature as cf\nimport cartopy.io.shapereader as shpreader\n\nimport matplotlib.pyplot as plt\nimport matplotlib as mpl\nimport matplotlib.patches as mpatches\n\nmpl.style.use('ggplot')\n\n\ndef get_sourceforge_stats(project,\n start_date,\n end_date=datetime.date.today(),\n path=\"/\"):\n\n \"\"\"\n \"\"\"\n\n # Get download statistics from SourceForge\n #\n # The API uses URLs very similar to the existing stats URLs. Here's an example:\n # https://sourceforge.net/projects/openofficeorg.mirror/files/stats/json?start_date=2014-10-29&end_date=2014-11-04\n #\n # The url parameters start_date and end_date are required and must be\n # dates in YYYY-MM-DD format. To access project-wide stats, use\n # /files/stats/json in the URL. To limit to a file or folder, use\n # /files/some/path/stats/json\n\n print(\"start_date: {0}\".format(start_date))\n query_url=\"https://sourceforge.net/projects/{0}/files/{1}/stats/json?start_date={2}&end_date={3}\".format(project,\n path,\n start_date.isoformat(),\n end_date.isoformat())\n print(\"Query: \\\"{0}\\\"...\".format(query_url))\n r = requests.get(query_url)\n\n if r.status_code == requests.codes.ok:\n return json.loads(r.text)\n else:\n r.raise_for_status()\n\n\n#project=\"itk\"\n#path=\"itk\"\n\nproject=\"simpleitk\"\npath=\"SimpleITK\"\nstart_date=datetime.date(2013,1,1)\nend_date=datetime.date.today() - datetime.timedelta(days=1)\n\n\n# Load the JSON data into a nested dictionary structure\nsf_json = get_sourceforge_stats(project,\n start_date,\n end_date,\n path)\n\n\n# Load the downloads over time into a Pandas Series\nsf_dbym = pd.DataFrame(sf_json[\"downloads\"])\nsf_dbym.columns=[\"Date\",\"Download Count\"]\nsf_dbym.set_index(sf_dbym.columns[0],inplace=True)\nsf_dbym.index = pd.to_datetime(sf_dbym.index)\n\nsf_dbym.plot(kind='area')\nplt.title(\"SimpleITK SourceForge Downloads\")\nplt.ylabel(\"Downloads per Month\")\nplt.show()\n\n\n# load the country, OS download counts into a DataFrame, from json\n# the json field \"oses_by_country\" is a dict of countries indexing a dict of OSes and download\ncbo_df = pd.DataFrame([v for (k,v) in sf_json[\"oses_by_country\"].items()], index=sf_json[\"oses_by_country\"].keys())\ncbo_df.index.name=\"Country\"\ncbo_df.fillna(0,inplace=True)\ncbo_df = cbo_df.astype(int)\n\n# sort the data frame with the most popular country and OS at 0 (upper left)\ncbo_df = cbo_df.loc[cbo_df.sum(axis=1).sort_values(ascending=False).index]\ncbo_df = cbo_df[cbo_df.sum(axis=0).sort_values(ascending=False).index]\nprint(cbo_df)\n\n\n# Graph OSes\n# TODO: Combine OSes into a \"Other\" group\nos_series= cbo_df.sum(axis=0).sort_values(ascending=False)\nos_series.name = \"OS\"\nos_series.plot(kind='pie',\n autopct='%1.1f%%',\n title=\"SourceForge Downloads by OS\")\nplt.show()\n\n\n# Graph countries with pie Chart\ntotal = cbo_df.sum(axis=1).sum()\npercent = 0.80\nbool_index = cbo_df.sum(axis=1).sort_values(ascending=False).cumsum()/total<percent\ndf = cbo_df.loc[bool_index].copy()\ndf.loc[\"Other\"] = cbo_df.loc[~(bool_index)].sum(axis=0)\nprint(df)\ndf.sum(axis=1).plot(kind='pie',\n autopct='%1.1f%%',\n title=\"Downloads by Country\")\nplt.show();\n\n#\n# Cartography plot of downloads by country\n#\nc_series = cbo_df.sum(axis=1)\nc_series = c_series.sort_values(ascending=False)\ncmap = mpl.cm.OrRd\n\nmax_dl = float(c_series.max())\nmin_dl = float(c_series.min())\n\nnorm = mpl.colors.LogNorm(vmin=min_dl, vmax=max_dl)\ntotal_users = c_series.sum()\nshapename = 'admin_0_countries'\ncountries_shp = shpreader.natural_earth(resolution='110m', category='cultural', name=shapename)\n\nplt.figure(figsize=(14,8))\nax = plt.axes(projection=ccrs.Robinson() )\nax.add_feature(cf.BORDERS)\nax.add_feature(cf.COASTLINE)\n#ax.add_feature(cf.OCEAN)\n#ax.add_feature(cf.LAND)\n\nhdl_dict = dict()\n\nfor country in shpreader.Reader(countries_shp).records():\n name = country.attributes['name_long']\n if name in c_series:\n num_users = c_series[name]\n hdl = ax.add_geometries(country.geometry, ccrs.PlateCarree(),\n facecolor=cmap(norm(num_users),alpha=True))\n hdl_dict[name] = hdl\n\n# Add ColorBar\nsm = plt.cm.ScalarMappable(cmap=cmap,norm=norm)\nsm._A = [] # WHAT? DANGER\nplt.colorbar(sm,ax=ax)\nplt.title(\"Source Forge Downloads by Country\\n{0} to {1}\".format(start_date, end_date))\n\n# Add Legend\ncnt = (cbo_df.sum(axis=1).sort_values(ascending=False).cumsum()/total < percent).sum()\n\np = [ mpatches.Patch(color=cmap(norm(v)), label=\"{0} ({1})\".format(k,v)) for (k,v) in c_series[0:cnt].iteritems()]\nplt.legend(handles=p,\n loc=3, fancybox=True)\nplt.savefig(\"{0}_CountriesCarto_{1}_{2}.pdf\".format(project,start_date, end_date), format='pdf')\nplt.show()\n\n##################################################\n#\n# PyPI Download Statistics - via Google BigData Query\n#\n#\n\"\"\"\nSELECT\n STRFTIME_UTC_USEC(timestamp, \"%Y-%m\") AS yyyymm,\n COUNT(*) as download_count\nFROM\n TABLE_DATE_RANGE(\n [the-psf:pypi.downloads],\n DATE_ADD(CURRENT_TIMESTAMP(), -12, \"month\"),\n CURRENT_TIMESTAMP()\n )\nWHERE\n file.project = 'simpleitk' and details.installer.name != 'bandersnatch'\nGROUP BY\n yyyymm, file.version,\nORDER BY\n yyyymm DESC, download_count DESC\nLIMIT 100\n\"\"\"\n#\n##################################################\n\npypi_ = pd.read_csv(\"psf-pypi-downloads-simpleitk-query.csv\")\nprint(df)\n\n# Load query results into a data frame\ndf[\"yyyymm\"] = pd.to_datetime(df[\"yyyymm\"], format=(\"%Y-%m\") )\ndf = df.pivot(index='yyyymm', columns='file_version', values='download_count')\ndf.index.name = \"Date\"\ndf.columns.name = \"Version\"\ndf.fillna(0,inplace=True)\ndf = df.astype(int)\nprint(df)\nprint(\"Total PyPI Downloads: {0}\".format(df.sum(axis=1).sum()))\n\n# Plot the PyPI downloads of different versions\ndf.plot(kind=\"area\",\n title=\"SimpleITK PyPI Downloads\")\nplt.ylabel(\"Downloads per Month\")\nplt.show()\n\n# Create Series for PyPI downloads by time\ns = df.sum(axis=1)\ns.index.name=\"Date\"\ns.name= \"PyPI Download Count\"\n\n\n# Manually enter dates of tags\ntags = pd.Series({\"2017-04-05\":\"v1.0.0\",\n \"2016-07-27\":\"v0.10.0\",\n \"2015-09-25\":\"v0.9.1\",\n \"2015-05-012\":\"v0.9.0\",\n \"2014-12-19\":\"v0.8.1\",\n \"2014-03-8\":\"v0.8.0\",\n \"2013-11-21\":\"v0.7.1\",\n \"2013-09-30\":\"v0.7.0\",\n \"2013-02-1\":\"v0.6.0\"})\ntags.index = pd.to_datetime(tags.index)\ntags.name = \"Releases\"\n\n\n#\n# Combine SourceForge and PyPI download statistics into Total Downloads\n#\ncombined_df = pd.concat([sf_dbym,pd.DataFrame(s)],axis=1)\ncombined_df.columns = [\"Source Forge Downloads\", combined_df.columns[1]]\n\nplt.figure(figsize=(8,10))\nax = combined_df.plot(kind=\"area\")\n\ni = 1\nfor (date,tag) in tags.iteritems():\n #ax.plot(date, 0, 'o')\n ax.annotate(tag,(date,800), horizontalalignment='left', verticalalignment='center', rotation=90)\n i = i +1\n\nplt.title(\"SimpleITK Downloads\");\nplt.ylabel(\"Downloads per Month\")\n\nplt.savefig(\"{0}_Downloads_{1}_{2}.pdf\".format(project,start_date, end_date), format='pdf')\nplt.show()\n"
] |
[
[
"matplotlib.pyplot.legend",
"pandas.to_datetime",
"matplotlib.colors.LogNorm",
"pandas.read_csv",
"matplotlib.pyplot.title",
"matplotlib.style.use",
"pandas.Series",
"matplotlib.pyplot.figure",
"pandas.DataFrame",
"matplotlib.pyplot.colorbar",
"matplotlib.pyplot.show",
"matplotlib.pyplot.cm.ScalarMappable",
"matplotlib.pyplot.ylabel"
]
] |
LeandroNog/Resolu-o-de-Sistemas-lineares
|
[
"477643d4f9ce60632f5ffeddb45497b5193533fb"
] |
[
"sistemasLineares.py"
] |
[
"#! /usr/bin/env python\n#coding: utf-8\n\nimport numpy as np\nimport timeit\nimport copy\nimport os\n\ndef readFile(fileName):\n data = np.loadtxt(fileName)\n A = np.array(data[:-1])\n b = data[-1]\n return A,b\n\n\ndef substituicoesSucessivas(b,L):\n assert np.allclose(L, np.tril(L)), \"Matriz L não é triangular inferior\"\n n = L.shape[0]\n x = np.zeros(n, dtype=float)\n x[0] = b[0]/L[0,0]\n for i in range(1,n):\n soma = 0\n for j in range(0,i):\n soma = soma + L[i,j]*x[j]\n x[i] = (b[i]-soma)/L[i,i]\n return x\n\n\ndef substituicoesRetroativas(b,U):\n\n assert np.allclose(U, np.triu(U)), \"Matriz L não é triangular superior\"\n n = U.shape[0]\n x = np.zeros(n, dtype=float)\n x[-1] = b[-1]/U[-1,-1]\n for i in range(n-2,-1,-1):\n soma = 0\n for j in range(i+1,n):\n soma = soma + U[i,j]*x[j]\n x[i] = (b[i]-soma)/U[i,i]\n return x\n\n\ndef eliminacaoGauss(b, M):\n n = M.shape[0]\n if(np.allclose(M, np.tril(M))):\n x = substituicoesSucessivas(b,M)\n return b,M,np.zeros((n*n)/2, dtype=float),x\n elif (np.allclose(M, np.triu(M))):\n x = substituicoesRetroativas(b,M)\n return b,M,np.zeros((n*n)/2, dtype=float),x\n\n n = M.shape[0]\n k=0\n\n multiplicadores = np.zeros((n*n)/2, dtype=float)\n n_multiplicadores=0\n for k in range(0,n):\n if (M[k,k]!=0):\n pivo = M[k,k]\n l=0\n while(l+k<n-1):\n multiplicadores[n_multiplicadores] = M[k+1+l,k]/pivo\n n_multiplicadores = n_multiplicadores + 1\n linha_de_cima=M[k]\n j=0\n while (j<n):\n M[k+1+l,j]=M[k+1+l,j]-multiplicadores[n_multiplicadores-1]*linha_de_cima[j]\n j=j+1\n b[k+l+1]= b[k+l+1] - b[k]*multiplicadores[n_multiplicadores-1]\n l=l+1\n else:\n assert(M[k,k]!=0), \"Não é possivel obter a solução por esse método.\"\n x = substituicoesRetroativas(b,M)\n\n return b, M, multiplicadores,x\n\n\ndef decomposicaoLU(b, M):\n\n b1 = copy.copy(b)\n M1 = copy.copy(M)\n\n if(np.allclose(M, np.tril(M))):\n x = substituicoesSucessivas(b,M)\n return x\n elif (np.allclose(M, np.triu(M))):\n x = substituicoesRetroativas(b,M)\n return x\n\n (b1,U,multiplicadores,xx) = eliminacaoGauss(b1,M1)\n n = len(b)\n L= np.zeros((n,n),dtype=float)\n preenchidos=0\n\n for i in range(0,n):\n for j in range (0,n):\n if (i==j): L[i][j]=1\n elif (i>j):\n L[i][j] = multiplicadores[preenchidos]\n preenchidos = preenchidos + 1\n else: L[i][j] =0\n\n y = substituicoesSucessivas(b,L)\n x = substituicoesRetroativas(y,U)\n\n return x\n\n\ndef criterioConvergencia_Linhas(M):\n n = M.shape[0]\n falha=0\n\n for i in range(n):\n soma=0\n for j in range(n):\n if (i!=j):soma = soma+ (M[i][j])\n if (soma/M[i][i]>1): falha =1\n if (falha==1): return False\n else: return True\n\ndef criterioSassenfeld(M):\n n = M.shape[0]\n soma=0\n b= np.ones(n,dtype=float)\n for i in range(1,n):\n soma = soma + abs(M[0][i])\n b[0]= soma/M[0][0]\n for j in range (0,n):\n somal=0\n for l in range (0,n):\n if (l!=j):\n somal= somal + (abs(M[j][l]))*b[l]\n b[j]=somal/M[j][j]\n if (max(b)<1): return True\n else: return False\n\n\ndef gaussJacobi(b,M):\n if ((criterioSassenfeld(M))==False):\n print(\"Aviso: Sistema não passa no teste de convergência de Sassenfeld.\")\n resposta = input(\"Deseja continuar?<s/n>\")\n if (resposta!='s'): return 0\n\n\n elif((criterioConvergencia_Linhas(M))==False):\n print(\"Aviso: Sistema não passa no teste de convergência das linhas.\")\n resposta = input(\"Deseja continuar?<s/n>\")\n if (resposta!='s'): return 0\n\n\n n= M.shape[0]\n x = np.zeros(n, dtype=float)\n xK = np.zeros(n, dtype=float)\n k = 0\n while((k<200)):\n for i in range (0,n):\n soma=0\n for j in range (0,n):\n if (i!=j): soma = soma + M[i][j]*x[j]\n xK[i]=(b[i]-soma)/M[i][i]\n\n x=list(xK)\n k = k +1\n return xK\n\ndef gaussSeidel(b,M):\n if ((criterioSassenfeld(M))==False):\n print(\"Aviso: Sistema não passa no teste de convergência de Sassenfeld.\")\n resposta = input(\"Deseja continuar?<s/n>\")\n if (resposta!='s'): return 0\n\n\n elif((criterioConvergencia_Linhas(M))==False):\n print(\"Aviso: Sistema não passa no teste de convergência das linhas.\")\n resposta = input(\"Deseja continuar?<s/n>\")\n if (resposta!='s'): return 0\n\n n= M.shape[0]\n x = np.zeros(n, dtype=float)\n xK = np.zeros(n, dtype=float)\n\n for k in range(0,100):\n for i in range (0,n):\n soma=0\n for j in range (0,n):\n if (j!=i): soma = soma + M[i][j]*xK[j]\n xK[i]=(b[i]-soma)/M[i][i]\n\n return xK\n\ndef residuo(b, L, x):\n n= L.shape[0]\n y = np.zeros(n, dtype=float)\n valorResiduo = np.zeros(n, dtype=float)\n for i in range(0,n):\n soma=0\n for j in range(0, n):\n soma = soma + L[i][j] * x[j]\n y[i]= soma\n for k in range (0, n):\n valorResiduo[k] = abs(y[k]-b[k])\n return valorResiduo\n\n\n\nL= np.zeros((4,4),dtype=float)\n(L,b) = readFile('matriz.txt')\nmL=copy.copy(L)\nmB= copy.copy(b)\n\n\nprint(\"\\n########## ELIMINACAO DE GAUSS ##########n\")\n\nini = timeit.timeit()\n(L,b) = readFile('matriz.txt')\nmL=copy.copy(L)\nmb= copy.copy(b)\n(b1,m1,mul,x) = eliminacaoGauss(b,L)\nfim = timeit.timeit()\nprint(\"A solução usando este método é:\\n \" + str(x))\nr = residuo(mb, mL, x)\nprint(\"\\nResiduo:\" + str(r))\nprint(\"\\nTempo de execução: \" + str(fim-ini))\n\nprint(\"\\n########## DECOMPOSIÇÃO LU ##########n\")\nini = timeit.timeit()\n(L,b) = readFile('matriz.txt')\nmL=copy.copy(L)\nmb= copy.copy(b)\nx = decomposicaoLU(b,L)\nfim = timeit.timeit()\nprint(\"A solução usando este método é:\\n \" + str(x))\nr = residuo(mb, mL, x)\nprint(\"Residuo: \" + str(r))\nprint(\"\\nTempo de execução: \" + str(fim-ini))\n\nprint(\"\\n########## GAUSS-JACOBI ##########\\n\")\nini = timeit.timeit()\n(L,b) = readFile('matriz.txt')\nmL=copy.copy(L)\nmb= copy.copy(b)\nx = gaussJacobi(b,L)\nfim = timeit.timeit()\nprint(\"A solução usando este método é:\\n \" + str(x))\nr = residuo(mb, mL, x)\nprint(\"Residuo: \",r)\nprint(\"\\nTempo de execução: \" + str(fim-ini))\n\nprint(\"\\n########## GAUSS-SEIDEL ########## \\n\")\nini = timeit.timeit()\n(L,b) = readFile('matriz.txt')\nmL=copy.copy(L)\nmb= copy.copy(b)\nx = gaussSeidel(b,L)\nfim = timeit.timeit()\nprint(\"A solução usando este método é:\\n \" + str(x))\nr = residuo(mb, mL, x)\nprint(\"Residuo: \",r)\nprint(\"\\nTempo de execução: \" + str(fim-ini))\n\nprint(\"\\n\\nDigite outra matriz no arquivo 'matriz.txt' para outros cálculos.\")\n"
] |
[
[
"numpy.ones",
"numpy.loadtxt",
"numpy.triu",
"numpy.array",
"numpy.zeros",
"numpy.tril"
]
] |
Hepynet/hepynet
|
[
"cab72aa5eb1a2fed26e3d3bd47833d05a5958f32"
] |
[
"hepynet/evaluate/evaluate_utils.py"
] |
[
"import logging\nimport pathlib\nfrom typing import Tuple\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\n\nfrom hepynet.common import config_utils\nfrom hepynet.data_io import numpy_io\nfrom hepynet.train import hep_model\n\nlogger = logging.getLogger(\"hepynet\")\n\n\ndef create_epoch_subdir(save_dir, epoch, n_digit) -> pathlib.Path:\n if save_dir is None:\n logger.error(f\"Invalid save_dir: {save_dir}\")\n return None\n if epoch is not None:\n sub_dir = pathlib.Path(f\"{save_dir}/epoch_{str(epoch).zfill(n_digit)}\")\n else:\n sub_dir = pathlib.Path(f\"{save_dir}/epoch_final\")\n sub_dir.mkdir(parents=True, exist_ok=True)\n return sub_dir\n\n\ndef dump_fit_df(\n model_wrapper: hep_model.Model_Base,\n df_raw,\n df_train,\n job_config,\n save_dir=\"./\",\n):\n ic = job_config.input.clone()\n tc = job_config.train.clone()\n ac = job_config.apply.clone()\n\n sample_list = ic.sig_list + ic.bkg_list\n if ic.apply_data:\n sample_list += ic.data_list\n\n platform_meta = config_utils.load_current_platform_meta()\n data_path = platform_meta[\"data_path\"]\n if not data_path:\n save_dir = pathlib.Path(save_dir)\n else:\n save_dir = pathlib.Path(data_path) / save_dir\n pathlib.Path(save_dir).mkdir(parents=True, exist_ok=True)\n logger.info(f\"> Saving dataframes to: {save_dir}\")\n\n for sample in sample_list:\n logger.info(f\"> > processing: {sample}\")\n dump_branches = ac.fit_df.branches + [\"weight\"]\n # prepare contents\n dump_df: pd.DataFrame = df_raw.loc[\n df_raw[\"sample_name\"] == sample, dump_branches\n ]\n input_df = df_train.loc[\n df_train[\"sample_name\"] == sample, ic.selected_features\n ]\n predictions, _, _ = k_folds_predict(\n model_wrapper.get_model(), input_df.values, silence=True\n )\n # dump\n if len(tc.output_bkg_node_names) == 0:\n dump_df[\"dnn_out_sig\"] = predictions\n else:\n for i, out_node in enumerate([\"sig\"] + tc.output_bkg_node_names):\n out_node = out_node.replace(\"+\", \"_\")\n branch_name = f\"dnn_out_{out_node}\"\n dump_df[branch_name] = predictions[:, i]\n dump_df.reset_index(inplace=True)\n save_path = save_dir / f\"{sample}.feather\"\n dump_df.to_feather(save_path)\n\n\ndef dump_fit_npy(\n model_wrapper: hep_model.Model_Base,\n df_raw,\n df_train,\n job_config,\n npy_dir=\"./\",\n):\n ic = job_config.input.clone()\n tc = job_config.train.clone()\n ac = job_config.apply.clone()\n\n sample_list = ic.sig_list + ic.bkg_list\n if ic.apply_data:\n sample_list += ic.data_list\n\n platform_meta = config_utils.load_current_platform_meta()\n data_path = platform_meta[\"data_path\"]\n if not data_path:\n save_dir = pathlib.Path(npy_dir)\n else:\n save_dir = pathlib.Path(data_path) / npy_dir\n pathlib.Path(save_dir).mkdir(parents=True, exist_ok=True)\n logger.info(f\"> Arrays to be saved to {save_dir}\")\n\n for sample in sample_list:\n dump_branches = ac.cfg_fit_npy.fit_npy_branches + [\"weight\"]\n # prepare contents\n dump_df = df_raw.loc[df_raw[\"sample_name\"] == sample, dump_branches]\n input_df = df_train.loc[\n df_train[\"sample_name\"] == sample, ic.selected_features\n ]\n predictions, _, _ = k_folds_predict(\n model_wrapper.get_model(), input_df.values\n )\n # dump\n for branch in dump_branches:\n branch_content = dump_df[branch].values\n save_path = f\"{save_dir}/{sample}_{branch}.npy\"\n numpy_io.save_npy_array(branch_content, save_path)\n if len(tc.output_bkg_node_names) == 0:\n save_path = f\"{save_dir}/{sample}_dnn_out.npy\"\n numpy_io.save_npy_array(predictions, save_path)\n else:\n for i, out_node in enumerate([\"sig\"] + tc.output_bkg_node_names):\n out_node = out_node.replace(\"+\", \"_\")\n save_path = f\"{save_dir}/{sample}_dnn_out_{out_node}.npy\"\n numpy_io.save_npy_array(predictions[:, i], save_path)\n\n\ndef k_folds_predict(\n k_fold_models, x, silence=False\n) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:\n y_pred_k_folds = list()\n if not silence:\n logger.info(\"Predicting y scores\")\n num_folds = len(k_fold_models)\n for fold_num, fold_model in enumerate(k_fold_models):\n if not silence:\n logger.info(\n f\"> Predicting with model in fold {fold_num + 1}/{num_folds}\"\n )\n y_fold_pred = fold_model.predict(x)\n y_pred_k_folds.append(y_fold_pred)\n y_pred_mean = np.mean(y_pred_k_folds, axis=0)\n y_pred_max = np.maximum.reduce(y_pred_k_folds)\n y_pred_min = np.minimum.reduce(y_pred_k_folds)\n return y_pred_mean, y_pred_min, y_pred_max\n\n\ndef paint_bars(\n ax,\n data,\n labels: list,\n weights,\n bins: int,\n range: tuple,\n title: str = None,\n x_label: str = None,\n y_label: str = None,\n x_unit: str = None,\n x_scale: float = None,\n density: bool = False,\n use_error: bool = False,\n color: str = None,\n fmt: str = \".k\",\n) -> None:\n \"\"\"Plot with vertical bar, can be used for data display.\n\n Note:\n According to ROOT:\n \"The error per bin will be computed as sqrt(sum of squares of weight) for each bin.\"\n\n \"\"\"\n plt.ioff()\n # Check input\n data_1dim = np.array([])\n weight_1dim = np.array([])\n if isinstance(data, np.ndarray):\n data = [data]\n weights = [weights]\n for datum, weight in zip(data, weights):\n assert isinstance(\n datum, np.ndarray\n ), \"data element should be numpy array.\"\n assert isinstance(\n weight, np.ndarray\n ), \"weights element should be numpy array.\"\n assert (\n datum.shape == weight.shape\n ), \"Input weights should be None or have same type as arrays.\"\n if len(data_1dim) == 0:\n data_1dim = datum\n weight_1dim = weight\n else:\n data_1dim = np.concatenate((data_1dim, datum))\n weight_1dim = np.concatenate((weight_1dim, weight))\n\n # Scale x axis\n if x_scale is not None:\n data_1dim = data_1dim * x_scale\n # Make bar plot\n # get bin error and edges\n plot_ys, _ = np.histogram(\n data_1dim, bins=bins, range=range, weights=weight_1dim, density=density\n )\n sum_weight_squares, bin_edges = np.histogram(\n data_1dim, bins=bins, range=range, weights=np.power(weight_1dim, 2)\n )\n if density:\n error_scale = 1 / (np.sum(weight_1dim) * (range[1] - range[0]) / bins)\n errors = np.sqrt(sum_weight_squares) * error_scale\n else:\n errors = np.sqrt(sum_weight_squares)\n # Only plot ratio when bin is not 0.\n bin_centers = np.array([])\n bin_ys = np.array([])\n bin_yerrs = np.array([])\n for i, y1 in enumerate(plot_ys):\n if y1 != 0:\n ele_center = np.array([0.5 * (bin_edges[i] + bin_edges[i + 1])])\n bin_centers = np.concatenate((bin_centers, ele_center))\n ele_y = np.array([y1])\n bin_ys = np.concatenate((bin_ys, ele_y))\n ele_yerr = np.array([errors[i]])\n bin_yerrs = np.concatenate((bin_yerrs, ele_yerr))\n # plot bar\n bin_size = bin_edges[1] - bin_edges[0]\n if use_error:\n ax.errorbar(\n bin_centers,\n bin_ys,\n xerr=bin_size / 2.0,\n yerr=bin_yerrs,\n fmt=fmt,\n label=labels,\n color=color,\n markerfacecolor=color,\n markeredgecolor=color,\n )\n else:\n ax.errorbar(\n bin_centers,\n bin_ys,\n xerr=bin_size / 2.0,\n yerr=None,\n fmt=fmt,\n label=labels,\n color=color,\n markerfacecolor=color,\n markeredgecolor=color,\n )\n # Config\n if title is not None:\n ax.set_title(title)\n if x_label is not None:\n if x_unit is not None:\n ax.set_xlabel(x_label + \"/\" + x_unit)\n else:\n ax.set_xlabel(x_label)\n else:\n if x_unit is not None:\n ax.set_xlabel(x_unit)\n if y_label is not None:\n ax.set_ylabel(y_label)\n if range is not None:\n ax.axis(xmin=range[0], xmax=range[1])\n ax.legend(loc=\"upper right\")\n"
] |
[
[
"numpy.sqrt",
"numpy.power",
"numpy.concatenate",
"matplotlib.pyplot.ioff",
"numpy.minimum.reduce",
"numpy.mean",
"numpy.array",
"numpy.histogram",
"numpy.sum",
"numpy.maximum.reduce"
]
] |
lhadhazy/sklearn_estimator_model
|
[
"9d94ed266dbc54f3ea5571bc63bdddc04a644f97"
] |
[
"EstimatorModel/svc.py"
] |
[
"from sklearn.base import ClassifierMixin, BaseEstimator\nfrom sklearn.svm import SVC\nfrom sklearn.pipeline import make_pipeline\nfrom TransformerModel.StandardScaler import StandardScaler\nfrom TransformerModel.NullColumnCleanse import NullColumnCleanse\nfrom TransformerModel.LDATransformer import LDA\n\n\n# Random Forest classifier decorator class\nclass CompositeSVCEstimator(BaseEstimator, ClassifierMixin):\n\n def __init__(self, C=1, kernel='rbf', gamma='auto',\n class_weight='balanced', cache_size=800, probability=False):\n self.decorated_estimator = SVC(C=C, kernel=kernel, gamma=gamma,\n class_weight=class_weight,\n cache_size=cache_size, max_iter=1,\n probability=probability)\n self.C = C\n self.kernel = kernel\n self.class_weight = class_weight\n self.gamma = gamma\n self.trained_estimator_ = None\n self.transform_steps = [\n NullColumnCleanse(),\n StandardScaler(),\n LDA(1)\n ]\n\n def fit(self, X, y):\n # forging of the data pipeline steps inside the fit method\n self.trained_estimator_ = make_pipeline(\n # self.transform_steps,\n self.decorated_estimator\n ).fit(X, y)\n\n print(self.decorated_estimator)\n return self\n\n def score(self, X, y=None):\n return(sum(self.predict(X)))\n\n def predict(self, X):\n return self.trained_estimator_.predict(X)\n"
] |
[
[
"sklearn.pipeline.make_pipeline",
"sklearn.svm.SVC"
]
] |
ruiyangsong/mCNN
|
[
"889f182245f919fb9c7a8d97965b11576b01a96c",
"889f182245f919fb9c7a8d97965b11576b01a96c"
] |
[
"src/Network/test/test3/wild_VS_wild_mutant_3_neighbor60_test01.py",
"src/Network/deepddg/feature118/regressor/SimpleConv1D_BlindTest_Epoch.py"
] |
[
"from hyperopt import Trials, STATUS_OK, tpe\nfrom hyperas import optim\nfrom hyperas.distributions import choice, uniform\n\nimport os, sys\nimport numpy as np\nfrom sklearn.utils import class_weight\nimport tensorflow as tf\nfrom keras.backend.tensorflow_backend import set_session\nfrom keras.utils import to_categorical\nfrom keras import Input, models, layers, regularizers, callbacks, optimizers\nfrom keras.utils import to_categorical\n\n\ndef data():\n random_seed = 10\n # data = np.load('/public/home/sry/mCNN/dataset/S2648/feature/mCNN/wild/npz/center_CA_PCA_False_neighbor_30.npz')\n data = np.load('/dl/sry/mCNN/dataset/S2648/feature/mCNN/mutant/npz/center_CA_PCA_False_neighbor_60.npz')\n # data = np.load('E:/projects/mCNN/yanglab/mCNN-master/dataset/S2648/mCNN/wild/center_CA_PCA_False_neighbor_30.npz')\n x = data['x']\n y = data['y']\n ddg = data['ddg'].reshape(-1)\n train_num = x.shape[0]\n indices = [i for i in range(train_num)]\n np.random.seed(random_seed)\n np.random.shuffle(indices)\n x = x[indices]\n y = y[indices]\n\n positive_indices, negative_indices = ddg >= 0, ddg < 0\n x_positive, x_negative = x[positive_indices], x[negative_indices]\n y_positive, y_negative = y[positive_indices], y[negative_indices]\n left_positive, left_negative = round(0.8 * x_positive.shape[0]), round(0.8 * x_negative.shape[0])\n x_train, x_test = np.vstack((x_positive[:left_positive], x_negative[:left_negative])), np.vstack(\n (x_positive[left_positive:], x_negative[left_negative:]))\n y_train, y_test = np.vstack((y_positive[:left_positive], y_negative[:left_negative])), np.vstack(\n (y_positive[left_positive:], y_negative[left_negative:]))\n # sort row default is chain\n # reshape and one-hot\n y_train = to_categorical(y_train)\n y_test = to_categorical(y_test)\n # normalization\n train_shape = x_train.shape\n test_shape = x_test.shape\n col_train = train_shape[-1]\n col_test = test_shape[-1]\n x_train = x_train.reshape((-1, col_train))\n x_test = x_test.reshape((-1, col_test))\n mean = x_train.mean(axis=0)\n std = x_train.std(axis=0)\n std[np.argwhere(std == 0)] = 0.01\n x_train -= mean\n x_train /= std\n x_test -= mean\n x_test /= std\n x_train = x_train.reshape(train_shape)\n x_test = x_test.reshape(test_shape)\n\n # reshape\n x_train = x_train.reshape(x_train.shape + (1,))\n x_test = x_test.reshape(x_test.shape + (1,))\n return x_train, y_train, x_test, y_test\n\n\n\ndef Conv2DClassifierIn1(x_train,y_train,x_test,y_test):\n summary = True\n verbose = 1\n\n # setHyperParams------------------------------------------------------------------------------------------------\n batch_size = {{choice([32,64,128,256,512])}}\n epoch = {{choice([25,50,75,100,125,150,175,200])}}\n\n conv_block={{choice(['two', 'three', 'four'])}}\n\n conv1_num={{choice([8, 16, 32, 64])}}\n conv2_num={{choice([16,32,64,128])}}\n conv3_num={{choice([32,64,128])}}\n conv4_num={{choice([32, 64, 128, 256])}}\n\n dense1_num={{choice([128, 256, 512])}}\n dense2_num={{choice([64, 128, 256])}}\n\n l1_regular_rate = {{uniform(0.00001, 1)}}\n l2_regular_rate = {{uniform(0.000001, 1)}}\n drop1_num={{uniform(0.1, 1)}}\n drop2_num={{uniform(0.0001, 1)}}\n\n activator={{choice(['elu','relu','tanh'])}}\n optimizer={{choice(['adam','rmsprop','SGD'])}}\n\n #---------------------------------------------------------------------------------------------------------------\n kernel_size = (3, 3)\n pool_size = (2, 2)\n initializer = 'random_uniform'\n padding_style = 'same'\n loss_type='binary_crossentropy'\n metrics=['accuracy']\n my_callback = None\n # early_stopping = EarlyStopping(monitor='val_loss', patience=4)\n # checkpointer = ModelCheckpoint(filepath='keras_weights.hdf5',\n # verbose=1,\n # save_best_only=True)\n # my_callback = callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.2,\n # patience=5, min_lr=0.0001)\n\n\n\n # build --------------------------------------------------------------------------------------------------------\n input_layer = Input(shape=x_train.shape[1:])\n conv = layers.Conv2D(conv1_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(input_layer)\n conv = layers.Conv2D(conv1_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(conv)\n pool = layers.MaxPooling2D(pool_size,padding=padding_style)(conv)\n if conv_block == 'two':\n conv = layers.Conv2D(conv2_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(pool)\n conv = layers.Conv2D(conv2_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(conv)\n BatchNorm = layers.BatchNormalization(axis=-1)(conv)\n pool = layers.MaxPooling2D(pool_size,padding=padding_style)(BatchNorm)\n elif conv_block == 'three':\n conv = layers.Conv2D(conv2_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(pool)\n conv = layers.Conv2D(conv2_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(conv)\n BatchNorm = layers.BatchNormalization(axis=-1)(conv)\n pool = layers.MaxPooling2D(pool_size,padding=padding_style)(BatchNorm)\n\n conv = layers.Conv2D(conv3_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(pool)\n conv = layers.Conv2D(conv3_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(conv)\n BatchNorm = layers.BatchNormalization(axis=-1)(conv)\n pool = layers.MaxPooling2D(pool_size,padding=padding_style)(BatchNorm)\n elif conv_block == 'four':\n conv = layers.Conv2D(conv2_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(pool)\n conv = layers.Conv2D(conv2_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(conv)\n BatchNorm = layers.BatchNormalization(axis=-1)(conv)\n pool = layers.MaxPooling2D(pool_size,padding=padding_style)(BatchNorm)\n\n conv = layers.Conv2D(conv3_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(pool)\n conv = layers.Conv2D(conv3_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(conv)\n BatchNorm = layers.BatchNormalization(axis=-1)(conv)\n pool = layers.MaxPooling2D(pool_size,padding=padding_style)(BatchNorm)\n\n conv = layers.Conv2D(conv4_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(pool)\n conv = layers.Conv2D(conv4_num,kernel_size,padding=padding_style,kernel_initializer=initializer,activation=activator)(conv)\n BatchNorm = layers.BatchNormalization(axis=-1)(conv)\n pool = layers.MaxPooling2D(pool_size,padding=padding_style)(BatchNorm)\n\n flat = layers.Flatten()(pool)\n drop = layers.Dropout(drop1_num)(flat)\n\n dense = layers.Dense(dense1_num, activation=activator, kernel_regularizer=regularizers.l1_l2(l1=l1_regular_rate,l2=l2_regular_rate))(drop)\n BatchNorm = layers.BatchNormalization(axis=-1)(dense)\n drop = layers.Dropout(drop2_num)(BatchNorm)\n\n dense = layers.Dense(dense2_num, activation=activator, kernel_regularizer=regularizers.l1_l2(l1=l1_regular_rate,l2=l2_regular_rate))(drop)\n\n output_layer = layers.Dense(len(np.unique(y_train)),activation='softmax')(dense)\n\n model = models.Model(inputs=input_layer, outputs=output_layer)\n\n if summary:\n model.summary()\n\n # train(self):\n class_weights = class_weight.compute_class_weight('balanced', np.unique(y_train), y_train.reshape(-1))\n class_weights_dict = dict(enumerate(class_weights))\n model.compile(optimizer=optimizer,\n loss=loss_type,\n metrics=metrics # accuracy\n )\n\n result = model.fit(x=x_train,\n y=y_train,\n batch_size=batch_size,\n epochs=epoch,\n verbose=verbose,\n callbacks=my_callback,\n validation_data=(x_test, y_test),\n shuffle=True,\n class_weight=class_weights_dict\n )\n\n validation_acc = np.amax(result.history['val_acc'])\n print('Best validation acc of epoch:', validation_acc)\n return {'loss': -validation_acc, 'status': STATUS_OK, 'model': model}\n\n\nif __name__ == '__main__':\n # config TF-----------------------------------------------------------------------------------------------------\n CUDA, max_eval = sys.argv[1:]\n os.environ['CUDA_VISIBLE_DEVICES'] = CUDA\n os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n set_session(tf.Session(config=config))\n\n # x_train, y_train, x_test, y_test = data()\n # Conv2DClassifierIn1(x_train, y_train, x_test, y_test)\n\n\n best_run, best_model = optim.minimize(model=Conv2DClassifierIn1,\n data=data,\n algo=tpe.suggest,\n max_evals=int(max_eval),\n keep_temp=False,\n trials=Trials())\n for trial in Trials():\n print(trial)\n X_train, Y_train, X_test, Y_test = data()\n print(\"Evalutation of best performing model:\")\n print(best_model.evaluate(X_test, Y_test))\n print(\"Best performing model chosen hyper-parameters:\")\n print(best_run)\n",
"import os, json\nimport sys\nimport time\n\nimport numpy as np\nfrom sklearn.utils import class_weight\nimport tensorflow as tf\nfrom sklearn.model_selection import StratifiedKFold\nfrom keras import backend as K\nfrom keras.backend.tensorflow_backend import set_session\nfrom keras import Input, models, layers, optimizers, callbacks\nfrom mCNN.Network.metrics import test_report_reg, pearson_r, rmse\nfrom keras.utils import to_categorical\nfrom matplotlib import pyplot as plt\n'''\n基于所有的训练数据，测试独立测试集（无验证集）做 blind test\n选择固定的epoch，做了1次 blind test，训练数据为1-th fold train append 1-th fold val\n'''\n\ndef data(train_data_pth,test_data_pth, val_data_pth):\n ## train data\n train_data = np.load(train_data_pth)\n x_train = train_data['x']\n y_train = train_data['y']\n ddg_train = train_data['ddg'].reshape(-1)\n # class_weights = class_weight.compute_class_weight('balanced', np.unique(y_train), y_train.reshape(-1))\n # class_weights_dict = dict(enumerate(class_weights))\n ## valid data\n val_data = np.load(val_data_pth)\n x_val = val_data['x']\n y_val = val_data['y']\n ddg_val = val_data['ddg'].reshape(-1)\n\n x_train = np.vstack((x_train,x_val))\n y_train = np.vstack((y_train,y_val))\n ddg_train = np.hstack((ddg_train,ddg_val))\n ## test data\n test_data = np.load(test_data_pth)\n x_test = test_data['x']\n y_test = test_data['y']\n ddg_test = test_data['ddg'].reshape(-1)\n\n # sort row default is chain, pass\n # reshape and one-hot\n y_train = to_categorical(y_train)\n y_test = to_categorical(y_test)\n # normalization\n train_shape = x_train.shape\n test_shape = x_test.shape\n col_train = train_shape[-1]\n col_test = test_shape[-1]\n x_train = x_train.reshape((-1, col_train))\n x_test = x_test.reshape((-1, col_test))\n mean = x_train.mean(axis=0)\n std = x_train.std(axis=0)\n std[np.argwhere(std == 0)] = 0.01\n x_train -= mean\n x_train /= std\n x_test -= mean\n x_test /= std\n x_train = x_train.reshape(train_shape)\n x_test = x_test.reshape(test_shape)\n\n # reshape\n # x_train = x_train.reshape(x_train.shape + (1,))\n # x_test = x_test.reshape(x_test.shape + (1,))\n return x_train, y_train, ddg_train, x_test, y_test, ddg_test\n\ndef ieee_net(x_train, y_train, ddg_train):\n row_num, col_num = x_train.shape[1:3]\n verbose = 1\n batch_size = 64\n epochs = int(sys.argv[1]) #[15, 12, 16, 29, 16, 12, 10, 31, 10, 19]\n\n metrics = ('mae', pearson_r, rmse)\n\n def step_decay(epoch):\n # drops as progression proceeds, good for sgd\n if epoch > 0.9 * epochs:\n lr = 0.00001\n elif epoch > 0.75 * epochs:\n lr = 0.0001\n elif epoch > 0.5 * epochs:\n lr = 0.001\n else:\n lr = 0.01\n print('lr: %f' % lr)\n return lr\n\n lrate = callbacks.LearningRateScheduler(step_decay, verbose=verbose)\n my_callbacks = [\n lrate\n ]\n\n network = models.Sequential()\n network.add(layers.Conv1D(filters=16, kernel_size=5, activation='relu', input_shape=(row_num, col_num)))\n network.add(layers.MaxPooling1D(pool_size=2))\n network.add(layers.Conv1D(32, 5, activation='relu'))\n network.add(layers.MaxPooling1D(pool_size=2))\n network.add(layers.Conv1D(64, 3, activation='relu'))\n network.add(layers.MaxPooling1D(pool_size=2))\n network.add(layers.Flatten())\n network.add(layers.Dense(128, activation='relu'))\n network.add(layers.Dropout(0.5))\n network.add(layers.Dense(16, activation='relu'))\n network.add(layers.Dropout(0.3))\n network.add(layers.Dense(1))\n # print(network.summary())\n # rmsp = optimizers.RMSprop(lr=0.0001, decay=0.1)\n rmsp = optimizers.RMSprop(lr=0.0001)\n network.compile(optimizer=rmsp,#'rmsprop', # SGD,adam,rmsprop\n loss='mse',\n metrics=list(metrics)) # mae平均绝对误差（mean absolute error） accuracy\n result = network.fit(x=x_train,\n y=ddg_train,\n batch_size=batch_size,\n epochs=epochs,\n verbose=verbose,\n callbacks=my_callbacks,\n shuffle=True,\n )\n return network, result.history\n\nif __name__ == '__main__':\n epochs = int(sys.argv[1])\n from mCNN.queueGPU import queueGPU\n CUDA_rate = '0.2'\n ## config TF\n queueGPU(USER_MEM=3000, INTERVAL=60)\n # os.environ['CUDA_VISIBLE_DEVICES'] = CUDA\n os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n if CUDA_rate != 'full':\n config = tf.ConfigProto()\n if float(CUDA_rate)<0.1:\n config.gpu_options.allow_growth = True\n else:\n config.gpu_options.per_process_gpu_memory_fraction = float(CUDA_rate)\n set_session(tf.Session(config=config))\n\n # modeldir = '/dl/sry/mCNN/src/Network/deepddg/regressor/TrySimpleConv1D_CrossValid_%s'%time.strftime(\"%Y.%m.%d.%H.%M.%S\", time.localtime())\n modeldir = '/dl/sry/mCNN/src/Network/deepddg/regressor/%s_%s'%(sys.argv[0][:-3]+sys.argv[1], time.strftime(\"%Y.%m.%d.%H.%M.%S\", time.localtime()))\n os.makedirs(modeldir, exist_ok=True)\n score_dict = {'pearson_coeff':[], 'std':[], 'mae':[]}\n train_score_dict = {'pearson_coeff':[], 'std':[], 'mae':[]}\n es_train_score_dict = {'pearson_coeff':[], 'std':[], 'mae':[]}\n\n test_data_pth = '/dl/sry/mCNN/dataset/deepddg/npz/wild/cross_valid/cro_foldall_test_center_CA_PCA_False_neighbor_120.npz'\n for i in range(1):\n k_count = i+1\n print('--cross validation begin, fold %s is processing.'%k_count)\n train_data_pth = '/dl/sry/mCNN/dataset/deepddg/npz/wild/cross_valid/cro_fold%s_train_center_CA_PCA_False_neighbor_120.npz'%k_count\n valid_data_pth = '/dl/sry/mCNN/dataset/deepddg/npz/wild/cross_valid/cro_fold%s_valid_center_CA_PCA_False_neighbor_120.npz'%k_count\n x_train, y_train, ddg_train, x_test, y_test, ddg_test = data(train_data_pth,test_data_pth,valid_data_pth)\n print('x_train: %s'\n '\\ny_train: %s'\n '\\nddg_train: %s'\n '\\nx_test: %s'\n '\\ny_test: %s'\n '\\nddg_test: %s'\n % (x_train.shape, y_train.shape, ddg_train.shape,\n x_test.shape, y_test.shape, ddg_test.shape))\n\n #\n # train & test\n #\n model, history_dict = ieee_net(x_train, y_train, ddg_train)\n\n #\n # save model architecture\n #\n try:\n model_json = model.to_json()\n with open('%s/fold_%s_model.json'%(modeldir,k_count), 'w') as json_file:\n json_file.write(model_json)\n except:\n print('save model.json to json failed, fold_num: %s' % k_count)\n #\n # save model weights\n #\n try:\n model.save_weights(filepath='%s/fold_%s_weightsFinal.h5' % (modeldir,k_count))\n except:\n print('save final model weights failed, fold_num: %s' % k_count)\n #\n # save training history\n #\n try:\n with open('%s/fold_%s_history.dict'%(modeldir,k_count), 'w') as file:\n file.write(str(history_dict))\n # with open('%s/fold_%s_history.dict'%(modeldir,k_count), 'r') as file:\n # print(eval(file.read()))\n except:\n print('save history_dict failed, fold_num: %s' % k_count)\n\n #\n # Load model\n #\n with open('%s/fold_%s_model.json'%(modeldir,k_count), 'r') as json_file:\n loaded_model_json = json_file.read()\n loaded_model = models.model_from_json(loaded_model_json) # keras.models.model_from_yaml(yaml_string)\n loaded_model.load_weights(filepath='%s/fold_%s_weightsFinal.h5' % (modeldir,k_count))\n\n #\n # Test model\n #\n # pearson_coeff, std, mae = test_report_reg(model, x_test, ddg_test)\n pearson_coeff, std, mae = test_report_reg(loaded_model, x_test, ddg_test)\n print('\\n----------Predict:'\n '\\npearson_coeff: %s, std: %s, mae: %s'\n % (pearson_coeff, std, mae))\n score_dict['pearson_coeff'].append(pearson_coeff)\n score_dict['std'].append(std)\n score_dict['mae'].append(mae)\n\n train_score_dict['pearson_coeff'].append(history_dict['pearson_r'][-1])\n train_score_dict['std'].append(history_dict['rmse'][-1])\n train_score_dict['mae'].append(history_dict['mean_absolute_error'][-1])\n\n k_count += 1\n\n #\n # save score dict\n #\n try:\n with open('%s/fold_._score.dict' % modeldir, 'w') as file:\n file.write(str(score_dict))\n except:\n print('save score dict failed')\n\n #\n # save AVG score\n #\n try:\n with open('%s/fold_.avg_score_train_test.txt' % modeldir, 'w') as file:\n file.writelines('----------train AVG results\\n')\n for key in score_dict.keys():\n file.writelines('*avg(%s): %s\\n'%(key,np.mean(train_score_dict[key])))\n file.writelines('----------test AVG results\\n')\n for key in score_dict.keys():\n file.writelines('*avg(%s): %s\\n'%(key,np.mean(score_dict[key])))\n except:\n print('save AVG score failed')\n\n print('\\nAVG results','-'*10)\n for key in score_dict.keys():\n print('*avg(%s): %s'%(key,np.mean(score_dict[key])))\n"
] |
[
[
"numpy.amax",
"numpy.random.seed",
"numpy.unique",
"numpy.random.shuffle",
"numpy.argwhere",
"tensorflow.ConfigProto",
"tensorflow.Session",
"numpy.load",
"numpy.vstack"
],
[
"numpy.hstack",
"numpy.argwhere",
"tensorflow.ConfigProto",
"numpy.mean",
"tensorflow.Session",
"numpy.load",
"numpy.vstack"
]
] |
tomsonsgs/TRAN-MMA-master
|
[
"91bf927c64a8d813ba60ae12e61e8f44830a82cc"
] |
[
"components/evaluator.py"
] |
[
"from __future__ import print_function\nfrom asdl.transition_system import GenTokenAction, TransitionSystem, ApplyRuleAction, ReduceAction,score_acts\nimport sys, traceback\nimport numpy as np\nfrom common.registerable import Registrable\nimport tqdm\ncachepredict=[]\ncachetrue=[]\nfrom dependency import nlp\nfrom nltk.tree import Tree\n@Registrable.register('default_evaluator')\nclass Evaluator(object):\n def __init__(self, transition_system=None, args=None):\n self.transition_system = transition_system\n self.default_metric = 'accuracy'\n\n def is_hyp_correct(self, example, hyp):\n return self.transition_system.compare_ast(hyp.tree, example.tgt_ast)#this func is at\n\n def evaluate_dataset(self, examples, decode_results, fast_mode=False):\n global cachepredict\n global cachetrue\n correct_array = []\n oracle_array = []\n cachepredict=[]\n cachetrue=[]\n allstats=[]\n for example, hyp_list,atts in tqdm.tqdm(zip(examples, decode_results[0],decode_results[1])):\n if fast_mode:\n hyp_list = hyp_list[:1]\n att=atts[:1]\n# ast=attss[:1]\n if hyp_list:\n if(hyp_list[0].tree.sort_removedup_self().to_string()!=example.tgt_ast.sort_removedup_self().to_string()):\n print(example.src_sent)\n## tree=Tree.fromstring(str(nlp.parse(' '.join(example.src_sent))))\n# \n print([item.name for item in example.table.header])\n print(att[0][1][0])\n print(hyp_list[0].actions)\n print([a.action for a in example.tgt_actions])\n# \n for action,at,ats in zip(hyp_list[0].actions,att[0][0],att[0][0]):\n# if(show and number>3):\n# if np.linalg.norm(at[-1]-at[0])>0.5:\n print(example.src_sent) \n print(action)\n print(at)\n# print(ats)\n# a=input('jk')\n# tree.draw() \n a=input('jk')\n# show=False\n# number=0\n# for at in att[0]:\n# if np.linalg.norm(at[-1]-at[0])>0.5:\n# show=True\n# number+=1\n# for action,at in zip(hyp_list[0].actions,att[0]):\n# if(show and number>3):\n# if np.linalg.norm(at[-1]-at[0])>0.5:\n# print(example.src_sent) \n# print(action)\n# print(at)\n# a=input('jk')\n# for hyp_id, hyp in enumerate(hyp_list):\n# try:\n# is_correct = self.is_hyp_correct(example, hyp)\n# except:\n# is_correct = False\n#\n# print('-' * 60, file=sys.stdout)\n# print('Error in evaluating Example %s, hyp %d {{ %s }}' % (example.idx, hyp_id, hyp.code),\n# file=sys.stdout)\n#\n# print('example id: %s, hypothesis id: %d' % (example.idx, hyp_id), file=sys.stdout)\n# traceback.print_exc(file=sys.stdout)\n# print('-' * 60, file=sys.stdout)\n#\n# hyp.is_correct = is_correct\n#\n# correct_array.append(hyp_list[0].is_correct)\n# correct_array.append(hyp_list[0].tree.to_string()==example.tgt_ast.to_string())\n correct_array.append(hyp_list[0].tree.sort_removedup_self().to_string()==example.tgt_ast.sort_removedup_self().to_string())\n# hyp_list[0].is_correct)\n# cachepredict.append(hyp_list[0].tree)\n# cachetrue.append(example.tgt_ast)\n# print(hyp_list[0].actions)\n# print([a.action for a in example.tgt_actions])\n# oracle_array.append(any(hyp.is_correct for hyp in hyp_list))\n# print(hyp_list[0].tree.to_string())\n# print(example.tgt_ast.to_string())\n# print(score_acts(hyp_list[0].actions,self.transition_system.get_actions(example.tgt_ast)))\n# p=input('gg')\n oracle_array.append(hyp_list[0].tree.sort_removedup_self().to_string()==example.tgt_ast.sort_removedup_self().to_string())\n allstats.append(self.finemet(hyp_list[0].tree,example.tgt_ast,example,oracle_array[-1]))\n# allstats.append([False,False,False])\n else:\n correct_array.append(False)\n oracle_array.append(False)\n allstats.append([False,False,False])\n\n acc = np.average(correct_array)\n allacc=np.mean(np.array(allstats),0)\n oracle_acc = np.average(oracle_array)\n eval_results = dict(accuracy=acc,\n oracle_accuracy=oracle_acc,allaccs=allacc)\n\n return eval_results\n\n\n@Registrable.register('cached_evaluator')\nclass CachedExactMatchEvaluator(Evaluator):\n def is_hyp_correct(self, example, hyp):\n raise hyp.is_correct\n\n def evaluate_dataset(self, examples, decode_results, fast_mode=False):\n if fast_mode:\n acc = sum(hyps[0].is_correct for hyps in decode_results if len(hyps) > 0) / float(len(examples))\n return acc\n\n acc_array = []\n oracle_array = []\n for hyp_list in decode_results:\n acc_array.append(hyp_list[0].is_correct if hyp_list else False)\n oracle_array.append(any(hyp.is_correct for hyp in hyp_list))\n\n return dict(accuracy=np.average(acc_array),\n oracle_array=np.average(oracle_array))\n"
] |
[
[
"numpy.array",
"numpy.average"
]
] |
aidoop/CoboMarkerTracking
|
[
"283195a82076450d00d1f56f15c45895df69f6ee"
] |
[
"object_tracker/applications/roi_arucomanager.py"
] |
[
"import numpy as np\nimport cv2\n\nfrom pyaidoop.aruco.aruco_detect import ArucoDetect\n\n\nclass ROIAruco2DManager:\n def __init__(self, markerSelectDict, markerSize, mtx, dist):\n # arouco marker id list\n self.arucoRangeList = []\n\n # ROI Region List\n self.ROIRegions = []\n self.ROIRegionIds = []\n\n # create an aruco detect object\n self.arucoDetect = ArucoDetect(markerSelectDict, markerSize, mtx, dist)\n\n def setMarkIdPair(self, arucoRangeData):\n self.arucoRangeList.append(arucoRangeData)\n\n def clearMakrIdPair(self):\n self.arucoRangeList.clear()\n\n def setROIRegion(self, pixelCoord1, pixelCoord2):\n self.ROIRegions.append((pixelCoord1, pixelCoord2))\n\n def setROIRegion(self, pixelCoord1, pixelCoord2, id):\n self.ROIRegions.append((pixelCoord1, pixelCoord2))\n self.ROIRegionIds.append(id)\n\n def getROIRegition(self):\n return self.ROIRegions\n\n def getROIRegionIDs(self):\n return self.ROIRegionIds\n\n def clearROIRegion(self):\n self.ROIRegions.clear()\n self.ROIRegionIds.clear()\n\n def printRangeData(self):\n for rdata in self.arucoRangeList:\n print(\"ID: \", self.ROIRegionIds[idx])\n print(\"Start: \" + str(rdata[0]) + \", End: \" + str(rdata[1]))\n\n def findROI(self, color_image, mtx, dist):\n # clear previous list\n self.clearROIRegion()\n\n # operations on the frame\n gray = cv2.cvtColor(color_image, cv2.COLOR_BGR2GRAY)\n\n # lists of ids and the corners belonging to each id\n corners, ids = self.arucoDetect.detect(gray)\n\n if np.all(ids != None):\n # estimate pose of each marker and return the values\n # rvet and tvec-different from camera coefficients\n rvec, tvec = self.arucoDetect.estimate_pose(corners)\n\n centerPoint = dict()\n for arucoIDRange in self.arucoRangeList:\n if (arucoIDRange[0] in ids) and (arucoIDRange[1] in ids):\n # get a retangle coordinates between two aruco marks\n for arucoMark in arucoIDRange:\n idx = list(ids).index(arucoMark)\n inputObjPts = np.float32([[0.0, 0.0, 0.0]]).reshape(-1, 3)\n imgpts, jac = cv2.projectPoints(\n inputObjPts, rvec[idx], tvec[idx], mtx, dist\n )\n centerPoint[arucoMark] = tuple(imgpts[0][0])\n\n # set the current region to a list\n self.setROIRegion(\n centerPoint[arucoIDRange[0]], centerPoint[arucoIDRange[1]]\n )\n\n return self.getROIRegition()\n\n def findROIPair(self, color_image, mtx, dist):\n # clear previous list\n self.clearROIRegion()\n\n # operations on the frame\n gray = cv2.cvtColor(color_image, cv2.COLOR_BGR2GRAY)\n\n # lists of ids and the corners belonging to each id\n corners, ids = self.arucoDetect.detect(gray)\n\n if np.all(ids != None):\n # estimate pose of each marker and return the values\n # rvet and tvec-different from camera coefficients\n rvec, tvec = self.arucoDetect.estimate_pose(corners)\n\n for idx in range(len(ids)):\n for subidx in range(idx + 1, len(ids)):\n if ids[idx] == ids[subidx]:\n inputObjPts = np.float32([[0.0, 0.0, 0.0]]).reshape(-1, 3)\n imgpts, jac = cv2.projectPoints(\n inputObjPts, rvec[idx], tvec[idx], mtx, dist\n )\n imgpts_sub, jac_sub = cv2.projectPoints(\n inputObjPts, rvec[subidx], tvec[subidx], mtx, dist\n )\n\n # set the current region to a list\n self.setROIRegion(\n tuple(imgpts[0][0]), tuple(imgpts_sub[0][0]), ids[idx][0]\n )\n\n # centerPoint = dict()\n # for arucoIDRange in self.arucoRangeList:\n # if (arucoIDRange[0] in ids) and (arucoIDRange[1] in ids):\n # # get a retangle coordinates between two aruco marks\n # for arucoMark in arucoIDRange:\n # idx = list(ids).index(arucoMark)\n # inputObjPts = np.float32([[0.0,0.0,0.0]]).reshape(-1,3)\n # imgpts, jac = cv2.projectPoints(inputObjPts, rvec[idx], tvec[idx], mtx, dist)\n # centerPoint[arucoMark] = tuple(imgpts[0][0])\n\n # # set the current region to a list\n # self.setROIRegion(centerPoint[arucoIDRange[0]], centerPoint[arucoIDRange[1]])\n\n return (self.getROIRegition(), self.getROIRegionIDs())\n\n\n###############################################################################\n# sample codes\n###############################################################################\nif __name__ == \"__main__\":\n pass\n"
] |
[
[
"numpy.all",
"numpy.float32"
]
] |
DavidChoi76/spotpy
|
[
"850f8f64873f648f3a5f179eee27be71558e25b2"
] |
[
"spotpy/examples/tutorial_dream_hymod.py"
] |
[
"# -*- coding: utf-8 -*-\n'''\nCopyright 2015 by Tobias Houska\nThis file is part of Statistical Parameter Estimation Tool (SPOTPY).\n\n:author: Tobias Houska\n\nThis class holds example code how to use the dream algorithm\n'''\n\nimport numpy as np\nimport spotpy\n#from spotpy.examples.spot_setup_hymod_exe import spot_setup\nfrom spotpy.examples.spot_setup_hymod_python import spot_setup\nimport matplotlib.pyplot as plt\nfrom spotpy.likelihoods import gaussianLikelihoodMeasErrorOut as GausianLike\nfrom spotpy.analyser import plot_parameter_trace\nfrom spotpy.analyser import plot_posterior_parameter_histogram\nif __name__ == \"__main__\":\n parallel ='seq'\n # Initialize the Hymod example (will only work on Windows systems)\n #spot_setup=spot_setup(parallel=parallel)\n spot_setup=spot_setup(GausianLike)\n \n # Create the Dream sampler of spotpy, alt_objfun is set to None to force SPOTPY\n # to jump into the def objectivefunction in the spot_setup class (default is\n # spotpy.objectivefunctions.log_p) \n \n #Select number of maximum repetitions\n rep=5000\n \n # Select five chains and set the Gelman-Rubin convergence limit\n nChains = 4\n convergence_limit = 1.2\n \n # Other possible settings to modify the DREAM algorithm, for details see Vrugt (2016)\n nCr = 3\n eps = 10e-6\n runs_after_convergence = 100\n acceptance_test_option = 6\n \n sampler=spotpy.algorithms.dream(spot_setup, dbname='DREAM_hymod', dbformat='csv')\n r_hat = sampler.sample(rep, nChains, nCr, eps, convergence_limit, \n runs_after_convergence,acceptance_test_option)\n \n \n \n \n # Load the results gained with the dream sampler, stored in DREAM_hymod.csv\n results = spotpy.analyser.load_csv_results('DREAM_hymod')\n # Get fields with simulation data\n fields=[word for word in results.dtype.names if word.startswith('sim')]\n \n \n # Example plot to show remaining parameter uncertainty #\n fig= plt.figure(figsize=(9,6))\n ax = plt.subplot(1,1,1)\n q5,q25,q75,q95=[],[],[],[]\n for field in fields:\n q5.append(np.percentile(results[field][-100:-1],2.5))# ALl 100 runs after convergence\n q95.append(np.percentile(results[field][-100:-1],97.5))# ALl 100 runs after convergence\n ax.plot(q5,color='dimgrey',linestyle='solid')\n ax.plot(q95,color='dimgrey',linestyle='solid')\n ax.fill_between(np.arange(0,len(q5),1),list(q5),list(q95),facecolor='dimgrey',zorder=0,\n linewidth=0,label='simulation uncertainty') \n ax.plot(spot_setup.evaluation(),color='red', markersize=2,label='data')\n ax.set_ylim(-50,450)\n ax.set_xlim(0,729)\n ax.set_ylabel('Discharge [l s-1]')\n ax.set_xlabel('Days')\n ax.legend()\n fig.savefig('DREAM_simulation_uncertainty_Hymod.png',dpi=150)\n #########################################################\n \n \n # Example plot to show the convergence #################\n spotpy.analyser.plot_gelman_rubin(results, r_hat, fig_name='DREAM_r_hat.png')\n ########################################################\n \n \n \n \n # Example plot to show the parameter distribution ######\n parameters = spotpy.parameter.get_parameters_array(spot_setup)\n \n fig, ax = plt.subplots(nrows=5, ncols=2)\n fig.set_figheight(9)\n fig.set_figwidth(9)\n for par_id in range(len(parameters)):\n plot_parameter_trace(ax[par_id][0], results, parameters[par_id])\n plot_posterior_parameter_histogram(ax[par_id][1], results, parameters[par_id])\n \n ax[-1][0].set_xlabel('Iterations')\n ax[-1][1].set_xlabel('Parameter range')\n \n plt.show()\n fig.tight_layout()\n fig.savefig('DREAM_parameter_uncertainty_Hymod.png',dpi=300)\n #######################################################"
] |
[
[
"matplotlib.pyplot.subplots",
"numpy.percentile",
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.show",
"matplotlib.pyplot.figure"
]
] |
sieniven/self-driving-project
|
[
"ae135319f0991a940241c71f498865822a4f5b80"
] |
[
"transfer-learning/vgg-demo.py"
] |
[
"# Load our images first, and we'll check what we have\nfrom glob import glob\nimport matplotlib.image as mpimg\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom keras.preprocessing import image\nfrom keras.applications.vgg16 import preprocess_input\n# Note - this will likely need to download a new version of VGG16\nfrom keras.applications.vgg16 import VGG16, decode_predictions\n\nimage_paths = glob('images/*.jpg')\n\n# Print out the image paths\nprint(image_paths)\n\n# View an example of an image\nexample = mpimg.imread(image_paths[0])\nplt.imshow(example)\nplt.show()\n\n# Here, we'll load an image and pre-process it\ni = 0 # Can change this to your desired image to test\nimg_path = image_paths[i]\nimg = image.load_img(img_path, target_size=(224, 224))\nx = image.img_to_array(img)\nx = np.expand_dims(x, axis=0)\nx = preprocess_input(x)\n\n# Load the pre-trained model\nmodel = VGG16(weights='imagenet')\n\n# Perform inference on our pre-processed image\npredictions = model.predict(x)\n\n# Check the top 3 predictions of the model\nprint('Predicted:', decode_predictions(predictions, top=3)[0])"
] |
[
[
"matplotlib.image.imread",
"matplotlib.pyplot.imshow",
"matplotlib.pyplot.show",
"numpy.expand_dims"
]
] |
flyingdutchman23/step-detector
|
[
"07d3a94917cc646cc3bb6e98c3284bd4725654e7"
] |
[
"data_processing/nn_models/mlp.py"
] |
[
"import tensorflow as tf\n\n\ndef build_mlp_model_fn(dense_layers=(20, 20), learning_rate=0.001, rho=0.95):\n def mlp_model_fn(features, labels, mode):\n \"\"\"Model function for MLP.\"\"\"\n acc_feat = features[\"accelerometer\"]\n layer = tf.reshape(acc_feat, [-1, acc_feat.shape[-2] * acc_feat.shape[-1]])\n\n for units in dense_layers:\n layer = tf.layers.dense(inputs=layer, units=units, activation=tf.nn.relu)\n layer = tf.layers.dropout(inputs=layer, rate=0.2, training=mode == tf.estimator.ModeKeys.TRAIN)\n\n # Logits Layer\n layer = tf.layers.dense(inputs=layer, units=2)\n\n predictions = {\n # Generate predictions (for PREDICT and EVAL mode)\n \"classes\": tf.argmax(input=layer, axis=1),\n # Add `softmax_tensor` to the graph. It is used for PREDICT and by the\n # `logging_hook`.\n \"probabilities\": tf.nn.softmax(layer, name=\"softmax_tensor\")}\n\n export_outputs = {'output_prediction': tf.estimator.export.PredictOutput(predictions)}\n\n if mode == tf.estimator.ModeKeys.PREDICT:\n return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions, export_outputs=export_outputs)\n\n # Calculate Loss (for both TRAIN and EVAL modes)\n onehot_labels = tf.one_hot(indices=tf.cast(labels, tf.int32), depth=2)\n loss = tf.losses.softmax_cross_entropy(onehot_labels=onehot_labels, logits=layer)\n\n # Configure the Training Op (for TRAIN mode)\n if mode == tf.estimator.ModeKeys.TRAIN:\n optimizer = tf.train.AdadeltaOptimizer(learning_rate=learning_rate, rho=rho, epsilon=1e-08)\n train_op = optimizer.minimize(loss=loss, global_step=tf.train.get_global_step())\n return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op, export_outputs=export_outputs)\n\n # Add evaluation metrics (for EVAL mode)\n eval_metric_ops = {\"accuracy\": tf.metrics.accuracy(labels=labels, predictions=predictions[\"classes\"]),\n \"true_pos\": tf.metrics.true_positives(labels=labels, predictions=predictions['classes']),\n \"true_neg\": tf.metrics.true_negatives(labels=labels, predictions=predictions['classes']),\n \"false_pos\": tf.metrics.false_positives(labels=labels, predictions=predictions['classes']),\n \"false_neg\": tf.metrics.false_negatives(labels=labels, predictions=predictions['classes'])}\n return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops, export_outputs=export_outputs)\n return mlp_model_fn\n"
] |
[
[
"tensorflow.nn.softmax",
"tensorflow.metrics.accuracy",
"tensorflow.metrics.true_negatives",
"tensorflow.metrics.false_negatives",
"tensorflow.estimator.export.PredictOutput",
"tensorflow.layers.dropout",
"tensorflow.reshape",
"tensorflow.cast",
"tensorflow.layers.dense",
"tensorflow.train.AdadeltaOptimizer",
"tensorflow.train.get_global_step",
"tensorflow.losses.softmax_cross_entropy",
"tensorflow.metrics.false_positives",
"tensorflow.estimator.EstimatorSpec",
"tensorflow.argmax",
"tensorflow.metrics.true_positives"
]
] |
liuweihust/worldcupodds
|
[
"72a6768587f54667332a13e910364f68c7a4f0ba"
] |
[
"src/datasets/WorldCup.py"
] |
[
"import csv\nimport sys\nimport json\nimport numpy as np\n\ndef VecScore2Res90(rec):\n if rec['comment'] != '':\n return [0.,1.,0.]\n elif rec['hscore'] > rec['gscore']:\n return [1.,0.,0.]\n elif rec['hscore'] < rec['gscore']:\n return [0.,0.,1.]\n else:\n return [0.,1.,0.]\n\ndef Score2Res90(rec):\n #[HostWin,Deuce,GuestWin]=[2,1,0]\n if rec['comment'] != '':\n return 1\n elif rec['hscore'] > rec['gscore']:\n return 2\n elif rec['hscore'] < rec['gscore']:\n return 0\n else:\n return 1\n\ndef offer2Res90(rec):\n rsum=0.\n rsum=rec['hwin']+rec['deuce']+rec['gwin']\n return [rec['hwin']/rsum,rec['deuce']/rsum,rec['gwin']/rsum]\n\nclass dataset_worldcup():\n def __init__(self,mode='WDL',batch_size=20):\n self._nationsdict=None\n self._datadir='../data/'\n self._trainfiles={'2006':'wc2006.csv','2010':'wc2010.csv','2014':'wc2014.csv'}\n self._testfiles={'2018':'wc2018.csv'}\n self._nationdictfile='nationdict.json'\n self._keys='date time host guest hwin deuce gwin hscore gscore comment'\n self._mode=mode\n\n self._batch_size=batch_size\n self._batchindex=0\n\n self._trainmatches={}\n self._traindata=[]\n self._matchnum=0\n\n self._testmatches={}\n self._testdata=[]\n\n def GetInputShape(self):\n return 3\n\n def GetNationName(self,nid):\n if self._nationsdict is None:\n return None\n \n for (key,value) in self._nationsdict.items():\n if value==nid:\n return key\n return None\n\n def GetNationCode(self,nation):\n if self._nationsdict is None:\n return None\n\n if self._nationsdict.has_key(nation):\n return self._nationsdict[nation]\n else:\n return None\n\n def loaddata(self,datadir='../data/'):\n with open(self._datadir+self._nationdictfile,'r') as f:\n self._nationsdict=json.load(f)\n f.close()\n\n lista=[]\n #print(self._trainfiles)\n for (key,dfile) in self._trainfiles.items():\n f = open(self._datadir+dfile,'r')\n reader = csv.reader(f)\n rows=[row for row in reader]\n lists=[]\n for row in rows:\n match = {}\n res=[]\n match['date']=row[0]\n match['time']=row[1]\n match['host']=self.GetNationCode(row[2])\n match['guest']=self.GetNationCode(row[3])\n match['hwin']=float(row[4])\n match['deuce']=float(row[5])\n match['gwin']=float(row[6])\n match['hscore']=int(row[7])\n match['gscore']=int(row[8])\n match['comment']=row[9]\n lists.insert(0,match)\n \n if self._mode == 'WDL':\n #res.extend(offer2Res90(match))\n #res.extend(Score2Res90(match))\n\n res.extend([match['hwin'],match['deuce'],match['gwin']])\n res.append( float(Score2Res90(match)) )\n lista.append(res)\n\n self._trainmatches[key]=lists\n self._traindata=np.array(lista)\n self._matchnum=self._traindata.shape[0]\n\n for (key,dfile) in self._testfiles.items():\n f = open(self._datadir+dfile,'r')\n reader = csv.reader(f)\n rows=[row for row in reader]\n lists=[]\n for row in rows:\n match = {}\n res=[]\n match['date']=row[0]\n match['time']=row[1]\n match['host']=self.GetNationCode(row[2])\n match['guest']=self.GetNationCode(row[3])\n match['hwin']=float(row[4])\n match['deuce']=float(row[5])\n match['gwin']=float(row[6])\n match['hscore']=int(row[7])\n match['gscore']=int(row[8])\n match['comment']=row[9]\n lists.insert(0,match)\n \n if self._mode == 'WDL':\n #res.extend(offer2Res90(match))\n #res.extend(Score2Res90(match))\n\n res.extend([match['hwin'],match['deuce'],match['gwin']])\n res.append( float(Score2Res90(match)) )\n lista.append(res)\n\n self._testmatches[key]=lists\n self._testdata=np.array(lista)\n\n def GetMatchDataByYear(self,year):\n return self._trainmatches[year]\n\n def PrintNations(self):\n mystr=json.dumps(self._nationsdict,sort_keys=True,indent=4)\n print(mystr)\n\n def PrintMatches(self):\n for (year,yeardata) in self._trainmatches.items():\n print(\"%s:\"%(year))\n sys.stdout.write(\"%12s\"%'date')\n sys.stdout.write(\"%6s\"%'time')\n sys.stdout.write(\"%12s\"%'host')\n sys.stdout.write(\"%12s\"%'guest')\n sys.stdout.write(\"%5s\"%'hwin')\n sys.stdout.write(\"%5s\"%'draw')\n sys.stdout.write(\"%5s\"%'gwin')\n sys.stdout.write(\"%8s\"%'hscore')\n sys.stdout.write(\"%8s\"%'gscore')\n sys.stdout.write(\"%5s\"%'comt')\n sys.stdout.write(\"\\n\")\n\n for match in yeardata:\n sys.stdout.write(\"%12s\"%match['date'])\n sys.stdout.write(\"%6s\"%match['time'])\n sys.stdout.write(\"%12s\"%self.GetNationName(match['host']))\n sys.stdout.write(\"%12s\"%self.GetNationName(match['guest']))\n sys.stdout.write(\"%5.1f\"%match['hwin'])\n sys.stdout.write(\"%5.1f\"%match['deuce'])\n sys.stdout.write(\"%5.1f\"%match['gwin'])\n sys.stdout.write(\"%8d\"%match['hscore'])\n sys.stdout.write(\"%8d\"%match['gscore'])\n sys.stdout.write(\"%5s\"%match['comment'])\n sys.stdout.write(\"\\n\")\n\n for (year,yeardata) in self._testmatches.items():\n print(\"%s:\"%(year))\n sys.stdout.write(\"%12s\"%'date')\n sys.stdout.write(\"%6s\"%'time')\n sys.stdout.write(\"%12s\"%'host')\n sys.stdout.write(\"%12s\"%'guest')\n sys.stdout.write(\"%5s\"%'hwin')\n sys.stdout.write(\"%5s\"%'draw')\n sys.stdout.write(\"%5s\"%'gwin')\n sys.stdout.write(\"%8s\"%'hscore')\n sys.stdout.write(\"%8s\"%'gscore')\n sys.stdout.write(\"%5s\"%'comt')\n sys.stdout.write(\"\\n\")\n\n for match in yeardata:\n sys.stdout.write(\"%12s\"%match['date'])\n sys.stdout.write(\"%6s\"%match['time'])\n sys.stdout.write(\"%12s\"%self.GetNationName(match['host']))\n sys.stdout.write(\"%12s\"%self.GetNationName(match['guest']))\n sys.stdout.write(\"%5.1f\"%match['hwin'])\n sys.stdout.write(\"%5.1f\"%match['deuce'])\n sys.stdout.write(\"%5.1f\"%match['gwin'])\n sys.stdout.write(\"%8d\"%match['hscore'])\n sys.stdout.write(\"%8d\"%match['gscore'])\n sys.stdout.write(\"%5s\"%match['comment'])\n sys.stdout.write(\"\\n\")\n\n def GetNextbatch(self):\n if self._batch_size+self._batchindex < self._matchnum:\n a = self._traindata[self._batchindex:self._batch_size+self._batchindex,0:3]\n b = self._traindata[self._batchindex:self._batch_size+self._batchindex,3]\n self._batchindex += self._batch_size\n if self._batchindex >= self._matchnum:\n self._batchindex=0\n return a,b\n else:\n a=self._traindata[self._batchindex:,0:3]\n b=self._traindata[self._batchindex:,3]\n if self._batch_size + self._batchindex > self._matchnum:\n aa = self._traindata[0:self._batch_size + self._batchindex - self._matchnum,0:3]\n bb = self._traindata[0:self._batch_size + self._batchindex - self._matchnum,3]\n a = np.concatenate(a,aa)\n b = np.concatenate(b,bb)\n self._batchindex = 0\n return a,b\n\n def GetTestData(self):\n return self._testdata[:,0:3],self._testdata[:,3]\n\ndef Usage(execname):\n print(\"Usage:\")\n print(\" %s [OutDictfile]\"%(execname))\n print(\"\")\n\nif __name__ == '__main__':\n data = dataset_worldcup()\n data.loaddata()\n data.PrintNations()\n data.PrintMatches()\n\n \"\"\"\n for _ in range(20):\n a,b = data.GetNextbatch()\n print(a,b)\n \"\"\"\n"
] |
[
[
"numpy.concatenate",
"numpy.array"
]
] |
soosten/halite-bot
|
[
"b5ecc20cb8407c6ecfda58c4850ac8017033f34a"
] |
[
"src/spawns.py"
] |
[
"import numpy as np\n\nfrom convert import working_yards\nfrom settings import (SPAWNING_STEP, STEPS_FINAL, MIN_SHIPS, SPAWNING_OFFSET,\n YARD_SCHEDULE)\n\n\nclass Spawns:\n def __init__(self, state, actions):\n # determine how many ships to build\n self.num_ships(state, actions)\n\n # positions of yards for which we can still decide actions\n yards = [state.my_yards[yard] for yard in actions.yards]\n self.spawn_pos = np.array(yards, dtype=int)\n\n # sort yard positions by preference for spawning - spawn\n # where there are less of our own ships in the area\n # but strongly prefer not to spawn at abandoned yards\n inds = np.ix_(state.my_ship_pos, self.spawn_pos)\n traffic = np.sum(state.dist[inds] <= 3, axis=0, initial=0)\n not_working = ~np.in1d(self.spawn_pos, working_yards(state))\n score = traffic + 10 * not_working.astype(int)\n self.spawn_pos = self.spawn_pos[score.argsort()]\n return\n\n def num_ships(self, state, actions):\n # determine how many ships we would like to spawn based on all players'\n # number of ships and score = halite + cargo\n ships = state.my_ship_pos.size\n score = state.my_halite + np.sum(state.my_ship_hal)\n max_opp_ships = max(state.opp_num_ships.values(), default=0)\n max_opp_score = max(state.opp_scores.values(), default=0)\n\n # keep at least MIN_SHIPS ships\n bound = MIN_SHIPS - ships\n new_ships = max(bound, 0)\n\n # spawn if we have fewer ships than the opponents\n # but take this less seriously at the end of the game\n offset = SPAWNING_OFFSET * (state.step / state.total_steps)\n bound = max_opp_ships - offset - ships\n new_ships = max(bound, new_ships)\n\n # spawn if we have more halite than opponents. the buffer below is\n # ~500 (= spawnCost) halfway through the game and ~1500\n # (= spawnCost + 2 * convertCost) when there are < 50 steps remaining\n op_costs = state.spawn_cost + state.convert_cost\n buffer = 2 * op_costs * ((state.step / state.total_steps) ** 2)\n bound = (score - max_opp_score - buffer) // state.spawn_cost\n new_ships = max(bound, new_ships)\n\n # spawn if we there is a lot of time left\n bound = len(YARD_SCHEDULE) * (state.step < SPAWNING_STEP)\n new_ships = max(bound, new_ships)\n\n # don't spawn if its no longer worth it and we have a few ships\n if (state.total_steps - state.step < STEPS_FINAL) and (ships >= 5):\n new_ships = 0\n\n # number of ships wanted without constraints\n self.ships_wanted = int(new_ships)\n\n # number of ships we can build with constraints\n possible = min(new_ships, state.my_halite // state.spawn_cost)\n self.ships_possible = min(int(possible), len(actions.yards))\n return\n\n def spawn(self, state, actions):\n # remove spawn_pos that are occupied by ships after this turn\n occupied = state.moved_this_turn[self.spawn_pos]\n free_pos = self.spawn_pos[~occupied]\n\n # get ids of the yards that should spawn\n pos_to_yard = {v: k for k, v in state.my_yards.items()}\n ids = [pos_to_yard[pos] for pos in free_pos[0:self.ships_possible]]\n\n # write the appropriate actions into actions.decided\n actions.decided.update({yard: \"SPAWN\" for yard in ids})\n actions.yards.clear()\n return\n"
] |
[
[
"numpy.ix_",
"numpy.array",
"numpy.sum"
]
] |
ktl014/mrec
|
[
"e3fb987572ab302ad0a17bba437bc9693e467af6"
] |
[
"mrec/data/dataset.py"
] |
[
"\"\"\"Dataset Operations\n\nDataset operations module currently contains functions for the following:\n- reading datasets\n- loading & processing datasets\n\n\"\"\"\n# Standard Dist\nfrom collections import namedtuple\nimport logging\nimport os\n\n# Third Party Imports\nimport pandas as pd\n\n# Project Level Imports\nfrom mrec.data.rel_database import Database\n\nlogger = logging.getLogger(__name__)\n\ndef load_data(csv_fnames, processed=False):\n \"\"\"Load dataset into tuple collection object\n\n Dataset will contain at default the raw dataset. Optionally, the feature\n engineered dataset can be included by turning on the `processed` argument.\n\n Usage\n\n >>> from mrec.data.dataset import load_data\n >>> csv_fnames = {'train': '../../dataset/raw/train.csv', 'validation': '../../dataset/raw/validation.csv'}\n >>> dataset = load_data(csv_fnames)\n MRECDataset(train=..., validation=...)\n\n Args:\n csv_fnames (dict): Dictionary containing csv absolute paths\n processed (bool): Flag for including processed dataset. Default is False.\n\n Returns:\n MRECDataset: MREC Dataset\n\n \"\"\"\n datasets = {}\n for data, csv_path in csv_fnames.items():\n if not os.path.exists(csv_path):\n raise FileNotFoundError(f\"File {csv_path} was not found. Current dir: {os.getcwd()}\")\n\n datasets[data] = pd.read_csv(csv_path)\n logger.debug(f'Loaded dataset ({data}:{csv_path})')\n\n if processed:\n raise ValueError(\"Processed dataset loading is not an option yet.\")\n\n MRECDataset = namedtuple('MRECDataset', list(datasets.keys()))\n return MRECDataset(**datasets)\n\n\ndef load_rel_database(db_path :str, table_name):\n \"\"\"Load dataset from rel database to dataframe\n\n Usage\n ------\n >>> from mrec.data.dataset import load_rel_database\n >>> table_name = 'mrec_table'\n >>> db_path = '../../dataset/external/mrec.db'\n >>> df = load_rel_database(db_path, table_name)\n\n Args:\n db_path (str): database file path to load data from\n table_name (str): the name of the table in the database\n\n Returns:\n DataFrame: unprocessed data from rel database\n \"\"\"\n if not isinstance(db_path, str):\n raise TypeError(\"Error found with type of input `db_path` when loading rel database\")\n\n if not os.path.exists(db_path):\n raise FileNotFoundError(f\"File {db_path} was not found. Current dir: {os.getcwd()}\")\n\n db = Database(db_path)\n SQL_QUERY = \"SELECT * FROM \" + table_name\n dataset = pd.read_sql(SQL_QUERY, con=db.conn)\n db.close_connection()\n\n return dataset\n"
] |
[
[
"pandas.read_csv",
"pandas.read_sql"
]
] |
LindgeW/BiaffineParser
|
[
"3671f9f5d4fdbcad67d90ecfdafbeb316e4378db"
] |
[
"modules/layer.py"
] |
[
"import torch\nimport torch.nn as nn\n\n\nclass NonlinearMLP(nn.Module):\n def __init__(self, in_feature, out_feature, activation=nn.ReLU(), bias=True):\n super(NonlinearMLP, self).__init__()\n\n if activation is None:\n self.activation = lambda x: x\n else:\n assert callable(activation)\n self.activation = activation\n\n self.bias = bias\n self.linear = nn.Linear(in_features=in_feature,\n out_features=out_feature,\n bias=bias)\n\n def reset_parameters(self):\n nn.init.orthogonal_(self.linear.weight)\n if self.bias:\n nn.init.zeros_(self.linear.bias)\n\n def forward(self, inputs):\n linear_out = self.linear(inputs)\n return self.activation(linear_out)\n\n\nclass Biaffine(nn.Module):\n def __init__(self, in_features,\n out_features=1,\n bias=(True, True) # True = 1 False = 0\n ):\n super(Biaffine, self).__init__()\n self.in_features = in_features # mlp_arc_size / mlp_label_size\n self.out_features = out_features # 1 / rel_size\n self.bias = bias\n\n # arc / label: mlp_size + 1\n self.linear_input_size = in_features + bias[0]\n # arc: mlp_size\n # label: (mlp_size + 1) * rel_size\n self.linear_output_size = out_features * (in_features + bias[1])\n\n self.linear = nn.Linear(in_features=self.linear_input_size,\n out_features=self.linear_output_size,\n bias=False)\n self.reset_parameters()\n\n def reset_parameters(self):\n nn.init.xavier_uniform_(self.linear.weight)\n # nn.init.zeros_(self.linear.weight)\n\n def forward(self, input1, input2):\n batch_size, len1, dim1 = input1.size()\n batch_size, len2, dim2 = input2.size()\n\n if self.bias[0]:\n ones = input1.data.new_ones(batch_size, len1, 1)\n input1 = torch.cat((input1, ones), dim=-1)\n # dim1 += 1\n if self.bias[1]:\n ones = input2.data.new_ones(batch_size, len2, 1)\n input2 = torch.cat((input2, ones), dim=-1)\n # dim2 += 1\n\n # (bz, len1, dim1+1) -> (bz, len1, linear_output_size)\n affine = self.linear(input1)\n\n # (bz, len1 * self.out_features, dim2)\n affine = affine.reshape(batch_size, len1 * self.out_features, -1)\n\n # (bz, len1 * out_features, dim2) * (bz, dim2, len2)\n # -> (bz, len1 * out_features, len2) -> (bz, len2, len1 * out_features)\n biaffine = torch.bmm(affine, input2.transpose(1, 2)).transpose(1, 2)\n\n # (bz, len2, len1, out_features) # out_features: 1 or rel_size\n biaffine = biaffine.reshape((batch_size, len2, len1, -1))\n\n return biaffine\n"
] |
[
[
"torch.cat",
"torch.nn.Linear",
"torch.nn.init.xavier_uniform_",
"torch.nn.init.orthogonal_",
"torch.nn.init.zeros_",
"torch.nn.ReLU"
]
] |
stevenstetzler/feets
|
[
"54804271bc78215f84c0261d0ee1282623274cce"
] |
[
"feets/extractors/ext_car.py"
] |
[
"#!/usr/bin/env python\n\n# The MIT License (MIT)\n\n# Copyright (c) 2017 Juan Cabral\n\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n\n# The above copyright notice and this permission notice shall be included in\n# all copies or substantial portions of the Software.\n\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n# SOFTWARE.\n\n\n# =============================================================================\n# DOC\n# =============================================================================\n\n\"\"\"\"\"\"\n\n\n# =============================================================================\n# IMPORTS\n# =============================================================================\n\nimport warnings\n\nimport numpy as np\n\nfrom scipy.optimize import minimize\n\nfrom .core import Extractor, FeatureExtractionWarning\n\n\n# =============================================================================\n# CONST\n# =============================================================================\n\nEPSILON = 1e-300\n\nCTE_NEG = -np.infty\n\n\n# =============================================================================\n# FUNCTIONS\n# =============================================================================\n\ndef _car_like(parameters, t, x, error_vars):\n sigma, tau = parameters\n\n t, x, error_vars = t.flatten(), x.flatten(), error_vars.flatten()\n\n b = np.mean(x) / tau\n num_datos = np.size(x)\n\n Omega = [(tau * (sigma ** 2)) / 2.]\n x_hat = [0.]\n x_ast = [x[0] - b * tau]\n\n loglik = 0.\n\n for i in range(1, num_datos):\n\n a_new = np.exp(-(t[i] - t[i - 1]) / tau)\n\n x_ast.append(x[i] - b * tau)\n\n x_hat.append(\n a_new * x_hat[i - 1] +\n (a_new * Omega[i - 1] / (Omega[i - 1] + error_vars[i - 1])) *\n (x_ast[i - 1] - x_hat[i - 1]))\n\n Omega.append(\n Omega[0] * (1 - (a_new ** 2)) + ((a_new ** 2)) * Omega[i - 1] *\n (1 - (Omega[i - 1] / (Omega[i - 1] + error_vars[i - 1]))))\n\n loglik_inter = np.log(\n ((2 * np.pi * (Omega[i] + error_vars[i])) ** -0.5) *\n (np.exp(-0.5 * (((x_hat[i] - x_ast[i]) ** 2) /\n (Omega[i] + error_vars[i]))) + EPSILON))\n\n loglik = loglik + loglik_inter\n\n if loglik <= CTE_NEG:\n warnings.warn(\n \"CAR log-likelihood to inf\", FeatureExtractionWarning)\n return -np.infty\n\n # the minus one is to perfor maximization using the minimize function\n return -loglik\n\n\n# =============================================================================\n# EXTRACTOR CLASS\n# =============================================================================\n\nclass CAR(Extractor):\n r\"\"\"In order to model the irregular sampled times series we use CAR\n (Brockwell and Davis, 2002), a continious time auto regressive model.\n\n CAR process has three parameters, it provides a natural and consistent way\n of estimating a characteristic time scale and variance of light-curves.\n CAR process is described by the following stochastic differential equation:\n\n .. math::\n\n dX(t) = - \\frac{1}{\\tau} X(t)dt +\n \\sigma_C \\sqrt{dt} \\epsilon(t) + bdt, \\\\\n for \\: \\tau, \\sigma_C, t \\geq 0\n\n where the mean value of the lightcurve :math:`X(t)` is :math:`b\\tau`\n and the variance is :math:`\\frac{\\tau\\sigma_C^2}{2}`.\n :math:`\\tau` is the relaxation time of the process :math:`X(t)`, it can\n be interpreted as describing the variability amplitude of the time series.\n :math:`\\sigma_C` can be interpreted as describing the variability of the\n time series on time scales shorter than :math:`\\tau`.\n :math:`\\epsilon(t)` is a white noise process with zero mean and variance\n equal to one.\n\n The likelihood function of a CAR model for a light-curve with observations\n :math:`x - \\{x_1, \\dots, x_n\\}` observed at times\n :math:`\\{t_1, \\dots, t_n\\}` with measurements error variances\n :math:`\\{\\delta_1^2, \\dots, \\delta_n^2\\}` is:\n\n .. math::\n\n p (x|b,\\sigma_C,\\tau) = \\prod_{i=1}^n \\frac{1}{\n [2 \\pi (\\Omega_i + \\delta_i^2 )]^{1/2}} exp \\{-\\frac{1}{2}\n \\frac{(\\hat{x}_i - x^*_i )^2}{\\Omega_i + \\delta^2_i}\\} \\\\\n\n x_i^* = x_i - b\\tau \\\\\n\n \\hat{x}_0 = 0 \\\\\n\n \\Omega_0 = \\frac{\\tau \\sigma^2_C}{2} \\\\\n\n \\hat{x}_i = a_i\\hat{x}_{i-1} + \\frac{a_i \\Omega_{i-1}}{\\Omega_{i-1} +\n \\delta^2_{i-1}} (x^*_{i-1} + \\hat{x}_{i-1}) \\\\\n\n \\Omega_i = \\Omega_0 (1- a_i^2 ) + a_i^2 \\Omega_{i-1}\n (1 - \\frac{\\Omega_{i-1}}{\\Omega_{i-1} + \\delta^2_{i-1}} )\n\n To find the optimal parameters we maximize the likelihood with respect to\n :math:`\\sigma_C` and :math:`\\tau` and calculate :math:`b` as the mean\n magnitude of the light-curve divided by :math:`\\tau`.\n\n .. code-block:: pycon\n\n >>> fs = feets.FeatureSpace(\n ... only=['CAR_sigma', 'CAR_tau','CAR_mean'])\n >>> features, values = fs.extract(**lc_periodic)\n >>> dict(zip(features, values))\n {'CAR_mean': -9.230698873903961,\n 'CAR_sigma': -0.21928049298842511,\n 'CAR_tau': 0.64112037377348619}\n\n References\n ----------\n\n .. [brockwell2002introduction] Brockwell, P. J., & Davis, R. A. (2002).\n Introduction toTime Seriesand Forecasting.\n\n .. [pichara2012improved] Pichara, K., Protopapas, P., Kim, D. W.,\n Marquette, J. B., & Tisserand, P. (2012). An improved quasar detection\n method in EROS-2 and MACHO LMC data sets. Monthly Notices of the Royal\n Astronomical Society, 427(2), 1284-1297.\n Doi:10.1111/j.1365-2966.2012.22061.x.\n\n \"\"\"\n data = ['magnitude', 'time', 'error']\n features = [\"CAR_sigma\", \"CAR_tau\", \"CAR_mean\"]\n params = {\"minimize_method\": \"nelder-mead\"}\n\n def _calculate_CAR(self, time, magnitude, error, minimize_method):\n magnitude = magnitude.copy()\n time = time.copy()\n error = error.copy() ** 2\n\n x0 = [10, 0.5]\n bnds = ((0, 100), (0, 100))\n with warnings.catch_warnings():\n warnings.filterwarnings('ignore')\n res = minimize(_car_like, x0,\n args=(time, magnitude, error),\n method=minimize_method, bounds=bnds)\n sigma, tau = res.x[0], res.x[1]\n return sigma, tau\n\n def fit(self, magnitude, time, error, minimize_method):\n sigma, tau = self._calculate_CAR(\n time, magnitude, error, minimize_method)\n mean = np.mean(magnitude) / tau\n\n return {\"CAR_sigma\": sigma, \"CAR_tau\": tau, \"CAR_mean\": mean}\n"
] |
[
[
"numpy.size",
"numpy.exp",
"numpy.mean",
"scipy.optimize.minimize"
]
] |
aksr-aashish/DaisyX-Extra
|
[
"e1cafbbb4f5a7845ffd70e16e4395e7e797b2cf7"
] |
[
"bassboost.py"
] |
[
"import asyncio\nimport io\nimport math\nimport os\n\nimport numpy as np\nfrom pydub import AudioSegment\nfrom telethon import types\n\nfrom DaisyX.utils import admin_cmd\n\n\n@bot.on(admin_cmd(pattern=\"bassbost ?(.*)\"))\nasync def __(message):\n v = False\n accentuate_db = 40\n reply = await message.get_reply_message()\n if not reply:\n await message.edit(\"Can You Reply To A MSG :?\")\n return\n if message.pattern_match.group(1):\n ar = message.pattern_match.group(1)\n try:\n int(ar)\n if int(ar) >= 2 and int(ar) <= 100:\n accentuate_db = int(ar)\n else:\n await message.edit(\"`BassBost Level Should Be From 2 to 100 Only.`\")\n return\n except Exception as exx:\n await message.edit(\"`SomeThing Went Wrong..` \\n**Error:** \" + str(exx))\n return\n else:\n accentuate_db = 2\n await message.edit(\"`Downloading This File...`\")\n fname = await borg.download_media(message=reply.media)\n await message.edit(\"`BassBoosting In Progress..`\")\n if fname.endswith(\".oga\") or fname.endswith(\".ogg\"):\n v = True\n audio = AudioSegment.from_file(fname)\n elif fname.endswith(\".mp3\") or fname.endswith(\".m4a\") or fname.endswith(\".wav\"):\n audio = AudioSegment.from_file(fname)\n else:\n await message.edit(\n \"`This Format is Not Supported Yet` \\n**Currently Supported :** `mp3, m4a and wav.`\"\n )\n os.remove(fname)\n return\n sample_track = list(audio.get_array_of_samples())\n await asyncio.sleep(0.3)\n est_mean = np.mean(sample_track)\n await asyncio.sleep(0.3)\n est_std = 3 * np.std(sample_track) / (math.sqrt(2))\n await asyncio.sleep(0.3)\n bass_factor = int(round((est_std - est_mean) * 0.005))\n await asyncio.sleep(5)\n attenuate_db = 0\n filtered = audio.low_pass_filter(bass_factor)\n await asyncio.sleep(5)\n out = (audio - attenuate_db).overlay(filtered + accentuate_db)\n await asyncio.sleep(6)\n m = io.BytesIO()\n if v:\n m.name = \"voice.ogg\"\n out.split_to_mono()\n await message.edit(\"`Now Exporting...`\")\n await asyncio.sleep(0.3)\n out.export(m, format=\"ogg\", bitrate=\"64k\", codec=\"libopus\")\n await message.edit(\"`Process Completed. Uploading Now Here..`\")\n await borg.send_file(\n message.to_id,\n m,\n reply_to=reply.id,\n voice_note=True,\n caption=\"Bass Boosted, \\nDone By VirtualUserbot\",\n )\n os.remove(m)\n else:\n m.name = \"BassBoosted.mp3\"\n await message.edit(\"`Now Exporting...`\")\n await asyncio.sleep(0.3)\n out.export(m, format=\"mp3\")\n await message.edit(\"`Process Completed. Uploading Now Here..`\")\n await borg.send_file(\n message.to_id,\n m,\n reply_to=reply.id,\n attributes=[\n types.DocumentAttributeAudio(\n duration=reply.document.attributes[0].duration,\n title=f\"BassBoost {str(accentuate_db)}lvl\",\n performer=\"BassBoost\",\n )\n ],\n caption=\"Bass Boosted, \\nDone By VirtualUserbot\",\n )\n os.remove(m)\n await message.delete()\n os.remove(fname)\n"
] |
[
[
"numpy.std",
"numpy.mean"
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.