repo_name
stringlengths 6
130
| hexsha
list | file_path
list | code
list | apis
list |
|---|---|---|---|---|
MaricelaM/torchdiffeq
|
[
"4bd6a7a57fc895fb56ad59c67924ec08baaf221e"
] |
[
"tests/gradient_tests.py"
] |
[
"import unittest\nimport torch\nimport torchdiffeq\n\nfrom problems import construct_problem, PROBLEMS, DEVICES, METHODS\n\n\ndef max_abs(tensor):\n return torch.max(torch.abs(tensor))\n\n\nclass TestGradient(unittest.TestCase):\n def test_odeint(self):\n for device in DEVICES:\n for method in METHODS:\n\n if method == 'scipy_solver':\n continue\n\n with self.subTest(device=device, method=method):\n f, y0, t_points, _ = construct_problem(device=device)\n func = lambda y0, t_points: torchdiffeq.odeint(f, y0, t_points, method=method)\n self.assertTrue(torch.autograd.gradcheck(func, (y0, t_points)))\n\n def test_adjoint(self):\n for device in DEVICES:\n for method in METHODS:\n\n with self.subTest(device=device, method=method):\n f, y0, t_points, _ = construct_problem(device=device)\n func = lambda y0, t_points: torchdiffeq.odeint_adjoint(f, y0, t_points, method=method)\n self.assertTrue(torch.autograd.gradcheck(func, (y0, t_points)))\n\n def test_adjoint_against_odeint(self):\n \"\"\"\n Test against dopri5\n \"\"\"\n for device in DEVICES:\n for ode in PROBLEMS:\n for t_grad in (True, False):\n if ode == 'constant':\n eps = 1e-12\n elif ode == 'linear':\n eps = 1e-5\n elif ode == 'sine':\n eps = 5e-3\n else:\n raise RuntimeError\n\n with self.subTest(device=device, ode=ode, t_grad=t_grad):\n f, y0, t_points, _ = construct_problem(device=device, ode=ode)\n t_points.requires_grad_(t_grad)\n\n ys = torchdiffeq.odeint(f, y0, t_points, rtol=1e-9, atol=1e-12)\n torch.manual_seed(0)\n gradys = torch.rand_like(ys)\n ys.backward(gradys)\n\n reg_y0_grad = y0.grad.clone()\n reg_t_grad = t_points.grad.clone() if t_grad else None\n reg_params_grads = []\n for param in f.parameters():\n reg_params_grads.append(param.grad.clone())\n\n y0.grad.zero_()\n if t_grad:\n t_points.grad.zero_()\n for param in f.parameters():\n param.grad.zero_()\n\n ys = torchdiffeq.odeint_adjoint(f, y0, t_points, rtol=1e-9, atol=1e-12)\n ys.backward(gradys)\n\n adj_y0_grad = y0.grad\n adj_t_grad = t_points.grad if t_grad else None\n adj_params_grads = []\n for param in f.parameters():\n adj_params_grads.append(param.grad)\n\n self.assertLess(max_abs(reg_y0_grad - adj_y0_grad), eps)\n if t_grad:\n self.assertLess(max_abs(reg_t_grad - adj_t_grad), eps)\n for reg_grad, adj_grad in zip(reg_params_grads, adj_params_grads):\n self.assertLess(max_abs(reg_grad - adj_grad), eps)\n\n\nclass TestCompareAdjointGradient(unittest.TestCase):\n\n def problem(self, device):\n class Odefunc(torch.nn.Module):\n def __init__(self):\n super(Odefunc, self).__init__()\n self.A = torch.nn.Parameter(torch.tensor([[-0.1, 2.0], [-2.0, -0.1]]))\n self.unused_module = torch.nn.Linear(2, 5)\n\n def forward(self, t, y):\n return torch.mm(y**3, self.A)\n\n y0 = torch.tensor([[2., 0.]], device=device, requires_grad=True)\n t_points = torch.linspace(0., 25., 10, device=device, requires_grad=True)\n func = Odefunc().to(device)\n return func, y0, t_points\n\n def test_against_dopri5(self):\n # TODO: add in adaptive adams if/when it's fixed.\n method_eps = {\n 'dopri5': (3e-4, 1e-4, 2e-3),\n 'scipy_solver': (3e-4, 1e-4, 2e-3),\n }\n for device in DEVICES:\n for method, eps in method_eps.items():\n for t_grad in (True, False):\n with self.subTest(device=device, method=method):\n func, y0, t_points = self.problem(device=device)\n t_points.requires_grad_(t_grad)\n\n ys = torchdiffeq.odeint_adjoint(func, y0, t_points, method=method)\n gradys = torch.rand_like(ys) * 0.1\n ys.backward(gradys)\n\n adj_y0_grad = y0.grad\n adj_t_grad = t_points.grad if t_grad else None\n adj_A_grad = func.A.grad\n self.assertEqual(max_abs(func.unused_module.weight.grad), 0)\n self.assertEqual(max_abs(func.unused_module.bias.grad), 0)\n\n func, y0, t_points = self.problem(device=device)\n ys = torchdiffeq.odeint(func, y0, t_points, method='dopri5')\n ys.backward(gradys)\n\n self.assertLess(max_abs(y0.grad - adj_y0_grad), eps[0])\n if t_grad:\n self.assertLess(max_abs(t_points.grad - adj_t_grad), eps[1])\n self.assertLess(max_abs(func.A.grad - adj_A_grad), eps[2])\n\n\nif __name__ == '__main__':\n unittest.main()\n"
] |
[
[
"torch.abs",
"torch.linspace",
"torch.mm",
"torch.rand_like",
"torch.manual_seed",
"torch.tensor",
"torch.nn.Linear",
"torch.autograd.gradcheck"
]
] |
ELEKTRONN/elektronn3
|
[
"502062995e6c31a99c56f256a3b777a502f2c20c"
] |
[
"elektronn3/training/metrics.py"
] |
[
"# ELEKTRONN3 - Neural Network Toolkit\n#\n# Copyright (c) 2017 - now\n# Max Planck Institute of Neurobiology, Munich, Germany\n# Authors: Martin Drawitsch\n\n# TODO: Update docs to show Evaluator\n\"\"\"Metrics and tools for evaluating neural network predictions\n\nReferences:\n\n- https://en.wikipedia.org/wiki/Confusion_matrix\n- https://stats.stackexchange.com/questions/273537/f1-dice-score-vs-iou\n- http://scikit-learn.org/stable/modules/model_evaluation.html\n\n.. note::\n\n ``sklearn.metrics`` has a lot of alternative implementations that can be\n compared with these here and could be used as inspiration for future work\n (http://scikit-learn.org/stable/modules/classes.html#classification-metrics).\n\n For example, to get the equivalent output to\n ``elektronn3.training.metrics.recall(target, pred, num_classes=2, mean=False) / 100``,\n from scikit-learn, you can compute\n ``sklearn.metrics.recall_score(target.view(-1).cpu().numpy(), pred.view(-1).cpu().numpy(), average=None).astype(np.float32)``.\n\n\n For most metrics, we don't use scikit-learn directly in this module for\n performance reasons:\n\n - PyTorch allows us to calculate metrics directly on GPU\n - We LRU-cache confusion matrices for cheap calculation of multiple metrics\n\"\"\"\n\nfrom functools import lru_cache\nfrom typing import Callable, Optional\n\nimport sklearn.metrics\nimport torch\n\n\neps = 0.0001 # To avoid divisions by zero\n\n# TODO: Tests would make a lot of sense here.\n\n\n@lru_cache(maxsize=128)\ndef confusion_matrix(\n target: torch.LongTensor,\n pred: torch.LongTensor,\n num_classes: int = 2,\n dtype: torch.dtype = torch.float32,\n device: torch.device = torch.device('cpu'),\n nan_when_empty: bool = True,\n ignore: Optional[int] = None,\n) -> torch.Tensor:\n \"\"\" Calculate per-class confusion matrix.\n\n Uses an LRU cache, so subsequent calls with the same arguments are very\n cheap.\n\n Args:\n pred: Tensor with predicted class values\n target: Ground truth tensor with true class values\n num_classes: Number of classes that the target can assume.\n E.g. for binary classification, this is 2.\n Classes are expected to start at 0\n dtype: ``torch.dtype`` to be used for calculation and output.\n ``torch.float32`` is used as default because it is robust\n against overflows and can be used directly in true divisions\n without re-casting.\n device: PyTorch device on which to store the confusion matrix\n nan_when_empty: If ``True`` (default), the confusion matrix will\n be filled with NaN values for each channel of which there are\n no positive entries in the ``target`` tensor.\n ignore: Index to be ignored for cm calculation\n\n Returns:\n Confusion matrix ``cm``, with shape ``(num_classes, 4)``, where\n each row ``cm[c]`` contains (in this order) the count of\n - true positives\n - true negatives\n - false positives\n - false negatives\n of ``pred`` w.r.t. ``target`` and class ``c``.\n\n E.g. ``cm[1][2]`` contains the number of false positive predictions\n of class ``1``.\n If ``nan_when_empty`` is enabled and there are no positive elements\n of class ``1`` in ``target``, ``cm[1]`` will instead be filled with\n NaN values.\n \"\"\"\n cm = torch.empty(num_classes, 4, dtype=dtype, device=device)\n for c in range(num_classes):\n pos_pred = pred == c\n neg_pred = ~pos_pred\n pos_target = target == c\n if ignore is not None:\n ign_target = target == ignore\n else:\n ign_target = False # Makes `& ~ign_target` a no-op\n # Manual conversion to Tensor because of a type promotion regression in PyTorch 1.5\n ign_target = torch.tensor(ign_target, dtype=torch.bool, device=device)\n neg_target = ~pos_target\n\n true_pos = (pos_pred & pos_target & ~ign_target).sum(dtype=dtype)\n true_neg = (neg_pred & neg_target & ~ign_target).sum(dtype=dtype)\n false_pos = (pos_pred & neg_target & ~ign_target).sum(dtype=dtype)\n false_neg = (neg_pred & pos_target & ~ign_target).sum(dtype=dtype)\n\n cm[c] = torch.tensor([true_pos, true_neg, false_pos, false_neg])\n\n if nan_when_empty and pos_target.sum(dtype=dtype) == 0:\n cm[c] = torch.tensor([float('nan')] * 4)\n\n return cm\n\n\ndef precision(target, pred, num_classes=2, mean=True, ignore=None):\n \"\"\"Precision metric (in %)\"\"\"\n cm = confusion_matrix(target, pred, num_classes=num_classes, ignore=ignore)\n tp, tn, fp, fn = cm.transpose(0, 1) # Transposing to put class axis last\n # Compute metrics for each class simulataneously\n prec = tp / (tp + fp + eps) # Per-class precision\n if mean:\n prec = prec.mean().item()\n return prec * 100\n\n\ndef recall(target, pred, num_classes=2, mean=True, ignore=None):\n \"\"\"Recall metric a.k.a. sensitivity a.k.a. hit rate (in %)\"\"\"\n cm = confusion_matrix(target, pred, num_classes=num_classes, ignore=ignore)\n tp, tn, fp, fn = cm.transpose(0, 1) # Transposing to put class axis last\n rec = tp / (tp + fn + eps) # Per-class recall\n if mean:\n rec = rec.mean().item()\n return rec * 100\n\n\ndef accuracy(target, pred, num_classes=2, mean=True, ignore=None):\n \"\"\"Accuracy metric (in %)\"\"\"\n cm = confusion_matrix(target, pred, num_classes=num_classes, ignore=ignore)\n tp, tn, fp, fn = cm.transpose(0, 1) # Transposing to put class axis last\n acc = (tp + tn) / (tp + tn + fp + fn + eps) # Per-class accuracy\n if mean:\n acc = acc.mean().item()\n return acc * 100\n\n\ndef dice_coefficient(target, pred, num_classes=2, mean=True, ignore=None):\n \"\"\"Sørensen–Dice coefficient a.k.a. DSC a.k.a. F1 score (in %)\"\"\"\n cm = confusion_matrix(target, pred, num_classes=num_classes, ignore=ignore)\n tp, tn, fp, fn = cm.transpose(0, 1) # Transposing to put class axis last\n dsc = 2 * tp / (2 * tp + fp + fn + eps) # Per-class (Sørensen-)Dice similarity coefficient\n if mean:\n dsc = dsc.mean().item()\n return dsc * 100\n\n\ndef iou(target, pred, num_classes=2, mean=True, ignore=None):\n \"\"\"IoU (Intersection over Union) a.k.a. IU a.k.a. Jaccard index (in %)\"\"\"\n cm = confusion_matrix(target, pred, num_classes=num_classes, ignore=ignore)\n tp, tn, fp, fn = cm.transpose(0, 1) # Transposing to put class axis last\n iu = tp / (tp + fp + fn + eps) # Per-class Intersection over Union\n if mean:\n iu = iu.mean().item()\n return iu * 100\n\n\ndef auroc(target, probs, mean=True):\n \"\"\" Area under Curve (AuC) of the ROC curve (in %).\n\n .. note::\n This implementation uses scikit-learn on the CPU to do the heavy\n lifting, so it's relatively slow (one call can take about 1 second\n for typical inputs).\n \"\"\"\n assert probs.dim() == target.dim() + 1\n num_classes = probs.shape[1]\n # target: (N, [D,], H, W) -> (N*[D,]*H*W,)\n target_npflat = target.view(-1).cpu().numpy()\n # probs: (N, C, [D,], H, W) -> (C, N*[D,]*H*W)\n probs_npflat = probs.transpose(1, 0).view(num_classes, -1).cpu().numpy()\n auc = torch.empty(num_classes)\n # Direct roc_auc_score() computation with multi-class arrays can take\n # hours, so split this into binary calculations manually here by looping\n # through classes:\n for c in range(num_classes):\n t = target_npflat == c # 1 where target is c, 0 everywhere else\n p = probs_npflat[c] # probs of class c\n auc[c] = sklearn.metrics.roc_auc_score(t, p)\n if mean:\n auc = auc.mean().item()\n return auc * 100\n\n\ndef average_precision(target, probs, mean=True):\n \"\"\"Average precision (AP) metric based on PR curves (in %).\n\n .. note::\n This implementation uses scikit-learn on the CPU to do the heavy\n lifting, so it's relatively slow (one call can take about 1 second\n for typical inputs).\n \"\"\"\n assert probs.dim() == target.dim() + 1\n num_classes = probs.shape[1]\n # target: (N, [D,], H, W) -> (N*[D,]*H*W,)\n target_npflat = target.view(-1).cpu().numpy()\n # probs: (N, C, [D,], H, W) -> (C, N*[D,]*H*W)\n probs_npflat = probs.transpose(1, 0).view(num_classes, -1).cpu().numpy()\n ap = torch.empty(num_classes)\n # Direct average_precision_score() computation with multi-class arrays can take\n # hours, so split this into binary calculations manually here by looping\n # through classes:\n for c in range(num_classes):\n t = target_npflat == c # 1 where target is c, 0 everywhere else\n p = probs_npflat[c] # probs of class c\n ap[c] = sklearn.metrics.average_precision_score(t, p)\n if mean:\n ap = ap.mean().item()\n return ap * 100\n\n\n@lru_cache(maxsize=128)\ndef _softmax(x, dim=1):\n return torch.nn.functional.softmax(x, dim)\n\n\n@lru_cache(maxsize=128)\ndef _argmax(x, dim=1):\n return x.argmax(dim)\n\n\n# Helper for multi-class metric construction\ndef channel_metric(metric, c, num_classes, argmax=True):\n \"\"\"Returns an evaluator that calculates the ``metric``\n and selects its value for channel ``c``.\n\n Example:\n >>> from elektronn3.training import metrics\n >>> num_classes = 5 # Example. Depends on model and data set\n >>> # Metric evaluator dict that registers DSCs of all output channels.\n >>> # You can pass it to elektronn3.training.Trainer as the ``valid_metrics``\n >>> # argument to make it log these values.\n >>> dsc_evaluators = {\n ... f'val_DSC_c{c}': channel_metric(\n ... metrics.dice_coefficient,\n ... c=c, num_classes=num_classes\n ... )\n ... for c in range(num_classes)\n ... }\n \"\"\"\n def evaluator(target, out):\n pred = _argmax(out) if argmax else out\n m = metric(target, pred, num_classes=num_classes, mean=False)\n return m[c]\n\n return evaluator\n\n\n# Metric evaluator shortcuts for raw network outputs in binary classification\n# tasks (\"bin_*\"). \"Raw\" means not softmaxed or argmaxed.\n\n# These are deprecated and will be removed later. Use Evaluators instead.\n\ndef bin_precision(target, out):\n pred = _argmax(out)\n return precision(\n target, pred, num_classes=2, mean=False\n )[1] # Take only the score for class 1\n\n\ndef bin_recall(target, out):\n pred = _argmax(out)\n return recall(\n target, pred, num_classes=2, mean=False\n )[1] # Take only the score for class 1\n\n\ndef bin_accuracy(target, out):\n pred = _argmax(out)\n return accuracy(\n target, pred, num_classes=2, mean=False\n )[1] # Take only the score for class 1\n\n\ndef bin_dice_coefficient(target, out):\n pred = _argmax(out)\n return dice_coefficient(\n target, pred, num_classes=2, mean=False\n )[1] # Take only the score for class 1\n\n\ndef bin_iou(target, out):\n pred = _argmax(out)\n return iou(\n target, pred, num_classes=2, mean=False\n )[1] # Take only the score for class 1\n\n\ndef bin_average_precision(target, out):\n probs = _softmax(out)\n return average_precision(\n target, probs, mean=False\n )[1] # Take only the score for class 1\n\n\ndef bin_auroc(target, out):\n probs = _softmax(out)\n return auroc(\n target, probs, mean=False\n )[1] # Take only the score for class 1\n\n\nclass Evaluator:\n name: str = 'generic'\n\n def __init__(\n self,\n metric_fn: Callable,\n index: Optional[int] = None,\n ignore: Optional[int] = None,\n ):\n self.metric_fn = metric_fn\n self.index = index\n self.ignore = ignore\n self.num_classes = None\n\n def __call__(self, target: torch.Tensor, out: torch.Tensor) -> float:\n if self.num_classes is None:\n self.num_classes = out.shape[1]\n pred = _argmax(out)\n m = self.metric_fn(target, pred, self.num_classes, mean=False, ignore=self.ignore)\n if self.index is None:\n return m.mean().item()\n return m[self.index].item()\n\n\nclass Accuracy(Evaluator):\n name = 'accuracy'\n def __init__(self, *args, **kwargs): super().__init__(accuracy, *args, **kwargs)\n\n\nclass Precision(Evaluator):\n name = 'precision'\n def __init__(self, *args, **kwargs): super().__init__(precision, *args, **kwargs)\n\n\nclass Recall(Evaluator):\n name = 'recall'\n def __init__(self, *args, **kwargs): super().__init__(recall, *args, **kwargs)\n\n\nclass IoU(Evaluator):\n name = 'IoU'\n def __init__(self, *args, **kwargs): super().__init__(iou, *args, **kwargs)\n\n\nclass DSC(Evaluator):\n name = 'DSC'\n def __init__(self, *args, **kwargs): super().__init__(dice_coefficient, *args, **kwargs)\n"
] |
[
[
"torch.device",
"torch.nn.functional.softmax",
"torch.empty",
"torch.tensor"
]
] |
cvxgrp/extquadcontrol
|
[
"be3b60e07755f1d0c514c7cafcd8cebeb61580fc"
] |
[
"examples/plot_settings.py"
] |
[
"import matplotlib.pyplot as plt\n\nplt.rc('font', family='serif', serif='Computer Modern Roman')\nplt.rc('text', usetex=True)\nplt.rc('xtick', labelsize=12)\nplt.rc('ytick', labelsize=12)\nplt.rc('axes', labelsize=12)\nplt.rc('legend', fontsize=12)\n\ndefault_width = 4\ndefault_height = default_width/1.618\n\ndef savefig(fig, loc, width=default_width, height=default_height):\n fig.set_size_inches(width, height)\n fig.savefig(loc)\n"
] |
[
[
"matplotlib.pyplot.rc"
]
] |
seqam-lab/MTDA-ITA
|
[
"5d249aa4a75f804180cbe30db1e0823668f068bd"
] |
[
"src/main.py"
] |
[
"import argparse\nimport os\nimport scipy.misc\nimport numpy as np\nimport tensorflow as tf\nfrom model import MDA\n\nparser = argparse.ArgumentParser(description='')\nparser.add_argument('--dataset_dir', dest='dataset_dir', default='svhn2mnist', help='path of the dataset')\nparser.add_argument('--epoch', dest='epoch', type=int, default=200, help='# of epoch')\nparser.add_argument('--batch_size', dest='batch_size', type=int, default=16, help='# images in batch')\nparser.add_argument('--train_size', dest='train_size', type=int, default=1e8, help='# images used to train')\nparser.add_argument('--load_size', dest='load_size', type=int, default=32, help='scale images to this size')\nparser.add_argument('--fine_size', dest='fine_size', type=int, default=32, help='then crop to this size')\nparser.add_argument('--ngf', dest='ngf', type=int, default=16, help='# of gen filters in first conv layer')\nparser.add_argument('--ndf', dest='ndf', type=int, default=8, help='# of discri filters in first conv layer')\nparser.add_argument('--input_nc', dest='input_nc', type=int, default=3, help='# of input image channels')\nparser.add_argument('--output_nc', dest='output_nc', type=int, default=3, help='# of output image channels')\nparser.add_argument('--num_domains', dest='num_domains', type=int, default=4, help='# domains')\nparser.add_argument('--num_source_domains', dest='num_source_domains', type=int, default=2, help='# source domains')\nparser.add_argument('--niter', dest='niter', type=int, default=200, help='# of iter at starting learning rate')\nparser.add_argument('--lr', dest='lr', type=float, default=0.0002, help='initial learning rate for adam')\nparser.add_argument('--beta1', dest='beta1', type=float, default=0.5, help='momentum term of adam')\nparser.add_argument('--flip', dest='flip', type=bool, default=True, help='if flip the images for data argumentation')\nparser.add_argument('--which_direction', dest='which_direction', default='AtoB', help='AtoB or BtoA')\nparser.add_argument('--phase', dest='phase', default='train', help='train, test')\nparser.add_argument('--is_pretrain', dest='is_pretrain', default=False, help='pretraining')\nparser.add_argument('--save_epoch_freq', dest='save_epoch_freq', type=int, default=10, help='save a model every save_epoch_freq epochs (does not overwrite previously saved models)')\nparser.add_argument('--save_latest_freq', dest='save_latest_freq', type=int, default=5000, help='save the latest model every latest_freq sgd iterations (overwrites the previous latest model)')\nparser.add_argument('--print_freq', dest='print_freq', type=int, default=50, help='print the debug information every print_freq iterations')\nparser.add_argument('--continue_train', dest='continue_train', type=bool, default=False, help='if continue training, load the latest model: 1: true, 0: false')\nparser.add_argument('--serial_batches', dest='serial_batches', type=bool, default=False, help='f 1, takes images in order to make batches, otherwise takes them randomly')\nparser.add_argument('--serial_batch_iter', dest='serial_batch_iter', type=bool, default=True, help='iter into serial image list')\nparser.add_argument('--checkpoint_dir', dest='checkpoint_dir', default='./checkpoint', help='models are saved here')\nparser.add_argument('--sample_dir', dest='sample_dir', default='./sample', help='sample are saved here')\nparser.add_argument('--test_dir', dest='test_dir', default='./test', help='test sample are saved here')\nparser.add_argument('--L1_lambda', dest='L1_lambda', type=float, default=10.0, help='weight on L1 term in objective')\nparser.add_argument('--use_resnet', dest='use_resnet', type=bool, default=True, help='generation network using reidule block')\nparser.add_argument('--use_lsgan', dest='use_lsgan', type=bool, default=True, help='gan loss defined in lsgan')\nparser.add_argument('--max_size', dest='max_size', type=int, default=50, help='max size of image pool, 0 means do not use image pool')\nparser.add_argument('--num_class', dest='num_class', type=int, default=10, help='Number of classes in source and target domains')\nparser.add_argument('--base_chnl', dest='base_chnl', type=int, default=16, help='Basic number of channels for the network')\n\n\nargs = parser.parse_args()\n\ndef main(_):\n if not os.path.exists(args.checkpoint_dir):\n os.makedirs(args.checkpoint_dir)\n if not os.path.exists(args.sample_dir):\n os.makedirs(args.sample_dir)\n if not os.path.exists(args.test_dir):\n os.makedirs(args.test_dir)\n\n with tf.Session() as sess:\n\n args.is_pretrain = False\n model = MDA(sess, args)\n #model.generate_reconstructed_images(args)\n #model.pretrain_private_encoder_shared_encoder_decoder(args)\n\n model.train(args) #if args.phase == 'train' \\\n #model.train_multiple_source(args) # if args.phase == 'train' \\\n #model.compute_accuracy(args)\n #model.visualization_2(args)\n #model.visualization(args)\n #model.new_sample_model(args)\n #with tf.Session () as sess:\n\n # args.is_pretrain = False\n # model = MDA (sess, args)\n\n #model.pretrain_private_encoder_shared_encoder_decoder (args)\n # args.is_pretrain = False\n #model.train(args) #if args.phase == 'train' \\\nif __name__ == '__main__':\n tf.app.run()\n"
] |
[
[
"tensorflow.Session",
"tensorflow.app.run"
]
] |
dho-IOD/futu_algo
|
[
"f4bdf5edcc261efbd252e9e9c53a89563b0ed68f"
] |
[
"fastquant/network.py"
] |
[
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue Apr 28, 2020\n\n\n@author: jpdeleon\n\"\"\"\n# Import standard library\nimport itertools\nfrom datetime import datetime\nfrom pathlib import Path\n\n# Import modules\nimport matplotlib.pyplot as pl\nimport numpy as np\nimport pandas as pd\nimport networkx as nx\n\n# Import from package\nfrom fastquant.data import get_pse_data_cache\nfrom fastquant.config import DATA_PATH, CALENDAR_FORMAT\n\nTODAY = datetime.now().date().strftime(CALENDAR_FORMAT)\n\n__all__ = [\"Network\"]\n\n\nclass Network:\n \"\"\"\n Parameters\n ----------\n symbol : str\n phisix company symbol (optional)\n sector : str\n specific sector\n sigma : float\n outlier rejection threshold (default=None)\n metric : str\n distance metrics:\n bonnano=distinguishes between a + or a - correlated pair of stocks;\n bonnano=does not distinguish\n n_companies : str\n limit to top n companies correlated to symbol (if symbol is given)\n \"\"\"\n\n def __init__(\n self,\n symbol=None,\n sector=None,\n start_date=\"1-1-2020\",\n end_date=None,\n metric=\"bonnano\",\n n_companies=5,\n sigma=5,\n exclude_symbols=None,\n interpolation_method=\"pad\",\n indicator=\"close\",\n verbose=True,\n clobber=False,\n update_cache=False,\n ):\n self.symbol = None if symbol is None else symbol.upper()\n self.sector = sector\n self.start_date = start_date\n self.end_date = TODAY if end_date is None else end_date\n self.stock_data = None\n self.verbose = verbose\n self.clobber = clobber\n self.sigma = sigma\n self.exclude_symbols = exclude_symbols\n self.indicator = indicator\n self.interpolation_method = interpolation_method\n self.n_companies = n_companies\n self.update_cache = update_cache\n self.data_cache = get_pse_data_cache(\n update=self.update_cache, verbose=False\n )\n self.data = self.data_cache.xs(indicator, level=1, axis=1)\n self.filtered_data = self.filter_data()\n self.company_table = self.load_company_table()\n self.all_sectors = self.company_table.Sector.unique().tolist()\n self.all_subsectors = self.company_table.Subsector.unique().tolist()\n self.price_corr = self.compute_corr()\n self.metric = metric.lower()\n self.dist, self.labs = self.build_distance_matrix()\n self.MST = self.build_minimum_spanning_tree()\n self.populate_graph_attribute()\n\n def load_company_table(self):\n fp = Path(DATA_PATH, \"stock_table.csv\")\n table = pd.read_csv(fp)\n self.company_table = table\n return table\n\n def get_sector_of_symbol(self, symbol):\n \"\"\"get sector or subsector where symbol belongs\n \"\"\"\n info = self.company_table.copy()\n sector = info.loc[\n info[\"Stock Symbol\"].isin([symbol]), \"Sector\"\n ].values[0]\n return sector\n\n def get_symbols_of_a_sector(self, sector, subsector=False, verbose=False):\n \"\"\"get symbols of members in the sector\n \"\"\"\n info = self.company_table.copy()\n column = \"Subsector\" if subsector else \"Sector\"\n sectors_dict = info[[\"Stock Symbol\", column]].groupby(column).groups\n\n sector_indices = sectors_dict[sector]\n sector_symbols = info.loc[sector_indices, \"Stock Symbol\"]\n data_availability_indices = self.filtered_data.columns.isin(\n sector_symbols\n )\n symbols_with_data = self.filtered_data.columns[\n data_availability_indices\n ].tolist()\n symbols_without_data = sector_symbols[\n ~sector_symbols.isin(symbols_with_data)\n ].tolist()\n if verbose:\n print(\n \"Symbols without data in {}:\\n{}\".format(\n sector, symbols_without_data\n )\n )\n return symbols_with_data\n\n def detrend_data(\n self, df=None, window=5, symbol=None, plot=False, return_trend=False\n ):\n \"\"\"detrend by dividing its rolling median (robust to outliers)\n Returns flattened (and detrended) data\n \"\"\"\n if df is None:\n df = self.data.copy()\n # min_periods=1 does not yield NaN\n df_rolling = df.rolling(window=window, min_periods=1).median()\n\n if plot:\n assert symbol is not None\n label = \"rolling mean (w={})\".format(window)\n ax = df[symbol].plot(label=symbol)\n df.df_rolling[symbol].plot(ax=ax, label=label)\n ax.legend()\n if return_trend:\n return df / df_rolling, df_rolling\n else:\n return df / df_rolling\n\n def remove_outliers(self, df=None, sigma=None):\n \"\"\"remove data sigma away from the mean of pct_change\n \"\"\"\n sigma = self.sigma if sigma is None else sigma\n\n if df is None:\n df = self.data.copy()\n # df2 = self.detrend_data(df)\n # #idx = (np.abs(stats.zscore(df)) < 3).all(axis=1)\n # idx = df2.apply(lambda x, sigma: abs(x - x.mean()) / x.std() < sigma, sigma=sigma).all(axis=1)\n idx = (df.pct_change() / df.pct_change().std()) < sigma\n symbols_half_original_data = idx.sum() < len(df) // 2\n if symbols_half_original_data.any():\n columns = df.columns[symbols_half_original_data].values\n errmsg = \"{}: removed since <1/2 of original data is left after outlier rejection\".format(\n columns\n )\n if self.verbose:\n print(errmsg)\n if symbols_half_original_data.sum() > len(df) // 2:\n errmsg = \"Less than half of original data is removed\"\n raise ValueError(errmsg)\n return df.drop(columns=columns, axis=1)\n else:\n return df[idx]\n\n def filter_data(\n self,\n df=None,\n symbol=None,\n sector=None,\n sigma=None,\n method=None,\n n_companies=None,\n start_date=None,\n end_date=None,\n indicator=\"close\",\n ):\n \"\"\"\n extreme outliers are filled as NaN\n \"\"\"\n symbol = self.symbol if symbol is None else symbol\n sector = self.sector if sector is None else sector\n sigma = self.sigma if sigma is None else sigma\n method = self.interpolation_method if method is None else method\n n_companies = self.n_companies if n_companies is None else n_companies\n start_date = self.start_date if start_date is None else start_date\n end_date = self.end_date if end_date is None else end_date\n\n if df is None:\n df = self.data_cache.copy()\n # filter date\n df = df[(df.index >= start_date) & (df.index <= end_date)]\n # choose 1 technical indicator\n df = df.xs(self.indicator, level=1, axis=1)\n # remove columns with all NaNs\n df.dropna(how=\"all\", axis=1, inplace=True)\n if self.exclude_symbols is not None:\n idx = df.columns.isin(self.exclude_symbols)\n if self.verbose:\n print(\"Removed: {}\".format(df.columns[idx].values))\n df = df.loc[:, df.columns[~idx]]\n # update\n self.data = df\n # remove outliers\n if sigma is not None:\n df = self.remove_outliers(df, sigma=sigma)\n # replace some few remaining NaNs with interpolated values\n df.interpolate(method=method, limit=5, inplace=True)\n # remove columns with any remaining NaNs\n # df.dropna(how=\"any\", axis=1, inplace=True)\n return df\n\n def compute_corr(\n self,\n symbol=None,\n sector=None,\n sigma=None,\n n_companies=None,\n start_date=None,\n end_date=None,\n indicator=\"close\",\n ):\n \"\"\"\n symbol : str\n company symbol\n n_companies : int\n top n postively and bottom n negatively correlated companies to symbol\n \"\"\"\n symbol = self.symbol if symbol is None else symbol\n sector = self.sector if sector is None else sector\n sigma = self.sigma if sigma is None else sigma\n n_companies = self.n_companies if n_companies is None else n_companies\n\n start_date = self.start_date if start_date is None else start_date\n end_date = self.end_date if end_date is None else end_date\n\n df = self.filtered_data.copy()\n if sector is not None:\n symbols = self.get_symbols_of_a_sector(sector)\n columns = df.columns[df.columns.isin(symbols)]\n df = df.loc[:, columns]\n\n # remove outliers\n if sigma is not None:\n df = self.remove_outliers(df, sigma=sigma)\n\n # compute correlation\n if symbol is not None:\n rank = df.corr()[symbol].sort_values(ascending=True)\n top = rank.tail(n_companies)\n top = list(top.index)\n bottom = rank.head(n_companies)\n bottom = list(bottom.index)\n chosen = list(itertools.chain.from_iterable([top, bottom]))\n idx = df.corr().index.isin(chosen)\n price_corr = df.corr().loc[idx, chosen]\n else:\n price_corr = df.corr()\n return price_corr\n\n def build_distance_matrix(self, metric=None):\n \"\"\"\n metric : str\n bonnano=distinguishes between a + or a - correlated pair of stocks;\n bonnano=does not distinguish\n \"\"\"\n metric = self.metric if metric is None else metric.lower()\n\n if (metric == \"bonnano\") | (metric == \"b\"):\n dist = np.sqrt(2 * (1 - self.price_corr))\n labs = list(dist.index)\n elif (metric == \"mktstk\") | (metric == \"m\"):\n dist = 1 - abs(self.price_corr)\n labs = list(dist.index)\n else:\n raise ValueError(\"Use bonnano or mktstk\")\n return dist, labs\n\n def build_minimum_spanning_tree(self, dist=None):\n \"\"\"\"\"\"\n dist = self.dist if dist is None else dist\n\n G = nx.from_numpy_matrix(dist.values)\n MST = nx.minimum_spanning_tree(G)\n return MST\n\n def plot_corr_matrix(self, symbols=None, sector=None, figsize=(10, 10)):\n \"\"\"\"\"\"\n try:\n import seaborn as sb\n except Exception:\n raise ModuleNotFoundError(\"pip install seaborn\")\n sector = self.sector if sector is None else sector\n\n if symbols is not None:\n errmsg = \"symbols should be a list of PSE symbols\"\n assert isinstance(symbols, list), errmsg\n price_corr = self.price_corr.loc[symbols, symbols]\n elif sector is not None:\n errmsg = \"sector not available\"\n assert sector in self.all_sectors, errmsg\n symbols = self.get_symbols_of_a_sector(sector)\n price_corr = self.price_corr.loc[symbols, symbols]\n else:\n price_corr = self.price_corr\n\n ## Generate a mask for the upper triangle\n mask = np.zeros_like(price_corr, dtype=np.bool)\n mask[np.triu_indices_from(mask)] = True\n\n ## Set up the matplotlib figure\n fig, ax = pl.subplots(1, 1, figsize=figsize)\n\n ## Generate a custom diverging colormap\n # cmap = sb.diverging_palette(220, 10, as_cmap=True)\n\n ## Draw the heatmap with the mask and correct aspect ratio\n fig = sb.heatmap(\n price_corr,\n mask=mask,\n vmax=0.3, # cmap=cmap,\n square=True,\n xticklabels=2,\n yticklabels=2,\n linewidths=0.5,\n cbar_kws={\"shrink\": 0.5, \"label\": \"correlation\"},\n ax=ax,\n )\n return fig\n\n def plot_corr_company(\n self,\n symbol=None,\n symbol2=None,\n positive=True,\n rescale=True,\n indicator=\"close\",\n ):\n \"\"\"\n plot company with highest positive/negative correlation with symbol\n \"\"\"\n symbol = self.symbol if symbol is None else symbol\n assert symbol is not None, \"Provide symbol\"\n\n df = self.filtered_data.copy()\n\n rank = self.price_corr[symbol].sort_values(ascending=True)\n\n fig, ax = pl.subplots(1, 2, figsize=(10, 5))\n\n if positive:\n # positively correlated\n if symbol2 is None:\n symbol2 = (\n rank.index[-2]\n if rank.index[-1] == symbol\n else rank.index[-1]\n )\n\n else:\n # negatively correlated\n if symbol2 is None:\n symbol2 = rank.index[0]\n\n if rescale:\n d1 = df[symbol] / df[symbol].max()\n d2 = df[symbol2] / df[symbol2].max()\n _ = d1.plot(ax=ax[0], label=symbol)\n d2.apply(lambda x: x).plot(ax=ax[0], label=symbol2)\n else:\n _ = df[symbol].plot(ax=ax[0], label=symbol)\n df[symbol2].plot(ax=ax[0], label=symbol2)\n pl.setp(ax[0], ylabel=\"rescaled {} price\".format(indicator))\n ax[0].legend()\n\n ax[1].plot(df[symbol], df[symbol2], \"o\")\n label = \" {} price\".format(indicator)\n pl.setp(ax[1], xlabel=symbol + label, ylabel=symbol2 + label)\n return fig\n\n def map_sector_to_color(self, MST, dtype=\"int\", use_subsector=False):\n \"\"\"\"\"\"\n grouping = \"subsector\" if use_subsector else \"sector\"\n\n sector_dict = nx.get_node_attributes(MST, grouping)\n sectors = pd.Series(sector_dict)\n codes = sectors.astype(\"category\").cat.codes\n if dtype == \"int\":\n return codes.values\n elif dtype == \"cint\":\n return [\"C\" + str(n) for n in codes.values]\n elif dtype == \"str\":\n return sectors.values\n elif dtype == \"cat\":\n # {int: str} mapping\n d = dict(enumerate(sectors.astype(\"category\").cat.categories))\n # {str: int} mapping (reverse)\n d = {v: k for k, v in d.items()}\n return d\n\n def populate_graph_attribute(self):\n \"\"\"\"\"\"\n for node in self.MST.nodes():\n sector = self.company_table[\n self.company_table[\"Stock Symbol\"] == self.labs[node]\n ].Sector.iloc[0]\n self.MST.nodes[node][\"sector\"] = sector\n subsector = self.company_table[\n self.company_table[\"Stock Symbol\"] == self.labs[node]\n ].Subsector.iloc[0]\n self.MST.nodes[node][\"subsector\"] = subsector\n self.MST.nodes[node][\"label\"] = self.labs[node]\n return None\n\n def plot_network(\n self,\n MST=None,\n show_subsector=False,\n iterations=50,\n figsize=(10, 10), # cmap=\"Set1\",\n ):\n \"\"\"\n Note: each instance may show different network structure\n \"\"\"\n MST = self.MST if MST is None else MST\n\n fig = pl.figure(figsize=figsize, constrained_layout=True)\n\n nx.draw_networkx(\n MST,\n pos=nx.spring_layout(MST, iterations=iterations),\n labels=nx.get_node_attributes(MST, \"label\"),\n node_color=self.map_sector_to_color(\n MST, use_subsector=show_subsector, dtype=\"cint\"\n ),\n # cmap=pl.get_cmap(cmap),\n font_color=\"k\",\n )\n # hack legend\n ColorLegend = self.map_sector_to_color(\n MST, use_subsector=show_subsector, dtype=\"cat\"\n )\n # values = self.map_sector_to_color(MST, dtype='int')\n # cNorm = mpl.colors.Normalize(vmin=0, vmax=max(values))\n # scalarMap = mpl.cm.ScalarMappable(norm=cNorm, cmap=pl.get_cmap(cmap))\n for label in ColorLegend:\n pl.plot(\n [0],\n [0],\n \"o\",\n color=\"C{}\".format(ColorLegend[label]),\n # color=scalarMap.to_rgba(ColorLegend[label]),\n label=label,\n )\n if len(ColorLegend) > 1:\n if show_subsector or (self.symbol is not None):\n pl.legend(title=\"Sub-sector\" if show_subsector else \"Sector\")\n if self.sector is not None:\n fig.suptitle(\"{} Sector\".format(self.sector), y=1.01)\n return fig\n\n\nif __name__ == \"__main__\":\n n = Network()\n # n = Network(symbol='JFC')\n fig = n.plot_network()\n pl.show()\n"
] |
[
[
"matplotlib.pyplot.legend",
"pandas.read_csv",
"pandas.Series",
"numpy.sqrt",
"numpy.triu_indices_from",
"matplotlib.pyplot.subplots",
"numpy.zeros_like",
"matplotlib.pyplot.setp",
"matplotlib.pyplot.show",
"matplotlib.pyplot.figure"
]
] |
Chandrahasd/OKGIT
|
[
"16f4dbbfca1020809d3bae0445ee564fa8af9193"
] |
[
"src/bertutils.py"
] |
[
"import sys\nimport os\n\nimport argparse\nimport numpy as np\nfrom lama.modules import build_model_by_name\nfrom lama.modules.base_connector import *\nimport torch\n\nclass BertUtils(object):\n def __init__(self, args):\n self.model = build_model_by_name(args.models, args)\n if args.use_cuda:\n self.model.try_cuda()\n\n def getBertTails(self, heads, relations, batch_size=-1):\n num_sentences = len(heads)\n sentence_list = []\n for idx in range(num_sentences):\n sentence = [\" \".join([heads[idx], relations[idx], MASK])+\".\"]\n # sentence = [\" \".join([heads[idx], relations[idx], MASK])]\n sentence_list.append(sentence)\n if batch_size < 0:\n context_embeddings, sentence_lengths, tokenized_text_list, masked_indices = self.model.get_contextual_embeddings_with_mask_indices(sentence_list)\n context_embeddings = context_embeddings[-1]\n bert_tail_embs = []\n for idx in range(num_sentences):\n bert_tail_embs.append(context_embeddings[idx, masked_indices[idx][0], :])\n else:\n bert_tail_embs = []\n for st_idx in range(0, num_sentences, batch_size):\n cur_sentences = sentence_list[st_idx:st_idx+batch_size]\n context_embeddings, sentence_lengths, tokenized_text_list, masked_indices = self.model.get_contextual_embeddings_with_mask_indices(cur_sentences)\n context_embeddings = context_embeddings[-1]\n for idx in range(len(cur_sentences)):\n # bert_tail_embs.append(context_embeddings[idx, 0, :])\n bert_tail_embs.append(context_embeddings[idx, masked_indices[idx][0], :])\n return torch.stack(bert_tail_embs)\n\n def getBertHeads(self, tails, relations, batch_size=-1):\n num_sentences = len(tails)\n sentence_list = []\n for idx in range(num_sentences):\n sentence = [\" \".join([MASK, relations[idx], tails[idx]])+\".\"]\n # sentence = [\" \".join([MASK, relations[idx], tails[idx]])]\n sentence_list.append(sentence)\n if batch_size < 0:\n context_embeddings, sentence_lengths, tokenized_text_list, masked_indices = self.model.get_contextual_embeddings_with_mask_indices(sentence_list)\n context_embeddings = context_embeddings[-1]\n bert_head_embs = []\n for idx in range(num_sentences):\n bert_head_embs.append(context_embeddings[idx, masked_indices[idx][0], :])\n else:\n bert_head_embs = []\n for st_idx in range(0, num_sentences, batch_size):\n cur_sentences = sentence_list[st_idx:st_idx+batch_size]\n context_embeddings, sentence_lengths, tokenized_text_list, masked_indices = self.model.get_contextual_embeddings_with_mask_indices(cur_sentences)\n context_embeddings = context_embeddings[-1]\n for idx in range(len(cur_sentences)):\n # bert_head_embs.append(context_embeddings[idx, 0, :])\n bert_head_embs.append(context_embeddings[idx, masked_indices[idx][0], :])\n return torch.stack(bert_head_embs)\n\n def getBertEmbs(self, heads, relations, tails, batch_size=-1):\n tail_emb = self.getBertTails(heads, relations, batch_size)\n head_emb = self.getBertHeads(tails, relations, batch_size)\n all_emb = torch.cat([tail_emb, head_emb], 1).reshape(len(heads)+len(tails), head_emb.shape[1])\n return all_emb"
] |
[
[
"torch.stack",
"torch.cat"
]
] |
DAB-Team/contracts
|
[
"ae58f66cff7af90cea188b321b2a9616091674c1"
] |
[
"solidity/python/theoretical_reserve.py"
] |
[
"import matplotlib.pyplot as plot\nimport cmath\nimport random\n\ndef sigmoid(l, d, a, b, x):\n \"\"\"\n CRR Curve Function\n :param l:\n :param d:\n :param a:\n :param b:\n :param x:\n :return: CRR\n \"\"\"\n return 1/(1+cmath.exp((x-l)/d))*a+b\n\n\n\ndef sigmoid_integral(l, d, a, b, x):\n \"\"\"\n DPT Balance Function (Not Used)\n :param l:\n :param d:\n :param a:\n :param b:\n :param x:\n :return: balance in DPT contract\n \"\"\"\n return -a*d*cmath.log((1+cmath.exp((l-x)/d))/(1+cmath.exp(l/d)))+b*x\n\n\n# Parameters to resize and move the CRR curve\na = 0.6\nb = 0.2\nl = 300000\nd = l/4\ntop = l*2\n\n# CRR Curve\ny = [ 0 for i in range(0, top)]\n# Line y=1\nh = [ 1 for i in range(0, top)]\n# Profit Ratio of Issuer just after Issuing\nf = [ 0 for i in range(0, top)]\n# Issuing Price of DPT\ns = [ 0 for i in range(0, top)]\n# Profit Ratio of First Issuer\nt = [ 0 for i in range(0, top)]\n# Circulation Price\np = [ 0 for i in range(0, top)]\nfor x in range(1, top):\n y[x] = sigmoid(l, d, a, b, x)\n s[x] = 1 / y[x]\ny[0] = y[1]\n\nh[0] = h[1]\ns[0] = s[1]\n\nx=[ i for i in range(0, top)]\np1=plot.plot(x,y)\n\np4=plot.plot(x,h)\np5=plot.plot(x,s)\n\n\nplot.show(p1)\n\nplot.show(p4)\nplot.show(p5)\n\n"
] |
[
[
"matplotlib.pyplot.plot",
"matplotlib.pyplot.show"
]
] |
L-Net-1992/DI-engine
|
[
"268d77db3cb54401b2cfc83e2bc3ec87c31e7b83"
] |
[
"dizoo/procgen/envs/procgen_env.py"
] |
[
"from typing import Any, List, Union, Optional\nfrom easydict import EasyDict\nimport time\nimport gym\nimport numpy as np\nfrom ding.envs import BaseEnv, BaseEnvTimestep\nfrom ding.envs.common.env_element import EnvElement, EnvElementInfo\nfrom ding.torch_utils import to_ndarray, to_list\nfrom ding.utils import ENV_REGISTRY, deep_merge_dicts\n\n\n@ENV_REGISTRY.register('procgen')\nclass ProcgenEnv(BaseEnv):\n\n #If control_level is True, you can control the specific level of the generated environment by controlling start_level and num_level.\n config = dict(\n control_level=True,\n start_level=0,\n num_levels=0,\n env_id='coinrun',\n )\n\n def __init__(self, cfg: dict) -> None:\n cfg = deep_merge_dicts(EasyDict(self.config), cfg)\n self._cfg = cfg\n self._seed = 0\n self._init_flag = False\n self._observation_space = gym.spaces.Box(\n low=np.zeros(shape=(3, 64, 64)), high=np.ones(shape=(3, 64, 64)) * 255, shape=(3, 64, 64), dtype=np.float32\n )\n\n self._action_space = gym.spaces.Discrete(15)\n\n self._reward_space = gym.spaces.Box(low=float(\"-inf\"), high=float(\"inf\"), shape=(1, ), dtype=np.float32)\n self._control_level = self._cfg.control_level\n self._start_level = self._cfg.start_level\n self._num_levels = self._cfg.num_levels\n self._env_name = 'procgen:procgen-'+self._cfg.env_id+'-v0'\n\n def reset(self) -> np.ndarray:\n if not self._init_flag:\n if self._control_level:\n self._env = gym.make(\n self._env_name, start_level=self._start_level, num_levels=self._num_levels\n )\n else:\n self._env = gym.make(self._env_name, start_level=0, num_levels=1)\n self._init_flag = True\n if hasattr(self, '_seed') and hasattr(self, '_dynamic_seed') and self._dynamic_seed:\n np_seed = 100 * np.random.randint(1, 1000)\n self._env.close()\n if self._control_level:\n self._env = gym.make(\n self._env_name, start_level=self._start_level, num_levels=self._num_levels\n )\n else:\n self._env = gym.make(self._env_name, start_level=self._seed + np_seed, num_levels=1)\n elif hasattr(self, '_seed'):\n self._env.close()\n if self._control_level:\n self._env = gym.make(\n self._env_name, start_level=self._start_level, num_levels=self._num_levels\n )\n else:\n self._env = gym.make(self._env_name, start_level=self._seed, num_levels=1)\n self._final_eval_reward = 0\n obs = self._env.reset()\n obs = to_ndarray(obs)\n obs = np.transpose(obs, (2, 0, 1))\n obs = obs.astype(np.float32)\n return obs\n\n def close(self) -> None:\n if self._init_flag:\n self._env.close()\n self._init_flag = False\n\n def seed(self, seed: int, dynamic_seed: bool = True) -> None:\n self._seed = seed\n self._dynamic_seed = dynamic_seed\n np.random.seed(self._seed)\n\n def step(self, action: np.ndarray) -> BaseEnvTimestep:\n assert isinstance(action, np.ndarray), type(action)\n if action.shape == (1, ):\n action = action.squeeze() # 0-dim array\n obs, rew, done, info = self._env.step(action)\n self._final_eval_reward += rew\n if done:\n info['final_eval_reward'] = self._final_eval_reward\n obs = to_ndarray(obs)\n obs = np.transpose(obs, (2, 0, 1))\n obs = obs.astype(np.float32)\n rew = to_ndarray([rew]) # wrapped to be transfered to a array with shape (1,)\n rew = rew.astype(np.float32)\n return BaseEnvTimestep(obs, rew, bool(done), info)\n\n @property\n def observation_space(self) -> gym.spaces.Space:\n return self._observation_space\n\n @property\n def action_space(self) -> gym.spaces.Space:\n return self._action_space\n\n @property\n def reward_space(self) -> gym.spaces.Space:\n return self._reward_space\n\n def __repr__(self) -> str:\n return \"DI-engine CoinRun Env\"\n\n def enable_save_replay(self, replay_path: Optional[str] = None) -> None:\n if replay_path is None:\n replay_path = './video'\n self._replay_path = replay_path\n self._env = gym.wrappers.Monitor(\n self._env, self._replay_path, video_callable=lambda episode_id: True, force=True\n )\n"
] |
[
[
"numpy.random.seed",
"numpy.ones",
"numpy.transpose",
"numpy.zeros",
"numpy.random.randint"
]
] |
kundajelab/seqxgene
|
[
"cd25818514ab90fad53c64550eea9f43908f2fbb"
] |
[
"preprocess/make_accessibility_joblib.py"
] |
[
"import joblib\nimport argparse\nimport gzip\nimport os\nfrom pyfaidx import Fasta\nfrom tqdm import tqdm\nimport numpy as np\n\n\"\"\"\nInput file must be a tab-separated gzipped file formatted as below.\n\nchr start end task1 task2 ... taskM\nchr1 50 1050 0 0 0\nchr1 1000 2000 1 0 1\nchr2 100 1100 1 0 1\n\nThe output is a set of joblib files, one per chromosome which will\nstore the one hot sequence of each interval along with labels and other\nmetadata.\n\"\"\"\n\nBASE_TO_INDEX = {\"A\":0, \"C\":1, \"G\":2, \"T\":3}\n\ndef fetch_args():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"--input\", \"-i\", type=str, help=\"Input tab-separated gzipped file in the specified format\")\n parser.add_argument(\"--genome_fasta\", \"-g\", type=str, help=\"Path to genome fasta\")\n parser.add_argument(\"--output_dir\", \"-o\", type=str, help=\"Output directory where chromosome-wise joblib files will be placed\")\n args = parser.parse_args()\n return args\n\ndef one_hot_packbit(chrm, start, end, genome):\n seq = str(genome[chrm][start:end])\n mask = np.tile([int(x in BASE_TO_INDEX) for x in seq], (4,1)).T\n indices = np.array([BASE_TO_INDEX[x] if x in BASE_TO_INDEX else 0 for x in seq])\n encoding = np.zeros((len(seq), 4)).astype(np.int8)\n encoding[np.arange(indices.size), indices] = 1\n encoding *= mask\n\n return np.packbits(encoding, axis=1)\n\ndef make_joblib(infile, out_dir, genome):\n print(\"PREPROCESS::: Reading file into memory\")\n f = gzip.open(infile)\n d = [x.decode().strip().split('\\t') for x in f]\n f.close()\n\n if not all([len(x)==len(d[0]) for x in d]):\n print(\"ERROR: Number of cols not constant\")\n exit(1)\n\n tasks = d[0][3:]\n d = d[1:]\n\n if not all([int(x[2])-int(x[1])==int(d[0][2])-int(d[0][1]) for x in d]):\n print(\"ERROR: Not all intervals have the same length\")\n exit(1)\n\n chrms = set([x[0] for x in d])\n dat = {c:{'num_cell_types': len(tasks),\n 'labels': [],\n 'label_metadata': tasks,\n 'example_metadata': [],\n 'features': []}\n for c in chrms}\n \n print(\"PREPROCESS::: Processing file\")\n for line in tqdm(d):\n chrm = line[0]\n pos = \"{}:{}-{}\".format(*line[:3])\n\n dat[chrm]['example_metadata'].append(pos)\n dat[chrm]['labels'].append([np.int8(x) for x in line[3:]])\n dat[chrm]['features'].append(one_hot_packbit(line[0], int(line[1])-1, int(line[2])-1, genome))\n\n print(\"PREPROCESS::: Writing output\")\n for chrm in chrms:\n dat[chrm]['labels'] = np.packbits(np.array(dat[chrm]['labels']), axis=1)\n dat[chrm]['features'] = np.array(dat[chrm]['features'])\n joblib.dump(dat[chrm], os.path.join(out_dir, \"dnase.{}.packbit.joblib\".format(chrm)))\n \n\nif __name__ == \"__main__\":\n args = fetch_args()\n genome = Fasta(args.genome_fasta)\n make_joblib(args.input, args.output_dir, genome)\n"
] |
[
[
"numpy.arange",
"numpy.array",
"numpy.packbits",
"numpy.int8"
]
] |
jamesdaus/NLPAccessibilitySC2
|
[
"759bea30ef3ca9d7f683a72c59b111e3ad0a0c82"
] |
[
"Starcraft/PythonSC2/examples/terran/ramp_wall.py"
] |
[
"import sys, os\n\nsys.path.append(os.path.join(os.path.dirname(__file__), \"../..\"))\n\nimport random, numpy as np\n\nimport sc2\nfrom sc2 import Race, Difficulty\nfrom sc2.constants import *\nfrom sc2.player import Bot, Computer\nfrom sc2.position import Point2, Point3\nfrom sc2.unit import Unit\nfrom sc2.units import Units\n\nfrom typing import List, Set\n\n\nclass RampWallBot(sc2.BotAI):\n def __init__(self):\n self.unit_command_uses_self_do = False\n\n async def on_step(self, iteration):\n ccs: Units = self.townhalls(UnitTypeId.COMMANDCENTER)\n if not ccs:\n return\n else:\n cc: Unit = ccs.first\n\n await self.distribute_workers()\n\n if self.can_afford(UnitTypeId.SCV) and self.workers.amount < 16 and cc.is_idle:\n self.do(cc.train(UnitTypeId.SCV))\n\n # Raise depos when enemies are nearby\n for depo in self.structures(UnitTypeId.SUPPLYDEPOT).ready:\n for unit in self.enemy_units:\n if unit.distance_to(depo) < 15:\n break\n else:\n depo(AbilityId.MORPH_SUPPLYDEPOT_LOWER)\n\n # Lower depos when no enemies are nearby\n for depo in self.structures(UnitTypeId.SUPPLYDEPOTLOWERED).ready:\n for unit in self.enemy_units:\n if unit.distance_to(depo) < 10:\n depo(AbilityId.MORPH_SUPPLYDEPOT_RAISE)\n break\n\n # Draw ramp points\n self.draw_ramp_points()\n\n # Draw all detected expansions on the map\n self.draw_expansions()\n\n # # Draw pathing grid\n # self.draw_pathing_grid()\n\n # Draw placement grid\n # self.draw_placement_grid()\n\n # Draw vision blockers\n # self.draw_vision_blockers()\n\n # Draw visibility pixelmap for debugging purposes\n # self.draw_visibility_pixelmap()\n\n # Draw some example boxes around units, lines towards command center, text on the screen and barracks\n # self.draw_example()\n\n # Draw if two selected units are facing each other - green if this guy is facing the other, red if he is not\n # self.draw_facing_units()\n\n depot_placement_positions: Set[Point2] = self.main_base_ramp.corner_depots\n # Uncomment the following if you want to build 3 supply depots in the wall instead of a barracks in the middle + 2 depots in the corner\n # depot_placement_positions = self.main_base_ramp.corner_depots | {self.main_base_ramp.depot_in_middle}\n\n barracks_placement_position: Point2 = self.main_base_ramp.barracks_correct_placement\n # If you prefer to have the barracks in the middle without room for addons, use the following instead\n # barracks_placement_position = self.main_base_ramp.barracks_in_middle\n\n depots: Units = self.structures.of_type({UnitTypeId.SUPPLYDEPOT, UnitTypeId.SUPPLYDEPOTLOWERED})\n\n # Filter locations close to finished supply depots\n if depots:\n depot_placement_positions: Set[Point2] = {\n d for d in depot_placement_positions if depots.closest_distance_to(d) > 1\n }\n\n # Build depots\n if self.can_afford(UnitTypeId.SUPPLYDEPOT) and self.already_pending(UnitTypeId.SUPPLYDEPOT) == 0:\n if len(depot_placement_positions) == 0:\n return\n # Choose any depot location\n target_depot_location: Point2 = depot_placement_positions.pop()\n workers: Units = self.workers.gathering\n if workers: # if workers were found\n worker: Unit = workers.random\n self.do(worker.build(UnitTypeId.SUPPLYDEPOT, target_depot_location))\n\n # Build barracks\n if depots.ready and self.can_afford(UnitTypeId.BARRACKS) and self.already_pending(UnitTypeId.BARRACKS) == 0:\n if self.structures(UnitTypeId.BARRACKS).amount + self.already_pending(UnitTypeId.BARRACKS) > 0:\n return\n workers = self.workers.gathering\n if workers and barracks_placement_position: # if workers were found\n worker: Unit = workers.random\n worker.build(UnitTypeId.BARRACKS, barracks_placement_position)\n\n async def on_building_construction_started(self, unit: Unit):\n print(f\"Construction of building {unit} started at {unit.position}.\")\n\n async def on_building_construction_complete(self, unit: Unit):\n print(f\"Construction of building {unit} completed at {unit.position}.\")\n\n def draw_ramp_points(self):\n for ramp in self.game_info.map_ramps:\n for p in ramp.points:\n h2 = self.get_terrain_z_height(p)\n pos = Point3((p.x, p.y, h2))\n color = Point3((255, 0, 0))\n if p in ramp.upper:\n color = Point3((0, 255, 0))\n if p in ramp.upper2_for_ramp_wall:\n color = Point3((0, 255, 255))\n if p in ramp.lower:\n color = Point3((0, 0, 255))\n self._client.debug_box2_out(pos + Point2((0.5, 0.5)), half_vertex_length=0.25, color=color)\n # Identical to above:\n # p0 = Point3((pos.x + 0.25, pos.y + 0.25, pos.z + 0.25))\n # p1 = Point3((pos.x + 0.75, pos.y + 0.75, pos.z - 0.25))\n # print(f\"Drawing {p0} to {p1}\")\n # self._client.debug_box_out(p0, p1, color=color)\n\n def draw_expansions(self):\n green = Point3((0, 255, 0))\n for expansion_pos in self.expansion_locations_list:\n height = self.get_terrain_z_height(expansion_pos)\n expansion_pos3 = Point3((*expansion_pos, height))\n self._client.debug_box2_out(expansion_pos3, half_vertex_length=2.5, color=green)\n\n def draw_pathing_grid(self):\n map_area = self._game_info.playable_area\n for (b, a), value in np.ndenumerate(self._game_info.pathing_grid.data_numpy):\n if value == 0:\n continue\n # Skip values outside of playable map area\n if not (map_area.x <= a < map_area.x + map_area.width):\n continue\n if not (map_area.y <= b < map_area.y + map_area.height):\n continue\n p = Point2((a, b))\n h2 = self.get_terrain_z_height(p)\n pos = Point3((p.x, p.y, h2))\n p0 = Point3((pos.x - 0.25, pos.y - 0.25, pos.z + 0.25)) + Point2((0.5, 0.5))\n p1 = Point3((pos.x + 0.25, pos.y + 0.25, pos.z - 0.25)) + Point2((0.5, 0.5))\n # print(f\"Drawing {p0} to {p1}\")\n color = Point3((0, 255, 0))\n self._client.debug_box_out(p0, p1, color=color)\n\n def draw_placement_grid(self):\n map_area = self._game_info.playable_area\n for (b, a), value in np.ndenumerate(self._game_info.placement_grid.data_numpy):\n if value == 0:\n continue\n # Skip values outside of playable map area\n if not (map_area.x <= a < map_area.x + map_area.width):\n continue\n if not (map_area.y <= b < map_area.y + map_area.height):\n continue\n p = Point2((a, b))\n h2 = self.get_terrain_z_height(p)\n pos = Point3((p.x, p.y, h2))\n p0 = Point3((pos.x - 0.25, pos.y - 0.25, pos.z + 0.25)) + Point2((0.5, 0.5))\n p1 = Point3((pos.x + 0.25, pos.y + 0.25, pos.z - 0.25)) + Point2((0.5, 0.5))\n # print(f\"Drawing {p0} to {p1}\")\n color = Point3((0, 255, 0))\n self._client.debug_box_out(p0, p1, color=color)\n\n def draw_vision_blockers(self):\n for p in self.game_info.vision_blockers:\n h2 = self.get_terrain_z_height(p)\n pos = Point3((p.x, p.y, h2))\n p0 = Point3((pos.x - 0.25, pos.y - 0.25, pos.z + 0.25)) + Point2((0.5, 0.5))\n p1 = Point3((pos.x + 0.25, pos.y + 0.25, pos.z - 0.25)) + Point2((0.5, 0.5))\n # print(f\"Drawing {p0} to {p1}\")\n color = Point3((255, 0, 0))\n self._client.debug_box_out(p0, p1, color=color)\n\n def draw_visibility_pixelmap(self):\n for (y, x), value in np.ndenumerate(self.state.visibility.data_numpy):\n p = Point2((x, y))\n h2 = self.get_terrain_z_height(p)\n pos = Point3((p.x, p.y, h2))\n p0 = Point3((pos.x - 0.25, pos.y - 0.25, pos.z + 0.25)) + Point2((0.5, 0.5))\n p1 = Point3((pos.x + 0.25, pos.y + 0.25, pos.z - 0.25)) + Point2((0.5, 0.5))\n # Red\n color = Point3((255, 0, 0))\n # If value == 2: show green (= we have vision on that point)\n if value == 2:\n color = Point3((0, 255, 0))\n self._client.debug_box_out(p0, p1, color=color)\n\n def draw_example(self):\n # Draw green boxes around SCVs if they are gathering, yellow if they are returning cargo, red the rest\n scv: Unit\n for scv in self.workers:\n pos = scv.position3d\n p0 = Point3((pos.x - 0.25, pos.y - 0.25, pos.z + 0.25))\n p1 = Point3((pos.x + 0.25, pos.y + 0.25, pos.z - 0.25))\n # Red\n color = Point3((255, 0, 0))\n if scv.is_gathering:\n color = Point3((0, 255, 0))\n elif scv.is_returning:\n color = Point3((255, 255, 0))\n self._client.debug_box_out(p0, p1, color=color)\n\n # Draw lines from structures to command center\n if self.townhalls:\n cc = self.townhalls[0]\n p0 = cc.position3d\n if not self.structures:\n return\n structure: Unit\n for structure in self.structures:\n if structure == cc:\n continue\n p1 = structure.position3d\n # Red\n color = Point3((255, 0, 0))\n self._client.debug_line_out(p0, p1, color=color)\n\n # Draw text on barracks\n if structure.type_id == UnitTypeId.BARRACKS:\n # Blue\n color = Point3((0, 0, 255))\n pos = structure.position3d + Point3((0, 0, 0.5))\n # TODO: Why is this text flickering\n self._client.debug_text_world(text=\"MY RAX\", pos=pos, color=color, size=16)\n\n # Draw text in top left of screen\n self._client.debug_text_screen(text=\"Hello world!\", pos=Point2((0, 0)), color=None, size=16)\n self._client.debug_text_simple(text=\"Hello world2!\")\n\n def draw_facing_units(self):\n \"\"\" Draws green box on top of selected_unit2, if selected_unit2 is facing selected_unit1 \"\"\"\n selected_unit1: Unit\n selected_unit2: Unit\n red = Point3((255, 0, 0))\n green = Point3((0, 255, 0))\n for selected_unit1 in (self.units | self.structures).selected:\n for selected_unit2 in self.units.selected:\n if selected_unit1 == selected_unit2:\n continue\n if selected_unit2.is_facing_unit(selected_unit1):\n self._client.debug_box2_out(selected_unit2, half_vertex_length=0.25, color=green)\n else:\n self._client.debug_box2_out(selected_unit2, half_vertex_length=0.25, color=red)\n\n\ndef main():\n map = random.choice(\n [\n # Most maps have 2 upper points at the ramp (len(self.main_base_ramp.upper) == 2)\n \"AutomatonLE\",\n \"BlueshiftLE\",\n \"CeruleanFallLE\",\n \"KairosJunctionLE\",\n \"ParaSiteLE\",\n \"PortAleksanderLE\",\n \"StasisLE\",\n \"DarknessSanctuaryLE\",\n \"ParaSiteLE\", # Has 5 upper points at the main ramp\n \"AcolyteLE\", # Has 4 upper points at the ramp to the in-base natural and 2 upper points at the small ramp\n \"HonorgroundsLE\", # Has 4 or 9 upper points at the large main base ramp\n ]\n )\n map = \"PillarsofGoldLE\"\n sc2.run_game(\n sc2.maps.get(\"BlackburnAIE\"),\n #sc2.maps.get(map),\n [Bot(Race.Terran, RampWallBot()), Computer(Race.Zerg, Difficulty.Hard)],\n realtime=True,\n # sc2_version=\"4.10.1\",\n )\n\n\nif __name__ == \"__main__\":\n main()\n"
] |
[
[
"numpy.ndenumerate"
]
] |
Mghane/Image-Classifier-with-Tensorflow-Keras
|
[
"cf6d018a0819e632441ef321b9b6a2c24dc4a309"
] |
[
"predict.py"
] |
[
"import tensorflow as tf\nfrom PIL import Image\nimport tensorflow_hub as hub\nfrom processing import process_image\n\nimport argparse\nimport numpy as np\nimport json\n\n\ndef predict(image_path, model, top_k, category_names):\n '''\n Image object ==> top k classes predicted by model along with their probabilities \n \n This function has three inputs: picture path, mode, and number of top k classes predicted by the model.\n It takes a picture from given path, applys necessary processing, uses the picture for prediction and returns \n top k classes predicted by the model.\n '''\n my_model = tf.keras.models.load_model(model, custom_objects={'KerasLayer':hub.KerasLayer})\n \n im = Image.open(image_path)\n test_image = np.asarray(im)\n processed_test_image = process_image(test_image)\n \n ## Model accepts 4-dimension array. To satisfy this requirement we need to expand the processed image of 3 dims to 4 dims\n processed_test_image = np.expand_dims(processed_test_image,axis=0)\n print('Expanded processed image shape is:', processed_test_image.shape)\n \n ## Read Json file\n with open(category_names, 'r') as f:\n class_names = json.load(f)\n\n ## predict\n ps = my_model.predict(processed_test_image)\n \n ## Extract probaility and class label for top k classes with highest probability\n indeces = ps.argsort()[0][::-1][:top_k].tolist() \n probs = ps[0][indeces].tolist()\n classes = [str(i) for i in indeces]\n flowers_name = [class_names[str(x+1)] for x in indeces] # add 1 to correspond the indexes from the prediction to the indexes in the class_names\n return probs, classes, flowers_name\n\nparser = argparse.ArgumentParser(description = \"Description for my parser\")\nparser.add_argument(\"image_path\",help=\"Image Path\", default=\"\")\nparser.add_argument(\"saved_model\",help=\"Model Path\", default=\"\") \nparser.add_argument(\"--top_k\", type = int, help=\"Top K Categories\", required = False, default=5) \nparser.add_argument(\"--category_names\", help=\"Category name\", required = False, default=\"label_map.json\") \nargs = parser.parse_args()\n\nprobs, classes, flowers_name = predict(args.image_path, args.saved_model, args.top_k, args.category_names)\nprint('probability distribution is:\\n', probs)\nprint('for label numbers of:\\n', classes)\nprint('and flower names of:\\n',flowers_name)\n"
] |
[
[
"numpy.asarray",
"tensorflow.keras.models.load_model",
"numpy.expand_dims"
]
] |
mananmadan/DeepLogo
|
[
"ebcd5793c270696cd6c6b1a74da603b017f11718"
] |
[
"single_inf.py"
] |
[
"import numpy as np\nimport os\nimport sys\nimport tarfile\nimport math\nimport tensorflow.compat.v1 as tf\nimport zipfile\nimport cv2\nfrom google.colab.patches import cv2_imshow\nfrom distutils.version import StrictVersion\nfrom collections import defaultdict\nfrom io import StringIO\nfrom matplotlib import pyplot as plt\nfrom PIL import Image,ImageDraw\ntry:\n from object_detection.utils import label_map_util\n from object_detection.utils import visualization_utils as vis_util\n from object_detection.utils import ops as utils_ops\nexcept:\n from DeepLogo.object_detection.utils import label_map_util\n from DeepLogo.object_detection.utils import visualization_utils as vis_util\n from DeepLogo.object_detection.utils import ops as utils_ops\nfrom numpy import asarray\n\n\ndef load_image_into_numpy_array(image):\n (im_width, im_height) = image.size\n if image.getdata().mode != \"RGB\":\n image = image.convert('RGB')\n #print(image.getdata().mode)\n np_array = np.array(image.getdata())\n reshaped = np_array.reshape((im_height, im_width, 3))\n return reshaped.astype(np.uint8)\n\n\n\"\"\"\nInference on single image\n----------------------------\nInput : Image and Tensorflow graph\nOutput : Dict Containing boxes , scores , classes , masks\n\"\"\"\ndef run_inference_for_single_image(image, graph):\n with graph.as_default():\n with tf.Session() as sess:\n # Get handles to input and output tensors\n ops = tf.get_default_graph().get_operations()\n all_tensor_names = {output.name for op in ops for output in op.outputs}\n tensor_dict = {}\n for key in [\n 'num_detections', 'detection_boxes', 'detection_scores',\n 'detection_classes', 'detection_masks'\n ]:\n tensor_name = key + ':0'\n if tensor_name in all_tensor_names:\n tensor_dict[key] = tf.get_default_graph().get_tensor_by_name(\n tensor_name)\n if 'detection_masks' in tensor_dict:\n # The following processing is only for single image\n detection_boxes = tf.squeeze(tensor_dict['detection_boxes'], [0])\n detection_masks = tf.squeeze(tensor_dict['detection_masks'], [0])\n # Reframe is required to translate mask from box coordinates to image coordinates and fit the image size.\n real_num_detection = tf.cast(tensor_dict['num_detections'][0], tf.int32)\n detection_boxes = tf.slice(detection_boxes, [0, 0], [real_num_detection, -1])\n detection_masks = tf.slice(detection_masks, [0, 0, 0], [real_num_detection, -1, -1])\n detection_masks_reframed = utils_ops.reframe_box_masks_to_image_masks(\n detection_masks, detection_boxes, image.shape[1], image.shape[2])\n detection_masks_reframed = tf.cast(\n tf.greater(detection_masks_reframed, 0.5), tf.uint8)\n # Follow the convention by adding back the batch dimension\n tensor_dict['detection_masks'] = tf.expand_dims(\n detection_masks_reframed, 0)\n image_tensor = tf.get_default_graph().get_tensor_by_name('image_tensor:0')\n\n # Run inference\n output_dict = sess.run(tensor_dict,\n feed_dict={image_tensor: image})\n\n # all outputs are float32 numpy arrays, so convert types as appropriate\n output_dict['num_detections'] = int(output_dict['num_detections'][0])\n output_dict['detection_classes'] = output_dict[\n 'detection_classes'][0].astype(np.int64)\n output_dict['detection_boxes'] = output_dict['detection_boxes'][0]\n output_dict['detection_scores'] = output_dict['detection_scores'][0]\n if 'detection_masks' in output_dict:\n output_dict['detection_masks'] = output_dict['detection_masks'][0]\n return output_dict\n\n\n\"\"\"\nGet the max detected logo and score\n-------------------------------------\nInput : model_name , label_map , path of the image\nOutput : highest probability of the logo detected\n\"\"\"\ndef main(model_name,label_map,path):\n MODEL_NAME = model_name\n # Path to frozen detection graph. This is the actual model that is used for the object detection.\n PATH_TO_FROZEN_GRAPH = MODEL_NAME + '/frozen_inference_graph.pb'\n # List of the strings that is used to add correct label for each box.\n PATH_TO_LABELS = label_map\n detection_graph = tf.Graph()\n with detection_graph.as_default():\n od_graph_def = tf.GraphDef()\n with tf.gfile.GFile(PATH_TO_FROZEN_GRAPH, 'rb') as fid:\n serialized_graph = fid.read()\n od_graph_def.ParseFromString(serialized_graph)\n tf.import_graph_def(od_graph_def, name='')\n category_index = label_map_util.create_category_index_from_labelmap(\n PATH_TO_LABELS, use_display_name=True)\n # Size, in inches, of the output images.\n IMAGE_SIZE = (12, 8)\n file_dict = {}\n image_path = str(path)\n #print(\"opening image ..\",image_path)\n image = Image.open(image_path)\n # the array based representation of the image will be used later in order to prepare the\n # result image with boxes and labels on it.\n mx = 0\n detected = \"\"\n image_np = load_image_into_numpy_array(image)\n # Expand dimensions since the model expects images to have shape: [1, None, None, 3]\n image_np_expanded = np.expand_dims(image_np, axis=0)\n # Actual detection.\n output_dict = run_inference_for_single_image(image_np_expanded, detection_graph)\n # Visualization of the results of a detection.\n cnt = 0\n for j in output_dict['detection_classes']:\n if output_dict['detection_scores'][cnt] > mx:\n mx = output_dict['detection_scores'][cnt]\n detected = category_index[j]['name']\n cnt = cnt + 1\n return (detected,mx)\n \n\n\"\"\"\nGet the graph and category_index\n----------------------------------\nPurpose : For detection in video , Generate the detection graph only once.\nInput : model_name , label_map\nOutput : detection_graph and category_index\n\"\"\"\ndef pre(model_name,label_map):\n MODEL_NAME = model_name\n # Path to frozen detection graph. This is the actual model that is used for the object detection.\n PATH_TO_FROZEN_GRAPH = MODEL_NAME + '/frozen_inference_graph.pb'\n # List of the strings that is used to add correct label for each box.\n PATH_TO_LABELS = label_map\n detection_graph = tf.Graph()\n with detection_graph.as_default():\n od_graph_def = tf.GraphDef()\n with tf.gfile.GFile(PATH_TO_FROZEN_GRAPH, 'rb') as fid:\n serialized_graph = fid.read()\n od_graph_def.ParseFromString(serialized_graph)\n tf.import_graph_def(od_graph_def, name='')\n category_index = label_map_util.create_category_index_from_labelmap(\n PATH_TO_LABELS, use_display_name=True)\n return (category_index,detection_graph)\n # Size, in inches, of the output images.\n\n\"\"\"\nGet the detected logo and score (for video)\n----------------------------------\nPurpose : For detection in video.\nInput : category_index detection_graph img\nOutput : detected_logo and score\n\"\"\"\n\ndef main_img(category_index,detection_graph,img):\n cv2.imwrite(\"temp.jpg\",img)\n image_path = \"temp.jpg\"\n try:\n image = Image.open(image_path)\n mx = 0\n detected = \"\"\n image_np = load_image_into_numpy_array(image)\n # Expand dimensions since the model expects images to have shape: [1, None, None, 3]\n image_np_expanded = np.expand_dims(image_np, axis=0)\n # Actual detection.\n output_dict = run_inference_for_single_image(image_np_expanded, detection_graph)\n # Visualization of the results of a detection.\n cnt = 0\n for j in output_dict['detection_classes']:\n if output_dict['detection_scores'][cnt] > mx:\n mx = output_dict['detection_scores'][cnt]\n detected = category_index[j]['name']\n cnt = cnt + 1\n return (detected,mx)\n except:\n return (\"\",-1)\n\n\"\"\"\nGet boxes score and name of all the logos detected in a frame\n---------------------------------------------------------------\nPurpose : For algo B\nInput : category_index detection_graph img\nOutput : list of boxes , score , name of the logos detected in an image\n\"\"\"\ndef getallbox(category_index,detection_graph,img):\n cv2.imwrite(\"temp.jpg\",img)\n image_path = \"temp.jpg\"\n image = Image.open(image_path)\n mx = 0\n detected = \"\"\n image_np = load_image_into_numpy_array(image)\n # Expand dimensions since the model expects images to have shape: [1, None, None, 3]\n image_np_expanded = np.expand_dims(image_np, axis=0)\n # Actual detection.\n output_dict = run_inference_for_single_image(image_np_expanded, detection_graph)\n # Visualization of the results of a detection.\n #print(\"New\")\n (im_width, im_height) = image.size\n cnt = 0\n #print(img.size)\n fullist = []\n for j in output_dict['detection_classes']:\n bb = [output_dict['detection_boxes'][cnt]]\n ymin = bb[0][0]\n xmin = bb[0][1]\n ymax = bb[0][2]\n xmax = bb[0][3]\n (left, right, top, bottom) = (xmin * im_width, xmax * im_width,\n ymin * im_height, ymax * im_height)\n left = math.floor(left)\n right = math.ceil(right)\n top = math.floor(top)\n bottom = math.ceil(bottom)\n fullist.append([category_index[j]['name'],output_dict['detection_scores'][cnt],(left,right,top,bottom)])\n cnt = cnt + 1\n \n return fullist"
] |
[
[
"tensorflow.compat.v1.get_default_graph",
"numpy.expand_dims",
"tensorflow.compat.v1.import_graph_def",
"tensorflow.compat.v1.expand_dims",
"tensorflow.compat.v1.Session",
"tensorflow.compat.v1.slice",
"tensorflow.compat.v1.Graph",
"tensorflow.compat.v1.gfile.GFile",
"tensorflow.compat.v1.GraphDef",
"tensorflow.compat.v1.cast",
"tensorflow.compat.v1.squeeze",
"tensorflow.compat.v1.greater"
]
] |
giganticode/bohr
|
[
"d3317bae621ad9f5629ef0d3f13591e4b8ac3ef5"
] |
[
"data-preprocessing/fine-grained-refactorings.py"
] |
[
"#!/usr/bin/env python3\n\nimport os\nimport subprocess\nimport tempfile\nfrom pathlib import Path\n\nimport pandas as pd\n\npath_to_file = os.path.realpath(__file__)\nrepo_root = Path(path_to_file).parent.parent\n\nINPUT_ZIP = repo_root / \"downloaded-data\" / \"fine-grained-refactorings.zip\"\nSAVE_TO = repo_root / \"data\" / \"fine-grained-refactorings.csv\"\n\n\nwith tempfile.TemporaryDirectory() as dir:\n subprocess.run([\"unzip\", INPUT_ZIP, \"-d\", dir])\n dfs = [\n pd.read_csv(file)\n for file in (Path(dir) / \"manualy_labeled_commits (goldset)\").iterdir()\n ]\n concat_dfs = pd.concat(dfs, axis=0, ignore_index=True)\n concat_dfs[\"owner\"] = \"\"\n concat_dfs[\"repository\"] = \"\"\n new_columns = concat_dfs.columns.values.tolist()\n new_columns[0] = \"sha\"\n concat_dfs.columns = new_columns\n concat_dfs.to_csv(SAVE_TO, index_label=\"commit_id\")\n\n\n# echo \"sha,commit_date,message,refactoring_class,refactoring_type,owner,repository\" >> \"$OUTPUT_CSV\"\n"
] |
[
[
"pandas.concat",
"pandas.read_csv"
]
] |
x5675602/fy4a-forest-fire
|
[
"155759cdb0abb92fb0c6e09d7d671b9dbb1a02f2"
] |
[
"main.py"
] |
[
"#!/usr/bin/env python\n# coding: utf-8\n#\n# Author: Kazuto Nakashima\n# URL: http://kazuto1011.github.io\n# Created: 2017-05-18\n\nfrom __future__ import print_function\n\nimport copy\nimport os.path as osp\n\nimport click\nimport cv2\nimport PIL\nimport matplotlib.cm as cm\nimport numpy as np\nimport torch\nimport torch.nn.functional as F\nfrom torchvision import models, transforms\n\nfrom grad_cam import (\n BackPropagation,\n Deconvnet,\n GradCAM,\n GuidedBackPropagation,\n occlusion_sensitivity,\n)\n\n# if a model includes LSTM, such as in image captioning,\n# torch.backends.cudnn.enabled = False\n\n\ndef get_device(cuda):\n cuda = cuda and torch.cuda.is_available()\n device = torch.device(\"cuda\" if cuda else \"cpu\")\n if cuda:\n current_device = torch.cuda.current_device()\n print(\"Device:\", torch.cuda.get_device_name(current_device))\n else:\n print(\"Device: CPU\")\n return device\n\n\ndef load_images(image_paths):\n images = []\n raw_images = []\n print(\"Images:\")\n for i, image_path in enumerate(image_paths):\n print(\"\\t#{}: {}\".format(i, image_path))\n image, raw_image = preprocess(image_path)\n images.append(image)\n raw_images.append(raw_image)\n return images, raw_images\n\n\ndef get_classtable():\n classes = []\n with open(\"samples/synset_words.txt\") as lines:\n for line in lines:\n line = line.strip().split(\" \", 1)[1]\n line = line.split(\", \", 1)[0].replace(\" \", \"_\")\n classes.append(line)\n return classes\n\n\ndef preprocess(image_path):\n raw_image = PIL.Image.open(image_path)\n raw_image = raw_image.resize((224,224))\n raw_image = np.array(raw_image)\n image = transforms.Compose(\n [\n transforms.ToTensor(), # change \n transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),\n ]\n )(raw_image.copy())\n print('image:', np.shape(image))\n return image, raw_image\n\n\ndef save_gradient(filename, gradient):\n gradient = gradient.cpu().numpy().transpose(1, 2, 0)\n gradient -= gradient.min()\n gradient /= gradient.max()\n gradient *= 255.0\n cv2.imwrite(filename, np.uint8(gradient))\n\n\ndef save_gradcam(filename, gcam, raw_image, paper_cmap=False):\n gcam = gcam.cpu().numpy()\n cmap = cm.jet_r(gcam)[..., :3] * 255.0\n if paper_cmap:\n alpha = gcam[..., None]\n gcam = alpha * cmap + (1 - alpha) * raw_image\n else:\n gcam = (cmap.astype(np.float) + raw_image.astype(np.float)) / 2\n cv2.imwrite(filename, np.uint8(gcam))\n\n\ndef save_sensitivity(filename, maps):\n maps = maps.cpu().numpy()\n scale = max(maps[maps > 0].max(), -maps[maps <= 0].min())\n maps = maps / scale * 0.5\n maps += 0.5\n maps = cm.bwr_r(maps)[..., :3]\n maps = np.uint8(maps * 255.0)\n maps = cv2.resize(maps, (224, 224), interpolation=cv2.INTER_NEAREST)\n cv2.imwrite(filename, maps)\n\n\n# models contained in the torchvision\nmodel_names = sorted(\n name\n for name in models.__dict__\n if name.islower() and not name.startswith(\"__\") and callable(models.__dict__[name])\n)\n\n\[email protected]()\[email protected]_context\ndef main(ctx):\n print(\"Mode:\", ctx.invoked_subcommand)\n\n\[email protected]()\[email protected](\"-i\", \"--image-paths\", type=str, multiple=True, required=True)\[email protected](\"-a\", \"--arch\", type=click.Choice(model_names), required=True)\[email protected](\"-t\", \"--target-layer\", type=str, required=True)\[email protected](\"-k\", \"--topk\", type=int, default=3)\[email protected](\"-o\", \"--output-dir\", type=str, default=\"./results\")\[email protected](\"--cuda/--cpu\", default=True)\ndef demo1(image_paths, target_layer, arch, topk, output_dir, cuda):\n \"\"\"\n Visualize model responses given multiple images\n \"\"\"\n\n device = get_device(cuda)\n\n # Synset words\n classes = get_classtable()\n\n # Model from torchvision\n model = models.__dict__[arch](pretrained=True)\n model.to(device)\n model.eval() # for evaluation mode\n\n # Images\n images, raw_images = load_images(image_paths)\n images = torch.stack(images).to(device)\n\n \"\"\"\n Common usage:\n 1. Wrap your model with visualization classes defined in grad_cam.py\n 2. Run forward() with images\n 3. Run backward() with a list of specific classes\n 4. Run generate() to export results\n \"\"\"\n\n # =========================================================================\n print(\"Vanilla Backpropagation:\")\n\n bp = BackPropagation(model=model)\n probs, ids = bp.forward(images) # sorted\n\n for i in range(topk):\n bp.backward(ids=ids[:, [i]])\n gradients = bp.generate()\n\n # Save results as image files\n for j in range(len(images)):\n print(\"\\t#{}: {} ({:.5f})\".format(j, classes[ids[j, i]], probs[j, i]))\n\n save_gradient(\n filename=osp.join(\n output_dir,\n \"{}-{}-vanilla_bp-{}.png\".format(j, arch, classes[ids[j, i]]),\n ),\n gradient=gradients[j],\n )\n\n # Remove all the hook function in the \"model\"\n bp.remove_hook()\n\n # =========================================================================\n print(\"Deconvolution:\")\n\n deconv = Deconvnet(model=model)\n _ = deconv.forward(images)\n\n for i in range(topk):\n deconv.backward(ids=ids[:, [i]])\n gradients = deconv.generate()\n\n for j in range(len(images)):\n print(\"\\t#{}: {} ({:.5f})\".format(j, classes[ids[j, i]], probs[j, i]))\n\n save_gradient(\n filename=osp.join(\n output_dir,\n \"{}-{}-deconvnet-{}.png\".format(j, arch, classes[ids[j, i]]),\n ),\n gradient=gradients[j],\n )\n\n deconv.remove_hook()\n\n # =========================================================================\n print(\"Grad-CAM/Guided Backpropagation/Guided Grad-CAM:\")\n\n gcam = GradCAM(model=model)\n _ = gcam.forward(images)\n\n gbp = GuidedBackPropagation(model=model)\n _ = gbp.forward(images)\n\n for i in range(topk):\n # Guided Backpropagation\n gbp.backward(ids=ids[:, [i]])\n gradients = gbp.generate()\n\n # Grad-CAM\n gcam.backward(ids=ids[:, [i]])\n regions = gcam.generate(target_layer=target_layer)\n\n for j in range(len(images)):\n print(\"\\t#{}: {} ({:.5f})\".format(j, classes[ids[j, i]], probs[j, i]))\n\n # Guided Backpropagation\n save_gradient(\n filename=osp.join(\n output_dir,\n \"{}-{}-guided_bp-{}.png\".format(j, arch, classes[ids[j, i]]),\n ),\n gradient=gradients[j],\n )\n\n # Grad-CAM\n save_gradcam(\n filename=osp.join(\n output_dir,\n \"{}-{}-gradcam-{}-{}.png\".format(\n j, arch, target_layer, classes[ids[j, i]]\n ),\n ),\n gcam=regions[j, 0],\n raw_image=raw_images[j],\n )\n\n # Guided Grad-CAM\n save_gradient(\n filename=osp.join(\n output_dir,\n \"{}-{}-guided_gradcam-{}-{}.png\".format(\n j, arch, target_layer, classes[ids[j, i]]\n ),\n ),\n gradient=torch.mul(regions, gradients)[j],\n )\n\n\[email protected]()\[email protected](\"-i\", \"--image-paths\", type=str, multiple=True, required=True)\[email protected](\"-o\", \"--output-dir\", type=str, default=\"./results\")\[email protected](\"--cuda/--cpu\", default=True)\ndef demo2(image_paths, output_dir, cuda):\n \"\"\"\n Generate Grad-CAM at different layers of ResNet-152\n \"\"\"\n\n device = get_device(cuda)\n\n # Synset words\n classes = get_classtable()\n\n # Model\n model = models.resnet152(pretrained=True)\n model.to(device)\n model.eval()\n\n # The four residual layers\n target_layers = [\"relu\", \"layer1\", \"layer2\", \"layer3\", \"layer4\"]\n target_class = 243 # \"bull mastif\"\n\n # Images\n images, raw_images = load_images(image_paths)\n images = torch.stack(images).to(device)\n\n gcam = GradCAM(model=model)\n probs, ids = gcam.forward(images)\n ids_ = torch.LongTensor([[target_class]] * len(images)).to(device)\n gcam.backward(ids=ids_)\n\n for target_layer in target_layers:\n print(\"Generating Grad-CAM @{}\".format(target_layer))\n\n # Grad-CAM\n regions = gcam.generate(target_layer=target_layer)\n\n for j in range(len(images)):\n print(\n \"\\t#{}: {} ({:.5f})\".format(\n j, classes[target_class], float(probs[ids == target_class])\n )\n )\n\n save_gradcam(\n filename=osp.join(\n output_dir,\n \"{}-{}-gradcam-{}-{}.png\".format(\n j, \"resnet152\", target_layer, classes[target_class]\n ),\n ),\n gcam=regions[j, 0],\n raw_image=raw_images[j],\n )\n\n\[email protected]()\[email protected](\"-i\", \"--image-paths\", type=str, multiple=True, required=True)\[email protected](\"-a\", \"--arch\", type=click.Choice(model_names), required=True)\[email protected](\"-k\", \"--topk\", type=int, default=3)\[email protected](\"-s\", \"--stride\", type=int, default=1)\[email protected](\"-b\", \"--n-batches\", type=int, default=128)\[email protected](\"-o\", \"--output-dir\", type=str, default=\"./results\")\[email protected](\"--cuda/--cpu\", default=True)\ndef demo3(image_paths, arch, topk, stride, n_batches, output_dir, cuda):\n \"\"\"\n Generate occlusion sensitivity maps\n \"\"\"\n\n device = get_device(cuda)\n\n # Synset words\n classes = get_classtable()\n\n # Model from torchvision\n model = models.__dict__[arch](pretrained=True)\n model = torch.nn.DataParallel(model)\n model.to(device)\n model.eval()\n\n # Images\n images, _ = load_images(image_paths)\n images = torch.stack(images).to(device)\n\n print(\"Occlusion Sensitivity:\")\n\n patche_sizes = [10, 15, 25, 35, 45, 90]\n\n logits = model(images)\n probs = F.softmax(logits, dim=1)\n probs, ids = probs.sort(dim=1, descending=True)\n\n for i in range(topk):\n for p in patche_sizes:\n print(\"Patch:\", p)\n sensitivity = occlusion_sensitivity(\n model, images, ids[:, [i]], patch=p, stride=stride, n_batches=n_batches\n )\n\n # Save results as image files\n for j in range(len(images)):\n print(\"\\t#{}: {} ({:.5f})\".format(j, classes[ids[j, i]], probs[j, i]))\n\n save_sensitivity(\n filename=osp.join(\n output_dir,\n \"{}-{}-sensitivity-{}-{}.png\".format(\n j, arch, p, classes[ids[j, i]]\n ),\n ),\n maps=sensitivity[j],\n )\n\n\nif __name__ == \"__main__\":\n main()\n"
] |
[
[
"torch.nn.functional.softmax",
"torch.cuda.current_device",
"numpy.uint8",
"matplotlib.cm.jet_r",
"matplotlib.cm.bwr_r",
"torch.mul",
"numpy.shape",
"torch.cuda.is_available",
"torch.cuda.get_device_name",
"torch.device",
"torch.nn.DataParallel",
"numpy.array",
"torch.stack"
]
] |
Timurff/dlcourse_ai
|
[
"ab7c0fb5d463f9e963a6624be78520dda1cf39e9"
] |
[
"assignments/assignment2/trainer.py"
] |
[
"from copy import deepcopy\n\nimport numpy as np\nfrom metrics import multiclass_accuracy\n\n\nclass Dataset:\n \"\"\"\n Utility class to hold training and validation data\n \"\"\"\n\n def __init__(self, train_X, train_y, val_X, val_y):\n self.train_X = train_X\n self.train_y = train_y\n self.val_X = val_X\n self.val_y = val_y\n\n\nclass Trainer:\n \"\"\"\n Trainer of the neural network models\n Perform mini-batch SGD with the specified data, model,\n training parameters and optimization rule\n \"\"\"\n\n def __init__(self, model, dataset, optim,\n num_epochs=20,\n batch_size=20,\n learning_rate=1e-2,\n learning_rate_decay=1.0):\n \"\"\"\n Initializes the trainer\n\n Arguments:\n model - neural network model\n dataset, instance of Dataset class - data to train on\n optim - optimization method (see optim.py)\n num_epochs, int - number of epochs to train\n batch_size, int - batch size\n learning_rate, float - initial learning rate\n learning_rate_decal, float - ratio for decaying learning rate\n every epoch\n \"\"\"\n self.dataset = dataset\n self.model = model\n self.optim = optim\n self.batch_size = batch_size\n self.learning_rate = learning_rate\n self.num_epochs = num_epochs\n self.learning_rate_decay = learning_rate_decay\n\n self.optimizers = None\n\n def setup_optimizers(self):\n params = self.model.params()\n self.optimizers = {}\n for param_name, param in params.items():\n self.optimizers[param_name] = deepcopy(self.optim)\n\n def compute_accuracy(self, X, y):\n \"\"\"\n Computes accuracy on provided data using mini-batches\n \"\"\"\n indices = np.arange(X.shape[0])\n sections = np.arange(self.batch_size, X.shape[0], self.batch_size)\n batches_indices = np.array_split(indices, sections)\n\n pred = np.zeros_like(y)\n\n for batch_indices in batches_indices:\n batch_X = X[batch_indices]\n pred_batch = self.model.predict(batch_X)\n pred[batch_indices] = pred_batch\n\n return multiclass_accuracy(pred, y)\n\n def fit(self):\n \"\"\"\n Trains a model\n \"\"\"\n if self.optimizers is None:\n self.setup_optimizers()\n\n num_train = self.dataset.train_X.shape[0]\n\n loss_history = []\n train_acc_history = []\n val_acc_history = []\n \n for epoch in range(self.num_epochs):\n shuffled_indices = np.arange(num_train)\n np.random.shuffle(shuffled_indices)\n sections = np.arange(self.batch_size, num_train, self.batch_size)\n batches_indices = np.array_split(shuffled_indices, sections)\n\n batch_losses = []\n\n for batch_indices in batches_indices:\n # TODO Generate batches based on batch_indices and\n # use model to generate loss and gradients for all\n # the params\n loss = self.model.compute_loss_and_gradients(X=self.dataset.train_X[batch_indices], y=self.dataset.train_y[batch_indices])\n\n for param_name, param in self.model.params().items():\n optimizer = self.optimizers[param_name]\n param.value = optimizer.update(param.value, param.grad, self.learning_rate)\n\n batch_losses.append(loss)\n\n if np.not_equal(self.learning_rate_decay, 1.0):\n # TODO: Implement learning rate decay\n self.learning_rate *= self.learning_rate_decay\n\n ave_loss = np.mean(batch_losses)\n\n train_accuracy = self.compute_accuracy(self.dataset.train_X,\n self.dataset.train_y)\n\n val_accuracy = self.compute_accuracy(self.dataset.val_X,\n self.dataset.val_y)\n\n # print(\"Loss: %f, Train accuracy: %f, val accuracy: %f\" %\n # (batch_losses[-1], train_accuracy, val_accuracy))\n\n loss_history.append(ave_loss)\n train_acc_history.append(train_accuracy)\n val_acc_history.append(val_accuracy)\n\n return loss_history, train_acc_history, val_acc_history\n"
] |
[
[
"numpy.arange",
"numpy.random.shuffle",
"numpy.zeros_like",
"numpy.mean",
"numpy.not_equal",
"numpy.array_split"
]
] |
dd-iuonac/vision3d
|
[
"9ea514c80eb99d265c3247321e59bfc1c2ccd94a"
] |
[
"pvrcnn/detector/proposal.py"
] |
[
"import torch\nimport math\nfrom torch import nn\nimport torch.nn.functional as F\n\nfrom pvrcnn.ops import sigmoid_focal_loss, batched_nms_rotated\nfrom pvrcnn.core.box_encode import decode\n\n\nclass ProposalLayer(nn.Module):\n \"\"\"\n Use BEV feature map to generate 3D box proposals.\n TODO: Fix long variable names, ugly line wraps.\n \"\"\"\n\n def __init__(self, cfg):\n super(ProposalLayer, self).__init__()\n self.cfg = cfg\n self.conv_cls = nn.Conv2d(\n cfg.PROPOSAL.C_IN, cfg.NUM_CLASSES * cfg.NUM_YAW, 1)\n self.conv_reg = nn.Conv2d(\n cfg.PROPOSAL.C_IN, cfg.NUM_CLASSES * cfg.NUM_YAW * cfg.BOX_DOF, 1)\n self.TOPK, self.DOF = cfg.PROPOSAL.TOPK, cfg.BOX_DOF\n self._init_weights()\n\n def _init_weights(self):\n nn.init.constant_(self.conv_cls.bias, (-math.log(1 - .01) / .01))\n nn.init.constant_(self.conv_reg.bias, 0)\n for m in (self.conv_cls.weight, self.conv_reg.weight):\n nn.init.normal_(m, std=0.01)\n\n def _generate_group_idx(self, B, n_cls):\n \"\"\"Compute unique group_idx based on (batch_idx, class_idx) tuples.\"\"\"\n batch_idx = torch.arange(B)[:, None].expand(-1, n_cls)\n class_idx = torch.arange(n_cls)[None, :].expand(B, -1)\n group_idx = class_idx + n_cls * batch_idx\n b, c, g = [x[..., None].expand(-1, -1, self.TOPK).reshape(-1)\n for x in (batch_idx, class_idx, group_idx)]\n return b, c, g\n\n def _above_score_thresh(self, scores, class_idx):\n \"\"\"Classes may have different score thresholds.\"\"\"\n thresh = scores.new_tensor([a['score_thresh'] for a in self.cfg.ANCHORS])\n mask = scores > thresh[class_idx]\n return mask\n\n def _multiclass_batch_nms(self, boxes, scores):\n \"\"\"Only boxes with same group_idx are jointly considered in nms\"\"\"\n B, n_cls = scores.shape[:2]\n scores = scores.view(-1)\n boxes = boxes.view(-1, self.DOF)\n bev_boxes = boxes[:, [0, 1, 3, 4, 6]]\n batch_idx, class_idx, group_idx = self._generate_group_idx(B, n_cls)\n idx = batched_nms_rotated(bev_boxes, scores, group_idx, iou_threshold=0.01)\n boxes, batch_idx, class_idx, scores = \\\n [x[idx] for x in (boxes, batch_idx, class_idx, scores)]\n mask = self._above_score_thresh(scores, class_idx)\n out = [x[mask] for x in (boxes, batch_idx, class_idx, scores)]\n return out\n\n def _decode(self, reg_map, anchors, anchor_idx):\n \"\"\"Expands anchors in batch dimension and calls decode.\"\"\"\n B, n_cls = reg_map.shape[:2]\n anchor_idx = anchor_idx[..., None].expand(-1, -1, -1, self.DOF)\n deltas = reg_map.reshape(B, n_cls, -1, self.cfg.BOX_DOF) \\\n .gather(2, anchor_idx)\n anchors = anchors.view(1, n_cls, -1, self.cfg.BOX_DOF) \\\n .expand(B, -1, -1, -1).gather(2, anchor_idx)\n boxes = decode(deltas, anchors)\n return boxes\n\n def inference(self, feature_map, anchors):\n \"\"\":return (boxes, batch_idx, class_idx, scores)\"\"\"\n cls_map, reg_map = self(feature_map)\n score_map = cls_map.sigmoid_()\n B, n_cls = score_map.shape[:2]\n scores, anchor_idx = score_map.view(B, n_cls, -1).topk(self.TOPK, -1)\n boxes = self._decode(reg_map, anchors, anchor_idx)\n out = self._multiclass_batch_nms(boxes, scores)\n return out\n\n def reshape_cls(self, cls_map):\n B, _, ny, nx = cls_map.shape\n shape = (B, self.cfg.NUM_CLASSES, self.cfg.NUM_YAW, ny, nx)\n cls_map = cls_map.view(shape)\n return cls_map\n\n def reshape_reg(self, reg_map):\n B, _, ny, nx = reg_map.shape\n shape = (B, self.cfg.NUM_CLASSES, self.cfg.BOX_DOF, -1, ny, nx)\n reg_map = reg_map.view(shape).permute(0, 1, 3, 4, 5, 2)\n return reg_map\n\n def forward(self, feature_map):\n cls_map = self.reshape_cls(self.conv_cls(feature_map))\n reg_map = self.reshape_reg(self.conv_reg(feature_map))\n return cls_map, reg_map\n\n\nclass ProposalLoss(nn.Module):\n \"\"\"\n Notation: (P_i, G_i, M_i) ~ (predicted, ground truth, mask).\n Loss is averaged by number of positive examples.\n TODO: Replace with compiled cuda focal loss.\n \"\"\"\n\n def __init__(self, cfg):\n super(ProposalLoss, self).__init__()\n self.cfg = cfg\n\n def masked_sum(self, loss, mask):\n \"\"\"Mask assumed to be binary.\"\"\"\n mask = mask.type_as(loss)\n loss = (loss * mask).sum()\n return loss\n\n def reg_loss(self, P_reg, G_reg, M_reg):\n \"\"\"Loss applied at all positive sites.\"\"\"\n P_xyz, P_wlh, P_yaw = P_reg.split([3, 3, 1], dim=-1)\n G_xyz, G_wlh, G_yaw = G_reg.split([3, 3, 1], dim=-1)\n loss_xyz = F.smooth_l1_loss(P_xyz, G_xyz, reduction='none')\n loss_wlh = F.smooth_l1_loss(P_wlh, G_wlh, reduction='none')\n loss_yaw = F.smooth_l1_loss(P_yaw, G_yaw, reduction='none') / math.pi\n loss = self.masked_sum(loss_xyz + loss_wlh + loss_yaw, M_reg)\n return loss\n\n def cls_loss(self, P_cls, G_cls, M_cls):\n \"\"\"Loss is applied at all non-ignore sites. Assumes logit scores.\"\"\"\n loss = sigmoid_focal_loss(P_cls, G_cls.float(), reduction='none')\n loss = self.masked_sum(loss, M_cls)\n return loss\n\n def forward(self, item):\n keys = ['G_cls', 'M_cls', 'P_cls', 'G_reg', 'M_reg', 'P_reg']\n G_cls, M_cls, P_cls, G_reg, M_reg, P_reg = map(item.get, keys)\n normalizer = M_reg.type_as(P_reg).sum().clamp_(min=1)\n cls_loss = self.cls_loss(P_cls, G_cls, M_cls) / normalizer\n reg_loss = self.reg_loss(P_reg, G_reg, M_reg) / normalizer\n loss = cls_loss + self.cfg.TRAIN.LAMBDA * reg_loss\n losses = dict(cls_loss=cls_loss, reg_loss=reg_loss, loss=loss)\n return losses\n"
] |
[
[
"torch.nn.init.constant_",
"torch.nn.Conv2d",
"torch.nn.init.normal_",
"torch.nn.functional.smooth_l1_loss",
"torch.arange"
]
] |
paulbaumgarten/examinations-timer
|
[
"686f3ecae255dd873bd85da893a81340a3149efc"
] |
[
"examtimer.py"
] |
[
"import pygame, time, random\nfrom pygame.locals import *\nimport pandas as pd\nimport json\nfrom datetime import datetime, timedelta\nimport threading, time\n\n\"\"\" Settings \"\"\"\nEXCEL_FILE = \"exams.xlsx\"\nWORKSHEET = \"exams\"\n\n\"\"\" Read excel file into json data \"\"\"\ndef get_excel_data(xlsx_filename, worksheet):\n xl = pd.read_excel(xlsx_filename, sheet_name=worksheet, index_col=None, na_values=[\"NA\"])\n data = []\n for rowid, row in sorted(xl.iterrows()):\n record = {}\n for k,v in row.items():\n k = k.lower()\n record[k] = v\n data.append(record)\n return(data)\n\ndef get_session_list(exams):\n res = []\n for exam in exams:\n if exam[\"session_id\"] not in res:\n res.append(exam[\"session_id\"])\n return res\n\n\"\"\" Initialise clock \"\"\"\nseconds_elapsed = 0\nclock_running = False\nquit = False\n\ndef clock_tick():\n global seconds_elapsed\n if clock_running:\n seconds_elapsed += 1\n if not quit:\n threading.Timer(1, clock_tick).start()\n pass\nticker = threading.Timer(1, clock_tick).start()\n\n\"\"\" Initialise Pygame \"\"\"\npygame.init()\n\n\"\"\" Pygame Constants \"\"\"\nBACKGROUND = (0x00, 0x00, 0x00)\nBACKGROUND_ROW = (0x33, 0x33, 0x33)\nFOREGROUND_PRIMARY = (0xC0, 0xC0, 0xA0)\nFOREGROUND_SECONDARY = (0xF0, 0xF0, 0xF0)\nHIGHLIGHT = (0x40, 0x40, 0x40)\nPAUSED = (0xA0, 0x00, 0x00)\nHELP_COLOUR = (0x00, 0x00, 0xA0)\nTEXT1 = pygame.font.SysFont(\"Arial\", 64)\nTEXT2 = pygame.font.SysFont(\"Arial\", 36)\nTEXT3 = pygame.font.SysFont(\"Arial\", 24)\nTEXT_MEGA = pygame.font.SysFont(\"Arial\", 72)\nCLOCK = pygame.font.SysFont(\"Consolas\", 64)\nWARNING1 = (0xD8, 0x61, 0x06)\nWARNING2 = (0xF4, 0x41, 0x41)\n\n#window = pygame.display.set_mode((1280, 720), pygame.FULLSCREEN)\nwindow = pygame.display.set_mode((1280, 720), pygame.RESIZABLE)\npygame_width, pygame_height = pygame.display.get_surface().get_size()\nfps = pygame.time.Clock()\nexams = get_excel_data(EXCEL_FILE, WORKSHEET)\nsession_list = get_session_list(exams)\nsession_id = None\npos = (0,0) ### HERE\nclick = (0,0) ### HERE\nshow_instructions = False\nwhile not quit:\n window.fill(BACKGROUND)\n for event in pygame.event.get():\n if event.type == QUIT:\n quit = True\n elif event.type == KEYDOWN:\n if event.key == K_ESCAPE:\n show_instructions = not show_instructions\n if event.key == K_x and show_instructions:\n quit = True\n if event.key == K_1 and session_id is not None:\n seconds_elapsed -= 60\n if event.key == K_2 and session_id is not None:\n seconds_elapsed += 60\n if event.key == K_SPACE and session_id is not None:\n clock_running = not clock_running\n if event.key == K_l:\n BACKGROUND = (0xFF, 0xFF, 0xFF)\n BACKGROUND_ROW = (0xDD, 0xDD, 0xDD)\n FOREGROUND_PRIMARY = (0x00, 0x00, 0x00)\n FOREGROUND_SECONDARY = (0x21, 0x21, 0x21)\n HIGHLIGHT = (0xB0, 0xB0, 0xB0)\n if event.key == K_d:\n BACKGROUND = (0x00, 0x00, 0x00)\n BACKGROUND_ROW = (0x33, 0x33, 0x33)\n FOREGROUND_PRIMARY = (0xC0, 0xC0, 0xA0)\n FOREGROUND_SECONDARY = (0xF0, 0xF0, 0xF0)\n HIGHLIGHT = (0x40, 0x40, 0x40)\n elif event.type == MOUSEMOTION:\n pos = event.pos\n elif event.type == MOUSEBUTTONDOWN:\n if session_id is None:\n click = event.pos\n else:\n clock_running = not clock_running\n\n if session_id is None: # no session selected yet\n # Display all sessions\n window.blit(TEXT2.render(\"Select session:\", 1, FOREGROUND_PRIMARY), (20, 20))\n for i in range(len(session_list)):\n y = 60+50*i\n h = 50\n if pos[1] > y and pos[1] < (y+h):\n pygame.draw.rect(window, HIGHLIGHT, (0,y,pygame_width,h))\n if click[1] > y and click[1] < (y+h):\n session_id = session_list[i]\n click = (0,0)\n window.blit(TEXT2.render(session_list[i], 1, FOREGROUND_SECONDARY), (20, y))\n\n else: # display session exam information:\n now = datetime.now()\n window.blit(TEXT1.render(now.strftime(\"%A, %d %B, %Y\"), 1, FOREGROUND_PRIMARY), (10, 10))\n if now.second % 2 == 0:\n window.blit(CLOCK.render(now.strftime(\"%H %M\"), 1, FOREGROUND_PRIMARY), (pygame_width-200, 10))\n else:\n window.blit(CLOCK.render(now.strftime(\"%H:%M\"), 1, FOREGROUND_PRIMARY), (pygame_width-200, 10))\n window.blit(TEXT3.render(\"EXAM\", 1, FOREGROUND_SECONDARY), (10, 110))\n window.blit(TEXT3.render(\"REMAINING\", 1, FOREGROUND_SECONDARY), (pygame_width-450, 110))\n window.blit(TEXT3.render(\"FINISH AT\", 1, FOREGROUND_SECONDARY), (pygame_width-200, 110))\n i = 0\n for exam in exams:\n if exam[\"session_id\"] == session_id:\n if \"seconds_duration\" not in exam:\n exam[\"seconds_duration\"] = int(exam[\"minutes\"]*60)\n y = 150+70*i\n\n # Display exam label\n window.blit(TEXT1.render(exam[\"exam_label\"], 1, FOREGROUND_SECONDARY), (10, y))\n\n # Calculate and display remaining time\n seconds_remaining = exam[\"seconds_duration\"] - seconds_elapsed\n h = seconds_remaining // 3600\n m = (seconds_remaining % 3600) // 60\n time_remaining = f\"{h:02}:{m:02}\"\n if clock_running and now.second % 2 == 0: # pulse between \"hh:mm\" and \"hh mm\"\n time_remaining = f\"{h:02} {m:02}\"\n if seconds_remaining < (5*60): # 5 minute warning\n pygame.draw.rect(window, WARNING2, (pygame_width-460,y-10,150,60))\n elif seconds_remaining < (30*60): # 30 minute warning\n pygame.draw.rect(window, WARNING1, (pygame_width-460,y-10,150,60))\n if seconds_remaining < 60:\n if now.second % 2 == 0:\n time_remaining = f\" {seconds_remaining:02}\"\n else:\n time_remaining = f\" .{seconds_remaining:02}\"\n if seconds_remaining < 0:\n time_remaining = \"stop\"\n window.blit(CLOCK.render(time_remaining, 1, FOREGROUND_SECONDARY), (pygame_width-450, y))\n\n # Calculate and display estimated finish time\n finish = now + timedelta(seconds=seconds_remaining)\n window.blit(CLOCK.render(finish.strftime(\"%H:%M\"), 1, FOREGROUND_SECONDARY), (pygame_width-200, y))\n\n if not clock_running:\n s = pygame.Surface((pygame_width - 400, pygame_height - 400))\n s.set_alpha(128)\n s.fill(PAUSED)\n window.blit(s, (200, 200))\n window.blit(TEXT_MEGA.render(\"PAUSED\", 1, FOREGROUND_PRIMARY), (500, 320))\n window.blit(TEXT3.render(\"Press SPACE to RESUME\", 1, FOREGROUND_PRIMARY), (500, 460))\n window.blit(TEXT3.render(\"Press ESC for HELP\", 1, FOREGROUND_PRIMARY), (500, 490))\n i += 1\n # end: if exam[\"session_id\"] == session_id:\n # end: for exam in exams\n if show_instructions:\n s = pygame.Surface((pygame_width - 400, pygame_height - 400))\n s.fill(HELP_COLOUR)\n window.blit(s, (200, 200))\n window.blit(TEXT1.render(\"INSTRUCTIONS\", 1, FOREGROUND_PRIMARY), (210, 210))\n window.blit(TEXT3.render(\"Press SPACE to PAUSE / RESUME countdown\", 1, FOREGROUND_PRIMARY), (210, 290))\n window.blit(TEXT3.render(\"Press ESC again to close instructions\", 1, FOREGROUND_PRIMARY), (210, 320))\n window.blit(TEXT3.render(\"Press 1 to add a minute to time remaining\", 1, FOREGROUND_PRIMARY), (210, 325))\n window.blit(TEXT3.render(\"Press 2 to subtract a minute from time remaining\", 1, FOREGROUND_PRIMARY), (210, 380))\n window.blit(TEXT3.render(\"Press L or D to switch between light and dark color modes\", 1, FOREGROUND_PRIMARY), (210, 410))\n window.blit(TEXT3.render(\"Press X now (from instruction screen) to exit\", 1, FOREGROUND_PRIMARY), (210, 440))\n\n pygame.display.update() # Actually does the screen update\n fps.tick(25) # Run the game at 25 frames per second\npygame.quit()\n\n"
] |
[
[
"pandas.read_excel"
]
] |
zcemctt/MPHY0041_Segmentation
|
[
"a89638153a44fe030b2ab9abd8e3136306bf2712"
] |
[
"UNet_3D_Cy/testing.py"
] |
[
"# Load Trained Model\n\nimport tensorflow as tf\nimport numpy as np\nimport os\nimport matplotlib.pyplot as plt\nfrom keras.optimizers import Adam, SGD\nfrom tqdm import tqdm\nimport random\nfrom metrics import dice_coef, dice_coef_loss\nimport yaml\n\n# Hyperparameters\nconfig = yaml.safe_load(open(\"hyper_parameters.yaml\"))\npath_to_data = config['path_to_data']\npath_to_save = config['path_to_save']\n\nN = config['N']\nN_test = config['N_test']\nval_size = config['val_size']\n\nimg_width = config['img_width']\nimg_height = config['img_height']\nimg_thickness = config['img_thickness']\nimg_channels = config['img_channels']\n\n# Load Training Data\nX_train = np.zeros((N, img_thickness, img_height, img_width, img_channels), dtype=np.float32)\nY_train = np.zeros((N, img_thickness, img_height, img_width, img_channels), dtype=np.float32)\n\nprint('','','')\nprint('','','')\nprint('Loading Training Data')\n\nfor n in tqdm(range(N)):\n image = np.load(os.path.join(path_to_data, \"image_train%02d.npy\" % n))\n label = np.load(os.path.join(path_to_data, \"label_train%02d.npy\" % n))\n X_train[n] = image[:,:,:,np.newaxis]\n Y_train[n] = label[:,:,:,np.newaxis]\n\nprint('Loaded Training Data')\n\n# Load Testing Data\nX_test = np.zeros((N_test, img_thickness, img_height, img_width, img_channels), dtype=np.float32)\n\nprint('','','')\nprint('','','')\nprint('Loading Testing Data')\n\nfor n in tqdm(range(N_test)):\n image = np.load(os.path.join(path_to_data, \"image_test%02d.npy\" % n))\n X_test[n] = image[:,:,:,np.newaxis]\n\nprint('Loaded Testing Data')\nprint('','','')\nprint('','','')\n\n# Load the trained model\n\nmodel = tf.keras.models.load_model('saved_model/3D_best_model.h5',\n custom_objects={'dice_coef_loss': dice_coef_loss,\n 'dice_coef': dice_coef})\ntf.print(model.summary())\n\nloss, dice = model.evaluate(X_train[int(X_train.shape[0]*(1-val_size)):], \n Y_train[int(Y_train.shape[0]*(1-val_size)):], verbose=1)\nprint('Restored model, average testing dice coefficient: {:5.2f}'.format(dice))\n\n# Save the masks\n\nidx = random.randint(0, N)\n\npreds_train = model.predict(X_train[:int(X_train.shape[0]*(1-val_size))], verbose=1)\npreds_val = model.predict(X_train[int(X_train.shape[0]*(1-val_size)):], verbose=1)\npreds_test = model.predict(X_test, verbose=1)\n\n\npreds_train_t = (preds_train > 0.5).astype(np.uint8)\npreds_val_t = (preds_val > 0.5).astype(np.uint8)\npreds_test_t = (preds_test > 0.5).astype(np.uint8)\n\nprint('','','')\nprint('','','')\nprint('Saving 3D Segmentation Training Masks')\n\nfor ix in tqdm(range(len(preds_train))):\n for iy in range(img_thickness):\n fig = plt.figure()\n fig.suptitle(f'3D Segmentation Training Masks (ix={ix+1}, slice={iy+1})', fontsize=12)\n ax1 = fig.add_subplot(131)\n plt.imshow(np.squeeze(X_train[ix,iy,:,:]))\n ax2 = fig.add_subplot(132)\n plt.imshow(np.squeeze(Y_train[ix,iy,:,:]))\n ax3 = fig.add_subplot(133)\n plt.imshow(np.squeeze(preds_train_t[ix,iy,:,:]))\n ax1.title.set_text('Clinical Image')\n ax2.title.set_text('Real Mask')\n ax3.title.set_text('Predicted Mask')\n plt.savefig(f'plots_training/Training_Masks_ix_{ix+1}_slice_{iy+1}.png')\n plt.close()\n\nprint('Finished Saving')\nprint('','','')\nprint('','','')\nprint('Saving 3D Segmentation Training Mask Overlays')\n\nfor ix in tqdm(range(len(preds_train))):\n for iy in range(img_thickness):\n fig = plt.figure()\n fig.suptitle(f'3D Segmentation Training Mask Overlay (ix={ix+1}, slice={iy+1})', fontsize=12)\n ax1 = fig.add_subplot()\n plt.imshow(np.squeeze(X_train[ix,iy,:,:]))\n plt.contour(np.squeeze(Y_train[ix,iy,:,:]),1,colors='yellow',linewidths=0.5)\n plt.contour(np.squeeze(preds_train_t[ix,iy,:,:]),1,colors='red',linewidths=0.5)\n plt.savefig(f'plots_training_overlay/Training_Overlay_ix_{ix+1}_slice_{iy+1}.png')\n plt.close()\n\nprint('Finished Saving')\nprint('','','')\nprint('','','')\nprint('Saving 3D Segmentation Testing Masks')\n\nfor ix in tqdm(range(len(preds_test))):\n for iy in range(img_thickness):\n fig = plt.figure()\n fig.suptitle(f'3D Segmentation Testing Masks (ix={ix+1}, slice={iy+1})', fontsize=12)\n ax1 = fig.add_subplot(121)\n plt.imshow(np.squeeze(X_test[ix,iy,:,:]))\n ax3 = fig.add_subplot(122)\n plt.imshow(np.squeeze(preds_test_t[ix,iy,:,:]))\n ax1.title.set_text('Clinical Image')\n ax3.title.set_text('Predicted Mask')\n plt.savefig(f'plots_testing/Testing_Masks_ix_{ix+1}_slice_{iy+1}.png')\n plt.close()\n\nprint('Finished Saving')\nprint('','','')\nprint('','','')\n\nprint('Training Script has sucessfully completed')\n"
] |
[
[
"tensorflow.keras.models.load_model",
"numpy.squeeze",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.close",
"numpy.zeros",
"matplotlib.pyplot.figure"
]
] |
rlouf/aehmc
|
[
"8c27dd1153e4642e8499e202bb967dfc2b190309"
] |
[
"tests/test_hmc.py"
] |
[
"import aesara\nimport aesara.tensor as at\nimport arviz\nimport numpy as np\nimport pytest\nimport scipy.stats as stats\nfrom aeppl import joint_logprob\n\nfrom aehmc import hmc, nuts\n\n\[email protected](reason=\"this test is flaky\")\ndef test_hmc():\n \"\"\"Test the HMC kernel on a gaussian target.\"\"\"\n step_size = 1.0\n inverse_mass_matrix = at.as_tensor(1.0)\n num_integration_steps = 10\n\n srng = at.random.RandomStream(seed=0)\n Y_rv = srng.normal(1, 2)\n\n def logprob_fn(y):\n logprob = joint_logprob({Y_rv: y})\n return logprob\n\n kernel = hmc.kernel(\n srng,\n logprob_fn,\n inverse_mass_matrix,\n num_integration_steps,\n )\n\n y_vv = Y_rv.clone()\n initial_state = hmc.new_state(y_vv, logprob_fn)\n\n trajectory, updates = aesara.scan(\n kernel,\n outputs_info=[\n {\"initial\": initial_state[0]},\n {\"initial\": initial_state[1]},\n {\"initial\": initial_state[2]},\n None,\n ],\n non_sequences=step_size,\n n_steps=2_000,\n )\n\n trajectory_generator = aesara.function((y_vv,), trajectory[0], updates=updates)\n\n samples = trajectory_generator(3.0)\n assert np.mean(samples[1000:]) == pytest.approx(1.0, rel=1e-1)\n assert np.var(samples[1000:]) == pytest.approx(4.0, rel=1e-1)\n\n\[email protected](reason=\"this test is flaky\")\ndef test_nuts():\n \"\"\"Test the NUTS kernel on a gaussian target.\"\"\"\n step_size = 0.1\n inverse_mass_matrix = at.as_tensor(1.0)\n\n srng = at.random.RandomStream(seed=0)\n Y_rv = srng.normal(1, 2)\n\n def logprob_fn(y):\n logprob = joint_logprob({Y_rv: y})\n return logprob\n\n kernel = nuts.kernel(\n srng,\n logprob_fn,\n inverse_mass_matrix,\n )\n\n y_vv = Y_rv.clone()\n initial_state = nuts.new_state(y_vv, logprob_fn)\n\n trajectory, updates = aesara.scan(\n kernel,\n outputs_info=[\n {\"initial\": initial_state[0]},\n {\"initial\": initial_state[1]},\n {\"initial\": initial_state[2]},\n None,\n None,\n None,\n None,\n ],\n non_sequences=step_size,\n n_steps=2000,\n )\n\n trajectory_generator = aesara.function((y_vv,), trajectory[0], updates=updates)\n\n samples = trajectory_generator(3.0)\n assert np.mean(samples[1000:]) == pytest.approx(1.0, rel=1e-1)\n assert np.var(samples[1000:]) == pytest.approx(4.0, rel=1e-1)\n\n\ndef compute_ess(samples):\n d = arviz.convert_to_dataset(np.expand_dims(samples, axis=0))\n ess = arviz.ess(d).to_array()\n return ess\n\n\ndef compute_error_probability(samples, true_param):\n \"\"\"Compute the probability of getting an error more extreme\n than the one we observe assuming the samples are really drawn\n from the target distribution.\n\n This computation assumes that the target distribution is a normal\n distribution.\n\n \"\"\"\n ess = compute_ess(samples)\n posterior_mean = np.mean(samples, axis=0)\n posterior_sd = np.std(samples, axis=0, ddof=1)\n avg_monte_carlo_standard_error = np.mean(posterior_sd, axis=0) / np.sqrt(ess)\n scaled_error = np.abs(posterior_mean - true_param) / avg_monte_carlo_standard_error\n return stats.norm.sf(scaled_error).squeeze()\n\n\ndef test_nuts_mcse():\n\n loc = np.array([0.0, 3.0])\n scale = np.array([1.0, 2.0])\n rho = np.array(0.75)\n\n cov = np.diag(scale**2)\n cov[0, 1] = rho * scale[0] * scale[1]\n cov[1, 0] = rho * scale[0] * scale[1]\n\n loc_tt = at.as_tensor(loc)\n cov_tt = at.as_tensor(cov)\n\n srng = at.random.RandomStream(seed=0)\n Y_rv = srng.multivariate_normal(loc_tt, cov_tt)\n\n def logprob_fn(y):\n return joint_logprob({Y_rv: y})\n\n kernel = nuts.kernel(\n srng,\n logprob_fn,\n at.as_tensor([1.0, 0.5]),\n )\n\n y_vv = Y_rv.clone()\n initial_state = nuts.new_state(y_vv, logprob_fn)\n\n trajectory, updates = aesara.scan(\n kernel,\n outputs_info=[\n {\"initial\": initial_state[0]},\n {\"initial\": initial_state[1]},\n {\"initial\": initial_state[2]},\n None,\n None,\n None,\n None,\n ],\n non_sequences=0.5,\n n_steps=2000,\n )\n\n trajectory_generator = aesara.function((y_vv,), trajectory[0], updates=updates)\n\n rng = np.random.default_rng(seed=32098)\n posterior_samples = trajectory_generator(rng.standard_normal(2))[-1000:]\n\n error_prob = compute_error_probability(posterior_samples, loc)\n np.testing.assert_array_less(0.01, error_prob)\n\n ess = compute_ess(posterior_samples)\n np.testing.assert_array_less(100, ess)\n\n\ndef test_hmc_mcse():\n\n loc = np.array([0.0, 3.0])\n scale = np.array([1.0, 2.0])\n rho = np.array(0.75)\n\n cov = np.diag(scale**2)\n cov[0, 1] = rho * scale[0] * scale[1]\n cov[1, 0] = rho * scale[0] * scale[1]\n\n loc_tt = at.as_tensor(loc)\n scale_tt = at.as_tensor(scale)\n cov_tt = at.as_tensor(cov)\n\n srng = at.random.RandomStream(seed=1)\n Y_rv = srng.multivariate_normal(loc_tt, cov_tt)\n\n def logprob_fn(y):\n return joint_logprob({Y_rv: y})\n\n kernel = hmc.kernel(srng, logprob_fn, scale_tt, at.as_tensor(100))\n\n y_vv = Y_rv.clone()\n initial_state = nuts.new_state(y_vv, logprob_fn)\n\n trajectory, updates = aesara.scan(\n kernel,\n outputs_info=[\n {\"initial\": initial_state[0]},\n {\"initial\": initial_state[1]},\n {\"initial\": initial_state[2]},\n None,\n ],\n non_sequences=0.5,\n n_steps=5000,\n )\n\n trajectory_generator = aesara.function((y_vv,), trajectory[0], updates=updates)\n\n rng = np.random.default_rng(seed=23982)\n posterior_samples = trajectory_generator(rng.standard_normal(2))[-1000:]\n\n error_prob = compute_error_probability(posterior_samples, loc)\n np.testing.assert_array_less(0.01, error_prob)\n\n ess = compute_ess(posterior_samples)\n np.testing.assert_array_less(100, ess)\n"
] |
[
[
"numpy.diag",
"numpy.expand_dims",
"numpy.sqrt",
"numpy.abs",
"numpy.testing.assert_array_less",
"numpy.std",
"numpy.mean",
"scipy.stats.norm.sf",
"numpy.var",
"numpy.array",
"numpy.random.default_rng"
]
] |
arjunakula/vit-pytorch
|
[
"b786029e18b3b2140f29ec43a50c06c801e1d135"
] |
[
"vit_pytorch/vit_pytorch.py"
] |
[
"import torch\nimport torch.nn.functional as F\nfrom einops import rearrange, repeat\nfrom torch import nn\n\nMIN_NUM_PATCHES = 16\n\nclass Residual(nn.Module):\n def __init__(self, fn):\n super().__init__()\n self.fn = fn\n def forward(self, x, **kwargs):\n return self.fn(x, **kwargs) + x\n\nclass PreNorm(nn.Module):\n def __init__(self, dim, fn):\n super().__init__()\n self.norm = nn.LayerNorm(dim)\n self.fn = fn\n def forward(self, x, **kwargs):\n return self.fn(self.norm(x), **kwargs)\n\nclass FeedForward(nn.Module):\n def __init__(self, dim, hidden_dim, dropout = 0.):\n super().__init__()\n self.net = nn.Sequential(\n nn.Linear(dim, hidden_dim),\n nn.GELU(),\n nn.Dropout(dropout),\n nn.Linear(hidden_dim, dim),\n nn.Dropout(dropout)\n )\n def forward(self, x):\n return self.net(x)\n\nclass Attention(nn.Module):\n def __init__(self, dim, heads = 8, dim_head = 64, dropout = 0.):\n super().__init__()\n inner_dim = dim_head * heads\n self.heads = heads\n self.scale = dim ** -0.5\n\n self.to_qkv = nn.Linear(dim, inner_dim * 3, bias = False)\n self.to_out = nn.Sequential(\n nn.Linear(inner_dim, dim),\n nn.Dropout(dropout)\n )\n\n def forward(self, x, mask = None):\n b, n, _, h = *x.shape, self.heads\n qkv = self.to_qkv(x).chunk(3, dim = -1)\n q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h = h), qkv)\n\n dots = torch.einsum('bhid,bhjd->bhij', q, k) * self.scale\n mask_value = -torch.finfo(dots.dtype).max\n\n if mask is not None:\n mask = F.pad(mask.flatten(1), (1, 0), value = True)\n assert mask.shape[-1] == dots.shape[-1], 'mask has incorrect dimensions'\n mask = mask[:, None, :] * mask[:, :, None]\n dots.masked_fill_(~mask, mask_value)\n del mask\n\n attn = dots.softmax(dim=-1)\n\n out = torch.einsum('bhij,bhjd->bhid', attn, v)\n out = rearrange(out, 'b h n d -> b n (h d)')\n out = self.to_out(out)\n return out\n\nclass Transformer(nn.Module):\n def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout):\n super().__init__()\n self.layers = nn.ModuleList([])\n for _ in range(depth):\n self.layers.append(nn.ModuleList([\n Residual(PreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout))),\n Residual(PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout)))\n ]))\n def forward(self, x, mask = None):\n for attn, ff in self.layers:\n x = attn(x, mask = mask)\n x = ff(x)\n return x\n\nclass ViT(nn.Module):\n def __init__(self, *, image_size, patch_size, num_classes, dim, depth, heads, mlp_dim, channels = 3, dim_head = 64, dropout = 0., emb_dropout = 0.):\n super().__init__()\n assert image_size % patch_size == 0, 'Image dimensions must be divisible by the patch size.'\n num_patches = (image_size // patch_size) ** 2\n patch_dim = channels * patch_size ** 2\n assert num_patches > MIN_NUM_PATCHES, f'your number of patches ({num_patches}) is way too small for attention to be effective (at least 16). Try decreasing your patch size'\n\n self.patch_size = patch_size\n\n self.pos_embedding = nn.Parameter(torch.randn(1, num_patches + 1, dim))\n self.patch_to_embedding = nn.Linear(patch_dim, dim)\n self.cls_token = nn.Parameter(torch.randn(1, 1, dim))\n self.dropout = nn.Dropout(emb_dropout)\n\n self.transformer = Transformer(dim, depth, heads, dim_head, mlp_dim, dropout)\n\n self.to_cls_token = nn.Identity()\n\n self.mlp_head = nn.Sequential(\n nn.LayerNorm(dim),\n nn.Linear(dim, num_classes)\n )\n\n def forward(self, img, mask = None):\n p = self.patch_size\n\n x = rearrange(img, 'b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1 = p, p2 = p)\n x = self.patch_to_embedding(x)\n b, n, _ = x.shape\n\n cls_tokens = repeat(self.cls_token, '() n d -> b n d', b = b)\n x = torch.cat((cls_tokens, x), dim=1)\n x += self.pos_embedding[:, :(n + 1)]\n x = self.dropout(x)\n\n x = self.transformer(x, mask)\n\n x = self.to_cls_token(x[:, 0])\n return self.mlp_head(x)\n"
] |
[
[
"torch.nn.Dropout",
"torch.nn.GELU",
"torch.cat",
"torch.einsum",
"torch.nn.ModuleList",
"torch.randn",
"torch.nn.LayerNorm",
"torch.nn.Linear",
"torch.nn.Identity",
"torch.finfo"
]
] |
BrenoPremoli/Faculdade
|
[
"dcf5d106b10453224e37af830a53b2214af1d2ee"
] |
[
"python/linguagem-de-programacao/arquivo-xlsx-e-csv/exercicio_4.py"
] |
[
"# 4. Crie um programa que carregue o arquivo Propaganda.csv, por meio da biblioteca Pandas. Calcule e apresente o valor máximo da coluna do arquivo 'Jornal'.\n\nimport pandas as pd\ndf = pd.read_csv('Propaganda.csv')\nprint('Valor máximo da coluna do arquivo Jornal: R$ {:.2f}'.format(max(df['Jornal'])))\n"
] |
[
[
"pandas.read_csv"
]
] |
ankushjain2001/FairPrep
|
[
"6c87a6d07a5789208b4e060ef996f341908db49f"
] |
[
"fp/dataset_experiments.py"
] |
[
"from fp.experiments import BinaryClassificationExperiment\nimport pandas as pd\nimport numpy as np\n\n\nclass AdultDatasetWhiteMaleExperiment(BinaryClassificationExperiment):\n\n def __init__(self, fixed_random_seed, train_data_sampler, missing_value_handler, numeric_attribute_scaler,\n learners, pre_processors, post_processors):\n\n test_set_ratio = 0.2\n validation_set_ratio = 0.1\n label_name = 'income-per-year'\n positive_label = '>50K'\n numeric_attribute_names = ['capital-gain', 'capital-loss', 'age', 'hours-per-week']\n categorical_attribute_names = ['workclass', 'education', 'marital-status', 'occupation', 'relationship',\n 'native-country']\n attributes_to_drop_names = ['fnlwgt']\n\n protected_attribute_names = ['race', 'sex']\n privileged_classes = [['White'], ['Male']]\n\n privileged_groups = [{'race': 1, 'sex': 1}]\n unprivileged_groups = [{'race': 1, 'sex': 0}, {'sex': 0}]\n\n dataset_metadata = {\n 'label_maps': [{1.0: '>50K', 0.0: '<=50K'}],\n 'protected_attribute_maps': [{1.0: 'White', 0.0: 'Non-white'}, {1.0: 'Male', 0.0: 'Female'}]\n }\n\n super().__init__(fixed_random_seed, test_set_ratio, validation_set_ratio, label_name, positive_label,\n numeric_attribute_names, categorical_attribute_names, attributes_to_drop_names,\n train_data_sampler, missing_value_handler, numeric_attribute_scaler, learners, pre_processors,\n post_processors, protected_attribute_names, privileged_classes, privileged_groups,\n unprivileged_groups, dataset_metadata, 'adultwhitemale')\n\n def load_raw_data(self):\n return pd.read_csv('datasets/raw/adult.csv', na_values='?', sep=',')\n\n\nclass AdultDatasetMaleExperiment(BinaryClassificationExperiment):\n\n def __init__(self, fixed_random_seed, train_data_sampler, missing_value_handler, numeric_attribute_scaler,\n learners, pre_processors, post_processors):\n\n test_set_ratio = 0.2\n validation_set_ratio = 0.1\n label_name = 'income-per-year'\n positive_label = '>50K'\n numeric_attribute_names = ['capital-gain', 'capital-loss', 'age', 'hours-per-week']\n categorical_attribute_names = ['workclass', 'education', 'marital-status', 'occupation', 'relationship',\n 'native-country']\n attributes_to_drop_names = ['fnlwgt', 'race']\n\n protected_attribute_names = ['sex']\n privileged_classes = [['Male']]\n\n privileged_groups = [{'sex': 1}]\n unprivileged_groups = [{'sex': 0}]\n\n dataset_metadata = {\n 'label_maps': [{1.0: '>50K', 0.0: '<=50K'}],\n 'protected_attribute_maps': [{1.0: 'Male', 0.0: 'Female'}]\n }\n\n super().__init__(fixed_random_seed, test_set_ratio, validation_set_ratio, label_name, positive_label,\n numeric_attribute_names, categorical_attribute_names, attributes_to_drop_names,\n train_data_sampler, missing_value_handler, numeric_attribute_scaler, learners, pre_processors,\n post_processors, protected_attribute_names, privileged_classes, privileged_groups,\n unprivileged_groups, dataset_metadata, 'adultmale')\n\n def load_raw_data(self):\n return pd.read_csv('datasets/raw/adult.csv', na_values='?', sep=',')\n\n\nclass AdultDatasetWhiteExperiment(BinaryClassificationExperiment):\n\n def __init__(self, fixed_random_seed, train_data_sampler, missing_value_handler, numeric_attribute_scaler,\n learners, pre_processors, post_processors):\n\n test_set_ratio = 0.2\n validation_set_ratio = 0.1\n label_name = 'income-per-year'\n positive_label = '>50K'\n numeric_attribute_names = ['capital-gain', 'capital-loss', 'age', 'hours-per-week']\n categorical_attribute_names = ['workclass', 'education', 'marital-status', 'occupation', 'relationship',\n 'native-country']\n attributes_to_drop_names = ['fnlwgt', 'sex']\n\n protected_attribute_names = ['race']\n privileged_classes = [['White']]\n\n privileged_groups = [{'race': 1}]\n unprivileged_groups = [{'race': 0}]\n\n dataset_metadata = {\n 'label_maps': [{1.0: '>50K', 0.0: '<=50K'}],\n 'protected_attribute_maps': [{1.0: 'White', 0.0: 'Non-white'}]\n }\n\n super().__init__(fixed_random_seed, test_set_ratio, validation_set_ratio, label_name, positive_label,\n numeric_attribute_names, categorical_attribute_names, attributes_to_drop_names,\n train_data_sampler, missing_value_handler, numeric_attribute_scaler, learners, pre_processors,\n post_processors, protected_attribute_names, privileged_classes, privileged_groups,\n unprivileged_groups, dataset_metadata, 'adultwhite')\n\n def load_raw_data(self):\n return pd.read_csv('datasets/raw/adult.csv', na_values='?', sep=',')\n\n\n\nclass PropublicaDatasetWhiteExperiment(BinaryClassificationExperiment):\n\n def __init__(self, fixed_random_seed, train_data_sampler, missing_value_handler, numeric_attribute_scaler,\n learners, pre_processors, post_processors):\n test_set_ratio = 0.2\n validation_set_ratio = 0.1\n label_name = 'two_year_recid'\n positive_label = 1\n numeric_attribute_names = ['age', 'decile_score', 'priors_count', 'days_b_screening_arrest', 'decile_score',\n 'is_recid']\n categorical_attribute_names = ['c_charge_degree', 'age_cat', 'score_text']\n attributes_to_drop_names = ['sex', 'c_jail_in', 'c_jail_out']\n\n protected_attribute_names = ['race']\n privileged_classes = [['Caucasian']]\n\n privileged_groups = [{'race': 1}]\n unprivileged_groups = [{'race': 0}]\n\n dataset_metadata = {\n 'label_maps': [{1.0: 1, 0.0: 0}],\n 'protected_attribute_maps': [{1.0: 'Caucasian', 0.0: 'Non-white'}]\n }\n\n super().__init__(fixed_random_seed, test_set_ratio, validation_set_ratio, label_name, positive_label,\n numeric_attribute_names, categorical_attribute_names, attributes_to_drop_names,\n train_data_sampler, missing_value_handler, numeric_attribute_scaler, learners, pre_processors,\n post_processors, protected_attribute_names, privileged_classes, privileged_groups,\n unprivileged_groups, dataset_metadata, 'propublicawhite')\n\n def load_raw_data(self):\n \"\"\"The custom pre-processing function is adapted from\n https://github.com/IBM/AIF360/blob/master/aif360/algorithms/preprocessing/optim_preproc_helpers/data_preproc_functions.py\n https://github.com/fair-preprocessing/nips2017/blob/master/compas/code/Generate_Compas_Data.ipynb\n \"\"\"\n df = pd.read_csv('datasets/raw/propublica-recidivism.csv', na_values='?', sep=',')\n df = df[['age', 'c_charge_degree', 'race', 'age_cat', 'score_text',\n 'sex', 'priors_count', 'days_b_screening_arrest', 'decile_score',\n 'is_recid', 'two_year_recid', 'c_jail_in', 'c_jail_out']]\n ix = df['days_b_screening_arrest'] <= 100\n ix = (df['days_b_screening_arrest'] >= -100) & ix\n ix = (df['is_recid'] != -1) & ix\n ix = (df['c_charge_degree'] != \"O\") & ix\n ix = (df['score_text'] != 'N/A') & ix\n df = df.loc[ix, :]\n df['length_of_stay'] = (pd.to_datetime(df['c_jail_out']) - pd.to_datetime(df['c_jail_in'])).apply(\n lambda x: x.days)\n return df\n\n\nclass GermanCreditDatasetSexExperiment(BinaryClassificationExperiment):\n\n\n def __init__(self, fixed_random_seed, train_data_sampler, missing_value_handler, numeric_attribute_scaler,\n learners, pre_processors, post_processors):\n\n test_set_ratio = 0.2\n validation_set_ratio = 0.1\n label_name = 'credit'\n positive_label = 1\n numeric_attribute_names = ['month', 'credit_amount', 'residence_since', 'age', 'number_of_credits',\n 'people_liable_for']\n categorical_attribute_names = ['credit_history', 'savings', 'employment']\n attributes_to_drop_names = ['personal_status', 'status', 'purpose', 'investment_as_income_percentage',\n 'other_debtors', 'property', 'installment_plans', 'housing', 'skill_level',\n 'telephone', 'foreign_worker']\n\n protected_attribute_names = ['sex']\n privileged_classes = [[1.0]]\n\n privileged_groups = [{'sex': 1.0}]\n unprivileged_groups = [{'sex': 0.0}]\n\n dataset_metadata = {\n 'label_maps': [{1.0: 1, 0.0: 0}],\n 'protected_attribute_maps': [{1.0: 'male', 0.0: 'female'}]\n }\n\n super().__init__(fixed_random_seed, test_set_ratio, validation_set_ratio, label_name, positive_label,\n numeric_attribute_names, categorical_attribute_names, attributes_to_drop_names,\n train_data_sampler, missing_value_handler, numeric_attribute_scaler, learners, pre_processors,\n post_processors, protected_attribute_names, privileged_classes, privileged_groups,\n unprivileged_groups, dataset_metadata, 'germancreditsex')\n\n def load_raw_data(self):\n df = pd.read_csv('datasets/raw/german.csv', na_values='?', sep=',')\n\n def group_credit_hist(x):\n if x in ['A30', 'A31', 'A32']:\n return 'None/Paid'\n elif x == 'A33':\n return 'Delay'\n elif x == 'A34':\n return 'Other'\n else:\n return 'NA'\n\n def group_employ(x):\n if x == 'A71':\n return 'Unemployed'\n elif x in ['A72', 'A73']:\n return '1-4 years'\n elif x in ['A74', 'A75']:\n return '4+ years'\n else:\n return 'NA'\n\n def group_savings(x):\n if x in ['A61', 'A62']:\n return '<500'\n elif x in ['A63', 'A64']:\n return '500+'\n elif x == 'A65':\n return 'Unknown/None'\n else:\n return 'NA'\n\n def group_status(x):\n if x in ['A11', 'A12']:\n return '<200'\n elif x in ['A13']:\n return '200+'\n elif x == 'A14':\n return 'None'\n else:\n return 'NA'\n\n status_map = {'A91': 1.0, 'A93': 1.0, 'A94': 1.0, 'A92': 0.0, 'A95': 0.0}\n df['sex'] = df['personal_status'].replace(status_map)\n # group credit history, savings, and employment\n df['credit_history'] = df['credit_history'].apply(lambda x: group_credit_hist(x))\n df['savings'] = df['savings'].apply(lambda x: group_savings(x))\n df['employment'] = df['employment'].apply(lambda x: group_employ(x))\n df['age'] = df['age'].apply(lambda x: np.float(x >= 25))\n df['status'] = df['status'].apply(lambda x: group_status(x))\n return df\n \nclass RicciRaceExperiment(BinaryClassificationExperiment):\n '''\n Check for fairness based on race (white vs minority i.e Black and Hispanic) while predicting if a candidate will pass i.e obtain total \n marks greater than or equal to 70.0 \n '''\n\n def __init__(self, fixed_random_seed, train_data_sampler, missing_value_handler, numeric_attribute_scaler,\n learners, pre_processors, post_processors):\n\n test_set_ratio = 0.2\n validation_set_ratio = 0.1\n \n label_name = 'combine'\n positive_label = 1\n numeric_attribute_names = ['oral', 'written']\n categorical_attribute_names = ['position']\n attributes_to_drop_names = []\n \n protected_attribute_names = ['race']\n privileged_classes = [[1.0]]\n \n privileged_groups = [{'race': 1.0}]\n unprivileged_groups = [{'race': 0.0}]\n\n dataset_metadata = {\n 'label_maps': [{1.0: 1, 0.0: 0}],\n 'protected_attribute_maps': [{1.0: 'W', 0.0: 'NW'}]\n }\n \n super().__init__(fixed_random_seed, test_set_ratio, validation_set_ratio, label_name, positive_label,\n numeric_attribute_names, categorical_attribute_names,attributes_to_drop_names,\n train_data_sampler, missing_value_handler, numeric_attribute_scaler, learners, pre_processors,\n post_processors, protected_attribute_names, privileged_classes, privileged_groups,\n unprivileged_groups, dataset_metadata, 'riccirace')\n\n def load_raw_data(self):\n df = pd.read_csv('datasets/raw/ricci.txt', na_values='?', sep=',')\n df.columns = map(str.lower, df.columns)\n\n def group_race_minority(x):\n if x in ['B', 'H', 'B']:\n return 'NW'\n else:\n return 'W'\n\n post_map = {'Captain': 0.0, 'Lieutenant': 1.0}\n df['position'] = df['position'].replace(post_map)\n \n #group minorities i.e Black and Hispanic are combined to 'NW'(non white)\n df['race'] = df['race'].apply(lambda x: group_race_minority(x))\n df['combine'] = df['combine'].apply(lambda x: int(x >= 70))\n\n return df\n\nclass GiveMeSomeCreditExperiment(BinaryClassificationExperiment):\n '''\n Fairness intervention for the Age attribute (priviledge for age>=25) while predicting if a person will experience 90 days past due delinquency or worse. \n '''\n def __init__(self, fixed_random_seed, train_data_sampler, missing_value_handler, numeric_attribute_scaler,\n learners, pre_processors, post_processors):\n\n test_set_ratio = 0.2\n validation_set_ratio = 0.1\n label_name = 'SeriousDlqin2yrs'\n positive_label = 1\n\n numeric_attribute_names = ['RevolvingUtilizationOfUnsecuredLines','age','NumberOfTime30-59DaysPastDueNotWorse',\n 'DebtRatio','MonthlyIncome','NumberOfOpenCreditLinesAndLoans','NumberOfTimes90DaysLate',\n 'NumberRealEstateLoansOrLines','NumberOfTime60-89DaysPastDueNotWorse','NumberOfDependents']\n categorical_attribute_names = []\n attributes_to_drop_names = []\n\n protected_attribute_names = ['age']\n privileged_classes = [[1.0]]\n\n privileged_groups = [{'age': 1}]\n unprivileged_groups = [{'age': 0}]\n\n dataset_metadata = {\n 'label_maps': [{1.0: 1, 0.0: 0}]\n }\n\n super().__init__(fixed_random_seed, test_set_ratio, validation_set_ratio, label_name, positive_label,\n numeric_attribute_names, categorical_attribute_names, attributes_to_drop_names,\n train_data_sampler, missing_value_handler, numeric_attribute_scaler, learners, pre_processors,\n post_processors, protected_attribute_names, privileged_classes, privileged_groups,\n unprivileged_groups, dataset_metadata, 'givecredit')\n\n def load_raw_data(self):\n df = pd.read_csv('datasets/raw/givemesomecredit.csv', na_values='?', sep=',',index_col=False)\n df['age'] = df['age'].apply(lambda x: int(x >= 25))\n return df\n \n"
] |
[
[
"pandas.read_csv",
"pandas.to_datetime",
"numpy.float"
]
] |
iwbailey/shakemap_oasisloss
|
[
"91789c9f6ff7e7d4f573cc28d1926f810dab9d36"
] |
[
"example/plot_footprintmap.py"
] |
[
"\"\"\"Read in the footprint and plot the exceedance probability for a given\nintensity.\n\n\"\"\"\n\nimport pandas as pd\nfrom matplotlib import pyplot as plt\nfrom matplotlib import pylab\nfrom oasis_utils import read_footprint, get_areaperilcoords, read_intensbins\n\n# import pdb\n\n# Parameters ------------------------------------------------------------------\neventId = 1\n\nifile_fp = \"static/footprint.csv\"\nifile_intensbins = \"static/intensity_bin_dict.csv\"\nifile_areaperil = \"./areaperilgrid.yaml\"\n\nintensval = 5.5\n\npd.options.display.max_rows = 10\n\n# Script ----------------------------------------------------------------------\n\n\ndef plot_footprintmap(locns, intensval):\n \"\"\" Plots a map of the locations, coloured by their loss\n \"\"\"\n print(\"Generating plot...\")\n fig, ax = plt.subplots(1, 1, facecolor='white')\n\n # Add the locations\n cax = ax.scatter(locns['lon'].values, locns['lat'].values,\n c=locns['prob'].values, s=2.0,\n marker='s',\n edgecolors=None)\n\n # Formatting\n ax.set_aspect('equal')\n ax.autoscale(tight=True)\n ax.grid()\n\n # Add a color bar\n plt.colorbar(cax, orientation='vertical',\n label='Exceedance Prob')\n\n plt.title(\"Prob of exceeding intensity %.2f\" % intensval)\n\n return 1\n\n\n# Read the footprint for the eventid we want\n\n# Read the footprint\nfp = read_footprint(ifile_fp, eventId)\n\n# Read the lat lon for all areaperil_ids\nareaperilxy = get_areaperilcoords(ifile_areaperil, fp.index.levels[0].values)\n\n# Combine with bins\nfp = pd.merge(fp, read_intensbins(ifile_intensbins), left_index=True,\n right_index=True)\n\n# Sum the prob for the bin containing the intensity we want to plot and higher\n# bins.\nfp_plot = fp[fp.right >= intensval]['prob'].groupby(level=0).sum()\n\n# Combine with the lat lon\nfp_plot = pd.concat([areaperilxy, fp_plot], axis=1)\n\n# Plot the map\nplot_footprintmap(fp_plot, intensval)\n\n# Show the plot\nprint('Pausing while plot is shown...')\npylab.show(block=True)\n"
] |
[
[
"pandas.concat",
"matplotlib.pylab.show",
"matplotlib.pyplot.title",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.colorbar"
]
] |
Mhmd-Elsersy/Reinforcement-Learning-Algorithms
|
[
"9b3aab1cd8d4347dee0baa8eb6557984554d4215"
] |
[
"Dynamic Programming/Value-Iteration.py"
] |
[
"import numpy as np\nimport pprint\nimport sys\nimport gym.spaces\nif \"../\" not in sys.path:\n sys.path.append(\"../\") \nfrom lib.envs.gridworld import GridworldEnv\n\n\npp = pprint.PrettyPrinter(indent=2)\nenv = GridworldEnv()\n\ndef value_iteration(env, epsilon=0.0001, discount_factor=1.0):\n \"\"\"\n Value Iteration Algorithm.\n \n Args:\n env: OpenAI env. env.P represents the transition probabilities of the environment.\n env.P[s][a] is a list of transition tuples (prob, next_state, reward, done).\n env.nS is a number of states in the environment. \n env.nA is a number of actions in the environment.\n theta: We stop evaluation once our value function change is less than theta for all states.\n discount_factor: Gamma discount factor.\n \n Returns:\n A tuple (policy, V) of the optimal policy and the optimal value function. \n \"\"\"\n def one_step_lookahead(V, a, s):\n\n \t\n \t[(prob, next_state, reward, done)] = env.P[s][a]\n \tv = prob * (reward + discount_factor * V[next_state])\n\n \treturn v\n \n #start with inital value function and intial policy\n V = np.zeros(env.nS)\n policy = np.zeros([env.nS, env.nA])\n\n #while not the optimal policy\n while True:\n\n \tdelta = 0\n\n \t#loop over state space\n \tfor s in range(env.nS):\n\n \t\tactions_values = np.zeros(env.nA)\n\n \t\t#loop over possible actions\n \t\tfor a in range(env.nA):\n\n \t\t\t#apply bellman eqn to get actions values\n \t\t\tactions_values[a] = one_step_lookahead(V, a, s)\n\n \t\t#pick the best action\n \t\tbest_action_value = max(actions_values)\n\n \t\t#get the biggest difference between best action value and our old value function\n \t\tdelta = max(delta, abs(best_action_value - V[s]))\n\n \t\t#apply bellman optimality eqn\n \t\tV[s] = best_action_value\n\n \t\t#to update the policy\n \t\tbest_action = np.argmax(actions_values)\n\n \t\t#update the policy\n \t\tpolicy[s] = np.eye(env.nA)[best_action]\n\n\n \t#if optimal value function\n \tif(delta < epsilon):\n \t\tbreak\n \n return policy, V\n\n\npolicy, v = value_iteration(env)\n\nprint(\"Policy Probability Distribution:\")\nprint(policy)\nprint(\"\")\n\nprint(\"Reshaped Grid Policy (0=up, 1=right, 2=down, 3=left):\")\nprint(np.reshape(np.argmax(policy, axis=1), env.shape))\nprint(\"\")\n\nprint(\"Value Function:\")\nprint(v)\nprint(\"\")\n\nprint(\"Reshaped Grid Value Function:\")\nprint(v.reshape(env.shape))\nprint(\"\")\n\n"
] |
[
[
"numpy.eye",
"numpy.argmax",
"numpy.zeros"
]
] |
vishalbelsare/fbooja
|
[
"c0a2293f39f3af37cd610eade80fbd61c531337f"
] |
[
"ctorch.py"
] |
[
"\"\"\"\nTensors with complex-valued entries.\n\nCopyright (c) Facebook, Inc. and its affiliates.\n\nThis source code is licensed under the MIT license found in the LICENSE file in\nthe root directory of this source tree.\n\"\"\"\n\nimport ctypes\nimport functools\n\nimport numpy as np\nimport torch\nfrom torch.autograd import Variable\n\ntensor_base = torch.Tensor().__class__.__bases__[0]\n\n\nclass ComplexTensor:\n\n def __init__(self, real, imag):\n assert real.size() == imag.size()\n self.real = real\n self.imag = imag\n\n def __add__(self, X):\n return ComplexTensor(self.real + X.real, self.imag + X.imag)\n\n def __sub__(self, X):\n return ComplexTensor(self.real - X.real, self.imag - X.imag)\n\n def __mul__(self, a):\n if isinstance(a, (int, float)):\n return ComplexTensor(self.real * a, self.imag * a)\n elif isinstance(a, tensor_base):\n return ComplexTensor(self.real * a, self.imag * a)\n elif isinstance(a, ComplexTensor):\n real = self.real * a.real - self.imag * a.imag\n imag = self.real * a.imag + self.imag * a.real\n return ComplexTensor(real, imag)\n else:\n raise NotImplementedError\n\n def __truediv__(self, a):\n assert isinstance(a, (int, float))\n return ComplexTensor(self.real / a, self.imag / a)\n\n def __rtruediv__(self, a):\n assert isinstance(a, (int, float))\n return ComplexTensor(a / self.real, a / self.imag)\n\n def __matmul__(self, X):\n real = self.real @ X.real - self.imag @ X.imag\n imag = self.real @ X.imag + self.imag @ X.real\n return ComplexTensor(real, imag)\n\n def __abs__(self):\n return torch.sqrt(self.real**2 + self.imag**2)\n\n def __setitem__(self, key, item):\n self.real[key] = item.real\n self.imag[key] = item.imag\n\n def __getitem__(self, key):\n return ComplexTensor(self.real[key], self.imag[key])\n\n def t(self):\n return ComplexTensor(self.real.t(), self.imag.t())\n\n def h(self):\n return ComplexTensor(self.real.t(), -self.imag.t())\n\n def conj(self):\n return ComplexTensor(self.real, -self.imag)\n\n def transpose(self, dim0, dim1):\n return ComplexTensor(self.real.transpose(dim0, dim1),\n self.imag.transpose(dim0, dim1))\n\n def permute(self, *args):\n return ComplexTensor(self.real.permute(*args),\n self.imag.permute(*args))\n\n def contiguous(self):\n return ComplexTensor(self.real.contiguous(), self.imag.contiguous())\n\n @property\n def shape(self):\n return self.real.shape\n\n def size(self):\n return self.real.shape\n\n def numel(self):\n return self.real.numel()\n\n def numpy(self):\n return self.real.cpu().numpy() + 1j * self.imag.cpu().numpy()\n\n def new(self, *args):\n return ComplexTensor(self.real.new(*args), self.imag.new(*args))\n\n def view(self, *args):\n return ComplexTensor(self.real.view(*args), self.imag.view(*args))\n\n def unsqueeze(self, *args):\n return ComplexTensor(self.real.unsqueeze(*args),\n self.imag.unsqueeze(*args))\n\n def squeeze(self, *args):\n return ComplexTensor(self.real.squeeze(*args),\n self.imag.squeeze(*args))\n\n def repeat(self, *args):\n return ComplexTensor(self.real.repeat(*args), self.imag.repeat(*args))\n\n def zero_(self):\n self.real.zero_()\n self.imag.zero_()\n return self\n\n def normal_(self, *args, **kwargs):\n self.real.normal_(*args, **kwargs)\n self.imag.normal_(*args, **kwargs)\n return self\n\n def double(self):\n return ComplexTensor(self.real.double(), self.imag.double())\n\n def float(self):\n return ComplexTensor(self.real.float(), self.imag.float())\n\n def cuda(self):\n return ComplexTensor(self.real.cuda(), self.imag.cuda())\n\n def cpu(self):\n return ComplexTensor(self.real.cpu(), self.imag.cpu())\n\n def requires_grad_(self):\n self.real.requires_grad_()\n self.imag.requires_grad_()\n return self\n\n @property\n def data(self):\n return ComplexTensor(self.real.data, self.imag.data)\n\n @property\n def variable(self):\n return ComplexTensor(Variable(self.real), Variable(self.imag))\n\n def __repr__(self):\n return 'real{}\\nimag{}'.format(repr(self.real), repr(self.imag))\n\n\ndef bmm(x, y):\n real = torch.bmm(x.real, y.real) - torch.bmm(x.imag, y.imag)\n imag = torch.bmm(x.real, y.imag) + torch.bmm(x.imag, y.real)\n return ComplexTensor(real, imag)\n\n\ndef cat(seq, **kwargs):\n \"\"\"Concatenates together the terms in the given sequence.\n \"\"\"\n real = torch.cat([x.real for x in seq], **kwargs)\n imag = torch.cat([x.imag for x in seq], **kwargs)\n return ComplexTensor(real, imag)\n\n\ndef norm(X, **kwargs):\n \"\"\"torch.norm after taking absolute values entrywise.\n \"\"\"\n return torch.norm(abs(X), **kwargs)\n\n\ndef from_numpy(x):\n \"\"\"Creates a ComplexTensor from a numpy.ndarray.\n \"\"\"\n a = x.real.copy()\n b = x.imag.copy()\n return ComplexTensor(torch.from_numpy(a), torch.from_numpy(b))\n\n\n# FFT\n#\n# Wrapper for the cuFFT library that mimics the `numpy.fft` API. It is designed\n# to work well for cases where `fft` is called multiple times on tensors with\n# the same sizes.\n#\n# Creating a new FFT plan is an expensive operation. This wrapper caches FFT\n# plans and reuses them whenever it's called on a tensors whose size it has\n# encountered before. The library we were using before created a new plan each\n# time `fft` was called.\n#\n# The wrapper does not currently destroy the FFT plans so it's possible to run\n# into memory problems if calling `fft` with different input sizes many, many\n# times. If this ever becomes an issue it shouldn't be too hard to modify the\n# wrapper to delete old plans.\n\ncufft = ctypes.cdll.LoadLibrary('libcufft.so')\nCUFFT_FORWARD = -1\nCUFFT_INVERSE = 1\nCUFFT_SUCCESS = 0x0\nCUFFT_Z2Z = 0x69\n\n\[email protected]_cache(maxsize=None)\ndef _plan(*shape):\n batch_size, *dims = shape\n plan = ctypes.c_int()\n n = (ctypes.c_int * len(dims))(*dims)\n assert cufft.cufftPlanMany(\n ctypes.byref(plan), len(dims), ctypes.byref(n), None, 0, 0, None, 0, 0,\n CUFFT_Z2Z, batch_size) == CUFFT_SUCCESS\n return plan\n\n\ndef _fft(x, rank, direction, plan_cache={}):\n assert isinstance(x, ComplexTensor)\n assert isinstance(x.real, torch.cuda.DoubleTensor)\n assert x.real.dim() >= rank\n orig_shape = x.shape\n if x.real.dim() == rank:\n x = x.unsqueeze(0)\n else:\n x = x.view(-1, *x.shape[-rank:])\n plan = _plan(*x.shape)\n x_stack = torch.stack((x.real, x.imag), dim=rank + 1)\n y_stack = x_stack.new(x_stack.shape)\n assert cufft.cufftExecZ2Z(\n plan, ctypes.c_void_p(x_stack.data_ptr()),\n ctypes.c_void_p(y_stack.data_ptr()), direction) == CUFFT_SUCCESS\n torch.cuda.synchronize()\n y_real, y_imag = y_stack.split(1, dim=rank + 1)\n y = ComplexTensor(y_real, y_imag).contiguous().view(orig_shape)\n if direction == CUFFT_INVERSE:\n y = y / float(np.prod(x.shape[-rank:]))\n return y\n\n\ndef fft(x):\n return _fft(x, 1, CUFFT_FORWARD)\n\n\ndef ifft(x):\n return _fft(x, 1, CUFFT_INVERSE)\n\n\ndef fft2(x):\n return _fft(x, 2, CUFFT_FORWARD)\n\n\ndef ifft2(x):\n return _fft(x, 2, CUFFT_INVERSE)\n"
] |
[
[
"torch.cuda.synchronize",
"torch.Tensor",
"torch.cat",
"torch.sqrt",
"torch.from_numpy",
"torch.bmm",
"numpy.prod",
"torch.stack",
"torch.autograd.Variable"
]
] |
abhishekkrthakur/clickbaits_revisited
|
[
"de9020635c58a7526a83e8ad002ee33a4597c456"
] |
[
"deepnets/LSTM_Title_Content_Numerical_with_GloVe.py"
] |
[
"# coding: utf-8\n\"\"\"\nLSTM on title + content text + numerical features with GloVe embeddings\n@author: Abhishek Thakur\n\"\"\"\n\nimport pandas as pd\nimport numpy as np\nfrom tqdm import tqdm\nfrom keras.models import Sequential\nfrom keras.layers.core import Dense, Activation, Dropout\nfrom keras.layers.embeddings import Embedding\nfrom keras.layers.recurrent import LSTM\nfrom keras.layers.normalization import BatchNormalization\nfrom keras.utils import np_utils\nfrom keras.engine.topology import Merge\nfrom keras.callbacks import ModelCheckpoint\nfrom keras.layers.advanced_activations import PReLU\nfrom keras.preprocessing import sequence, text\nfrom sklearn import preprocessing\n\ntrain = pd.read_csv('../data/train_v2.csv')\ntest = pd.read_csv('../data/test_v2.csv')\n\ny_train = train.label.values\ny_test = test.label.values\n\ntrain_num = train[[\"size\", \"html_len\", \"number_of_links\", \"number_of_buttons\",\n \"number_of_inputs\", \"number_of_ul\", \"number_of_ol\", \"number_of_lists\",\n \"number_of_h1\", \"number_of_h2\", \"total_h1_len\", \"total_h2_len\", \"avg_h1_len\", \"avg_h2_len\",\n \"number_of_images\", \"number_of_tags\", \"number_of_unique_tags\"]].values\n\ntest_num = test[[\"size\", \"html_len\", \"number_of_links\", \"number_of_buttons\",\n \"number_of_inputs\", \"number_of_ul\", \"number_of_ol\", \"number_of_lists\",\n \"number_of_h1\", \"number_of_h2\", \"total_h1_len\", \"total_h2_len\", \"avg_h1_len\", \"avg_h2_len\",\n \"number_of_images\", \"number_of_tags\", \"number_of_unique_tags\"]].values\n\ntk = text.Tokenizer(nb_words=200000)\ntrain.link_name = train.link_name.astype(str)\ntest.link_name = test.link_name.astype(str)\ntrain.textdata = train.textdata.astype(str)\ntest.textdata = test.textdata.astype(str)\n\nmax_len = 80\n\ntk.fit_on_texts(list(train.link_name.values) + list(train.textdata.values) + list(test.link_name.values) + list(\n test.textdata.values))\nx_train_title = tk.texts_to_sequences(train.link_name.values)\nx_train_title = sequence.pad_sequences(x_train_title, maxlen=max_len)\n\nx_train_textdata = tk.texts_to_sequences(train.textdata.values)\nx_train_textdata = sequence.pad_sequences(x_train_textdata, maxlen=max_len)\n\nx_test_title = tk.texts_to_sequences(test.link_name.values)\nx_test_title = sequence.pad_sequences(x_test_title, maxlen=max_len)\n\nx_test_textdata = tk.texts_to_sequences(test.textdata.values)\nx_test_textdata = sequence.pad_sequences(x_test_textdata, maxlen=max_len)\n\nword_index = tk.word_index\nytrain_enc = np_utils.to_categorical(y_train)\n\nembeddings_index = {}\nf = open('../data/glove.840B.300d.txt')\nfor line in tqdm(f):\n values = line.split()\n word = values[0]\n coefs = np.asarray(values[1:], dtype='float32')\n embeddings_index[word] = coefs\nf.close()\n\nembedding_matrix = np.zeros((len(word_index) + 1, 300))\nfor word, i in tqdm(word_index.items()):\n embedding_vector = embeddings_index.get(word)\n if embedding_vector is not None:\n embedding_matrix[i] = embedding_vector\n\nscl = preprocessing.StandardScaler()\ntrain_num_scl = scl.fit_transform(train_num)\ntest_num_scl = scl.transform(test_num)\n\nmodel1 = Sequential()\nmodel1.add(Embedding(len(word_index) + 1,\n 300,\n weights=[embedding_matrix],\n input_length=80,\n trainable=False))\nmodel1.add(LSTM(300, dropout_W=0.2, dropout_U=0.2))\n\nmodel2 = Sequential()\nmodel2.add(Embedding(len(word_index) + 1,\n 300,\n weights=[embedding_matrix],\n input_length=80,\n trainable=False))\nmodel2.add(LSTM(300, dropout_W=0.2, dropout_U=0.2))\n\nmodel3 = Sequential()\nmodel3.add(Dense(100, input_dim=train_num_scl.shape[1]))\nmodel3.add(PReLU())\nmodel3.add(Dropout(0.2))\nmodel3.add(BatchNormalization())\n\nmodel3.add(Dense(100))\nmodel3.add(PReLU())\nmodel3.add(Dropout(0.2))\nmodel3.add(BatchNormalization())\n\nmerged_model = Sequential()\nmerged_model.add(Merge([model1, model2, model3], mode='concat'))\nmerged_model.add(BatchNormalization())\n\nmerged_model.add(Dense(200))\nmerged_model.add(PReLU())\nmerged_model.add(Dropout(0.2))\nmerged_model.add(BatchNormalization())\n\nmerged_model.add(Dense(200))\nmerged_model.add(PReLU())\nmerged_model.add(Dropout(0.2))\nmerged_model.add(BatchNormalization())\n\nmerged_model.add(Dense(2))\nmerged_model.add(Activation('softmax'))\n\nmerged_model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy', 'precision', 'recall'])\n\ncheckpoint = ModelCheckpoint('../data/weights_title+content_tdd.h5', monitor='val_acc', save_best_only=True, verbose=2)\n\nmerged_model.fit([x_train_title, x_train_textdata, train_num_scl], y=ytrain_enc,\n batch_size=128, nb_epoch=200, verbose=2, validation_split=0.1,\n shuffle=True, callbacks=[checkpoint])\n"
] |
[
[
"numpy.asarray",
"sklearn.preprocessing.StandardScaler",
"pandas.read_csv"
]
] |
navchandar/File-Convertor-Utils
|
[
"4a68653c02cf8d4bb592d91d0ee0239226481fd1"
] |
[
"Excel2str.py"
] |
[
"#! python3\r\n# -*- coding: utf-8 -*-\r\n\"\"\"\r\nExcel2str extracts string content from Excel files\r\n\"\"\"\r\nimport pandas as pd\r\n\r\n\r\ndef convertExcel(xl_filename, txt_filename):\r\n '''\r\n Input should be a single excel file.\r\n Output will be a single txt file with all content as string.\r\n '''\r\n xl = pd.ExcelFile(xl_filename)\r\n sheet_names = xl.sheet_names # see all sheet names\r\n print('Found %s sheets in the file %s' % (sheet_names, xl_filename))\r\n for sheet in sheet_names:\r\n df = xl.parse(sheet, header=None, index_col=None)\r\n # print(df.head())\r\n df = df.fillna('')\r\n row_count, column_count = (df.shape)\r\n print('Rows = %s, Cols = %s in the sheet %s' % (row_count, column_count, sheet))\r\n all_lines = []\r\n for index, row in df.iterrows():\r\n line = []\r\n for i in range(column_count):\r\n line.append(row[i])\r\n all_lines.append(line)\r\n print('%s lines in %s' % (len(all_lines), xl_filename))\r\n\r\n if len(all_lines) > 0:\r\n with open(txt_filename, 'a') as f:\r\n for line in all_lines:\r\n s = ', '.join(str(e) for e in line)\r\n f.write('%s\\n' % (s))\r\n print('%s created successfully' % txt_filename)\r\n\r\n\r\ndef convertBigExcel(xl_filename, txt_filename):\r\n '''\r\n Input should be a single excel file which is very big for processing.\r\n Output will be a single txt file with all content as string.\r\n '''\r\n xl = pd.ExcelFile(xl_filename)\r\n sheet_names = xl.sheet_names # see all sheet names\r\n print('Found %s sheets in the file %s' % (sheet_names, xl_filename))\r\n with open(txt_filename, 'a') as f:\r\n for sheet in sheet_names:\r\n df = xl.parse(sheet, header=None, index_col=None)\r\n # print(df.head())\r\n df = df.fillna('')\r\n row_count, column_count = (df.shape)\r\n print('Rows = %s, Cols = %s in the sheet %s' % (row_count, column_count, sheet))\r\n for index, row in df.iterrows():\r\n line = []\r\n for i in range(column_count):\r\n line.append(row[i])\r\n s = ', '.join(str(e) for e in line)\r\n f.write('%s\\n' % (s))\r\n print('%s created successfully' % txt_filename)\r\n\r\n"
] |
[
[
"pandas.ExcelFile"
]
] |
amazon-research/network-deconvolution-pp
|
[
"99e27ecec7d27c7c4c3fb230e96005bdcbf6f2ce"
] |
[
"Classification/net_util.py"
] |
[
"from __future__ import print_function\n\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport torch.nn.functional as F\nimport torch.backends.cudnn as cudnn\n\nimport torchvision\nimport torchvision.transforms as transforms\n\nimport os\nimport argparse\nimport time\nfrom copy import deepcopy\nfrom torch.autograd import Variable\n\nfrom util import tensor2array\nimport shutil\n\n\n\ndef set_parameters(args):\n '''\n This function is called before training/testing to set parameters\n :param args:\n :return args:\n '''\n\n if not args.__contains__('train_losses'):\n args.train_losses=[]\n\n if not args.__contains__('train_accuracies'):\n args.train_accuracies = []\n\n if not args.__contains__('valid_losses'):\n args.valid_losses = []\n if not args.__contains__('valid_accuracies'):\n args.valid_accuracies = []\n\n if not args.__contains__('test_losses'):\n args.test_losses = []\n if not args.__contains__('test_accuracies'):\n args.test_accuracies = []\n\n if not args.__contains__('best_acc'):\n args.best_acc = 0.0\n\n if not args.__contains__('lowest_loss'):\n args.lowest_loss = 1e4\n\n if not args.__contains__('checkpoint_path'):\n args.checkpoint_path = 'checkpoints'\n\n if not os.path.exists(args.checkpoint_path):\n os.makedirs(args.checkpoint_path)\n\n if not args.__contains__('checkpoint_epoch'):\n args.checkpoint_epoch = 5\n\n\n\n\ndef train_net(net,args):\n\n top1 = AverageMeter()\n top5 = AverageMeter()\n losses = AverageMeter()\n\n print('training at epoch {}'.format(args.epoch+1))\n\n net.train()\n\n total_time=0\n data_time=0\n total=1e-3\n correct=0\n extra=0.\n\n optimizer=args.current_optimizer\n\n end_time = time.time()\n\n for batch_idx, (inputs, targets) in enumerate(args.data_loader):\n #ff\n if args.use_gpu:\n targets = targets.cuda()\n\n data_time += (time.time() - end_time)#loading time\n\n outputs = net(inputs)\n\n maps=None\n if type(outputs) is list:\n maps=outputs\n outputs=outputs[-1]\n\n #loss = args.criterion(outputs, targets).mean()\n\n if args.loss=='CE':\n loss = args.criterion(outputs, targets)#.mean()\n elif args.loss=='L2':\n from util import targets_to_one_hot\n targets_one_hot=targets_to_one_hot(targets,args.num_outputs)\n loss = args.criterion(outputs, targets_one_hot)*args.num_outputs*0.5\n losses.update(loss.item(), inputs.size(0))\n\n prec1, prec5 = accuracy(outputs.data, targets, topk=(1, 5))\n top1.update(prec1[0].item(), inputs.size(0))\n top5.update(prec5[0].item(), inputs.size(0))\n\n\n\n #bp\n loss.backward()\n\n optimizer.step()\n \n if args.lr_scheduler == 'cosine':\n args.current_scheduler.step()\n \n if args.tensorboard:\n if args.logger_n_iter%args.print_freq==0:\n args.writer.add_scalar('loss', loss.item(), args.logger_n_iter )\n\n args.logger_n_iter += 1\n optimizer.zero_grad() # flush\n total_time += (time.time() - end_time)\n end_time = time.time()\n\n if args.msg:\n print('Loss: %.3f | top1: %.3f%% ,top5: %.3f%%'\n % (losses.avg, prec1[0].item(), prec5[0].item()))\n\n\n args.train_batch_logger.log({\n 'epoch': (args.epoch+1),\n 'batch': batch_idx + 1,\n 'loss': losses.avg,\n 'top1': top1.avg,\n 'top5': top5.avg,\n 'time': total_time,\n\n })\n\n\n args.train_epoch_logger.log({\n 'epoch': (args.epoch+1),\n 'loss': losses.avg,\n 'top1': top1.avg,\n 'top5':top5.avg,\n 'time': total_time,\n })\n\n print('Loss: %.3f | top1: %.3f%%, top5: %.3f%% elasped time: %3.f seconds.'\n % (losses.avg, top1.avg, top5.avg, total_time))\n args.train_accuracies.append(top1.avg)\n\n args.train_losses.append(losses.avg)\n\n\n\n\ndef eval_net(net,args):\n\n top1 = AverageMeter()\n top5 = AverageMeter()\n losses = AverageMeter()\n\n if args.validating:\n print('Validating at epoch {}'.format(args.epoch + 1))\n\n if args.testing:\n print('Testing at epoch {}'.format(args.epoch + 1))\n\n\n if not args.__contains__('validating'):\n args.validating = False\n if not args.__contains__('testing'):\n args.testing = False\n\n\n net.eval()\n total = 1e-3\n total_time = 0\n\n\n\n end_time = time.time()\n for batch_idx, (inputs, targets) in enumerate(args.data_loader):\n\n with torch.no_grad():\n\n if args.use_gpu:\n targets = targets.cuda()\n\n outputs = net(inputs)\n if type(outputs) is list:\n outputs = outputs[-1]\n\n if args.loss == 'CE':\n loss = args.criterion(outputs, targets) # .mean()\n elif args.loss == 'L2':\n from util import targets_to_one_hot\n targets_one_hot = targets_to_one_hot(targets, args.num_outputs)\n loss = args.criterion(outputs, targets_one_hot)*args.num_outputs*0.5\n\n losses.update(loss.item(), inputs.size(0))\n\n prec1, prec5 = accuracy(outputs, targets, topk=(1, 5))\n top1.update(prec1[0].item(), inputs.size(0))\n top5.update(prec5[0].item(), inputs.size(0))\n\n total_time += (time.time() - end_time)\n end_time = time.time()\n\n if args.msg:\n print('Loss: %.3f | top1: %.3f%% ,top5: %.3f%%'\n % (losses.avg, prec1[0].item(), prec5[0].item()))\n\n\n\n if args.testing:\n args.test_losses.append(losses.avg)\n args.test_accuracies.append(top1.avg)\n\n args.test_epoch_logger.log({\n 'epoch': (args.epoch + 1),\n 'loss': losses.avg,\n 'top1': top1.avg,\n 'top5': top5.avg,\n 'time': total_time,\n })\n\n if args.validating:\n args.valid_losses.append(losses.avg)\n args.valid_accuracies.append(top1.avg)\n\n args.valid_epoch_logger.log({\n 'epoch': (args.epoch + 1),\n 'loss': losses.avg,\n 'top1': top1.avg,\n 'top5': top5.avg,\n 'time': total_time,\n })\n # Save checkpoint.\n\n is_best=(top1.avg > args.best_acc)\n if is_best:\n args.best_acc = top1.avg\n\n states = {\n 'state_dict': net.module.state_dict() if hasattr(net,'module') else net.state_dict(),\n 'epoch': args.epoch+1,\n 'arch': args.arch,\n 'best_acc': args.best_acc,\n 'train_losses': args.train_losses,\n 'optimizer': args.current_optimizer.state_dict()\n }\n\n\n if args.__contains__('acc'):\n states['acc']=top1.avg,\n\n if args.__contains__('valid_losses'):\n states['valid_losses']=args.valid_losses\n if args.__contains__('test_losses'):\n states['test_losses'] = args.test_losses\n\n\n if (args.checkpoint_epoch > 0):\n if not os.path.isdir(args.checkpoint_path):\n os.mkdir(args.checkpoint_path)\n\n\n save_file_path = os.path.join(args.checkpoint_path, 'checkpoint.pth.tar')\n torch.save(states, save_file_path)\n\n if is_best:\n shutil.copyfile(save_file_path, os.path.join(args.checkpoint_path,'model_best.pth.tar'))\n\n\n print('Loss: %.3f | top1: %.3f%%, top5: %.3f%%, elasped time: %3.f seconds. Best Acc: %.3f%%'\n % (losses.avg , top1.avg, top5.avg, total_time, args.best_acc))\n\n\n\n\nimport csv\n\nclass Logger(object):\n def __init__(self, path, header):\n self.log_file = open(path, 'w')\n self.logger = csv.writer(self.log_file, delimiter='\\t')\n\n self.logger.writerow(header)\n self.header = header\n\n def __del(self):\n self.log_file.close()\n\n def log(self, values):\n write_values = []\n for col in self.header:\n assert col in values\n write_values.append(values[col])\n\n self.logger.writerow(write_values)\n self.log_file.flush()\n\n\n\nclass AverageMeter(object):\n \"\"\"Computes and stores the average and current value\"\"\"\n def __init__(self):\n self.reset()\n\n def reset(self):\n self.val = 0\n self.avg = 0\n self.sum = 0\n self.count = 0\n\n def update(self, val, n=1):\n self.val = val\n self.sum += val * n\n self.count += n\n self.avg = self.sum / self.count\n\ndef accuracy(output, target, topk=(1,)):\n \"\"\"Computes the precision@k for the specified values of k\"\"\"\n with torch.no_grad():\n maxk = max(topk)\n batch_size = target.size(0)\n\n _, pred = output.topk(maxk, 1, True, True)\n pred = pred.t()\n correct = pred.eq(target.view(1, -1).expand_as(pred))\n\n res = []\n for k in topk:\n correct_k = correct[:k].view(-1).float().sum(0, keepdim=True)\n res.append(correct_k.mul_(100.0 / batch_size))\n return res"
] |
[
[
"torch.no_grad",
"torch.save"
]
] |
bpblakely/safegraph_py
|
[
"661452c97cc779177a0337d09692cb0fb5c397d1"
] |
[
"tests/explode_array_test.py"
] |
[
"# content of explode_array_test.py\nfrom safegraph_py_functions.safegraph_py_functions import *\nimport pytest\nimport pandas.util.testing as pdt\n\n\n### Expected DFs\n\nexpected_output_data = {\n 'safegraph_place_id': ['sg:64d0ee4695af4ab4906fe82997ead9ff', 'sg:64d0ee4695af4ab4906fe82997ead9ff', 'sg:64d0ee4695af4ab4906fe82997ead9ff', 'sg:64d0ee4695af4ab4906fe82997ead9ff', 'sg:64d0ee4695af4ab4906fe82997ead9ff', 'sg:64d0ee4695af4ab4906fe82997ead9ff', 'sg:64d0ee4695af4ab4906fe82997ead9ff', 'sg:001955fa1c994b4c8c877316a66dd986', 'sg:001955fa1c994b4c8c877316a66dd986', 'sg:001955fa1c994b4c8c877316a66dd986', 'sg:001955fa1c994b4c8c877316a66dd986', 'sg:001955fa1c994b4c8c877316a66dd986', 'sg:001955fa1c994b4c8c877316a66dd986', 'sg:001955fa1c994b4c8c877316a66dd986', 'sg:001e39c6b18645a5950b13a278b242c3', 'sg:001e39c6b18645a5950b13a278b242c3', 'sg:001e39c6b18645a5950b13a278b242c3', 'sg:001e39c6b18645a5950b13a278b242c3', 'sg:001e39c6b18645a5950b13a278b242c3', 'sg:001e39c6b18645a5950b13a278b242c3', 'sg:001e39c6b18645a5950b13a278b242c3', 'sg:00267c6356804259b6c92ba31c842f5a', 'sg:00267c6356804259b6c92ba31c842f5a', 'sg:00267c6356804259b6c92ba31c842f5a', 'sg:00267c6356804259b6c92ba31c842f5a', 'sg:00267c6356804259b6c92ba31c842f5a', 'sg:00267c6356804259b6c92ba31c842f5a', 'sg:00267c6356804259b6c92ba31c842f5a', 'sg:0029991464e349e8b5b985609360cfa4', 'sg:0029991464e349e8b5b985609360cfa4', 'sg:0029991464e349e8b5b985609360cfa4', 'sg:0029991464e349e8b5b985609360cfa4', 'sg:0029991464e349e8b5b985609360cfa4', 'sg:0029991464e349e8b5b985609360cfa4', 'sg:0029991464e349e8b5b985609360cfa4'],\n 'visits_by_day': [[8,8,9,6,7,7,4], [8,8,9,6,7,7,4], [8,8,9,6,7,7,4], [8,8,9,6,7,7,4], [8,8,9,6,7,7,4], [8,8,9,6,7,7,4], [8,8,9,6,7,7,4], [3,9,9,4,11,7,4], [3,9,9,4,11,7,4], [3,9,9,4,11,7,4], [3,9,9,4,11,7,4], [3,9,9,4,11,7,4], [3,9,9,4,11,7,4], [3,9,9,4,11,7,4], [14,4,6,4,6,4,4], [14,4,6,4,6,4,4], [14,4,6,4,6,4,4], [14,4,6,4,6,4,4], [14,4,6,4,6,4,4], [14,4,6,4,6,4,4], [14,4,6,4,6,4,4], [1,3,1,3,0,0,2], [1,3,1,3,0,0,2], [1,3,1,3,0,0,2], [1,3,1,3,0,0,2], [1,3,1,3,0,0,2], [1,3,1,3,0,0,2], [1,3,1,3,0,0,2], [2,4,2,2,5,5,0], [2,4,2,2,5,5,0], [2,4,2,2,5,5,0], [2,4,2,2,5,5,0], [2,4,2,2,5,5,0], [2,4,2,2,5,5,0], [2,4,2,2,5,5,0]],\n 'visitor_home_cbgs': [{\"484391113102\":4,\"484391057043\":4,\"484391219014\":4}, {\"484391113102\":4,\"484391057043\":4,\"484391219014\":4}, {\"484391113102\":4,\"484391057043\":4,\"484391219014\":4}, {\"484391113102\":4,\"484391057043\":4,\"484391219014\":4}, {\"484391113102\":4,\"484391057043\":4,\"484391219014\":4}, {\"484391113102\":4,\"484391057043\":4,\"484391219014\":4}, {\"484391113102\":4,\"484391057043\":4,\"484391219014\":4}, {\"484391113205\":4,\"484391057222\":4,\"484391219218\":4}, {\"484391113205\":4,\"484391057222\":4,\"484391219218\":4}, {\"484391113205\":4,\"484391057222\":4,\"484391219218\":4}, {\"484391113205\":4,\"484391057222\":4,\"484391219218\":4}, {\"484391113205\":4,\"484391057222\":4,\"484391219218\":4}, {\"484391113205\":4,\"484391057222\":4,\"484391219218\":4}, {\"484391113205\":4,\"484391057222\":4,\"484391219218\":4}, {\"484391113305\":4,\"484391057333\":4,\"484391219318\":5}, {\"484391113305\":4,\"484391057333\":4,\"484391219318\":5}, {\"484391113305\":4,\"484391057333\":4,\"484391219318\":5}, {\"484391113305\":4,\"484391057333\":4,\"484391219318\":5}, {\"484391113305\":4,\"484391057333\":4,\"484391219318\":5}, {\"484391113305\":4,\"484391057333\":4,\"484391219318\":5}, {\"484391113305\":4,\"484391057333\":4,\"484391219318\":5}, {\"484391113405\":4,\"484391057444\":4,\"484391219412\":4}, {\"484391113405\":4,\"484391057444\":4,\"484391219412\":4}, {\"484391113405\":4,\"484391057444\":4,\"484391219412\":4}, {\"484391113405\":4,\"484391057444\":4,\"484391219412\":4}, {\"484391113405\":4,\"484391057444\":4,\"484391219412\":4}, {\"484391113405\":4,\"484391057444\":4,\"484391219412\":4}, {\"484391113405\":4,\"484391057444\":4,\"484391219412\":4}, {\"484391113505\":4,\"484391057555\":4,\"484391219512\":4}, {\"484391113505\":4,\"484391057555\":4,\"484391219512\":4}, {\"484391113505\":4,\"484391057555\":4,\"484391219512\":4}, {\"484391113505\":4,\"484391057555\":4,\"484391219512\":4}, {\"484391113505\":4,\"484391057555\":4,\"484391219512\":4}, {\"484391113505\":4,\"484391057555\":4,\"484391219512\":4}, {\"484391113505\":4,\"484391057555\":4,\"484391219512\":4}],\n 'date_range_start': ['2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-04:00', '2020-06-22T00:00:00-04:00', '2020-06-22T00:00:00-04:00', '2020-06-22T00:00:00-04:00', '2020-06-22T00:00:00-04:00', '2020-06-22T00:00:00-04:00', '2020-06-22T00:00:00-04:00', '2020-06-22T00:00:00-07:00', '2020-06-22T00:00:00-07:00', '2020-06-22T00:00:00-07:00', '2020-06-22T00:00:00-07:00', '2020-06-22T00:00:00-07:00', '2020-06-22T00:00:00-07:00', '2020-06-22T00:00:00-07:00'],\n 'visits_by_day_value': [8,8,9,6,7,7,4,3,9,9,4,11,7,4,14,4,6,4,6,4,4,1,3,1,3,0,0,2,2,4,2,2,5,5,0],\n 'visits_by_day_sequence': [1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7, 1, 2, 3, 4, 5, 6, 7]\n }\n\n### End Expected DFs\n\n\ntest_input_data = {'safegraph_place_id': ['sg:64d0ee4695af4ab4906fe82997ead9ff', 'sg:001955fa1c994b4c8c877316a66dd986', 'sg:001e39c6b18645a5950b13a278b242c3', 'sg:00267c6356804259b6c92ba31c842f5a', 'sg:0029991464e349e8b5b985609360cfa4'],\n 'visits_by_day': [[8,8,9,6,7,7,4], [3,9,9,4,11,7,4], [14,4,6,4,6,4,4], [1,3,1,3,0,0,2], [2,4,2,2,5,5,0]],\n 'visitor_home_cbgs': [{\"484391113102\":4,\"484391057043\":4,\"484391219014\":4}, {\"484391113205\":4,\"484391057222\":4,\"484391219218\":4}, {\"484391113305\":4,\"484391057333\":4,\"484391219318\":5}, {\"484391113405\":4,\"484391057444\":4,\"484391219412\":4}, {\"484391113505\":4,\"484391057555\":4,\"484391219512\":4}],\n 'date_range_start': ['2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-05:00', '2020-06-22T00:00:00-04:00', '2020-06-22T00:00:00-07:00']\n }\n\ndf = pd.DataFrame(test_input_data)\n\nnew_index = [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4]\n\n### Test section\n\ndef test_explode_array():\n\n ''' This is a test of explode json array '''\n \n action = explode_json_array(df)\n\n expected = pd.DataFrame(expected_output_data)\n\n pdt.assert_frame_equal(action, expected)\n\ndef test_explode_array_fast():\n ''' This is a test of explode json array fast '''\n\n action1 = explode_json_array_fast(df)\n\n expected1 = pd.DataFrame(expected_output_data)\n\n pdt.assert_frame_equal(action1, expected1)\n"
] |
[
[
"pandas.util.testing.assert_frame_equal"
]
] |
AnthonySMaida/RBP_predcode
|
[
"8714862d891e3df44445d8f6155f5a633f6a16f0"
] |
[
"data_utils_RBP.py"
] |
[
"#import hickle as hkl\nimport numpy as np\nfrom keras import backend as K\nfrom keras.preprocessing.image import Iterator\nimport matplotlib.pyplot as plt\n\n# Defines one class: SequenceGenerator. a subclass of Iterator\n# ====================================\n\n# Called from kitti_train.py and kitti_evaluate.py.\n# Class SequenceGenerator is a subclass of Iterator.\n# Data generator that creates sequences for input into PredNet.\nclass SequenceGenerator(Iterator): # Iterator: can be iterated over in for-loop\n def __init__(self, data_file, source_file, nt,\n batch_size=8, shuffle=False, seed=None,\n output_mode='error', sequence_start_mode='all', N_seq=None,\n data_format=K.image_data_format()):\n print(\"\\ndata_utils_RPB.py: Instantiating sequence generator:\\n\")\n \n # LOAD DATA FILE\n print(\"data_utils_RBP.py: Data file: \\n\", data_file)\n self.X = np.load(data_file) # X will be like (n_images, nb_cols, nb_rows, nb_channels) \n #self.X =hkl.transpose(self.X, (0, 3, 2, 1))\n \n# ===============================================================\n# Added statements to print out two consecutive frames. ASM\n print(\"data_utils.py: self.X.shape\\n\", self.X.shape) # e.g., (41396, 128, 160, 3)\n # print(\"1st row:\\n\", self.X[0,:,:,:]) # will print the raw array\n # Print 1st two consecutive frames\n # NOTE: the video sequence seems to be stored in reverse order!!! Is this a bug?\n # 1. When called from \"kitti_train.py\" the frames for X_train.py and X_val.py seem\n # to be stored in reverse order.\n # 2. When called from \"kitti_evaluate.py\" the frames for X_test.py seem to be\n # in correct order.\n # 3. Need to make sure that the source files properly match the data files.\n my_temp = np.array(self.X[0,:,:,:], dtype = int, copy = True) # convert from float to int\n plt.imshow(my_temp) # look at 1st image\n plt.show()\n my_temp = np.array(self.X[1,:,:,:], dtype = int, copy = True) # convert from float to int\n plt.imshow(my_temp) # look at 2nd image\n plt.show()\n \n # LOAD SOURCE FILE\n print(\"data_utils.py: Source file: \\n\", source_file)\n self.sources = np.load(source_file) # Labels in b'string' format\n # Above: source for each image so when creating sequences can assure that consecutive \n # frames are from same video\n print(\"data_utils.py: self.sources.shape\\n\", self.sources.shape) # e.g., (41396,)\n print(self.sources[0]) # should print a byte literal representation of a string\n# End of print statements\n# ===============================================================\n\n # SET OTHER PARAMS\n self.nt = nt # 10\n self.batch_size = batch_size # 4 if called from \"kitti_train.py\"\n self.data_format = data_format # K.image_data_format()\n assert sequence_start_mode in {'all', 'unique'}, 'sequence_start_mode must be in {all, unique}'\n self.sequence_start_mode = sequence_start_mode # default is 'all'\n assert output_mode in {'error', 'prediction'}, 'output_mode must be in {error, prediction}'\n self.output_mode = output_mode # default is 'error'\n\n if self.data_format == 'channels_first': # tensorflow data format is 'channels_last'\n self.X = np.transpose(self.X, (0, 3, 1, 2))\n self.im_shape = self.X[0].shape # (128, 160, 3) I think.\n\n if self.sequence_start_mode == 'all': # allow for any possible sequence, starting from any frame\n self.possible_starts = np.array([i for i in range(self.X.shape[0] - self.nt) if self.sources[i] == self.sources[i + self.nt - 1]])\n print(\"data_utils.py: possible_starts all: \", self.possible_starts)\n elif self.sequence_start_mode == 'unique': #create sequences where each unique frame is in at most one sequence\n curr_location = 0\n possible_starts = []\n while curr_location < self.X.shape[0] - self.nt + 1:\n if self.sources[curr_location] == self.sources[curr_location + self.nt - 1]:\n possible_starts.append(curr_location)\n curr_location += self.nt\n else:\n curr_location += 1\n self.possible_starts = possible_starts\n print(\"data_utils.py: possible_starts unique: \", self.possible_starts)\n\n if shuffle:\n self.possible_starts = np.random.permutation(self.possible_starts)\n if N_seq is not None and len(self.possible_starts) > N_seq: # select a subset of sequences if want to\n self.possible_starts = self.possible_starts[:N_seq]\n self.N_sequences = len(self.possible_starts)\n super(SequenceGenerator, self).__init__(len(self.possible_starts), batch_size, shuffle, seed)\n # End of __init__()\n\n def __getitem__(self, null):\n return self.next()\n\n def next(self): # Returns a batch of x and y data\n with self.lock:\n current_index = (self.batch_index * self.batch_size) % self.n\n index_array, current_batch_size = next(self.index_generator), self.batch_size\n batch_x = np.zeros((current_batch_size, self.nt) + self.im_shape, np.float32)\n for i, idx in enumerate(index_array):\n idx = self.possible_starts[idx]\n batch_x[i] = self.preprocess(self.X[idx:idx+self.nt])\n if self.output_mode == 'error': # model outputs errors, so y should be zeros\n batch_y = np.zeros(current_batch_size, np.float32)\n elif self.output_mode == 'prediction': # output actual pixels\n batch_y = batch_x\n return batch_x, batch_y # inputs, targets\n\n def preprocess(self, X):\n return X.astype(np.float32) / 255 # maps to [0, 1]\n\n # Returns 10 frames\n def create_all(self):\n # Below: plus operator is concatentation. Initialize multidim array of float32 zeros w/ specified shape\n X_all = np.zeros((self.N_sequences, self.nt) + self.im_shape, np.float32)\n for i, idx in enumerate(self.possible_starts):\n X_all[i] = self.preprocess(self.X[idx:idx+self.nt]) # map [0,255] to [0,1] for 10 frames\n return X_all\n"
] |
[
[
"matplotlib.pyplot.imshow",
"numpy.random.permutation",
"numpy.transpose",
"numpy.load",
"numpy.array",
"numpy.zeros",
"matplotlib.pyplot.show"
]
] |
kabrapratik28/Stanford_courses
|
[
"9b02845ad15103d7e7f934319f43298f8cd8a364",
"9b02845ad15103d7e7f934319f43298f8cd8a364"
] |
[
"cs224n/assignment3/q2_rnn.py",
"cs20si/tf-stanford-tutorials/assignments/style_transfer/style_transfer_sols.py"
] |
[
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nQ2: Recurrent neural nets for NER\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\n\nimport argparse\nimport logging\nimport sys\nimport time\nfrom datetime import datetime\n\nimport tensorflow as tf\nimport numpy as np\n\nfrom util import print_sentence, write_conll, read_conll\nfrom data_util import load_and_preprocess_data, load_embeddings, ModelHelper\nfrom ner_model import NERModel\nfrom defs import LBLS\nfrom q2_rnn_cell import RNNCell\nfrom q3_gru_cell import GRUCell\n\nlogger = logging.getLogger(\"hw3.q2\")\nlogger.setLevel(logging.DEBUG)\nlogging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG)\n\nclass Config:\n \"\"\"Holds model hyperparams and data information.\n\n The config class is used to store various hyperparameters and dataset\n information parameters. Model objects are passed a Config() object at\n instantiation.\n \"\"\"\n n_word_features = 2 # Number of features for every word in the input.\n window_size = 1\n n_features = (2 * window_size + 1) * n_word_features # Number of features for every word in the input.\n max_length = 120 # longest sequence to parse\n n_classes = 5\n dropout = 0.5\n embed_size = 50\n hidden_size = 300\n batch_size = 32\n n_epochs = 10\n max_grad_norm = 10.\n lr = 0.001\n\n def __init__(self, args):\n self.cell = args.cell\n\n if \"model_path\" in args:\n # Where to save things.\n self.output_path = args.model_path\n else:\n self.output_path = \"results/{}/{:%Y%m%d_%H%M%S}/\".format(self.cell, datetime.now())\n self.model_output = self.output_path + \"model.weights\"\n self.eval_output = self.output_path + \"results.txt\"\n self.conll_output = self.output_path + \"{}_predictions.conll\".format(self.cell)\n self.log_output = self.output_path + \"log\"\n\ndef pad_sequences(data, max_length):\n \"\"\"Ensures each input-output seqeunce pair in @data is of length\n @max_length by padding it with zeros and truncating the rest of the\n sequence.\n\n TODO: In the code below, for every sentence, labels pair in @data,\n (a) create a new sentence which appends zero feature vectors until\n the sentence is of length @max_length. If the sentence is longer\n than @max_length, simply truncate the sentence to be @max_length\n long.\n (b) create a new label sequence similarly.\n (c) create a _masking_ sequence that has a True wherever there was a\n token in the original sequence, and a False for every padded input.\n\n Example: for the (sentence, labels) pair: [[4,1], [6,0], [7,0]], [1,\n 0, 0], and max_length = 5, we would construct\n - a new sentence: [[4,1], [6,0], [7,0], [0,0], [0,0]]\n - a new label seqeunce: [1, 0, 0, 4, 4], and\n - a masking seqeunce: [True, True, True, False, False].\n\n Args:\n data: is a list of (sentence, labels) tuples. @sentence is a list\n containing the words in the sentence and @label is a list of\n output labels. Each word is itself a list of\n @n_features features. For example, the sentence \"Chris\n Manning is amazing\" and labels \"PER PER O O\" would become\n ([[1,9], [2,9], [3,8], [4,8]], [1, 1, 4, 4]). Here \"Chris\"\n the word has been featurized as \"[1, 9]\", and \"[1, 1, 4, 4]\"\n is the list of labels. \n max_length: the desired length for all input/output sequences.\n Returns:\n a new list of data points of the structure (sentence', labels', mask).\n Each of sentence', labels' and mask are of length @max_length.\n See the example above for more details.\n \"\"\"\n ret = []\n\n # Use this zero vector when padding sequences.\n zero_vector = [0] * Config.n_features\n zero_label = 4 # corresponds to the 'O' tag\n\n for sentence, labels in data:\n ### YOUR CODE HERE (~4-6 lines)\n sentence_length = len(sentence)\n mask = [True,] * sentence_length\n if sentence_length > max_length:\n ret.append((sentence[:max_length], labels[:max_length], mask[:max_length]))\n else:\n padding_size = max_length - sentence_length\n new_sentence = sentence + [zero_vector,] * padding_size\n new_labels = labels + [zero_label,] * padding_size\n new_mask = mask + [False,] * padding_size\n ret.append((new_sentence, new_labels, new_mask))\n ### END YOUR CODE ###\n return ret\n\nclass RNNModel(NERModel):\n \"\"\"\n Implements a recursive neural network with an embedding layer and\n single hidden layer.\n This network will predict a sequence of labels (e.g. PER) for a\n given token (e.g. Henry) using a featurized window around the token.\n \"\"\"\n\n def add_placeholders(self):\n \"\"\"Generates placeholder variables to represent the input tensors\n\n These placeholders are used as inputs by the rest of the model building and will be fed\n data during training. Note that when \"None\" is in a placeholder's shape, it's flexible\n (so we can use different batch sizes without rebuilding the model).\n\n Adds following nodes to the computational graph\n\n input_placeholder: Input placeholder tensor of shape (None, self.max_length, n_features), type tf.int32\n labels_placeholder: Labels placeholder tensor of shape (None, self.max_length), type tf.int32\n mask_placeholder: Mask placeholder tensor of shape (None, self.max_length), type tf.bool\n dropout_placeholder: Dropout value placeholder (scalar), type tf.float32\n\n TODO: Add these placeholders to self as the instance variables\n self.input_placeholder\n self.labels_placeholder\n self.mask_placeholder\n self.dropout_placeholder\n\n HINTS:\n - Remember to use self.max_length NOT Config.max_length\n\n (Don't change the variable names)\n \"\"\"\n ### YOUR CODE HERE (~4-6 lines)\n self.input_placeholder = tf.placeholder(dtype=tf.int32, shape=(None, self.max_length, Config.n_features))\n self.labels_placeholder = tf.placeholder(dtype=tf.int32, shape=(None, self.max_length))\n self.dropout_placeholder = tf.placeholder(dtype=tf.float32, shape=())\n self.mask_placeholder = tf.placeholder(dtype=tf.bool, shape=(None, self.max_length))\n ### END YOUR CODE\n\n def create_feed_dict(self, inputs_batch, mask_batch, labels_batch=None, dropout=1):\n \"\"\"Creates the feed_dict for the dependency parser.\n\n A feed_dict takes the form of:\n\n feed_dict = {\n <placeholder>: <tensor of values to be passed for placeholder>,\n ....\n }\n\n Hint: The keys for the feed_dict should be a subset of the placeholder\n tensors created in add_placeholders.\n Hint: When an argument is None, don't add it to the feed_dict.\n\n Args:\n inputs_batch: A batch of input data.\n mask_batch: A batch of mask data.\n labels_batch: A batch of label data.\n dropout: The dropout rate.\n Returns:\n feed_dict: The feed dictionary mapping from placeholders to values.\n \"\"\"\n ### YOUR CODE (~6-10 lines)\n feed_dict = {}\n feed_dict[self.input_placeholder] = inputs_batch\n feed_dict[self.dropout_placeholder] = dropout\n feed_dict[self.mask_placeholder] = mask_batch\n if labels_batch is not None:\n feed_dict[self.labels_placeholder] = labels_batch \n ### END YOUR CODE\n return feed_dict\n\n def add_embedding(self):\n \"\"\"Adds an embedding layer that maps from input tokens (integers) to vectors and then\n concatenates those vectors:\n\n TODO:\n - Create an embedding tensor and initialize it with self.pretrained_embeddings.\n - Use the input_placeholder to index into the embeddings tensor, resulting in a\n tensor of shape (None, max_length, n_features, embed_size).\n - Concatenates the embeddings by reshaping the embeddings tensor to shape\n (None, max_length, n_features * embed_size).\n\n HINTS:\n - You might find tf.nn.embedding_lookup useful.\n - You can use tf.reshape to concatenate the vectors. See\n following link to understand what -1 in a shape means.\n https://www.tensorflow.org/api_docs/python/array_ops/shapes_and_shaping#reshape.\n\n Returns:\n embeddings: tf.Tensor of shape (None, max_length, n_features*embed_size)\n \"\"\"\n ### YOUR CODE HERE (~4-6 lines)\n embeddings = tf.Variable(self.pretrained_embeddings)\n embedding_features = tf.nn.embedding_lookup(embeddings,self.input_placeholder)\n embeddings = tf.reshape(embedding_features,shape=(-1, self.max_length, self.config.n_features * self.config.embed_size))\n ### END YOUR CODE\n return embeddings\n\n def add_prediction_op(self):\n \"\"\"Adds the unrolled RNN:\n h_0 = 0\n for t in 1 to T:\n o_t, h_t = cell(x_t, h_{t-1})\n o_drop_t = Dropout(o_t, dropout_rate)\n y_t = o_drop_t U + b_2\n\n TODO: There a quite a few things you'll need to do in this function:\n - Define the variables U, b_2.\n - Define the vector h as a constant and inititalize it with\n zeros. See tf.zeros and tf.shape for information on how\n to initialize this variable to be of the right shape.\n https://www.tensorflow.org/api_docs/python/constant_op/constant_value_tensors#zeros\n https://www.tensorflow.org/api_docs/python/array_ops/shapes_and_shaping#shape\n - In a for loop, begin to unroll the RNN sequence. Collect\n the predictions in a list.\n - When unrolling the loop, from the second iteration\n onwards, you will HAVE to call\n tf.get_variable_scope().reuse_variables() so that you do\n not create new variables in the RNN cell.\n See https://www.tensorflow.org/versions/master/how_tos/variable_scope/\n - Concatenate and reshape the predictions into a predictions\n tensor.\n Hint: You will find the function tf.pack (similar to np.asarray)\n useful to assemble a list of tensors into a larger tensor.\n https://www.tensorflow.org/api_docs/python/array_ops/slicing_and_joining#pack\n Hint: You will find the function tf.transpose and the perms\n argument useful to shuffle the indices of the tensor.\n https://www.tensorflow.org/api_docs/python/array_ops/slicing_and_joining#transpose\n\n Remember:\n * Use the xavier initilization for matrices.\n * Note that tf.nn.dropout takes the keep probability (1 - p_drop) as an argument.\n The keep probability should be set to the value of self.dropout_placeholder\n\n Returns:\n pred: tf.Tensor of shape (batch_size, max_length, n_classes)\n \"\"\"\n\n x = self.add_embedding()\n dropout_rate = self.dropout_placeholder\n\n preds = [] # Predicted output at each timestep should go here!\n\n # Use the cell defined below. For Q2, we will just be using the\n # RNNCell you defined, but for Q3, we will run this code again\n # with a GRU cell!\n if self.config.cell == \"rnn\":\n cell = RNNCell(Config.n_features * Config.embed_size, Config.hidden_size)\n elif self.config.cell == \"gru\":\n cell = GRUCell(Config.n_features * Config.embed_size, Config.hidden_size)\n else:\n raise ValueError(\"Unsuppported cell type: \" + self.config.cell)\n\n # Define U and b2 as variables.\n # Initialize state as vector of zeros.\n ### YOUR CODE HERE (~4-6 lines)\n U = tf.get_variable(\"U\", shape=[Config.hidden_size,Config.n_classes],initializer=tf.contrib.layers.xavier_initializer())\n b2 = tf.get_variable(\"b_2\",shape=(Config.n_classes),initializer=tf.zeros_initializer())\n h = tf.zeros((1,Config.hidden_size))\n ### END YOUR CODE\n\n with tf.variable_scope(\"RNN\"):\n for time_step in range(self.max_length):\n ### YOUR CODE HERE (~6-10 lines)\n if time_step > 0:\n tf.get_variable_scope().reuse_variables()\n x_input = x[:,time_step]\n o_t, h_t = cell(x_input,h)\n o_drop_t = tf.nn.dropout(o_t, dropout_rate)\n y_t = tf.matmul(o_drop_t,U) + b2\n preds.append(y_t)\n h = h_t\n ### END YOUR CODE\n\n # Make sure to reshape @preds here.\n ### YOUR CODE HERE (~2-4 lines)\n # if axis == 0 then the output tensor will have the shape (N, A, B, C). \n # if axis == 1 then the output tensor will have the shape (A, N, B, C). Etc\n # print (len(preds))\n # print (preds[0].get_shape())\n preds = tf.stack(preds,axis=1)\n # print (preds.get_shape())\n ### END YOUR CODE\n\n assert preds.get_shape().as_list() == [None, self.max_length, self.config.n_classes], \"predictions are not of the right shape. Expected {}, got {}\".format([None, self.max_length, self.config.n_classes], preds.get_shape().as_list())\n return preds\n\n def add_loss_op(self, preds):\n \"\"\"Adds Ops for the loss function to the computational graph.\n\n TODO: Compute averaged cross entropy loss for the predictions.\n Importantly, you must ignore the loss for any masked tokens.\n\n Hint: You might find tf.boolean_mask useful to mask the losses on masked tokens.\n Hint: You can use tf.nn.sparse_softmax_cross_entropy_with_logits to simplify your\n implementation. You might find tf.reduce_mean useful.\n Args:\n pred: A tensor of shape (batch_size, max_length, n_classes) containing the output of the neural\n network before the softmax layer.\n Returns:\n loss: A 0-d tensor (scalar)\n \"\"\"\n ### YOUR CODE HERE (~2-4 lines)\n labels_mask = tf.boolean_mask(self.labels_placeholder, self.mask_placeholder)\n pred_mask = tf.boolean_mask(self.pred, self.mask_placeholder)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels_mask,logits=pred_mask)\n loss = tf.reduce_mean(cross_entropy)\n ### END YOUR CODE\n return loss\n\n def add_training_op(self, loss):\n \"\"\"Sets up the training Ops.\n\n Creates an optimizer and applies the gradients to all trainable variables.\n The Op returned by this function is what must be passed to the\n `sess.run()` call to cause the model to train. See\n\n https://www.tensorflow.org/versions/r0.7/api_docs/python/train.html#Optimizer\n\n for more information.\n\n Use tf.train.AdamOptimizer for this model.\n Calling optimizer.minimize() will return a train_op object.\n\n Args:\n loss: Loss tensor, from cross_entropy_loss.\n Returns:\n train_op: The Op for training.\n \"\"\"\n ### YOUR CODE HERE (~1-2 lines)\n optimizer = tf.train.AdamOptimizer(self.config.lr)\n train_op = optimizer.minimize(loss)\n ### END YOUR CODE\n return train_op\n\n def preprocess_sequence_data(self, examples):\n def featurize_windows(data, start, end, window_size = 1):\n \"\"\"Uses the input sequences in @data to construct new windowed data points.\n \"\"\"\n ret = []\n for sentence, labels in data:\n from util import window_iterator\n sentence_ = []\n for window in window_iterator(sentence, window_size, beg=start, end=end):\n sentence_.append(sum(window, []))\n ret.append((sentence_, labels))\n return ret\n\n examples = featurize_windows(examples, self.helper.START, self.helper.END)\n return pad_sequences(examples, self.max_length)\n\n def consolidate_predictions(self, examples_raw, examples, preds):\n \"\"\"Batch the predictions into groups of sentence length.\n \"\"\"\n assert len(examples_raw) == len(examples)\n assert len(examples_raw) == len(preds)\n\n ret = []\n for i, (sentence, labels) in enumerate(examples_raw):\n _, _, mask = examples[i]\n labels_ = [l for l, m in zip(preds[i], mask) if m] # only select elements of mask.\n assert len(labels_) == len(labels)\n ret.append([sentence, labels, labels_])\n return ret\n\n def predict_on_batch(self, sess, inputs_batch, mask_batch):\n feed = self.create_feed_dict(inputs_batch=inputs_batch, mask_batch=mask_batch)\n predictions = sess.run(tf.argmax(self.pred, axis=2), feed_dict=feed)\n return predictions\n\n def train_on_batch(self, sess, inputs_batch, labels_batch, mask_batch):\n feed = self.create_feed_dict(inputs_batch, labels_batch=labels_batch, mask_batch=mask_batch,\n dropout=Config.dropout)\n _, loss = sess.run([self.train_op, self.loss], feed_dict=feed)\n return loss\n\n def __init__(self, helper, config, pretrained_embeddings, report=None):\n super(RNNModel, self).__init__(helper, config, report)\n self.max_length = min(Config.max_length, helper.max_length)\n Config.max_length = self.max_length # Just in case people make a mistake.\n self.pretrained_embeddings = pretrained_embeddings\n\n # Defining placeholders.\n self.input_placeholder = None\n self.labels_placeholder = None\n self.mask_placeholder = None\n self.dropout_placeholder = None\n\n self.build()\n\ndef test_pad_sequences():\n Config.n_features = 2\n data = [\n ([[4,1], [6,0], [7,0]], [1, 0, 0]),\n ([[3,0], [3,4], [4,5], [5,3], [3,4]], [0, 1, 0, 2, 3]),\n ]\n ret = [\n ([[4,1], [6,0], [7,0], [0,0]], [1, 0, 0, 4], [True, True, True, False]),\n ([[3,0], [3,4], [4,5], [5,3]], [0, 1, 0, 2], [True, True, True, True])\n ]\n\n ret_ = pad_sequences(data, 4)\n assert len(ret_) == 2, \"Did not process all examples: expected {} results, but got {}.\".format(2, len(ret_))\n for i in range(2):\n assert len(ret_[i]) == 3, \"Did not populate return values corrected: expected {} items, but got {}.\".format(3, len(ret_[i]))\n for j in range(3):\n assert ret_[i][j] == ret[i][j], \"Expected {}, but got {} for {}-th entry of {}-th example\".format(ret[i][j], ret_[i][j], j, i)\n\ndef do_test1(_):\n logger.info(\"Testing pad_sequences\")\n test_pad_sequences()\n logger.info(\"Passed!\")\n\ndef do_test2(args):\n logger.info(\"Testing implementation of RNNModel\")\n config = Config(args)\n helper, train, dev, train_raw, dev_raw = load_and_preprocess_data(args)\n embeddings = load_embeddings(args, helper)\n config.embed_size = embeddings.shape[1]\n\n with tf.Graph().as_default():\n logger.info(\"Building model...\",)\n start = time.time()\n model = RNNModel(helper, config, embeddings)\n logger.info(\"took %.2f seconds\", time.time() - start)\n\n init = tf.global_variables_initializer()\n saver = None\n\n with tf.Session() as session:\n session.run(init)\n model.fit(session, saver, train, dev)\n\n logger.info(\"Model did not crash!\")\n logger.info(\"Passed!\")\n\ndef do_train(args):\n # Set up some parameters.\n config = Config(args)\n helper, train, dev, train_raw, dev_raw = load_and_preprocess_data(args)\n embeddings = load_embeddings(args, helper)\n config.embed_size = embeddings.shape[1]\n helper.save(config.output_path)\n\n handler = logging.FileHandler(config.log_output)\n handler.setLevel(logging.DEBUG)\n handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))\n logging.getLogger().addHandler(handler)\n\n report = None #Report(Config.eval_output)\n\n with tf.Graph().as_default():\n logger.info(\"Building model...\",)\n start = time.time()\n model = RNNModel(helper, config, embeddings)\n logger.info(\"took %.2f seconds\", time.time() - start)\n\n init = tf.global_variables_initializer()\n saver = tf.train.Saver()\n\n with tf.Session() as session:\n session.run(init)\n model.fit(session, saver, train, dev)\n if report:\n report.log_output(model.output(session, dev_raw))\n report.save()\n else:\n # Save predictions in a text file.\n output = model.output(session, dev_raw)\n sentences, labels, predictions = zip(*output)\n predictions = [[LBLS[l] for l in preds] for preds in predictions]\n output = zip(sentences, labels, predictions)\n\n with open(model.config.conll_output, 'w') as f:\n write_conll(f, output)\n with open(model.config.eval_output, 'w') as f:\n for sentence, labels, predictions in output:\n print_sentence(f, sentence, labels, predictions)\n\ndef do_evaluate(args):\n config = Config(args)\n helper = ModelHelper.load(args.model_path)\n input_data = read_conll(args.data)\n embeddings = load_embeddings(args, helper)\n config.embed_size = embeddings.shape[1]\n\n with tf.Graph().as_default():\n logger.info(\"Building model...\",)\n start = time.time()\n model = RNNModel(helper, config, embeddings)\n\n logger.info(\"took %.2f seconds\", time.time() - start)\n\n init = tf.global_variables_initializer()\n saver = tf.train.Saver()\n\n with tf.Session() as session:\n session.run(init)\n saver.restore(session, model.config.model_output)\n for sentence, labels, predictions in model.output(session, input_data):\n predictions = [LBLS[l] for l in predictions]\n print_sentence(args.output, sentence, labels, predictions)\n\ndef do_shell(args):\n config = Config(args)\n helper = ModelHelper.load(args.model_path)\n embeddings = load_embeddings(args, helper)\n config.embed_size = embeddings.shape[1]\n\n with tf.Graph().as_default():\n logger.info(\"Building model...\",)\n start = time.time()\n model = RNNModel(helper, config, embeddings)\n logger.info(\"took %.2f seconds\", time.time() - start)\n\n init = tf.global_variables_initializer()\n saver = tf.train.Saver()\n\n with tf.Session() as session:\n session.run(init)\n saver.restore(session, model.config.model_output)\n\n print(\"\"\"Welcome!\nYou can use this shell to explore the behavior of your model.\nPlease enter sentences with spaces between tokens, e.g.,\ninput> Germany 's representative to the European Union 's veterinary committee .\n\"\"\")\n while True:\n # Create simple REPL\n try:\n sentence = raw_input(\"input> \")\n tokens = sentence.strip().split(\" \")\n for sentence, _, predictions in model.output(session, [(tokens, [\"O\"] * len(tokens))]):\n predictions = [LBLS[l] for l in predictions]\n print_sentence(sys.stdout, sentence, [\"\"] * len(tokens), predictions)\n except EOFError:\n print(\"Closing session.\")\n break\n\nif __name__ == \"__main__\":\n parser = argparse.ArgumentParser(description='Trains and tests an NER model')\n subparsers = parser.add_subparsers()\n\n command_parser = subparsers.add_parser('test1', help='')\n command_parser.set_defaults(func=do_test1)\n\n command_parser = subparsers.add_parser('test2', help='')\n command_parser.add_argument('-dt', '--data-train', type=argparse.FileType('r'), default=\"data/tiny.conll\", help=\"Training data\")\n command_parser.add_argument('-dd', '--data-dev', type=argparse.FileType('r'), default=\"data/tiny.conll\", help=\"Dev data\")\n command_parser.add_argument('-v', '--vocab', type=argparse.FileType('r'), default=\"data/vocab.txt\", help=\"Path to vocabulary file\")\n command_parser.add_argument('-vv', '--vectors', type=argparse.FileType('r'), default=\"data/wordVectors.txt\", help=\"Path to word vectors file\")\n command_parser.add_argument('-c', '--cell', choices=[\"rnn\", \"gru\"], default=\"rnn\", help=\"Type of RNN cell to use.\")\n command_parser.set_defaults(func=do_test2)\n\n command_parser = subparsers.add_parser('train', help='')\n command_parser.add_argument('-dt', '--data-train', type=argparse.FileType('r'), default=\"data/train.conll\", help=\"Training data\")\n command_parser.add_argument('-dd', '--data-dev', type=argparse.FileType('r'), default=\"data/dev.conll\", help=\"Dev data\")\n command_parser.add_argument('-v', '--vocab', type=argparse.FileType('r'), default=\"data/vocab.txt\", help=\"Path to vocabulary file\")\n command_parser.add_argument('-vv', '--vectors', type=argparse.FileType('r'), default=\"data/wordVectors.txt\", help=\"Path to word vectors file\")\n command_parser.add_argument('-c', '--cell', choices=[\"rnn\", \"gru\"], default=\"rnn\", help=\"Type of RNN cell to use.\")\n command_parser.set_defaults(func=do_train)\n\n command_parser = subparsers.add_parser('evaluate', help='')\n command_parser.add_argument('-d', '--data', type=argparse.FileType('r'), default=\"data/dev.conll\", help=\"Training data\")\n command_parser.add_argument('-m', '--model-path', help=\"Training data\")\n command_parser.add_argument('-v', '--vocab', type=argparse.FileType('r'), default=\"data/vocab.txt\", help=\"Path to vocabulary file\")\n command_parser.add_argument('-vv', '--vectors', type=argparse.FileType('r'), default=\"data/wordVectors.txt\", help=\"Path to word vectors file\")\n command_parser.add_argument('-c', '--cell', choices=[\"rnn\", \"gru\"], default=\"rnn\", help=\"Type of RNN cell to use.\")\n command_parser.add_argument('-o', '--output', type=argparse.FileType('w'), default=sys.stdout, help=\"Training data\")\n command_parser.set_defaults(func=do_evaluate)\n\n command_parser = subparsers.add_parser('shell', help='')\n command_parser.add_argument('-m', '--model-path', help=\"Training data\")\n command_parser.add_argument('-v', '--vocab', type=argparse.FileType('r'), default=\"data/vocab.txt\", help=\"Path to vocabulary file\")\n command_parser.add_argument('-vv', '--vectors', type=argparse.FileType('r'), default=\"data/wordVectors.txt\", help=\"Path to word vectors file\")\n command_parser.add_argument('-c', '--cell', choices=[\"rnn\", \"gru\"], default=\"rnn\", help=\"Type of RNN cell to use.\")\n command_parser.set_defaults(func=do_shell)\n\n ARGS = parser.parse_args()\n if ARGS.func is None:\n parser.print_help()\n sys.exit(1)\n else:\n ARGS.func(ARGS)\n",
"\"\"\" An implementation of the paper \"A Neural Algorithm of Artistic Style\"\nby Gatys et al. in TensorFlow.\n\nAuthor: Chip Huyen ([email protected])\nPrepared for the class CS 20SI: \"TensorFlow for Deep Learning Research\"\nFor more details, please read the assignment handout:\nhttp://web.stanford.edu/class/cs20si/assignments/a2.pdf\n\"\"\"\nfrom __future__ import print_function\n\nimport os\nimport time\n\nimport numpy as np\nimport tensorflow as tf\n\nimport vgg_model\nimport utils\n\n# parameters to manage experiments\nSTYLE = 'guernica'\nCONTENT = 'deadpool'\nSTYLE_IMAGE = 'styles/' + STYLE + '.jpg'\nCONTENT_IMAGE = 'content/' + CONTENT + '.jpg'\nIMAGE_HEIGHT = 250\nIMAGE_WIDTH = 333\nNOISE_RATIO = 0.6 # percentage of weight of the noise for intermixing with the content image\n\nCONTENT_WEIGHT = 0.01\nSTYLE_WEIGHT = 1\n\n# Layers used for style features. You can change this.\nSTYLE_LAYERS = ['conv1_1', 'conv2_1', 'conv3_1', 'conv4_1', 'conv5_1']\nW = [0.5, 1.0, 1.5, 3.0, 4.0] # give more weights to deeper layers.\n\n# Layer used for content features. You can change this.\nCONTENT_LAYER = 'conv4_2'\n\nITERS = 300\nLR = 2.0\n\nMEAN_PIXELS = np.array([123.68, 116.779, 103.939]).reshape((1,1,1,3))\n\"\"\" MEAN_PIXELS is defined according to description on their github:\nhttps://gist.github.com/ksimonyan/211839e770f7b538e2d8\n'In the paper, the model is denoted as the configuration D trained with scale jittering. \nThe input images should be zero-centered by mean pixel (rather than mean image) subtraction. \nNamely, the following BGR values should be subtracted: [103.939, 116.779, 123.68].'\n\"\"\"\n\n# VGG-19 parameters file\nVGG_DOWNLOAD_LINK = 'http://www.vlfeat.org/matconvnet/models/imagenet-vgg-verydeep-19.mat'\nVGG_MODEL = 'imagenet-vgg-verydeep-19.mat'\nEXPECTED_BYTES = 534904783\n\ndef _create_content_loss(p, f):\n \"\"\" Calculate the loss between the feature representation of the\n content image and the generated image.\n \n Inputs: \n p, f are just P, F in the paper \n (read the assignment handout if you're confused)\n Note: we won't use the coefficient 0.5 as defined in the paper\n but the coefficient as defined in the assignment handout.\n Output:\n the content loss\n\n \"\"\"\n return tf.reduce_sum((f - p) ** 2) / (4.0 * p.size)\n\ndef _gram_matrix(F, N, M):\n \"\"\" Create and return the gram matrix for tensor F\n Hint: you'll first have to reshape F\n \"\"\"\n F = tf.reshape(F, (M, N))\n return tf.matmul(tf.transpose(F), F)\n\ndef _single_style_loss(a, g):\n \"\"\" Calculate the style loss at a certain layer\n Inputs:\n a is the feature representation of the real image\n g is the feature representation of the generated image\n Output:\n the style loss at a certain layer (which is E_l in the paper)\n\n Hint: 1. you'll have to use the function _gram_matrix()\n 2. we'll use the same coefficient for style loss as in the paper\n 3. a and g are feature representation, not gram matrices\n \"\"\"\n N = a.shape[3] # number of filters\n M = a.shape[1] * a.shape[2] # height times width of the feature map\n A = _gram_matrix(a, N, M)\n G = _gram_matrix(g, N, M)\n return tf.reduce_sum((G - A) ** 2 / ((2 * N * M) ** 2))\n\ndef _create_style_loss(A, model):\n \"\"\" Return the total style loss\n \"\"\"\n n_layers = len(STYLE_LAYERS)\n E = [_single_style_loss(A[i], model[STYLE_LAYERS[i]]) for i in range(n_layers)]\n \n ###############################\n ## TO DO: return total style loss\n return sum([W[i] * E[i] for i in range(n_layers)])\n ###############################\n\ndef _create_losses(model, input_image, content_image, style_image):\n with tf.variable_scope('loss') as scope:\n with tf.Session() as sess:\n sess.run(input_image.assign(content_image)) # assign content image to the input variable\n p = sess.run(model[CONTENT_LAYER])\n content_loss = _create_content_loss(p, model[CONTENT_LAYER])\n\n with tf.Session() as sess:\n sess.run(input_image.assign(style_image))\n A = sess.run([model[layer_name] for layer_name in STYLE_LAYERS]) \n style_loss = _create_style_loss(A, model)\n\n ##########################################\n ## TO DO: create total loss. \n ## Hint: don't forget the content loss and style loss weights\n total_loss = CONTENT_WEIGHT * content_loss + STYLE_WEIGHT * style_loss\n ##########################################\n\n return content_loss, style_loss, total_loss\n\ndef _create_summary(model):\n \"\"\" Create summary ops necessary\n Hint: don't forget to merge them\n \"\"\"\n with tf.name_scope('summaries'):\n tf.summary.scalar('content loss', model['content_loss'])\n tf.summary.scalar('style loss', model['style_loss'])\n tf.summary.scalar('total loss', model['total_loss'])\n tf.summary.histogram('histogram content loss', model['content_loss'])\n tf.summary.histogram('histogram style loss', model['style_loss'])\n tf.summary.histogram('histogram total loss', model['total_loss'])\n return tf.summary.merge_all()\n\ndef train(model, generated_image, initial_image):\n \"\"\" Train your model.\n Don't forget to create folders for checkpoints and outputs.\n \"\"\"\n skip_step = 1\n with tf.Session() as sess:\n saver = tf.train.Saver()\n ###############################\n ## TO DO: \n ## 1. initialize your variables\n ## 2. create writer to write your graph\n saver = tf.train.Saver()\n sess.run(tf.global_variables_initializer())\n writer = tf.summary.FileWriter('./graphs', sess.graph)\n ###############################\n sess.run(generated_image.assign(initial_image))\n ckpt = tf.train.get_checkpoint_state(os.path.dirname('checkpoints/checkpoint'))\n if ckpt and ckpt.model_checkpoint_path:\n saver.restore(sess, ckpt.model_checkpoint_path)\n initial_step = model['global_step'].eval()\n \n start_time = time.time()\n for index in range(initial_step, ITERS):\n if index >= 5 and index < 20:\n skip_step = 10\n elif index >= 20:\n skip_step = 20\n \n sess.run(model['optimizer'])\n if (index + 1) % skip_step == 0:\n ###############################\n ## TO DO: obtain generated image and loss\n gen_image, total_loss, summary = sess.run([generated_image, model['total_loss'], \n model['summary_op']])\n\n ###############################\n gen_image = gen_image + MEAN_PIXELS\n writer.add_summary(summary, global_step=index)\n print('Step {}\\n Sum: {:5.1f}'.format(index + 1, np.sum(gen_image)))\n print(' Loss: {:5.1f}'.format(total_loss))\n print(' Time: {}'.format(time.time() - start_time))\n start_time = time.time()\n\n filename = 'outputs/%d.png' % (index)\n utils.save_image(filename, gen_image)\n\n if (index + 1) % 20 == 0:\n saver.save(sess, 'checkpoints/style_transfer', index)\n\ndef main():\n with tf.variable_scope('input') as scope:\n # use variable instead of placeholder because we're training the intial image to make it\n # look like both the content image and the style image\n input_image = tf.Variable(np.zeros([1, IMAGE_HEIGHT, IMAGE_WIDTH, 3]), dtype=tf.float32)\n \n utils.download(VGG_DOWNLOAD_LINK, VGG_MODEL, EXPECTED_BYTES)\n model = vgg_model.load_vgg(VGG_MODEL, input_image)\n model['global_step'] = tf.Variable(0, dtype=tf.int32, trainable=False, name='global_step')\n \n content_image = utils.get_resized_image(CONTENT_IMAGE, IMAGE_HEIGHT, IMAGE_WIDTH)\n content_image = content_image - MEAN_PIXELS\n style_image = utils.get_resized_image(STYLE_IMAGE, IMAGE_HEIGHT, IMAGE_WIDTH)\n style_image = style_image - MEAN_PIXELS\n\n model['content_loss'], model['style_loss'], model['total_loss'] = _create_losses(model, \n input_image, content_image, style_image)\n ###############################\n ## TO DO: create optimizer\n model['optimizer'] = tf.train.AdamOptimizer(LR).minimize(model['total_loss'], \n global_step=model['global_step'])\n ###############################\n model['summary_op'] = _create_summary(model)\n\n initial_image = utils.generate_noise_image(content_image, IMAGE_HEIGHT, IMAGE_WIDTH, NOISE_RATIO)\n train(model, input_image, initial_image)\n\nif __name__ == '__main__':\n main()\n"
] |
[
[
"tensorflow.zeros",
"tensorflow.stack",
"tensorflow.train.AdamOptimizer",
"tensorflow.boolean_mask",
"tensorflow.Graph",
"tensorflow.Variable",
"tensorflow.contrib.layers.xavier_initializer",
"tensorflow.Session",
"tensorflow.train.Saver",
"tensorflow.argmax",
"tensorflow.nn.dropout",
"tensorflow.matmul",
"tensorflow.zeros_initializer",
"tensorflow.placeholder",
"tensorflow.global_variables_initializer",
"tensorflow.nn.sparse_softmax_cross_entropy_with_logits",
"tensorflow.nn.embedding_lookup",
"tensorflow.reduce_mean",
"tensorflow.reshape",
"tensorflow.variable_scope",
"tensorflow.get_variable_scope"
],
[
"tensorflow.transpose",
"tensorflow.summary.FileWriter",
"tensorflow.Variable",
"tensorflow.reduce_sum",
"tensorflow.reshape",
"tensorflow.global_variables_initializer",
"tensorflow.summary.merge_all",
"tensorflow.name_scope",
"tensorflow.Session",
"tensorflow.train.AdamOptimizer",
"tensorflow.variable_scope",
"tensorflow.train.Saver",
"numpy.array",
"tensorflow.summary.scalar",
"numpy.sum",
"numpy.zeros",
"tensorflow.summary.histogram"
]
] |
jeffmacinnes/pyneal
|
[
"750f0ec5a231ccfa77aea960242de9b5019ba493",
"750f0ec5a231ccfa77aea960242de9b5019ba493"
] |
[
"tests/pyneal_tests/test_pynealAnalysis.py",
"pyneal_scanner/utils/Siemens_utils.py"
] |
[
"import os\nfrom os.path import join\nimport sys\n\nimport numpy as np\nimport nibabel as nib\n\nimport pyneal_helper_tools as helper_tools\n\n# get dictionary with relevant paths for tests within this module\npaths = helper_tools.get_pyneal_test_paths()\nif paths['pynealDir'] not in sys.path:\n sys.path.insert(0, paths['pynealDir'])\n\nfrom src.pynealAnalysis import Analyzer\n\nmaskFile = join(paths['testDataDir'], 'testSeries_mask.nii.gz')\nseriesFile = join(paths['testDataDir'], 'testSeries.nii.gz')\n\nclass Test_pynealAnalysis:\n \"\"\" Test pyneal.src.pynealAnalysis module \"\"\"\n\n def test_average(self):\n \"\"\" test Analyzer computing average signal within mask \"\"\"\n # settings dictionary for this test\n settings = {'maskFile': maskFile,\n 'analysisChoice': 'Average',\n 'maskIsWeighted': False}\n\n # create instance of Analyzer class\n analyzer = Analyzer(settings)\n\n # loop over series and test\n seriesData = nib.load(seriesFile)\n results = []\n for volIdx in range(seriesData.shape[3]):\n # extract the 3d array for this vol\n thisVol = seriesData.get_fdata()[:, :, :, volIdx]\n result = analyzer.runAnalysis(thisVol, volIdx)\n\n results.append(result['average'])\n\n # make np arrays of results and what results are expected to be\n results = np.array(results)\n expectedResults = np.array([1029.15, 1032.78, 1034.14])\n\n # use np testing method to assert with customized precision\n np.testing.assert_almost_equal(results, expectedResults, decimal=2)\n\n def test_weightedAverage(self):\n \"\"\" test Analyzer computing weighted average signal within mask \"\"\"\n # settings dictionary for this test\n settings = {'maskFile': maskFile,\n 'analysisChoice': 'Average',\n 'maskIsWeighted': True}\n\n # create instance of Analyzer class\n analyzer = Analyzer(settings)\n\n # loop over series and test\n seriesData = nib.load(seriesFile)\n results = []\n for volIdx in range(seriesData.shape[3]):\n # extract the 3d array for this vol\n thisVol = seriesData.get_fdata()[:, :, :, volIdx]\n result = analyzer.runAnalysis(thisVol, volIdx)\n\n results.append(result['weightedAverage'])\n\n # make np arrays of results and what results are expected to be\n results = np.array(results)\n expectedResults = np.array([1015.42, 1018.94, 1020.68])\n\n # use np testing method to assert with customized precision\n np.testing.assert_almost_equal(results, expectedResults, decimal=2)\n\n def test_median(self):\n \"\"\" test Analyzer computing mediansignal within mask \"\"\"\n # settings dictionary for this test\n settings = {'maskFile': maskFile,\n 'analysisChoice': 'Median',\n 'maskIsWeighted': False}\n\n # create instance of Analyzer class\n analyzer = Analyzer(settings)\n\n # loop over series and test\n seriesData = nib.load(seriesFile)\n results = []\n for volIdx in range(seriesData.shape[3]):\n # extract the 3d array for this vol\n thisVol = seriesData.get_fdata()[:, :, :, volIdx]\n result = analyzer.runAnalysis(thisVol, volIdx)\n\n results.append(result['median'])\n\n # make np arrays of results and what results are expected to be\n results = np.array(results)\n expectedResults = np.array([1017.00, 1020.5, 1026.00])\n\n # use np testing method to assert with customized precision\n np.testing.assert_almost_equal(results, expectedResults, decimal=2)\n\n def test_weightedMedian(self):\n \"\"\" test Analyzer computing weighted median signal within mask \"\"\"\n # settings dictionary for this test\n settings = {'maskFile': maskFile,\n 'analysisChoice': 'Median',\n 'maskIsWeighted': True}\n\n # create instance of Analyzer class\n analyzer = Analyzer(settings)\n\n # loop over series and test\n seriesData = nib.load(seriesFile)\n results = []\n for volIdx in range(seriesData.shape[3]):\n # extract the 3d array for this vol\n thisVol = seriesData.get_fdata()[:, :, :, volIdx]\n result = analyzer.runAnalysis(thisVol, volIdx)\n\n results.append(result['weightedMedian'])\n\n # make np arrays of results and what results are expected to be\n results = np.array(results)\n expectedResults = np.array([1000.00, 1014.00, 1012.00])\n\n # use np testing method to assert with customized precision\n np.testing.assert_almost_equal(results, expectedResults, decimal=2)\n\n def test_customAnalysis(self):\n \"\"\" test Analyzer computing customAnalysis within mask \"\"\"\n # settings dictionary for this test\n settings = {'maskFile': maskFile,\n 'numTimepts': 3,\n 'analysisChoice': join(paths['testDataDir'], 'test_customAnalysisScript.py'),\n 'maskIsWeighted': False}\n\n # create instance of Analyzer class\n analyzer = Analyzer(settings)\n\n # loop over series and test\n seriesData = nib.load(seriesFile)\n results = []\n for volIdx in range(seriesData.shape[3]):\n # extract the 3d array for this vol\n thisVol = seriesData.get_fdata()[:, :, :, volIdx]\n result = analyzer.runAnalysis(thisVol, volIdx)\n\n results.append(result['customResult'])\n\n # make np arrays of results and what results are expected to be\n results = np.array(results)\n expectedResults = np.array([1029.15, 1032.78, 1034.14])\n\n # use np testing method to assert with customized precision\n np.testing.assert_almost_equal(results, expectedResults, decimal=2)\n",
"\"\"\" Set of classes and methods specific to Siemens scanning environments\n\n\"\"\"\nfrom __future__ import print_function\nfrom __future__ import division\n\nimport os\nfrom os.path import join\nimport sys\nimport time\nimport re\nimport json\nimport glob\nimport logging\nfrom threading import Thread\nfrom queue import Queue\n\nimport numpy as np\nimport pydicom\nimport nibabel as nib\nfrom nibabel.nicom import dicomreaders\nimport zmq\n\n# regEx for Siemens style file naming\nSiemens_filePattern = re.compile('\\d{3}_\\d{6}_\\d{6}.dcm')\n\n# regEx for pulling the volume field out of the mosaic file name\nSiemens_mosaicVolumeNumberField = re.compile('(?<=\\d{6}_)\\d{6}')\nSiemens_mosaicSeriesNumberField = re.compile('(?<=\\d{3}_)\\d{6}(?=_\\d{6}.dcm)')\n\n\nclass Siemens_DirStructure():\n \"\"\" Finding the names and paths of series directories in a Siemens scanning\n environment.\n\n In Siemens environments, using the ideacmdtool, the scanner is set up to\n export data in real-time to a shared directory that is accessible from a\n remote workstation (running Pyneal Scanner). For functional data, Siemens\n scanners store reconstructed slices images by taking all of the slices for\n a single volume, and placing them side-by-side in a larger \"mosaic\" dicom\n image. A scan will produce one mosaic image per volume.\n\n For anatomical data, dicom images for each 2D slice will be written as\n separate files, numbered sequentially, and saved in the `sessionDir`.\n\n All dicom images for all scans across a single session will be stored in\n the same directory. We'll call this directory the `sessionDir`.\n\n A single `sessionDir` will hold all of the mosaic files for all of the\n series for the current session. The series number is contained in the\n filename, which follows the pattern:\n\n [session#]_[series#]_[vol#].dcm\n\n These files will appear in real-time as the scan progresses.\n\n This class contains methods to retrieve the current `sessionDir`, show the\n current series that are present, and monitor the `sessionDir` for the\n appearance of new series files.\n\n \"\"\"\n def __init__(self, scannerSettings):\n \"\"\" Initialize the class\n\n Parameters\n ----------\n scannerSettings : object\n class attributes represent all of the settings unique to the\n current scanning environment (many of them read from\n `scannerConfig.yaml`)\n\n See Also\n --------\n general_utils.ScannerSettings\n \"\"\"\n # initialize class attributes\n if 'scannerSessionDir' in scannerSettings.allSettings:\n self.sessionDir = scannerSettings.allSettings['scannerSessionDir']\n else:\n print('No scannerSessionDir found in scannerConfig file')\n sys.exit()\n\n def print_currentSeries(self):\n \"\"\" Find all of the series present in given sessionDir, and print them\n all, along with time since last modification, and directory size\n\n \"\"\"\n # find the sessionDir, if not already found\n if self.sessionDir is None:\n self.findSessionDir()\n print('Session Dir: ')\n print('{}'.format(self.sessionDir))\n\n # find all mosaic files in the sessionDir\n self.uniqueSeries = self.getUniqueSeries()\n if len(self.uniqueSeries) == 0:\n print('No mosaic files found in {}'.format(self.sessionDir))\n else:\n # print out info on each unique series in sessionDir\n currentTime = int(time.time())\n print('Unique Series: ')\n for series in sorted(self.uniqueSeries):\n # get list of all dicoms that match this series number\n thisSeriesDicoms = glob.glob(join(self.sessionDir, ('*_' + series + '_*.dcm')))\n\n # get time since last modification for last dicom in list\n lastModifiedTime = os.stat(thisSeriesDicoms[-1]).st_mtime\n timeElapsed = currentTime - lastModifiedTime\n m, s = divmod(timeElapsed, 60)\n time_string = '{} min, {} s ago'.format(int(m), int(s))\n\n print(' {}\\t{} files \\t{}'.format(series, len(thisSeriesDicoms), time_string))\n\n def getUniqueSeries(self):\n \"\"\" Return a list of unique series numbers from the filenames of the\n files found in the sessionDir\n\n \"\"\"\n uniqueSeries = []\n self.allMosaics = [f for f in os.listdir(self.sessionDir) if Siemens_filePattern.match(f)]\n if len(self.allMosaics) > 0:\n # find unique series numbers among all mosaics\n seriesNums = []\n for f in self.allMosaics:\n seriesNums.append(Siemens_mosaicSeriesNumberField.search(f).group())\n uniqueSeries = set(seriesNums)\n\n return uniqueSeries\n\n def waitForNewSeries(self, interval=.1):\n \"\"\" Listen for the appearance of new series files\n\n Once a scan starts, new series mosaic files will be created in the\n `sessionDir`. By the time this function is called, this class should\n already have the `sessionDir` defined\n\n Parameters\n ----------\n interval : float, optional\n time, in seconds, to wait between polling for a new directory\n\n Returns\n -------\n newSeries : string\n seriesNum of the new series\n\n \"\"\"\n keepWaiting = True\n existingSeries = self.getUniqueSeries()\n\n while keepWaiting:\n # get all of the unique series again\n currentSeries = self.getUniqueSeries()\n\n # compare against existing series\n diff = currentSeries - existingSeries\n if len(diff) > 0:\n newSeries = diff.pop()\n keepWaiting = False\n\n # pause before searching directories again\n time.sleep(interval)\n\n # return the found series name\n return newSeries\n\n\nclass Siemens_BuildNifti():\n \"\"\" Tools to build a 3D or 4D Nifti image from all of the dicom mosaic\n images in a directory.\n\n Input is a path to a series directory containing dicom images (either\n mosaic images for functional data, or 2D slice image for anatomical data).\n Image parameters, like voxel spacing and dimensions, are obtained\n automatically from the info in the dicom tags\n\n End result is a Nifti1 formatted 3D (anat) or 4D (func) file in RAS+\n orientation\n\n \"\"\"\n def __init__(self, seriesDir, seriesNum):\n \"\"\" Initialize class, and set/obtain basic class attributes like file\n paths and scan parameters\n\n Parameters\n ----------\n seriesDir : string\n full path to the directory containing the raw dicom mosaic files\n for each volume in the series\n seriesNum : string\n series number of the series that you'd like to build the nifti\n image from\n\n \"\"\"\n # initialize attributes\n self.seriesDir = seriesDir\n self.seriesNum = seriesNum\n self.niftiImage = None\n\n # make a list of the specified raw dicom mosaic files in this dir\n rawDicoms = glob.glob(join(self.seriesDir, ('*_' + str(self.seriesNum).zfill(6) + '_*.dcm')))\n\n # figure out what type of image this is, 4d or 3d\n self.scanType = self._determineScanType(rawDicoms[0])\n\n # build the nifti image\n if self.scanType == 'anat':\n self.niftiImage = self.buildAnat(rawDicoms)\n elif self.scanType == 'func':\n self.niftiImage = self.buildFunc(rawDicoms)\n\n def buildAnat(self, dicomFiles):\n \"\"\" Build a 3D structural/anatomical image from list of dicom files\n\n Given a list of `dicomFiles`, build a 3D anatomical image from them.\n Figure out the image dimensions and affine transformation to map\n from voxels to mm from the dicom tags\n\n Parameters\n ----------\n dicomFiles : list\n list containing the file names (file names ONLY, no path) of all\n dicom slice images to be used in constructing the final nifti image\n\n Returns\n -------\n anatImage_RAS : Nifti1Image\n nifti-1 formated image of the 3D anatomical data, oriented in\n RAS+\n\n See Also\n --------\n nibabel.nifti1.Nifti1Image()\n\n \"\"\"\n # read the first dicom in the list to get overall image dimensions\n dcm = pydicom.dcmread(join(self.seriesDir, dicomFiles[0]), stop_before_pixels=1)\n sliceDims = (getattr(dcm, 'Columns'), getattr(dcm, 'Rows'))\n self.nSlicesPerVol = len(dicomFiles)\n sliceThickness = getattr(dcm, 'SliceThickness')\n\n ### Build 3D array of voxel data\n # create an empty array to store the slice data\n imageMatrix = np.zeros(shape=(\n sliceDims[0],\n sliceDims[1],\n self.nSlicesPerVol), dtype='int16')\n\n # Use the InstanceNumber tag to order the slices. This works for anat\n # 3D images only, since the instance numbers do not repeat as they would\n # with functional data with multiple volumes\n sliceDict = {}\n for s in dicomFiles:\n dcm = pydicom.dcmread(join(self.seriesDir, s))\n sliceDict[dcm.InstanceNumber] = join(self.seriesDir, s)\n\n # sort by InStackPositionNumber and assemble the image\n for sliceIdx, ISPN in enumerate(sorted(sliceDict.keys())):\n dcm = pydicom.dcmread(sliceDict[ISPN])\n\n # extract the pixel data as a numpy array. Transpose\n # so that the axes order go [cols, rows]\n pixel_array = dcm.pixel_array.T\n\n # place in the image matrix\n imageMatrix[:, :, sliceIdx] = pixel_array\n\n ### create the affine transformation to map from vox to mm space\n # in order to do this, we need to get some values from the first and\n # last slices in the volume.\n firstSlice = sliceDict[sorted(sliceDict.keys())[0]]\n lastSlice = sliceDict[sorted(sliceDict.keys())[-1]]\n\n dcm_first = pydicom.dcmread(firstSlice)\n dcm_last = pydicom.dcmread(lastSlice)\n self.pixelSpacing = getattr(dcm_first, 'PixelSpacing')\n self.firstSlice_IOP = np.array(getattr(dcm_first, 'ImageOrientationPatient'))\n self.firstSlice_IPP = np.array(getattr(dcm_first, 'ImagePositionPatient'))\n self.lastSlice_IPP = np.array(getattr(dcm_last, 'ImagePositionPatient'))\n\n # now we can build the affine\n affine = self.buildAffine()\n\n ### Build a Nifti object, reorder it to RAS+\n anatImage = nib.Nifti1Image(imageMatrix, affine=affine)\n anatImage_RAS = nib.as_closest_canonical(anatImage) # reoder to RAS+\n print('Nifti image dims: {}'.format(anatImage_RAS.shape))\n\n return anatImage_RAS\n\n def buildFunc(self, dicomFiles):\n \"\"\" Build a 4D functional image from list of dicom files\n\n Given a list of dicomFile paths, build a 4d functional image. For\n Siemens scanners, each dicom file is assumed to represent a mosaic\n image comprised of mulitple slices. This tool will split apart the\n mosaic images, and construct a 4D nifti object. The 4D nifti object\n contain a voxel array ordered like RAS+ as well the affine\n transformation to map between vox and mm space\n\n Parameters\n ----------\n dicomFiles : list\n list containing the file names (file names ONLY, no path) of all\n dicom mosaic images to be used in constructing the final nifti\n image\n\n \"\"\"\n imageMatrix = None\n affine = None\n TR = None\n\n # make dicomFiles store the full path\n dicomFiles = [join(self.seriesDir, f) for f in dicomFiles]\n\n ### Loop over all dicom mosaic files\n nVols = len(dicomFiles)\n for mosaic_dcm_fname in dicomFiles:\n ### Parse the mosaic image into a 3D volume\n # we use the nibabel mosaic_to_nii() method which does a lot of the\n # heavy-lifting of extracting slices, arranging in a 3D array, and\n # grabbing the affine\n dcm = pydicom.dcmread(mosaic_dcm_fname) # create dicom object\n\n # for mosaic files, the instanceNumber tag will correspond to the\n # volume number (using a 1-based indexing, so subtract by 1)\n volIdx = dcm.InstanceNumber - 1\n\n # convert the dicom object to nii\n thisVol = dicomreaders.mosaic_to_nii(dcm)\n\n # convert to RAS+\n thisVol_RAS = nib.as_closest_canonical(thisVol)\n\n if TR is None:\n TR = dcm.RepetitionTime / 1000\n\n # construct the imageMatrix if it hasn't been made yet\n if imageMatrix is None:\n imageMatrix = np.zeros(shape=(thisVol_RAS.shape[0],\n thisVol_RAS.shape[1],\n thisVol_RAS.shape[2],\n nVols), dtype=np.uint16)\n\n # construct the affine if it isn't made yet\n if affine is None:\n affine = thisVol_RAS.affine\n\n # Add this data to the image matrix\n imageMatrix[:, :, :, volIdx] = thisVol_RAS.get_fdata()\n\n ### Build a Nifti object\n funcImage = nib.Nifti1Image(imageMatrix, affine=affine)\n pixDims = np.array(funcImage.header.get_zooms())\n pixDims[3] = TR\n funcImage.header.set_zooms(pixDims)\n\n return funcImage\n\n def buildAffine(self):\n \"\"\" Build the affine matrix that will transform the data to RAS+.\n\n This function should only be called once the required data has been\n extracted from the dicom tags from the relevant slices. The affine\n matrix is constructed by using the information in the\n ImageOrientationPatient and ImagePositionPatient tags from the first\n and last slices in a volume.\n\n However, note that those tags will tell you how to orient the image to\n DICOM reference coordinate space, which is LPS+. In order to to get to\n RAS+ we have to invert the first two axes.\n\n Notes\n -----\n For more info on building this affine, please see the documentation at:\n http://nipy.org/nibabel/dicom/dicom_orientation.html\n http://nipy.org/nibabel/coordinate_systems.html\n\n \"\"\"\n ### Get the ImageOrientation values from the first slice,\n # split the row-axis values (0:3) and col-axis values (3:6)\n # and then invert the first and second values of each\n rowAxis_orient = self.firstSlice_IOP[0:3] * np.array([-1, -1, 1])\n colAxis_orient = self.firstSlice_IOP[3:6] * np.array([-1, -1, 1])\n\n ### Get the voxel size along Row and Col axis\n voxSize_row = float(self.pixelSpacing[0])\n voxSize_col = float(self.pixelSpacing[1])\n\n ### Figure out the change along the 3rd axis by subtracting the\n # ImagePosition of the last slice from the ImagePosition of the first,\n # then dividing by 1/(total number of slices-1), then invert to\n # make it go from LPS+ to RAS+\n slAxis_orient = (self.firstSlice_IPP - self.lastSlice_IPP) / (1 - self.nSlicesPerVol)\n slAxis_orient = slAxis_orient * np.array([-1, -1, 1])\n\n ### Invert the first two values of the firstSlice ImagePositionPatient.\n # This tag represents the translation needed to take the origin of our 3D voxel\n # array to the origin of the LPS+ reference coordinate system. Since we want\n # RAS+, need to invert those first two axes\n voxTranslations = self.firstSlice_IPP * np.array([-1, -1, 1])\n\n ### Assemble the affine matrix\n affine = np.matrix([\n [rowAxis_orient[0] * voxSize_row, colAxis_orient[0] * voxSize_col, slAxis_orient[0], voxTranslations[0]],\n [rowAxis_orient[1] * voxSize_row, colAxis_orient[1] * voxSize_col, slAxis_orient[1], voxTranslations[1]],\n [rowAxis_orient[2] * voxSize_row, colAxis_orient[2] * voxSize_col, slAxis_orient[2], voxTranslations[2]],\n [0, 0, 0, 1]\n ])\n\n return affine\n\n def _determineScanType(self, dicomFile):\n \"\"\" Figure out what type of scan this is, anat or func\n\n This tool will determine the scan type from a given dicom file.\n Possible scan types are either single 3D volume (anat), or a 4D dataset\n built up of 2D slices (func). The scan type is determined by reading\n the `MRAcquisitionType` tag from the dicom file\n\n Parameters\n ----------\n dcmFile : string\n file name of dicom file from the current series that you would like\n to open to read the imaging parameters from\n\n Returns\n -------\n scanType : string\n either 'anat' or 'func' depending on scan type stored in dicom tag\n\n \"\"\"\n # read the dicom file\n dcm = pydicom.dcmread(join(self.seriesDir, dicomFile), stop_before_pixels=1)\n\n if getattr(dcm, 'MRAcquisitionType') == '3D':\n scanType = 'anat'\n elif getattr(dcm, 'MRAcquisitionType') == '2D':\n scanType = 'func'\n else:\n print('Cannot determine a scan type from this image!')\n sys.exit()\n\n return scanType\n\n def get_scanType(self):\n \"\"\" Return the scan type \"\"\"\n return self.scanType\n\n def get_niftiImage(self):\n \"\"\" Return the constructed Nifti Image \"\"\"\n return self.niftiImage\n\n def write_nifti(self, output_path):\n \"\"\" Write the nifti file to disk\n\n Parameters\n ----------\n outputPath : string\n full path, including filename, you want to use to save the nifti\n image\n\n \"\"\"\n nib.save(self.niftiImage, output_path)\n print('Image saved at: {}'.format(output_path))\n\n\nclass Siemens_monitorSessionDir(Thread):\n \"\"\" Class to monitor for new mosaic images to appear in the sessionDir.\n\n This class will run independently in a separate thread. Each new mosaic\n file that appears and matches the current series number will be added to\n the Queue for further processing\n\n \"\"\"\n def __init__(self, sessionDir, seriesNum, dicomQ, interval=.2):\n \"\"\" Initialize the class, and set basic class attributes\n\n Parameters\n ----------\n sessionDir : string\n full path to the session directory where new dicom mosaic files\n will appear\n seriesNum : string\n series number assigned to the new series\n dicomQ : object\n instance of python queue class to hold new dicom files before they\n have been processed. This class will add items to that queue.\n interval : float, optional\n time, in seconds, to wait before repolling the seriesDir to check\n for any new files\n\n \"\"\"\n # start the thread upon completion\n Thread.__init__(self)\n\n # set up logger\n self.logger = logging.getLogger(__name__)\n\n # initialize class parameters\n self.interval = interval # interval for polling for new files\n self.sessionDir = sessionDir # full path to series directory\n self.seriesNum = seriesNum # series number of current series\n self.dicomQ = dicomQ # queue to store dicom mosaic files\n self.alive = True # thread status\n self.numMosaicsAdded = 0 # counter to keep track of # mosaics\n self.queued_mosaic_files = set() # empty set to store names of queued mosaic\n\n def run(self):\n # function that runs while the Thread is still alive\n while self.alive:\n\n # create a set of all mosaic files with the current series num\n #currentMosaics = set(os.listdir(self.seriesDir))\n currentMosaics = set(glob.glob(join(self.sessionDir, ('*_' + str(self.seriesNum).zfill(6) + '_*.dcm'))))\n\n # grab only the ones that haven't already been added to the queue\n newMosaics = [f for f in currentMosaics if f not in self.queued_mosaic_files]\n\n # loop over each of the new mosaic files, add each to queue\n for f in newMosaics:\n mosaic_fname = join(self.sessionDir, f)\n try:\n self.dicomQ.put(mosaic_fname)\n except:\n self.logger.error('failed on: {}'.format(mosaic_fname))\n print(sys.exc_info())\n sys.exit()\n if len(newMosaics) > 0:\n self.logger.debug('Put {} new mosaic file on the queue'.format(len(newMosaics)))\n self.numMosaicsAdded += len(newMosaics)\n\n # now update the set of mosaics added to the queue\n self.queued_mosaic_files.update(set(newMosaics))\n\n # pause\n time.sleep(self.interval)\n\n def get_numMosaicsAdded(self):\n \"\"\" Return the cumulative number of mosaic files added to the queue thus far \"\"\"\n return self.numMosaicsAdded\n\n def stop(self):\n \"\"\" Set the `alive` flag to False, stopping thread \"\"\"\n self.alive = False\n\n\nclass Siemens_processMosaic(Thread):\n \"\"\" Class to process each mosaic file in the queue.\n\n This class will run in a separate thread. While running, it will pull\n 'tasks' off of the queue and process each one. Processing each task\n involves reading the mosaic file, converting it to a 3D Nifti object,\n reordering it to RAS+, and then sending the volume out over the\n pynealSocket\n\n \"\"\"\n def __init__(self, dicomQ, pynealSocket, interval=.2):\n \"\"\" Initialize the class\n\n Parameters\n ----------\n dicomQ : object\n instance of python queue class that will store the dicom slice file\n names. This class will pull items from that queue.\n pynealSocket : object\n instance of ZMQ style socket that will be used to communicate with\n Pyneal. This class will use this socket to send image data and\n headers to Pyneal during the real-time scan.\n See also: general_utils.create_pynealSocket()\n interval : float, optional\n time, in seconds, to wait before repolling the queue to see if\n there are any new file names to process\n\n \"\"\"\n # start the threat upon creation\n Thread.__init__(self)\n\n # set up logger\n self.logger = logging.getLogger(__name__)\n\n # initialize class parameters\n self.dicomQ = dicomQ\n self.interval = interval # interval between polling queue for new files\n self.alive = True\n self.pynealSocket = pynealSocket\n self.totalProcessed = 0 # counter for total number of slices processed\n\n def run(self):\n self.logger.debug('Siemens_processMosaic started')\n\n # function to run on loop\n while self.alive:\n\n # if there are any mosaic files in the queue, process them\n if not self.dicomQ.empty():\n numMosaicsInQueue = self.dicomQ.qsize()\n\n # loop through all mosaics currently in queue & process\n for m in range(numMosaicsInQueue):\n # retrieve file name from queue\n mosaic_dcm_fname = self.dicomQ.get(True, 2)\n\n # ensure the file has copied completely\n file_size = 0\n while True:\n file_info = os.stat(mosaic_dcm_fname)\n if file_info.st_size == 0 or file_info.st_size > file_size:\n file_size = file_info.st_size\n else:\n break\n\n # process this mosaic\n self.processMosaicFile(mosaic_dcm_fname)\n\n # complete this task, thereby clearing it from the queue\n self.dicomQ.task_done()\n\n # log how many were processed\n self.totalProcessed += numMosaicsInQueue\n self.logger.debug('Processed {} tasks from the queue ({} total)'.format(numMosaicsInQueue, self.totalProcessed))\n\n # pause for a bit\n time.sleep(self.interval)\n\n def processMosaicFile(self, mosaic_dcm_fname):\n \"\"\" Process a given mosaic dicom file\n\n This method will read the dicom mosaic file. Convert to a nifti object\n that will provide the 3D voxel array for this mosaic. Reorder to RAS+,\n and then send to the pynealSocket\n\n Parameters\n ----------\n mosaic_dcm_fname : string\n full path to the dicom mosaic file that you want to process\n\n \"\"\"\n ### Figure out the volume index for this mosaic by reading\n # the field from the file name itself\n mosaicFile_root, mosaicFile_name = os.path.split(mosaic_dcm_fname)\n volIdx = int(Siemens_mosaicVolumeNumberField.search(mosaicFile_name).group(0)) - 1\n self.logger.info('Volume {} processing'.format(volIdx))\n\n ### Parse the mosaic image into a 3D volume\n # we use the nibabel mosaic_to_nii() method which does a lot of the\n # heavy-lifting of extracting slices, arranging in a 3D array, and\n # grabbing the affine\n dcm = pydicom.dcmread(mosaic_dcm_fname) # create dicom object\n thisVol = dicomreaders.mosaic_to_nii(dcm) # convert to nifti\n\n # convert to RAS+\n thisVol_RAS = nib.as_closest_canonical(thisVol)\n\n # get the data as a contiguous array (required for ZMQ)\n thisVol_RAS_data = np.ascontiguousarray(thisVol_RAS.get_fdata())\n\n ### Create a header with metadata info\n volHeader = {\n 'volIdx': volIdx,\n 'dtype': str(thisVol_RAS_data.dtype),\n 'shape': thisVol_RAS_data.shape,\n 'affine': json.dumps(thisVol_RAS.affine.tolist()),\n 'TR': str(dcm.RepetitionTime / 1000)}\n\n ### Send the voxel array and header to the pynealSocket\n self.sendVolToPynealSocket(volHeader, thisVol_RAS_data)\n\n def sendVolToPynealSocket(self, volHeader, voxelArray):\n \"\"\" Send the volume data to Pyneal\n\n Send the image data and header information for the specified volume to\n Pyneal via the `pynealSocket`.\n\n Parameters\n ----------\n volHeader : dict\n key:value pairs for all of the relevant metadata for this volume\n voxelArray : numpy array\n 3D numpy array of voxel data from the volume, reoriented to RAS+\n\n \"\"\"\n self.logger.debug('TO pynealSocket: vol {}'.format(volHeader['volIdx']))\n\n ### Send data out the socket, listen for response\n self.pynealSocket.send_json(volHeader, zmq.SNDMORE) # header as json\n self.pynealSocket.send(voxelArray, flags=0, copy=False, track=False)\n pynealSocketResponse = self.pynealSocket.recv_string()\n\n # log the success\n self.logger.debug('FROM pynealSocket: {}'.format(pynealSocketResponse))\n\n # check if that was the last volume, and if so, stop\n if 'STOP' in pynealSocketResponse:\n self.stop()\n\n def stop(self):\n \"\"\" set the `alive` flag to False, stopping the thread \"\"\"\n self.alive = False\n\n\ndef Siemens_launch_rtfMRI(scannerSettings, scannerDirs):\n \"\"\" Launch a real-time session in a Siemens environment.\n This method should be called from pynealScanner.py before starting the\n scanner. Once called, this method will take care of:\n - monitoring the sessionDir for new series files to appear (and\n then returing the new series number)\n - set up the socket connection to send volume data over\n - creating a Queue to store newly arriving DICOM files\n - start a separate thread to monitor the new series appearing\n - start a separate thread to process DICOMs that are in the Queue\n\n \"\"\"\n # Create a reference to the logger. This assumes the logger has already\n # been created and customized by pynealScanner.py\n logger = logging.getLogger(__name__)\n\n #### SET UP PYNEAL SOCKET (this is what we'll use to\n #### send data (e.g. header, volume voxel data) to remote connections)\n # figure out host and port number to use\n host = scannerSettings.get_pynealSocketHost()\n port = scannerSettings.get_pynealSocketPort()\n logger.debug('Scanner Socket Host: {}'.format(host))\n logger.debug('Scanner Socket Port: {}'.format(port))\n\n # create a socket connection\n from .general_utils import create_pynealSocket\n pynealSocket = create_pynealSocket(host, port)\n logger.debug('Created pynealSocket')\n\n # wait for remote to connect on pynealSocket\n logger.info('Connecting to pynealSocket...')\n while True:\n msg = 'hello from pyneal_scanner '\n pynealSocket.send_string(msg)\n msgResponse = pynealSocket.recv_string()\n if msgResponse == msg:\n break\n logger.info('pynealSocket connected')\n\n ### Wait for a new series directory appear\n logger.info('Waiting for new series files to appear...')\n seriesNum = scannerDirs.waitForNewSeries()\n logger.info('New Series Number: {}'.format(seriesNum))\n\n ### Start threads to A) watch for new mosaic files, and B) process\n # them as they appear\n # initialize the dicom queue to keep store newly arrived\n # dicom mosaic images, and keep track of which have been processed\n dicomQ = Queue()\n\n # create instance of class that will monitor sessionDir for new mosaic\n # images to appear. Pass in a copy of the dicom queue. Start the thread\n scanWatcher = Siemens_monitorSessionDir(scannerDirs.sessionDir, seriesNum, dicomQ)\n scanWatcher.start()\n\n # create an instance of the class that will grab mosaic dicoms\n # from the queue, reformat the data, and pass over the socket\n # to pyneal. Start the thread going\n mosaicProcessor = Siemens_processMosaic(dicomQ, pynealSocket)\n mosaicProcessor.start()\n"
] |
[
[
"numpy.testing.assert_almost_equal",
"numpy.array"
],
[
"numpy.matrix",
"numpy.array",
"numpy.zeros"
]
] |
qusaykaid/pythonic-learning-machine
|
[
"38cbca7c56720ecc1f9f0dfc89702e9c18c5ae2c"
] |
[
"src/algorithms/semantic_learning_machine/algorithm.py"
] |
[
"from algorithms.common.neural_network.node import Sensor\nfrom algorithms.common.neural_network.neural_network import NeuralNetwork, create_neuron\nfrom algorithms.common.neural_network.connection import Connection\nfrom algorithms.semantic_learning_machine.solution import Solution\nfrom algorithms.common.algorithm import EvolutionaryAlgorithm\nfrom numpy import array, matrix, dot, resize, shape\nfrom numpy.linalg import pinv\nfrom random import uniform, sample, randint\nfrom copy import copy, deepcopy\n\n\nclass SemanticLearningMachine(EvolutionaryAlgorithm):\n \"\"\"\n Class represents Semantic Learning Machine (SLM) algorithms:\n https://www.researchgate.net/publication/300543369_Semantic_Learning_Machine_\n A_Feedforward_Neural_Network_Construction_Algorithm_Inspired_by_Geometric_Semantic_Genetic_Programming\n\n Attributes:\n layer: Number of layers for base topology.\n learning_step: Weight for connection to output neuron.\n max_connections: Maximum connections for neuron.\n mutation_operator: Operator that augments neural network.\n next_champion: Solution that will replace champion.\n\n Notes:\n learning_step can be positive numerical value of 'optimized' for optimized learning step.\n \"\"\"\n\n def __init__(self, population_size, stopping_criterion,\n layers, learning_step, max_connections, mutation_operator):\n super().__init__(population_size, stopping_criterion)\n self.layers = layers\n self.learning_step = learning_step\n self.max_connections = max_connections\n self.mutation_operator = mutation_operator\n self.next_champion = None\n\n def _get_learning_step(self, partial_semantics):\n \"\"\"Returns learning step.\"\"\"\n\n # If learning step is 'optimized', calculate optimized learning step.\n if self.learning_step == 'optimized':\n return self._get_optimized_learning_step(partial_semantics)\n # Else, return numerical learning step.\n else:\n return self.learning_step\n\n def _get_optimized_learning_step(self, partial_semantics):\n \"\"\"Calculates optimized learning step.\"\"\"\n\n # Calculates distance to target vector.\n delta_target = copy(self.target_vector).astype(float)\n if self.champion:\n delta_target -= self.champion.neural_network.get_predictions()\n # Calculates pseudo-inverse of partial_semantics.\n inverse = array(pinv(matrix(partial_semantics)))\n # Returns dot product between inverse and delta.\n return dot(inverse.transpose(), delta_target)[0]\n\n def _get_connection_weight(self, weight):\n \"\"\"Returns connection weight if defined, else random value between -1 and 1.\"\"\"\n\n return weight if weight else uniform(-1, 1)\n\n def _connect_nodes(self, from_nodes, to_nodes, weight=None, random=False):\n \"\"\"\n Connects list of from_nodes with list of to_nodes.\n\n Args:\n from_nodes: List of from_nodes.\n to_nodes: List of to_nodes.\n weight: Weight from connection.\n random: Flag if random number of connections.\n\n Notes:\n If weight is None, then weight will be chosen at random between -1 and 1.\n \"\"\"\n\n for to_node in to_nodes:\n # If random, create random sample of connection partners\n if random:\n max_connections = self.max_connections if len(from_nodes) > self.max_connections else len(from_nodes)\n random_connections = randint(1, max_connections)\n from_nodes_sample = sample(from_nodes, random_connections)\n else:\n from_nodes_sample = from_nodes\n # Connect to_node to each node in from_node_sample.\n for from_node in from_nodes_sample:\n Connection(from_node, to_node, self._get_connection_weight(weight))\n\n def _connect_nodes_mutation(self, hidden_layers):\n \"\"\"Connects new mutation neurons to remainder of network.\"\"\"\n\n # Sets reference to champion neural network.\n neural_network = self.champion.neural_network\n # Create hidden origin layer.\n from_layers = [copy(hidden_layer) for hidden_layer in hidden_layers]\n for hidden_layer_new, hidden_layer_old in zip(from_layers, neural_network.hidden_layers):\n hidden_layer_new.extend(hidden_layer_old)\n # Establish connections.\n self._connect_nodes(neural_network.sensors, hidden_layers[0], random=True)\n previous_neurons = from_layers[0]\n for from_layer, to_layer in zip(from_layers[1:], hidden_layers[1:]):\n self._connect_nodes(previous_neurons, to_layer, random=True)\n previous_neurons = from_layer\n\n def _connect_learning_step(self, neural_network):\n \"\"\"Connects last hidden neuron with defined learning step.\"\"\"\n\n # Get last hidden neuron.\n last_neuron = neural_network.hidden_layers[-1][-1]\n # Get semantics of last neuron.\n last_semantics = last_neuron.semantics\n # Connect last neuron to output neuron.\n self._connect_nodes([last_neuron], [neural_network.output_neuron], self._get_learning_step(last_semantics))\n\n def _create_solution(self, neural_network):\n \"\"\"Creates solution for population.\"\"\"\n\n # Creates solution object.\n solution = Solution(neural_network, None, None)\n # Calculates error.\n solution.value = self.metric.evaluate(neural_network.get_predictions(), self.target_vector)\n # Checks, if solution is better than parent.\n solution.better_than_ancestor = self._is_better_solution(solution, self.champion)\n # After the output semantics are updated, we can remove the semantics from the final hidden neuron.\n neural_network.output_neuron.input_connections[-1].from_node.semantics = None\n # Returns solution.\n return solution\n\n def _initialize_sensors(self):\n \"\"\"Initializes sensors based on input matrix.\"\"\"\n\n return [Sensor(input_data) for input_data in self.input_matrix.T]\n\n def _initialize_bias(self, neural_network):\n \"\"\"Initializes biases with same length as sensors.\"\"\"\n\n return Sensor(resize(array([1]), shape(neural_network.sensors[0].semantics)))\n\n def _initialize_hidden_layers(self, neural_network):\n \"\"\"Initializes hidden layers, based on defined number of layers.\"\"\"\n\n # Create hidden layers with one neuron with random activation function each.\n hidden_layers = [[create_neuron(None, neural_network.bias)] for i in range(self.layers - 1)]\n # Add final hidden layer with one neuron with tanh activation function.\n hidden_layers.append([create_neuron('tanh', neural_network.bias)])\n # Returns hidden layers.\n return hidden_layers\n\n def _initialize_topology(self):\n \"\"\"Initializes topology.\"\"\"\n\n # Create sensors.\n sensors = self._initialize_sensors()\n # Create neural network.\n neural_network = NeuralNetwork(sensors, None, None, None)\n # Create bias.\n neural_network.bias = self._initialize_bias(neural_network)\n # Return neural network.\n return neural_network\n\n def _initialize_neural_network(self, topology):\n \"\"\"Creates neural network from initial topology.\"\"\"\n\n # Create shallow copy of topology.\n neural_network = copy(topology)\n # Create output neuron.\n neural_network.output_neuron = create_neuron('identity', None)\n # Create hidden layer.\n neural_network.hidden_layers = self._initialize_hidden_layers(neural_network)\n # Establish connections\n self._connect_nodes(neural_network.sensors, neural_network.hidden_layers[0], random=True)\n previous_neurons = neural_network.hidden_layers[0]\n for hidden_layer in neural_network.hidden_layers[1:]:\n self._connect_nodes(previous_neurons, hidden_layer, random=False)\n previous_neurons = hidden_layer\n # Calculate hidden neurons.\n for layer in neural_network.hidden_layers:\n for neuron in layer:\n neuron.calculate()\n # Connect last neuron to output neuron with learning step.\n self._connect_learning_step(neural_network)\n # Calculate output semantics.\n neural_network.output_neuron.calculate()\n # Return neural network.\n return neural_network\n\n def _initialize_solution(self, topology):\n \"\"\"Creates solution for initial population.\"\"\"\n\n # Initialize neural network.\n neural_network = self._initialize_neural_network(topology)\n # Create solution.\n solution = self._create_solution(neural_network)\n # Return solution.\n return solution\n\n def _initialize_population(self):\n \"\"\"Initializes population in first generation.\"\"\"\n\n # Initializes neural network topology.\n topology = self._initialize_topology()\n # Create initial population from topology.\n for i in range(self.population_size):\n solution = self._initialize_solution(topology)\n if not self.next_champion:\n self.next_champion = solution\n elif self._is_better_solution(solution, self.next_champion):\n self.next_champion.neural_network = None\n self.next_champion = solution\n else:\n solution.neural_network = None\n self.population.append(solution)\n\n def _mutate_network(self):\n \"\"\"Creates mutated offspring from champion neural network.\"\"\"\n\n # Create shallow copy of champion neural network.\n neural_network = copy(self.champion.neural_network)\n # Create mutated hidden layers.\n mutation_layers = self.mutation_operator.mutate_network(self)\n # Connect hidden neurons to remainder of network.\n self._connect_nodes_mutation(mutation_layers)\n # Calculate mutated hidden layer.\n for mutation_layer in mutation_layers:\n for neuron in mutation_layer:\n neuron.calculate()\n # Extend hidden layers.\n for hidden_layer, mutation_layers in zip(neural_network.hidden_layers, mutation_layers):\n hidden_layer.extend(mutation_layers)\n # Connect final hidden neuron to output neuron.\n self._connect_learning_step(neural_network)\n # Get most recent connection.\n connection = neural_network.output_neuron.input_connections[-1]\n # Update semantics of output neuron.\n neural_network.output_neuron.semantics += connection.from_node.semantics * connection.weight\n # Return neural network.\n return neural_network\n\n def _mutate_solution(self):\n \"\"\"Applies mutation operator to current champion solution.\"\"\"\n\n # Created mutated offspring of champion neural network.\n neural_network = self._mutate_network()\n # Create solution.\n solution = self._create_solution(neural_network)\n # Return solution.\n return solution\n\n def _mutate_population(self):\n \"\"\"\"\"\"\n for i in range(self.population_size):\n solution = self._mutate_solution()\n if not self.next_champion:\n if self._is_better_solution(solution, self.champion):\n self.next_champion = solution\n else:\n solution.neural_network = None\n elif self._is_better_solution(solution, self.next_champion):\n self.next_champion.neural_network = None\n self.next_champion = solution\n else:\n solution.neural_network = None\n self.population.append(solution)\n\n def _wipe_population(self):\n self.population = list()\n\n def _override_current_champion(self):\n if self.next_champion:\n self.champion = self.next_champion\n self.next_champion = None\n\n def _epoch(self):\n if self.current_generation == 0:\n self._initialize_population()\n else:\n self._mutate_population()\n stopping_criterion = self.stopping_criterion.evaluate(self)\n self._override_current_champion()\n self._wipe_population()\n return stopping_criterion\n\n def fit(self, input_matrix, target_vector, metric, verbose=False):\n super().fit(input_matrix, target_vector, metric, verbose)\n self.champion.neural_network = deepcopy(self.champion.neural_network)\n\n def predict(self, input_matrix):\n neural_network = self.champion.neural_network\n neural_network.load_sensors(input_matrix)\n neural_network.calculate()\n return neural_network.get_predictions()\n"
] |
[
[
"numpy.matrix",
"numpy.array",
"numpy.shape"
]
] |
Chizuchizu/riadd
|
[
"c3f55aebc0f582d9fa55dc517b1489963cf0506f"
] |
[
"src/loss.py"
] |
[
"import torch\nfrom torch import nn\n\n\nclass BCEFocalLoss(nn.Module):\n\n def __init__(self, gamma=2, alpha=None, reduction='elementwise_mean'):\n super().__init__()\n self.gamma = gamma\n self.alpha = alpha\n self.reduction = reduction\n\n def forward(self, _input, target):\n pt = torch.sigmoid(_input)\n loss = - (1 - pt) ** self.gamma * target * torch.log(pt) - \\\n pt ** self.gamma * (1 - target) * torch.log(1 - pt)\n if self.alpha:\n loss = loss * self.alpha\n if self.reduction == 'elementwise_mean':\n loss = torch.mean(loss)\n elif self.reduction == 'sum':\n loss = torch.sum(loss)\n return loss\n\n\n# Code taken from https://github.com/fhopfmueller/bi-tempered-loss-pytorch/blob/master/bi_tempered_loss_pytorch.py\n\ndef log_t(u, t):\n \"\"\"Compute log_t for `u'.\"\"\"\n if t == 1.0:\n return u.log()\n else:\n return (u.pow(1.0 - t) - 1.0) / (1.0 - t)\n\n\ndef exp_t(u, t):\n \"\"\"Compute exp_t for `u'.\"\"\"\n if t == 1:\n return u.exp()\n else:\n return (1.0 + (1.0 - t) * u).relu().pow(1.0 / (1.0 - t))\n\n\ndef compute_normalization_fixed_point(activations, t, num_iters):\n \"\"\"Returns the normalization value for each example (t > 1.0).\n Args:\n activations: A multi-dimensional tensor with last dimension `num_classes`.\n t: Temperature 2 (> 1.0 for tail heaviness).\n num_iters: Number of iterations to run the method.\n Return: A tensor of same shape as activation with the last dimension being 1.\n \"\"\"\n mu, _ = torch.max(activations, -1, keepdim=True)\n normalized_activations_step_0 = activations - mu\n\n normalized_activations = normalized_activations_step_0\n\n for _ in range(num_iters):\n logt_partition = torch.sum(\n exp_t(normalized_activations, t), -1, keepdim=True)\n normalized_activations = normalized_activations_step_0 * \\\n logt_partition.pow(1.0 - t)\n\n logt_partition = torch.sum(\n exp_t(normalized_activations, t), -1, keepdim=True)\n normalization_constants = - log_t(1.0 / logt_partition, t) + mu\n\n return normalization_constants\n\n\ndef compute_normalization_binary_search(activations, t, num_iters):\n \"\"\"Returns the normalization value for each example (t < 1.0).\n Args:\n activations: A multi-dimensional tensor with last dimension `num_classes`.\n t: Temperature 2 (< 1.0 for finite support).\n num_iters: Number of iterations to run the method.\n Return: A tensor of same rank as activation with the last dimension being 1.\n \"\"\"\n\n mu, _ = torch.max(activations, -1, keepdim=True)\n normalized_activations = activations - mu\n\n effective_dim = \\\n torch.sum(\n (normalized_activations > -1.0 / (1.0 - t)).to(torch.int32),\n dim=-1, keepdim=True).to(activations.dtype)\n\n shape_partition = activations.shape[:-1] + (1,)\n lower = torch.zeros(shape_partition, dtype=activations.dtype, device=activations.device)\n upper = -log_t(1.0 / effective_dim, t) * torch.ones_like(lower)\n\n for _ in range(num_iters):\n logt_partition = (upper + lower) / 2.0\n sum_probs = torch.sum(\n exp_t(normalized_activations - logt_partition, t),\n dim=-1, keepdim=True)\n update = (sum_probs < 1.0).to(activations.dtype)\n lower = torch.reshape(\n lower * update + (1.0 - update) * logt_partition,\n shape_partition)\n upper = torch.reshape(\n upper * (1.0 - update) + update * logt_partition,\n shape_partition)\n\n logt_partition = (upper + lower) / 2.0\n return logt_partition + mu\n\n\nclass ComputeNormalization(torch.autograd.Function):\n \"\"\"\n Class implementing custom backward pass for compute_normalization. See compute_normalization.\n \"\"\"\n\n @staticmethod\n def forward(ctx, activations, t, num_iters):\n if t < 1.0:\n normalization_constants = compute_normalization_binary_search(activations, t, num_iters)\n else:\n normalization_constants = compute_normalization_fixed_point(activations, t, num_iters)\n\n ctx.save_for_backward(activations, normalization_constants)\n ctx.t = t\n return normalization_constants\n\n @staticmethod\n def backward(ctx, grad_output):\n activations, normalization_constants = ctx.saved_tensors\n t = ctx.t\n normalized_activations = activations - normalization_constants\n probabilities = exp_t(normalized_activations, t)\n escorts = probabilities.pow(t)\n escorts = escorts / escorts.sum(dim=-1, keepdim=True)\n grad_input = escorts * grad_output\n\n return grad_input, None, None\n\n\ndef compute_normalization(activations, t, num_iters=5):\n \"\"\"Returns the normalization value for each example.\n Backward pass is implemented.\n Args:\n activations: A multi-dimensional tensor with last dimension `num_classes`.\n t: Temperature 2 (> 1.0 for tail heaviness, < 1.0 for finite support).\n num_iters: Number of iterations to run the method.\n Return: A tensor of same rank as activation with the last dimension being 1.\n \"\"\"\n return ComputeNormalization.apply(activations, t, num_iters)\n\n\ndef tempered_sigmoid(activations, t, num_iters=5):\n \"\"\"Tempered sigmoid function.\n Args:\n activations: Activations for the positive class for binary classification.\n t: Temperature tensor > 0.0.\n num_iters: Number of iterations to run the method.\n Returns:\n A probabilities tensor.\n \"\"\"\n internal_activations = torch.stack([activations,\n torch.zeros_like(activations)],\n dim=-1)\n internal_probabilities = tempered_softmax(internal_activations, t, num_iters)\n return internal_probabilities[..., 0]\n\n\ndef tempered_softmax(activations, t, num_iters=5):\n \"\"\"Tempered softmax function.\n Args:\n activations: A multi-dimensional tensor with last dimension `num_classes`.\n t: Temperature > 1.0.\n num_iters: Number of iterations to run the method.\n Returns:\n A probabilities tensor.\n \"\"\"\n if t == 1.0:\n return activations.softmax(dim=-1)\n\n normalization_constants = compute_normalization(activations, t, num_iters)\n return exp_t(activations - normalization_constants, t)\n\n\n# def bi_tempered_binary_logistic_loss(activations,\n# labels,\n# t1,\n# t2,\n# label_smoothing=0.0,\n# num_iters=5,\n# reduction='mean'):\n# \"\"\"Bi-Tempered binary logistic loss.\n# Args:\n# activations: A tensor containing activations for class 1.\n# labels: A tensor with shape as activations, containing probabilities for class 1\n# t1: Temperature 1 (< 1.0 for boundedness).\n# t2: Temperature 2 (> 1.0 for tail heaviness, < 1.0 for finite support).\n# label_smoothing: Label smoothing\n# num_iters: Number of iterations to run the method.\n# Returns:\n# A loss tensor.\n# \"\"\"\n# internal_activations = torch.stack([activations,\n# torch.zeros_like(activations)],\n# dim=-1)\n# internal_labels = torch.stack([labels.to(activations.dtype),\n# 1.0 - labels.to(activations.dtype)],\n# dim=-1)\n# return bi_tempered_logistic_loss(internal_activations,\n# internal_labels,\n# t1,\n# t2,\n# label_smoothing=label_smoothing,\n# num_iters=num_iters,\n# reduction=reduction)\n\nclass BiT(nn.Module):\n def __init__(self, t1, t2, label_smoothing=0, num_iters=5, reduction=\"mean\"):\n super().__init__()\n\n self.t1 = t1\n self.t2 = t2\n self.label_smoothing = label_smoothing\n self.num_iters = num_iters\n self.reduction = reduction\n\n def forward(self, activations,\n labels):\n \"\"\"Bi-Tempered Logistic Loss.\n Args:\n activations: A multi-dimensional tensor with last dimension `num_classes`.\n labels: A tensor with shape and dtype as activations (onehot),\n or a long tensor of one dimension less than activations (pytorch standard)\n t1: Temperature 1 (< 1.0 for boundedness).\n t2: Temperature 2 (> 1.0 for tail heaviness, < 1.0 for finite support).\n label_smoothing: Label smoothing parameter between [0, 1). Default 0.0.\n num_iters: Number of iterations to run the method. Default 5.\n reduction: ``'none'`` | ``'mean'`` | ``'sum'``. Default ``'mean'``.\n ``'none'``: No reduction is applied, return shape is shape of\n activations without the last dimension.\n ``'mean'``: Loss is averaged over minibatch. Return shape (1,)\n ``'sum'``: Loss is summed over minibatch. Return shape (1,)\n Returns:\n A loss tensor.\n \"\"\"\n\n activations = torch.sigmoid(activations)\n\n if len(labels.shape) < len(activations.shape): # not one-hot\n labels_onehot = torch.zeros_like(activations)\n labels_onehot.scatter_(1, labels[..., None], 1)\n else:\n labels_onehot = labels\n\n if self.label_smoothing > 0:\n num_classes = labels_onehot.shape[-1]\n labels_onehot = (1 - self.label_smoothing * num_classes / (num_classes - 1)) \\\n * labels_onehot + \\\n self.label_smoothing / (num_classes - 1)\n\n probabilities = tempered_softmax(activations, self.t2, self.num_iters)\n\n loss_values = labels_onehot * log_t(labels_onehot + 1e-10, self.t1) \\\n - labels_onehot * log_t(probabilities, self.t1) \\\n - labels_onehot.pow(2.0 - self.t1) / (2.0 - self.t1) \\\n + probabilities.pow(2.0 - self.t1) / (2.0 - self.t1)\n loss_values = loss_values.sum(dim=-1) # sum over classes\n\n if self.reduction == 'none':\n return loss_values\n if self.reduction == 'sum':\n return loss_values.sum()\n if self.reduction == 'mean':\n return loss_values.mean()\n\n\nclass TaylorSoftmax(nn.Module):\n '''\n This is the autograd version\n '''\n\n def __init__(self, dim=1, n=2):\n super(TaylorSoftmax, self).__init__()\n assert n % 2 == 0\n self.dim = dim\n self.n = n\n\n def forward(self, x):\n '''\n usage similar to nn.Softmax:\n >>> mod = TaylorSoftmax(dim=1, n=4)\n >>> inten = torch.randn(1, 32, 64, 64)\n >>> out = mod(inten)\n '''\n fn = torch.ones_like(x)\n denor = 1.\n for i in range(1, self.n + 1):\n denor *= i\n fn = fn + x.pow(i) / denor\n out = fn / fn.sum(dim=self.dim, keepdims=True)\n return out\n\n\nclass LabelSmoothingLoss(nn.Module):\n def __init__(self, classes=5, smoothing=0.0, dim=-1):\n super(LabelSmoothingLoss, self).__init__()\n self.confidence = 1.0 - smoothing\n self.smoothing = smoothing\n self.cls = classes\n self.dim = dim\n\n def forward(self, pred, target):\n pred = pred.log_softmax(dim=self.dim)\n with torch.no_grad():\n true_dist = torch.zeros_like(pred)\n true_dist.fill_(self.\n smoothing / (self.cls - 1))\n true_dist.scatter_(1, target.data, self.confidence)\n return torch.mean(torch.sum(-true_dist * pred, dim=self.dim))\n\n\nclass TaylorCrossEntropyLoss(nn.Module):\n def __init__(self, target_size, n=2, ignore_index=-1, reduction='mean', smoothing=0.05):\n super(TaylorCrossEntropyLoss, self).__init__()\n assert n % 2 == 0\n self.taylor_softmax = TaylorSoftmax(dim=1, n=n)\n self.reduction = reduction\n self.ignore_index = ignore_index\n self.lab_smooth = LabelSmoothingLoss(target_size, smoothing=smoothing)\n\n def forward(self, logits, labels):\n logits = torch.sigmoid(logits)\n log_probs = self.taylor_softmax(logits).log()\n # loss = F.nll_loss(log_probs, labels, reduction=self.reduction,\n # ignore_index=self.ignore_index)\n loss = self.lab_smooth(log_probs, labels.long())\n return loss\n\n\n__CRITERIONS__ = {\n \"BCEFocalLoss\": BCEFocalLoss,\n \"BiT\": BiT,\n \"TaylorCrossEntropyLoss\": TaylorCrossEntropyLoss\n}\n\n\ndef get_criterion(cfg):\n if hasattr(nn, cfg.loss.name):\n return getattr(nn, cfg.loss.name)(**cfg.loss.param)\n elif __CRITERIONS__.get(cfg.loss.name) is not None:\n return __CRITERIONS__[cfg.loss.name](**cfg.loss.param)\n else:\n raise NotImplementedError\n"
] |
[
[
"torch.mean",
"torch.sigmoid",
"torch.max",
"torch.zeros",
"torch.reshape",
"torch.zeros_like",
"torch.sum",
"torch.no_grad",
"torch.log",
"torch.ones_like"
]
] |
kuadrat/data-slicer
|
[
"1634929569491579b7fe7ed5d928da790f552337"
] |
[
"data_slicer/cmaps.py"
] |
[
"\"\"\"\nConvert some of the nicer matplotlib and kustom colormaps to pyqtgraph \ncolormaps.\n\"\"\"\nimport copy\nimport logging\nimport os\nimport pathlib\nimport pickle\nimport pkg_resources\nimport warnings\n\nimport numpy as np\nfrom matplotlib import cm\nfrom matplotlib.colors import LinearSegmentedColormap\nfrom matplotlib.pyplot import colormaps\nfrom pyqtgraph import ColorMap\n\nfrom data_slicer.utilities import CACHED_CMAPS_FILENAME, CONFIG_DIR\n\nlogger = logging.getLogger('ds.'+__name__)\n\nclass ds_cmap(ColorMap) :\n \"\"\" Simple subclass of :class:`pyqtgraph.ColorMap`. Adds vmax, \n powerlaw normalization and a convenience function to change alpha.\n \"\"\"\n def __init__(self, pos, color, gamma=1, **kwargs) :\n super().__init__(pos, color, **kwargs)\n\n # Initialize instance variables\n self.alpha = 0.5\n self.vmax = 1\n self.gamma = 1\n\n # Retain a copy of the originally given positions\n self.original_pos = self.pos.copy()\n # Apply the powerlaw-norm\n self.set_gamma(gamma)\n\n def apply_transformations(self) :\n \"\"\" Recalculate the positions where the colormapping is defined by \n applying (in sequence) alpha, then a linear map to the range \n [0, vmax] and finally the powerlaw scaling: ``pos' = pos**gamma``.\n \"\"\"\n # Reset the cache in pyqtgraph.Colormap\n self.stopsCache = dict()\n\n # Apply alpha\n self.color[:,-1] = 255*self.alpha\n\n # Linearly transform color values to the new range\n old_max = self.original_pos.max()\n old_min = self.original_pos.min()\n new_max = old_max * self.vmax\n m = (new_max - old_min) / (old_max - old_min)\n self.pos = m * (self.original_pos - old_max) + new_max\n\n # Apply a powerlaw norm to the positions\n self.pos = self.pos**(1/self.gamma)\n\n def set_gamma(self, gamma=1) :\n \"\"\" Set the exponent for the power-law norm that maps the colors to \n values. I.e. the values where the colours are defined are mapped like \n ``y=x**gamma``.\n \"\"\"\n self.gamma = gamma\n self.apply_transformations()\n\n def set_alpha(self, alpha) :\n \"\"\" Set the value of alpha for the whole colormap to *alpha* where \n *alpha* can be a float or an array of length ``len(self.color)``.\n \"\"\"\n self.alpha = alpha\n self.apply_transformations()\n\n def set_vmax(self, vmax=1) :\n \"\"\" Set the relative (to the maximum of the data) maximum of the \n colorscale. \n \"\"\"\n self.vmax = vmax\n self.apply_transformations()\n\ndef convert_matplotlib_to_pyqtgraph(matplotlib_cmap, alpha=1) :\n \"\"\" Take a matplotlib colormap and convert it to a pyqtgraph ColorMap.\n\n **Parameters**\n\n =============== ===========================================================\n matplotlib_cmap either a str representing the name of a matplotlib \n colormap or a \n :class:`<matplotlib.colors.LinearSegmentedColormap>` or \n :class:`<matplotlib.colors.ListedColormap>` instance.\n alpha float or array of same length as there are defined \n colors in the matplotlib cmap; the alpha (transparency) \n value to be assigned to the whole cmap. matplotlib cmaps \n default to 1.\n =============== ===========================================================\n\n **Returns**\n\n =============== ===========================================================\n pyqtgraph_cmap :class:`pyqtgraph.ColorMap`\n =============== ===========================================================\n \"\"\"\n # Get the colormap object if a colormap name is given \n if isinstance(matplotlib_cmap, str) :\n matplotlib_cmap = cm.get_cmap(matplotlib_cmap)\n # Number of entries in the matplotlib colormap\n N = matplotlib_cmap.N\n # Create the mapping values in the interval [0, 1]\n values = np.linspace(0, 1, N)\n # Extract RGBA values from the matplotlib cmap\n indices = np.arange(N)\n rgba = matplotlib_cmap(indices)\n # Apply alpha\n rgba[:,-1] = alpha\n # Convert to range 0-255\n rgba *= 255\n\n return ds_cmap(values, rgba)\n\ndef convert_ds_to_matplotlib(data_slicer_cmap, cmap_name='converted_cmap') :\n \"\"\" Create a matplotlib colormap from a :class:`ds_cmap \n <data_slicer.cmaps.ds_cmap>` instance.\n\n **Parameters**\n\n ================ ==========================================================\n data_slicer_cmap :class:`ds_cmap <data_slicer.cmaps.ds_cmap>`\n cmap_name str; optional name for the created cmap.\n ================ ==========================================================\n\n **Returns**\n\n =============== ===========================================================\n matplotlib_cmap :class:`<matplotlib.colors.LinearSegmentedColormap>`\n =============== ===========================================================\n \"\"\"\n # Reset the transformations - matplotlib can take care of them itself\n data_slicer_cmap.set_gamma(1)\n data_slicer_cmap.set_vmax(1)\n # Convert the colors from the range [0-255] to [0-1]\n colors = data_slicer_cmap.color / 255\n N = len(colors)\n # Create the matplotlib colormap\n matplotlib_cmap = LinearSegmentedColormap.from_list(cmap_name,\n colors, N)\n return matplotlib_cmap\n\ndef load_custom_cmap(filename) :\n \"\"\" Create a :class:`ds_cmap <data_slicer.cmaps.ds_cmap>` instance from \n data stored in a file with three columns, red, green and blue - either in \n integer form from 0-255 or as floats from 0.0 to 1.0 (ignores fourth \n alpha column).\n The suffix can be left out in the file name.\n Also, an `_r` can be appended to the colormap name to indicate that the \n inverse of a cmap is requested (e.g. my_cmap_r will give the reverse of \n my_cmap).\n \"\"\"\n # Split off suffix\n full_basename, suffix = os.path.splitext(filename)\n path, basename = os.path.split(full_basename)\n # Split off '_r' ending, if found\n if basename.endswith('_r') :\n reverse = True\n basename = basename[:-2]\n else :\n reverse = False\n # If no suffix was given, look for a file that matches\n if suffix == '' :\n # Split path and filename\n files = os.listdir(path)\n for f in files :\n if f.startswith(basename) :\n actual_filename = path + '/' + f\n break\n else :\n actual_filename = path + '/' + basename + suffix\n logger.debug(f'Trying to load cmap {actual_filename}.')\n data = np.loadtxt(actual_filename)[:,:3]\n # Invert cmap, if required\n if reverse :\n data = data[::-1]\n data /= data.max() \n # Convert to range [0-255] for pyqtgraph 0.0.11\n data *= 255\n N = len(data)\n # Append a column of 1's\n cmap = np.hstack([data, np.ones(N).reshape((N, 1))])\n pos = np.linspace(0, 1, N)\n return ds_cmap(pos, cmap)\n\n# Load the cmaps dictionary (this is broken)\ndata_path = pkg_resources.resource_filename('data_slicer', 'data/')\n\ndef load_cmap(cmap_name) :\n \"\"\" Return a ds_cmap object for the colormap specified by *cmap_name*.\n *cmap_name* can be either\n \n 1. one of the matplotlib colormap names\n\n 2. one of the colormap names supplied by the data slicer package. At \n the time of this writing, these are `rainbow_light`, `neutrons` and \n `kocean`. This list is not regularly updated. Check the .cmap files \n in the data/ directory of the installation (loacation depends on \n your system) to find out all options.\n\n 3. any file found in the cmaps/ subdirectory of your config directory \n (check documentation).\n \"\"\"\n # Try to convert a matplotlib cmap\n try :\n return convert_matplotlib_to_pyqtgraph(cmap_name)\n except ValueError as e :\n # Store the error for later\n matplotlib_error = e\n\n logger.debug(f'Did not find {cmap_name} in MPL cmaps.')\n\n # If that didn't work, try converting a package cmap\n try :\n logger.debug(data_path + cmap_name)\n return load_custom_cmap(data_path + cmap_name)\n # numpy.loadtxt raises OSError\n except OSError :\n logger.debug(f'Did not find {cmap_name} in package cmaps.')\n\n # Finally, try to load a cmap from the config dir\n config_path = pathlib.Path.home() / CONFIG_DIR / 'cmaps/'\n try :\n logger.debug(config_path / cmap_name)\n return load_custom_cmap(config_path / cmap_name)\n # numpy.loadtxt raises OSError\n except OSError :\n # Re-raise the matplotlib error which shows a list of valid \n # matplotlib cmap names.\n logger.debug(f'Did not find {cmap_name} in user cmaps.')\n raise ValueError(matplotlib_error)\n\n# Add user supplied colormaps\ndef load_user_cmaps(cmaps) :\n \"\"\" Append user supplied colormaps to the dictionary *cmaps*. \"\"\"\n config_path = pathlib.Path.home() / CONFIG_DIR / 'cmaps/'\n try :\n files = os.listdir(config_path)\n except FileNotFoundError :\n files = []\n\n for cmap in files :\n name, suffix = cmap.split('.')\n # Only load files with the .cmap suffix\n if suffix != 'cmap' :\n continue\n cmap_object = load_custom_cmap(config_path / cmap)\n cmaps.update({name: cmap_object})\n # Also add the inverse cmap\n inverse = ds_cmap(cmap_object.pos, cmap_object.color[::-1])\n cmaps.update({name + '_r': inverse})\n\n# +-------------------+ #\n# | Prepare colormaps | # ======================================================\n# +-------------------+ #\n\nif __name__ == '__main__' :\n # Caching colormaps is no longer necessary, but kept for the time being.\n from datetime import datetime\n print('Caching colormaps...')\n n = datetime.now\n\n cmaps = dict()\n # Convert all matplotlib colormaps to pyqtgraph ones and make them available \n # in the dict cmaps\n start = n()\n for name in colormaps() :\n cmap = cm.get_cmap(name)\n cmaps.update({name: convert_matplotlib_to_pyqtgraph(cmap)})\n print('mpl: ', n()-start)\n\n # Add additional colormaps from package\n data_path = pkg_resources.resource_filename('data_slicer', 'data/')\n try :\n datafiles = os.listdir(data_path)\n except FileNotFoundError :\n warnings.warn('Package colormaps were not found.')\n datafiles = []\n\n for cmap in datafiles :\n name, suffix = cmap.split('.')\n # Only load files with the .cmap suffix\n if suffix != 'cmap' :\n continue\n cmap_object = load_custom_cmap(data_path + cmap)\n cmaps.update({name: cmap_object})\n # Also add the inverse cmap\n inverse = ds_cmap(cmap_object.pos, cmap_object.color[::-1])\n cmaps.update({name + '_r': inverse})\n print('data/: ', n()-start)\n\n # Store the cmaps dict\n with open(data_path + CACHED_CMAPS_FILENAME, 'wb') as f :\n pickle.dump(cmaps, f)\n\n"
] |
[
[
"numpy.linspace",
"numpy.arange",
"matplotlib.pyplot.colormaps",
"numpy.ones",
"matplotlib.cm.get_cmap",
"matplotlib.colors.LinearSegmentedColormap.from_list",
"numpy.loadtxt"
]
] |
alejoe91/python-neo
|
[
"7695048371b15b57beaf546b9982f19856c658ea"
] |
[
"neo/io/nsdfio.py"
] |
[
"\"\"\"\nModule for reading and writing NSDF files\n\nAuthor: Mieszko Grodzicki\n\nThis module support both reading and writing NDSF files.\nNote: Read file must be written using this IO\n\"\"\"\n\n\nimport numpy as np\nimport quantities as pq\n\nfrom uuid import uuid1\nimport pickle\nfrom datetime import datetime\nimport os\n\ntry:\n import nsdf\nexcept ImportError as err:\n HAVE_NSDF = False\n NSDF_ERR = err\nelse:\n HAVE_NSDF = True\n NSDF_ERR = None\n\nfrom neo.io.baseio import BaseIO\nfrom neo.core import Block, Segment, AnalogSignal, ChannelIndex\n\n\nclass NSDFIO(BaseIO):\n \"\"\"\n Class for reading and writing files in NSDF Format.\n\n It supports reading and writing: Block, Segment, AnalogSignal, ChannelIndex, with all relationships and metadata.\n \"\"\"\n is_readable = True\n is_writable = False # True - disabled pending update to Neo 0.9 API\n\n supported_objects = [Block, Segment, AnalogSignal, ChannelIndex]\n\n readable_objects = [Block, Segment]\n writeable_objects = [] # [Block, Segment] - disabled pending update to Neo 0.9 API\n\n has_header = False\n is_streameable = False\n\n name = 'NSDF'\n extensions = ['h5']\n mode = 'file'\n\n def __init__(self, filename=None):\n \"\"\"\n Initialise NSDFIO instance\n\n :param filename: Path to the file\n \"\"\"\n if not HAVE_NSDF:\n raise Exception(\"Failed to import NSDF.\")\n\n if filename is None:\n raise ValueError(\"Must provide an input file.\")\n\n BaseIO.__init__(self)\n\n self.filename = filename\n self.dt_format = '%d/%m/%Y %H:%M:%S'\n self.modeltree_path = '/model/modeltree/neo/'\n\n def write_all_blocks(self, blocks):\n \"\"\"\n Write list of blocks to the file\n\n :param blocks: List of blocks to be written\n \"\"\"\n raise NotImplementedError(\"Implementation not yet updated for Neo 0.9\")\n writer = self._init_writing()\n neo_model, blocks_model, segments_model = self._prepare_model_tree(writer)\n\n name_pattern = self._name_pattern(len(blocks))\n for i, block in enumerate(blocks):\n self.write_block(block, name_pattern.format(i), writer, blocks_model)\n\n def write_block(self, block=None, name='0', writer=None, parent=None):\n \"\"\"\n Write a Block to the file\n\n :param block: Block to be written\n :param name: Name for block representation in NSDF model tree (optional)\n :param writer: NSDFWriter instance (optional)\n :param parent: NSDF ModelComponent which will be the parent of block NSDF representation (optional)\n \"\"\"\n raise NotImplementedError(\"Implementation not yet updated for Neo 0.9\")\n if not isinstance(block, Block):\n raise ValueError(\"Must provide a Block to write.\")\n\n if writer is None:\n writer = self._init_writing()\n\n if parent is None:\n neo_model, parent, segments_model = self._prepare_model_tree(writer)\n\n block_model = nsdf.ModelComponent(name, uid=uuid1().hex, parent=parent)\n self._write_container_metadata(block, block_model)\n self._write_model_component(block_model, writer)\n\n self._write_block_children(block, block_model, writer)\n\n self._clean_nsdfio_annotations(block)\n\n def _write_block_children(self, block, block_model, writer):\n segments_model = nsdf.ModelComponent(name='segments', uid=uuid1().hex, parent=block_model)\n self._write_model_component(segments_model, writer)\n name_pattern = self._name_pattern(len(block.segments))\n for i, segment in enumerate(block.segments):\n self.write_segment(segment=segment, name=name_pattern.format(i),\n writer=writer, parent=segments_model)\n\n channel_indexes_model = nsdf.ModelComponent(\n name='channel_indexes', uid=uuid1().hex, parent=block_model)\n self._write_model_component(channel_indexes_model, writer)\n name_pattern = self._name_pattern(len(block.channel_indexes))\n for i, channelindex in enumerate(block.channel_indexes):\n self.write_channelindex(channelindex=channelindex, name=name_pattern.format(i),\n writer=writer, parent=channel_indexes_model)\n\n def write_segment(self, segment=None, name='0', writer=None, parent=None):\n \"\"\"\n Write a Segment to the file\n\n :param segment: Segment to be written\n :param name: Name for segment representation in NSDF model tree (optional)\n :param writer: NSDFWriter instance (optional)\n :param parent: NSDF ModelComponent which will be the parent of segment NSDF representation (optional)\n \"\"\"\n raise NotImplementedError(\"Implementation not yet updated for Neo 0.9\")\n if not isinstance(segment, Segment):\n raise ValueError(\"Must provide a Segment to write.\")\n\n if writer is None:\n writer = self._init_writing()\n\n single_segment = False\n if parent is None:\n neo_model, blocks_model, parent = self._prepare_model_tree(writer)\n single_segment = True\n\n model = nsdf.ModelComponent(name, uid=uuid1().hex, parent=parent)\n self._write_container_metadata(segment, model)\n self._write_model_component(model, writer)\n\n self._write_segment_children(model, segment, writer)\n\n if single_segment:\n self._clean_nsdfio_annotations(segment)\n\n def _write_segment_children(self, model, segment, writer):\n analogsignals_model = nsdf.ModelComponent(\n name='analogsignals', uid=uuid1().hex, parent=model)\n self._write_model_component(analogsignals_model, writer)\n name_pattern = self._name_pattern(len(segment.analogsignals))\n for i, signal in enumerate(segment.analogsignals):\n self.write_analogsignal(signal=signal, name=name_pattern.format(i),\n parent=analogsignals_model, writer=writer)\n\n def write_analogsignal(self, signal, name, writer, parent):\n \"\"\"\n Write an AnalogSignal to the file\n\n :param signal: AnalogSignal to be written\n :param name: Name for signal representation in NSDF model tree\n :param writer: NSDFWriter instance\n :param parent: NSDF ModelComponent which will be the parent of signal NSDF representation\n \"\"\"\n raise NotImplementedError(\"Implementation not yet updated for Neo 0.9\")\n uid = uuid1().hex\n model = nsdf.ModelComponent(name, uid=uid, parent=parent)\n\n if signal.annotations.get('nsdfio_uid') is not None:\n model.attrs['reference_to'] = signal.annotations['nsdfio_uid']\n self._write_model_component(model, writer)\n return\n\n self._write_basic_metadata(model, signal)\n signal.annotations['nsdfio_uid'] = uid\n\n r_signal = np.swapaxes(signal, 0, 1)\n channels_model, channels, source_ds = self._create_signal_data_sources(\n model, r_signal, uid, writer)\n self._write_signal_data(model, channels, r_signal, signal, source_ds, writer)\n\n self._write_model_component(model, writer)\n self._write_model_component(channels_model, writer)\n for channel_model in channels:\n self._write_model_component(channel_model, writer)\n\n def write_channelindex(self, channelindex, name, writer, parent):\n \"\"\"\n Write a ChannelIndex to the file\n\n :param channelindex: ChannelIndex to be written\n :param name: Name for channelindex representation in NSDF model tree\n :param writer: NSDFWriter instance\n :param parent: NSDF ModelComponent which will be the parent of channelindex NSDF representation\n \"\"\"\n raise NotImplementedError(\"Implementation not yet updated for Neo 0.9\")\n uid = uuid1().hex\n model = nsdf.ModelComponent(name, uid=uid, parent=parent)\n\n self._write_basic_metadata(model, channelindex)\n self._write_model_component(model, writer)\n\n self._write_channelindex_arrays(model, channelindex, writer)\n\n self._write_channelindex_children(channelindex, model, writer)\n\n def _write_channelindex_children(self, channelindex, model, writer):\n analogsignals_model = nsdf.ModelComponent(\n name='analogsignals', uid=uuid1().hex, parent=model)\n self._write_model_component(analogsignals_model, writer)\n name_pattern = self._name_pattern(len(channelindex.analogsignals))\n for i, signal in enumerate(channelindex.analogsignals):\n self.write_analogsignal(signal=signal, name=name_pattern.format(i),\n parent=analogsignals_model, writer=writer)\n\n def _init_writing(self):\n return nsdf.NSDFWriter(self.filename, mode='w')\n\n def _prepare_model_tree(self, writer):\n neo_model = nsdf.ModelComponent('neo', uid=uuid1().hex)\n self._write_model_component(neo_model, writer)\n\n blocks_model = nsdf.ModelComponent('blocks', uid=uuid1().hex, parent=neo_model)\n self._write_model_component(blocks_model, writer)\n\n segments_model = nsdf.ModelComponent('segments', uid=uuid1().hex, parent=neo_model)\n self._write_model_component(segments_model, writer)\n\n return neo_model, blocks_model, segments_model\n\n def _number_of_digits(self, n):\n return len(str(n))\n\n def _name_pattern(self, how_many_items):\n return '{{:0{}d}}'.format(self._number_of_digits(max(how_many_items - 1, 0)))\n\n def _clean_nsdfio_annotations(self, object):\n nsdfio_annotations = ('nsdfio_uid',)\n\n for key in nsdfio_annotations:\n object.annotations.pop(key, None)\n\n if hasattr(object, 'children'):\n for child in object.children:\n self._clean_nsdfio_annotations(child)\n\n def _write_model_component(self, model, writer):\n if model.parent is None:\n nsdf.add_model_component(model, writer.model['modeltree/'])\n else:\n nsdf.add_model_component(model, model.parent.hdfgroup)\n\n def _write_container_metadata(self, container, container_model):\n self._write_basic_metadata(container_model, container)\n\n self._write_datetime_attributes(container_model, container)\n self._write_index_attribute(container_model, container)\n\n def _write_basic_metadata(self, model, object):\n self._write_basic_attributes(model, object)\n self._write_annotations(model, object)\n\n def _write_basic_attributes(self, model, object):\n if object.name is not None:\n model.attrs['name'] = object.name\n if object.description is not None:\n model.attrs['description'] = object.description\n\n def _write_datetime_attributes(self, model, object):\n if object.rec_datetime is not None:\n model.attrs['rec_datetime'] = object.rec_datetime.strftime(self.dt_format)\n\n def _write_index_attribute(self, model, object):\n if object.index is not None:\n model.attrs['index'] = object.index\n\n def _write_annotations(self, model, object):\n if object.annotations is not None:\n model.attrs['annotations'] = pickle.dumps(object.annotations)\n\n def _write_signal_data(self, model, channels, r_signal, signal, source_ds, writer):\n dataobj = nsdf.UniformData('signal', unit=str(signal.units.dimensionality))\n dataobj.dtype = signal.dtype\n for i in range(len(channels)):\n dataobj.put_data(channels[i].uid, r_signal[i])\n\n dataobj.set_dt(float(signal.sampling_period.magnitude),\n str(signal.sampling_period.dimensionality))\n\n rescaled_tstart = signal.t_start.rescale(signal.sampling_period.dimensionality)\n writer.add_uniform_data(source_ds, dataobj,\n tstart=float(rescaled_tstart.magnitude))\n model.attrs['t_start_unit'] = str(signal.t_start.dimensionality)\n\n def _create_signal_data_sources(self, model, r_signal, uid, writer):\n channels = []\n channels_model = nsdf.ModelComponent(name='channels', uid=uuid1().hex, parent=model)\n name_pattern = '{{:0{}d}}'.format(self._number_of_digits(max(len(r_signal) - 1, 0)))\n for i in range(len(r_signal)):\n channels.append(nsdf.ModelComponent(name_pattern.format(i),\n uid=uuid1().hex,\n parent=channels_model))\n\n source_ds = writer.add_uniform_ds(uid, [channel.uid for channel in channels])\n return channels_model, channels, source_ds\n\n def _write_channelindex_arrays(self, model, channelindex, writer):\n group = model.hdfgroup\n\n self._write_array(group, 'index', channelindex.index)\n if channelindex.channel_names is not None:\n self._write_array(group, 'channel_names', channelindex.channel_names)\n if channelindex.channel_ids is not None:\n self._write_array(group, 'channel_ids', channelindex.channel_ids)\n if channelindex.coordinates is not None:\n self._write_array(group, 'coordinates', channelindex.coordinates)\n\n def _write_array(self, group, name, array):\n if isinstance(array, pq.Quantity):\n group.create_dataset(name, data=array.magnitude)\n group[name].attrs['dimensionality'] = str(array.dimensionality)\n else:\n group.create_dataset(name, data=array)\n\n def read_all_blocks(self, lazy=False):\n \"\"\"\n Read all blocks from the file\n\n :param lazy: Enables lazy reading\n :return: List of read blocks\n \"\"\"\n assert not lazy, 'Do not support lazy'\n\n reader = self._init_reading()\n blocks = []\n\n blocks_path = self.modeltree_path + 'blocks/'\n for block in reader.model[blocks_path].values():\n blocks.append(self.read_block(group=block, reader=reader))\n\n return blocks\n\n def read_block(self, lazy=False, group=None, reader=None):\n \"\"\"\n Read a Block from the file\n\n :param lazy: Enables lazy reading\n :param group: HDF5 Group representing the block in NSDF model tree (optional)\n :param reader: NSDFReader instance (optional)\n :return: Read block\n \"\"\"\n assert not lazy, 'Do not support lazy'\n\n block = Block()\n group, reader = self._select_first_container(group, reader, 'block')\n\n if group is None:\n return None\n\n attrs = group.attrs\n\n self._read_block_children(block, group, reader)\n block.create_many_to_one_relationship()\n\n self._read_container_metadata(attrs, block)\n\n return block\n\n def _read_block_children(self, block, group, reader):\n for child in group['segments/'].values():\n block.segments.append(self.read_segment(group=child, reader=reader))\n for child in group['channel_indexes/'].values():\n block.channel_indexes.append(self.read_channelindex(group=child, reader=reader))\n\n def read_segment(self, lazy=False, group=None, reader=None):\n \"\"\"\n Read a Segment from the file\n\n :param lazy: Enables lazy reading\n :param group: HDF5 Group representing the segment in NSDF model tree (optional)\n :param reader: NSDFReader instance (optional)\n :return: Read segment\n \"\"\"\n assert not lazy, 'Do not support lazy'\n\n segment = Segment()\n group, reader = self._select_first_container(group, reader, 'segment')\n\n if group is None:\n return None\n\n attrs = group.attrs\n\n self._read_segment_children(group, reader, segment)\n\n self._read_container_metadata(attrs, segment)\n\n return segment\n\n def _read_segment_children(self, group, reader, segment):\n for child in group['analogsignals/'].values():\n segment.analogsignals.append(self.read_analogsignal(group=child, reader=reader))\n\n def read_analogsignal(self, lazy=False, group=None, reader=None):\n \"\"\"\n Read an AnalogSignal from the file (must be child of a Segment)\n\n :param lazy: Enables lazy reading\n :param group: HDF5 Group representing the analogsignal in NSDF model tree\n :param reader: NSDFReader instance\n :return: Read AnalogSignal\n \"\"\"\n assert not lazy, 'Do not support lazy'\n\n attrs = group.attrs\n\n if attrs.get('reference_to') is not None:\n return self.objects_dict[attrs['reference_to']]\n\n uid = attrs['uid']\n data_group = reader.data['uniform/{}/signal'.format(uid)]\n\n t_start = self._read_analogsignal_t_start(attrs, data_group)\n signal = self._create_analogsignal(data_group, group, t_start, uid, reader)\n\n self._read_basic_metadata(attrs, signal)\n\n self.objects_dict[uid] = signal\n return signal\n\n def read_channelindex(self, lazy=False, group=None, reader=None):\n \"\"\"\n Read a ChannelIndex from the file (must be child of a Block)\n\n :param lazy: Enables lazy reading\n :param group: HDF5 Group representing the channelindex in NSDF model tree\n :param reader: NSDFReader instance\n :return: Read ChannelIndex\n \"\"\"\n assert not lazy, 'Do not support lazy'\n\n attrs = group.attrs\n\n channelindex = self._create_channelindex(group)\n self._read_channelindex_children(group, reader, channelindex)\n\n self._read_basic_metadata(attrs, channelindex)\n\n return channelindex\n\n def _read_channelindex_children(self, group, reader, channelindex):\n for child in group['analogsignals/'].values():\n channelindex.analogsignals.append(self.read_analogsignal(group=child, reader=reader))\n\n def _init_reading(self):\n reader = nsdf.NSDFReader(self.filename)\n self.file_datetime = datetime.fromtimestamp(os.stat(self.filename).st_mtime)\n self.objects_dict = {}\n return reader\n\n def _select_first_container(self, group, reader, name):\n if reader is None:\n reader = self._init_reading()\n\n if group is None:\n path = self.modeltree_path + name + 's/'\n if len(reader.model[path].values()) > 0:\n group = reader.model[path].values()[0]\n\n return group, reader\n\n def _read_container_metadata(self, attrs, container):\n self._read_basic_metadata(attrs, container)\n\n self._read_datetime_attributes(attrs, container)\n self._read_index_attribute(attrs, container)\n\n def _read_basic_metadata(self, attrs, signal):\n self._read_basic_attributes(attrs, signal)\n self._read_annotations(attrs, signal)\n\n def _read_basic_attributes(self, attrs, object):\n if attrs.get('name') is not None:\n object.name = attrs['name']\n if attrs.get('description') is not None:\n object.description = attrs['description']\n object.file_origin = self.filename\n\n def _read_datetime_attributes(self, attrs, object):\n object.file_datetime = self.file_datetime\n if attrs.get('rec_datetime') is not None:\n object.rec_datetime = datetime.strptime(attrs['rec_datetime'], self.dt_format)\n\n def _read_annotations(self, attrs, object):\n if attrs.get('annotations') is not None:\n object.annotations = pickle.loads(attrs['annotations'])\n\n def _read_index_attribute(self, attrs, object):\n if attrs.get('index') is not None:\n object.index = attrs['index']\n\n def _create_analogsignal(self, data_group, group, t_start, uid, reader):\n # for lazy\n # data_shape = data_group.shape\n # data_shape = (data_shape[1], data_shape[0])\n dataobj = reader.get_uniform_data(uid, 'signal')\n data = self._read_signal_data(dataobj, group)\n signal = self._create_normal_analogsignal(data, dataobj, uid, t_start)\n return signal\n\n def _read_analogsignal_t_start(self, attrs, data_group):\n t_start = float(data_group.attrs['tstart']) * pq.Quantity(1, data_group.attrs['tunit'])\n t_start = t_start.rescale(attrs['t_start_unit'])\n return t_start\n\n def _read_signal_data(self, dataobj, group):\n data = []\n for channel in group['channels/'].values():\n channel_uid = channel.attrs['uid']\n data += [dataobj.get_data(channel_uid)]\n return data\n\n def _create_normal_analogsignal(self, data, dataobj, uid, t_start):\n return AnalogSignal(np.swapaxes(data, 0, 1), dtype=dataobj.dtype, units=dataobj.unit,\n t_start=t_start, sampling_period=pq.Quantity(dataobj.dt, dataobj.tunit))\n\n def _create_channelindex(self, group):\n return ChannelIndex(index=self._read_array(group, 'index'),\n channel_names=self._read_array(group, 'channel_names'),\n channel_ids=self._read_array(group, 'channel_ids'),\n coordinates=self._read_array(group, 'coordinates'))\n\n def _read_array(self, group, name):\n if group.__contains__(name) == False:\n return None\n array = group[name][:]\n\n if group[name].attrs.get('dimensionality') is not None:\n return pq.Quantity(array, group[name].attrs['dimensionality'])\n return array\n"
] |
[
[
"numpy.swapaxes"
]
] |
demdecuong/SEGMENT
|
[
"629dc55dcbc9629b35fb237e313b95ceacecdc89"
] |
[
"layers/decoder.py"
] |
[
"\"\"\"FocusSeq2Seq\nCopyright (c) 2019-present NAVER Corp.\nMIT license\n\"\"\"\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nimport math\n\nfrom .copy_attention import BahdanauAttention, CopySwitch, PointerGenerator\nfrom .beam_search import Beam\n\n\ndef repeat(tensor, K):\n \"\"\"\n [B, ...] => [B*K, ...]\n\n #-- Important --#\n Used unsqueeze and transpose to avoid [K*B] when using torch.Tensor.repeat\n \"\"\"\n if isinstance(tensor, torch.Tensor):\n B, *size = tensor.size()\n repeat_size = [1] + [K] + [1] * (tensor.dim() - 1)\n tensor = tensor.unsqueeze(1).repeat(*repeat_size).view(B * K, *size)\n return tensor\n elif isinstance(tensor, list):\n out = []\n for x in tensor:\n for _ in range(K):\n out.append(x.copy())\n return out\n\n\nclass Maxout(nn.Module):\n def __init__(self, pool_size):\n super().__init__()\n self._pool_size = pool_size\n\n def forward(self, x):\n assert x.shape[-1] % self._pool_size == 0, \\\n 'Wrong input last dim size ({}) for Maxout({})'.format(\n x.shape[-1], self._pool_size)\n m, i = x.view(*x.shape[:-1], x.shape[-1] //\n self._pool_size, self._pool_size).max(-1)\n return m\n\n\nclass NQGReadout(nn.Module):\n def __init__(self, enc_hidden_size=512, dec_hidden_size=256, embed_size=300, vocab_size=30000, dropout_p=0.5,\n pool_size=2, tie=False):\n super().__init__()\n\n self.tie = tie\n\n if tie:\n self.W = nn.Linear(embed_size + enc_hidden_size + dec_hidden_size, embed_size)\n self.Wo = nn.Linear(embed_size, vocab_size, bias=False)\n self.dropout = nn.Dropout(dropout_p)\n\n else:\n # self.Wr = nn.Linear(embed_size, hidden_size, bias=False)\n # self.Ur = nn.Linear(hidden_size, hidden_size, bias=False)\n # self.Vr = nn.Linear(hidden_size, hidden_size, bias=False)\n self.W = nn.Linear(embed_size + enc_hidden_size + dec_hidden_size, dec_hidden_size)\n self.maxout = Maxout(pool_size=pool_size)\n self.dropout = nn.Dropout(dropout_p)\n self.Wo = nn.Linear(dec_hidden_size // pool_size, vocab_size, bias=False)\n\n def forward(self, word_emb, context, decoder_state):\n # [B, 2 * hidden_size]\n\n if self.tie:\n r = self.W(torch.cat([word_emb, context, decoder_state], dim=1))\n\n r = torch.tanh(r)\n r = self.dropout(r)\n energy = self.Wo(r)\n\n else:\n r = self.W(torch.cat([word_emb, context, decoder_state], dim=1))\n # r = self.Wr(word_emb) + self.Ur(context) + self.Vr(decoder_state)\n\n # [B, hidden_size // 2]\n r = self.maxout(r)\n r = self.dropout(r)\n\n # [B, vocab_size]\n energy = self.Wo(r)\n\n return energy\n\n\nclass PGReadout(nn.Module):\n def __init__(self, enc_hidden_size=512, dec_hidden_size=256, embed_size=128, vocab_size=50000, dropout_p=0.5,\n tie=False):\n super().__init__()\n\n self.tie = tie\n\n if tie:\n self.W1 = nn.Linear(enc_hidden_size + dec_hidden_size, embed_size)\n self.dropout = nn.Dropout(dropout_p)\n self.tanh = nn.Tanh()\n self.Wo = nn.Linear(embed_size, vocab_size, bias=False)\n\n else:\n if dropout_p > 0:\n self.mlp = nn.Sequential(\n nn.Linear(enc_hidden_size + dec_hidden_size, dec_hidden_size),\n nn.Dropout(dropout_p),\n nn.Linear(dec_hidden_size, vocab_size)\n )\n else:\n self.mlp = nn.Sequential(\n nn.Linear(enc_hidden_size + dec_hidden_size, dec_hidden_size),\n # nn.Dropout(dropout_p),\n nn.Linear(dec_hidden_size, vocab_size)\n )\n\n def forward(self, context, decoder_state):\n # [B, hidden_size] | [B, hidden_size]\n\n if self.tie:\n # => [B, hidden_size]\n r = self.W1(torch.cat([context, decoder_state], dim=1))\n r = self.dropout(r)\n r = self.tanh(r)\n\n # => [B, vocab_size]\n energy = self.Wo(r)\n else:\n energy = self.mlp(torch.cat([context, decoder_state], dim=1))\n\n return energy\n\n\nclass NQGDecoder(nn.Module):\n def __init__(self, embed_size=300, enc_hidden_size=512, dec_hidden_size=512,\n attention_size=512,\n vocab_size=20000, dropout_p=0.5,\n rnn='GRU', tie=False, n_mixture=None):\n \"\"\"Neural Question Generation from Text: A Preliminary Study (2017)\n incorporated with copying mechanism of Pointing the Unknown Words (ACL 2016)\"\"\"\n super().__init__()\n\n input_size = embed_size + dec_hidden_size\n\n self.hidden_size = dec_hidden_size\n self.vocab_size = vocab_size\n\n if rnn == 'GRU':\n self.rnn_type = 'GRU'\n self.rnncell = nn.GRUCell(input_size=input_size,\n hidden_size=dec_hidden_size)\n elif rnn == 'LSTM':\n self.rnn_type = 'LSTM'\n self.rnncell = nn.LSTMCell(input_size=input_size,\n hidden_size=dec_hidden_size)\n\n # Attention\n self.attention = BahdanauAttention(\n enc_hidden_size, dec_hidden_size, attention_size=attention_size)\n self.copy_switch = CopySwitch(enc_hidden_size, dec_hidden_size)\n\n self.readout = NQGReadout(enc_hidden_size=enc_hidden_size,\n dec_hidden_size=dec_hidden_size,\n embed_size=embed_size,\n vocab_size=vocab_size,\n dropout_p=dropout_p, tie=tie)\n\n self.tie = tie\n\n self.n_mixture = n_mixture\n if n_mixture:\n self.mixture_embedding = nn.Embedding(n_mixture, embed_size)\n\n def forward(self,\n enc_outputs,\n s,\n source_WORD_encoding,\n answer_WORD_encoding=None,\n mixture_id=None,\n target_WORD_encoding=None,\n source_WORD_encoding_extended=None,\n train=True,\n decoding_type='beam',\n K=10,\n max_dec_len=30,\n temperature=1.0,\n diversity_lambda=0.5):\n\n device = enc_outputs.device\n B, max_source_len = source_WORD_encoding.size()\n V = self.vocab_size + max_source_len\n\n PAD_ID = 0 # word2id['<pad>']\n UNK_ID = 1 # word2id['<unk>']\n SOS_ID = 2 # word2id['<sos>']\n EOS_ID = 3 # word2id['<eos>']\n\n # Initial input for decoder (Start of sequence token; SOS)\n dec_input_word = torch.tensor([SOS_ID] * B, dtype=torch.long, device=device)\n\n # attention mask [B, max_source_len]\n pad_mask = (source_WORD_encoding == PAD_ID)\n\n if train:\n # Number of decoding iteration\n max_dec_len = target_WORD_encoding.size(1)\n else:\n # Number of decoding iteration\n max_dec_len = max_dec_len\n\n # Repeat with beam/group size\n if decoding_type in ['beam', 'diverse_beam', 'topk_sampling']:\n # [B] => [B*K]\n dec_input_word = repeat(dec_input_word, K)\n # [B, hidden_size] => [B*K, hidden_size]\n if self.rnn_type == 'GRU':\n s = repeat(s, K)\n elif self.rnn_type == 'LSTM':\n s = (repeat(s[0], K), repeat(s[1], K))\n # [B*K, max_source_len, hidden*2]\n enc_outputs = repeat(enc_outputs, K)\n # [B*K, max_source_len]\n pad_mask = repeat(pad_mask, K)\n\n if decoding_type in ['beam', 'diverse_beam']:\n # Initialize log probability scores [B, K]\n score = torch.zeros(B, K, device=device)\n # Avoid duplicated beams\n score[:, 1:] = -math.inf\n # Initialize Beam\n beam = Beam(B, K, EOS_ID)\n n_finished = torch.zeros(B, dtype=torch.long, device=device)\n\n elif decoding_type == 'topk_sampling':\n # Initialize log probability scores [B, K]\n score = torch.zeros(B * K, device=device)\n finished = torch.zeros(B * K, dtype=torch.uint8, device=device)\n\n else:\n finished = torch.zeros(B, dtype=torch.uint8, device=device)\n score = torch.zeros(B, device=device)\n\n # Outputs will be concatenated\n out_log_p = []\n output_sentence = []\n\n # for attention visualization\n self.attention_list = []\n\n for i in range(max_dec_len):\n\n if i == 0 and self.n_mixture:\n dec_input_word_embed = self.mixture_embedding(mixture_id)\n else:\n dec_input_word_embed = self.word_embed(dec_input_word)\n\n # Feed context vector to decoder rnn\n if i == 0:\n # [B, hidden_size]\n context = torch.zeros_like(enc_outputs[:, 0])\n dec_input = torch.cat([dec_input_word_embed, context], dim=1)\n\n s = self.rnncell(dec_input, s)\n\n # ------ Attention ------#\n # Bahdanau Attention (Softmaxed)\n # [B, max_source_len]\n if self.rnn_type == 'GRU':\n attention = self.attention(enc_outputs, s, pad_mask)\n if self.rnn_type == 'LSTM':\n attention = self.attention(enc_outputs, s[0], pad_mask)\n\n self.attention_list.append(attention)\n\n # Context vector: attention-weighted sum of enc outputs\n # [B, 1, max_source_len] @ [B, max_source_len, hidden]\n # => [B, 1, hidden]\n context = torch.bmm(attention.unsqueeze(1), enc_outputs)\n # => [B, hidden]\n context = context.squeeze(1)\n\n # ------ Copy Switch ------#\n # [B, 1]\n if self.rnn_type == 'GRU':\n p_copy = self.copy_switch(s, context)\n if self.rnn_type == 'LSTM':\n p_copy = self.copy_switch(s[0], context)\n\n # ------ Output Word Probability (Before Softmax) ------#\n # [B, vocab_size]\n if self.rnn_type == 'GRU':\n p_vocab = self.readout(dec_input_word_embed, context, s)\n if self.rnn_type == 'LSTM':\n p_vocab = self.readout(dec_input_word_embed, context, s[0])\n\n # suppress PAD / UNK tokens in the decoding\n if not train:\n p_vocab[:, PAD_ID] = -math.inf\n p_vocab[:, UNK_ID] = -math.inf\n\n p_vocab = F.softmax(p_vocab, dim=1)\n\n # V = vocab_size + max_source_len\n # [B, V]\n p_out = torch.cat([(1 - p_copy) * p_vocab,\n p_copy * attention], dim=1)\n # if train:\n p_out = p_out + 1e-12\n\n log_p = p_out.log()\n out_log_p.append(log_p)\n\n # ------ Training ------#\n if train:\n # ------ Teacher forcing ------#\n # dec_input_word = question[:, i]\n # dec_input_word.masked_fill_(dec_input_word >= self.vocab_size, UNK_ID)\n\n dec_input_word = target_WORD_encoding[:, i]\n unk = torch.full_like(dec_input_word, UNK_ID)\n dec_input_word = torch.where(\n dec_input_word >= self.vocab_size, unk, dec_input_word)\n\n # ------ Decoding ------#\n else:\n if decoding_type in ['beam', 'diverse_beam']:\n # [B*K, V] => [B, K, V]\n current_score = log_p.view(B, K, V)\n\n # if i+1 < min_dec_len:\n # current_score[:, EOS_ID] = -math.inf\n\n # Reduce Branching Size from Vocab size => K\n # [B, K, K]\n # current_score_topk, current_score_topk_idx = current_score.topk(K, dim=2)\n\n # [B, K] => [B, K, 1] => [B, K, K]\n # score = score.view(B, K, 1) + current_score_topk\n\n if decoding_type == 'diverse_beam':\n diversity_penalty = torch.zeros(B, V, device=device)\n for k in range(K):\n # [B, V]\n current_beam_score = current_score[:, k]\n if k > 0:\n diversity_penalty.scatter_add_(\n 1, beam_word_id, torch.ones(B, V, device=device))\n current_beam_score -= diversity_lambda * diversity_penalty\n # [B, 1]\n beam_word_id = current_beam_score.argmax(dim=1, keepdim=True)\n\n # [B, K] => [B, K, 1] => [B, K, V]\n score = score.view(B, K, 1) + current_score\n\n # [B, K, V] => [B, K*V]\n score = score.view(B, -1)\n\n # Select top k 'vocab' candidates (range: 0 ~ K*V-1)\n # [B, K]\n topk_score, topk_idx = score.topk(K, dim=1)\n\n # [B, K]\n # topk_idx = current_score_topk_idx.view(B, K*K).gather(1, topk_idx)\n\n # [B, K], (0 ~ K-1)\n topk_beam_idx = topk_idx // V\n # [B, K], (0 ~ V-1)\n topk_word_id = topk_idx % V\n\n beam.back_pointers.append(topk_beam_idx.clone()) # [B, K]\n beam.token_ids.append(topk_word_id.clone()) # [B, K]\n beam.scores.append(topk_score.clone()) # [B, K]\n\n # Top-k scored sequence index in each batch (which batch + which beam inside batch)\n # batch_indices [B, K]\n # [[0, ... 0 ],\n # [K, ... K ],\n # [K * 2, ... K * 2 ],\n # ...\n # [K * (B-1), ..., K * (B-1)]\n batch_starting_indices = torch.arange(0, B * K, step=K, device=device)\n batch_indices = batch_starting_indices.unsqueeze(1)\n topk_beam_idx_flat = (batch_indices + topk_beam_idx).flatten()\n\n # Prepare next iteration\n # [B*K, hidden_size]\n # [B, hidden_size] => [B*K, hidden_size]\n if self.rnn_type == 'GRU':\n s = s.index_select(0, topk_beam_idx_flat)\n elif self.rnn_type == 'LSTM':\n s = (s[0].index_select(0, topk_beam_idx_flat),\n s[1].index_select(0, topk_beam_idx_flat))\n\n score = topk_score # [B, K]\n where_EOS = topk_word_id == EOS_ID\n score.masked_fill_(where_EOS, -math.inf)\n\n predicted_word_id = topk_word_id.flatten()\n where_oov = predicted_word_id >= self.vocab_size\n dec_input_word = predicted_word_id.masked_fill(where_oov, UNK_ID)\n\n # [B, K]\n generated_eos = topk_word_id == EOS_ID\n if generated_eos.any():\n # [B]\n n_finished += generated_eos.long().sum(dim=1)\n if n_finished.min().item() >= K:\n break\n\n elif decoding_type in ['greedy', 'topk_sampling']:\n if decoding_type == 'greedy':\n # [B]\n log_p_sampled, predicted_word_id = log_p.max(dim=1)\n\n # Hierarchical Neural Story Generation (ACL 2018)\n elif decoding_type == 'topk_sampling':\n topk = 10\n # [B*K, topk]\n log_p_topk, predicted_word_id_topk = log_p.topk(\n topk, dim=1)\n\n temperature_scaled_score = (log_p_topk / temperature).exp()\n\n # [B*K, 1]\n sampled_idx = temperature_scaled_score.multinomial(1)\n\n # [B*K]\n log_p_sampled = temperature_scaled_score.gather(\n 1, sampled_idx).squeeze(1)\n predicted_word_id = predicted_word_id_topk.gather(\n 1, sampled_idx).squeeze(1)\n\n log_p_sampled.masked_fill_(finished, 0)\n score += log_p_sampled\n\n where_oov = predicted_word_id >= self.vocab_size\n dec_input_word = predicted_word_id.masked_fill(\n where_oov, UNK_ID)\n\n output_sentence.append(predicted_word_id)\n\n # [B]\n generated_eos = predicted_word_id == EOS_ID\n if generated_eos.any():\n finished += generated_eos\n finished.clamp_(0, 1)\n\n if finished.min().item() > 0:\n break\n\n # ------ End-of-Decoder! ------#\n\n if train:\n # [B, max_dec_len, V]\n log_p = torch.stack(out_log_p, dim=1)\n return log_p\n\n else:\n if decoding_type in ['beam', 'diverse_beam']:\n # Top-K sentence / score\n output_sentence, score = beam.backtrack() # [B, K, max_dec_len]\n # [B, K, max_dec_len], [B, K]\n return output_sentence, score\n else:\n output_sentence = torch.stack(output_sentence, dim=-1).view(B, 1, -1)\n # [B, 1, max_dec_len], [B, 1]\n return output_sentence, score\n\n\nclass PGDecoder(nn.Module):\n def __init__(self, embed_size=128, enc_hidden_size=512, dec_hidden_size=256,\n attention_size=700,\n vocab_size=50000, dropout_p=0.0,\n rnn='LSTM', tie=False, n_mixture=None):\n \"\"\"Get To The Point: Summarization with Pointer-Generator Networks (ACL 2017)\"\"\"\n super().__init__()\n\n input_size = embed_size\n self.input_linear = nn.Linear(embed_size + enc_hidden_size + 32, input_size)\n\n self.hidden_size = dec_hidden_size\n self.vocab_size = vocab_size\n\n if rnn == 'GRU':\n self.rnn_type = 'GRU'\n self.rnncell = nn.GRUCell(input_size=input_size,\n hidden_size=dec_hidden_size)\n elif rnn == 'LSTM':\n self.rnn_type = 'LSTM'\n self.rnncell = nn.LSTMCell(input_size=input_size,\n hidden_size=dec_hidden_size)\n\n # Attention\n self.attention = BahdanauAttention(enc_hidden_size=enc_hidden_size,\n dec_hidden_size=dec_hidden_size if rnn == 'GRU' else 2 * dec_hidden_size,\n attention_size=attention_size,\n coverage=True)\n self.pointer_switch = PointerGenerator(enc_hidden_size=enc_hidden_size,\n dec_hidden_size=dec_hidden_size if rnn == 'GRU' else 2 * dec_hidden_size,\n embed_size=embed_size)\n\n self.readout = PGReadout(enc_hidden_size=enc_hidden_size,\n dec_hidden_size=dec_hidden_size,\n embed_size=embed_size,\n vocab_size=vocab_size,\n dropout_p=dropout_p,\n tie=tie)\n\n self.tie = tie\n\n self.n_mixture = n_mixture\n if n_mixture:\n self.mixture_embedding = nn.Embedding(n_mixture, embed_size)\n\n def forward(self,\n enc_outputs,\n s,\n source_WORD_encoding,\n answer_WORD_encoding=None,\n mixture_id=None,\n target_WORD_encoding=None,\n source_WORD_encoding_extended=None,\n train=True,\n decoding_type='beam',\n K=10,\n focus_mask=None,\n focus_segment_mask=None,\n pos_context=None,\n max_dec_len=100,\n temperature=1.0,\n diversity_lambda=0.5):\n\n device = enc_outputs.device\n B, max_source_len = source_WORD_encoding.size()\n\n PAD_ID = 0 # word2id['<pad>']\n UNK_ID = 1 # word2id['<unk>']\n SOS_ID = 2 # word2id['<sos>']\n EOS_ID = 3 # word2id['<eos>']\n\n # Initial input for decoder (Start of sequence token; SOS)\n dec_input_word = torch.tensor([SOS_ID] * B, dtype=torch.long, device=device)\n\n # attention mask [B, max_source_len]\n pad_mask = (source_WORD_encoding == PAD_ID)\n\n # coverage [B, max_source_len]\n coverage = torch.zeros(B, max_source_len, device=device)\n\n max_n_oov = source_WORD_encoding_extended.max().item() - self.vocab_size + 1\n max_n_oov = max(max_n_oov, 1)\n V = self.vocab_size + max_n_oov\n\n if train:\n # Number of decoding iteration\n max_dec_len = target_WORD_encoding.size(1)\n\n else:\n # Number of decoding iteration\n max_dec_len = max_dec_len\n # Repeat with beam/group size\n if decoding_type in ['beam', 'diverse_beam', 'topk_sampling']:\n # [B] => [B*K]\n dec_input_word = repeat(dec_input_word, K)\n # [B, hidden_size] => [B*K, hidden_size]\n if self.rnn_type == 'GRU':\n s = repeat(s, K)\n elif self.rnn_type == 'LSTM':\n s = (repeat(s[0], K), repeat(s[1], K))\n # [B*K, max_source_len, hidden*2]\n enc_outputs = repeat(enc_outputs, K)\n # pos_context = repeat(pos_context, K)\n # focus_mask = repeat(focus_mask,K)\n # focus_segment_mask = repeat(focus_segment_mask,K)\n # [B*K, max_source_len]\n pad_mask = repeat(pad_mask, K)\n # [B*K, max_source_len]\n source_WORD_encoding_extended = repeat(source_WORD_encoding_extended, K)\n source_WORD_encoding = repeat(source_WORD_encoding,K)\n # [B*K, max_source_len]\n coverage = repeat(coverage, K)\n\n if decoding_type in ['beam', 'diverse_beam']:\n # Initialize log probability scores [B, K]\n score = torch.zeros(B, K, device=device)\n # Avoid duplicated beams\n score[:, 1:] = -math.inf\n # Initialize Beam\n beam = Beam(B, K, EOS_ID)\n n_finished = torch.zeros(B, dtype=torch.long, device=device)\n\n elif decoding_type == 'topk_sampling':\n # Initialize log probability scores [B, K]\n score = torch.zeros(B * K, device=device)\n finished = torch.zeros(B * K, dtype=torch.uint8, device=device)\n\n else:\n finished = torch.zeros(B, dtype=torch.uint8, device=device)\n score = torch.zeros(B, device=device)\n\n # Outputs will be concatenated\n out_log_p = []\n output_sentence = []\n coverage_loss_list = []\n\n # focus_embed = self.focus_embed(focus_mask)\n # focus_segment_embed = self.focus_segment_embed(focus_segment_mask) \n # spotlight_embed = torch.cat([focus_embed,focus_segment_embed],dim = -1)\n \n # for attention visualization\n self.attention_list = []\n\n for i in range(max_dec_len):\n\n if i == 0 and self.n_mixture:\n dec_input_word_embed = self.mixture_embedding(mixture_id)\n else:\n dec_input_word_embed = self.word_embed(dec_input_word)\n\n dec_focus_mask = get_dec_focus_mask(source_WORD_encoding,dec_input_word)\n dec_focus_embed = self.focus_embed(dec_focus_mask)\n\n # Feed context vector to decoder rnn\n if i == 0:\n # [B, hidden_size]\n context = torch.zeros_like(enc_outputs[:, 0])\n dec_input = self.input_linear(torch.cat([dec_input_word_embed,dec_focus_embed, context], dim=1))\n\n s = self.rnncell(dec_input, s)\n\n if self.rnn_type == 'LSTM':\n s_cat = torch.cat([s[0], s[1]], dim=1)\n\n\n # spotlight_mask = get_spotlight_mask(i,source_WORD_encoding,dec_input_word,focus_mask,K,train)\n # spotlight_embed = self.focus_segment_embed(focus_segment_mask) + self.focus_embed(focus_mask)\n \n # ------ Attention ------#\n # Bahdanau Attention (Softmaxed)\n # [B, max_source_len]\n if self.rnn_type == 'GRU':\n attention = self.attention(enc_outputs, s, pad_mask, coverage)\n if self.rnn_type == 'LSTM':\n attention = self.attention(enc_outputs, s_cat, pad_mask, coverage)\n\n self.attention_list.append(attention)\n\n # Context vector: attention-weighted sum of enc outputs\n # [B, 1, max_source_len] * [B, max_source_len, hidden]\n # => [B, 1, hidden]\n context = torch.bmm(attention.unsqueeze(1), enc_outputs)\n # => [B, hidden]\n context = context.squeeze(1)\n\n # #------ Coverage ------#\n if train:\n # [B]\n step_coverage_loss = torch.sum(torch.min(attention, coverage), dim=1)\n coverage_loss_list.append(step_coverage_loss)\n\n # Update coverage vector by adding attention\n coverage = coverage + attention\n # assert coverage.min().item() >= 0\n\n # ------ Copy Switch ------#\n # P(Generation)\n # [B, 1]\n if self.rnn_type == 'GRU':\n p_gen = self.pointer_switch(context, s, dec_input)\n if self.rnn_type == 'LSTM':\n p_gen = self.pointer_switch(context, s_cat, dec_input)\n\n # ------ Output Word Probability ------#\n # 1) In-Vocab Probability: P(Vocab)\n # [B, Vocab_size]\n if self.rnn_type == 'GRU':\n p_vocab = self.readout(context, s)\n if self.rnn_type == 'LSTM':\n p_vocab = self.readout(context, s[0])\n\n # suppress PAD / UNK tokens in the decoding\n if not train:\n p_vocab[:, PAD_ID] = -math.inf\n p_vocab[:, UNK_ID] = -math.inf\n p_vocab = F.softmax(p_vocab, dim=1)\n\n # 2) Copy from answer sentence: P(Copy)\n # If attended to\n # In-Vocab Words => Add to In-Vocab Probability\n # OOV Words (UNK) => Pointer candidates\n # p_copy = torch.zeros(p_vocab.size(0), V, device=device)\n\n # p_copy.scatter_add_(1, source_WORD_encoding, attention)\n # if not train:\n # p_copy[:, UNK_ID] = 0\n\n # 3) Total Prob: Mix P(Vocab) and P(Copy) with P(Generation)\n # [B, V]\n # = [B, vocab_size + n_max_oovs]\n # p_vocab = torch.cat([\n # p_vocab,\n # torch.zeros(p_vocab.size(0), max_n_oov, device=device)], dim=1)\n\n # ext_zero_size = (p_vocab.size(0), max_n_oov)\n # print(ext_zero_size)\n ext_zeros = torch.zeros(p_vocab.size(0), max_n_oov, device=device)\n p_out = torch.cat([p_vocab, ext_zeros], dim=1)\n p_out = p_out * p_gen\n\n # p_out = torch.cat(\n # [p_gen * p_vocab, torch.zeros(p_vocab.size(0), max_n_oov, device=device)], dim=1)\n \n # attention [B, source_len]\n # copy_attention = get_copy_attention(attention,focus_mask)\n\n p_out.scatter_add_(1, source_WORD_encoding_extended, (1 - p_gen) * attention)\n if not train:\n p_out[:, UNK_ID] = 0\n\n # p_out = p_gen * p_vocab + (1 - p_gen) * p_copy\n\n # if train:\n p_out = p_out + 1e-12\n\n log_p = p_out.log()\n out_log_p.append(log_p)\n\n # ------ Training ------#\n if train:\n # ------ Teacher forcing ------#\n # dec_input_word = question[:, i]\n # dec_input_word.masked_fill_(dec_input_word >= self.vocab_size, UNK_ID)\n\n dec_input_word = target_WORD_encoding[:, i]\n unk = torch.full_like(dec_input_word, UNK_ID)\n dec_input_word = torch.where(\n dec_input_word >= self.vocab_size, unk, dec_input_word)\n # ------ Decoding ------#\n else:\n if decoding_type in ['beam', 'diverse_beam']:\n\n # [B*K, V] => [B, K, V]\n current_score = log_p.view(B, K, V)\n\n # if decoding_type == 'diverse_beam':\n #\n # diversity_score = 0\n #\n # current_score = current_score + diversity_score\n\n if max_dec_len > 30:\n min_dec_len = 35\n if i + 1 < min_dec_len:\n current_score[:, :, EOS_ID] = -math.inf\n # current_score[:, EOS_ID] = -1e7\n\n # Reduce Branching Size from Vocab size => K\n # [B, K, K]\n # current_score_topk, current_score_topk_idx = current_score.topk(K, dim=2)\n\n # [B, K] => [B, K, 1] => [B, K, K]\n # score = score.view(B, K, 1) + current_score_topk\n\n if decoding_type == 'diverse_beam':\n diversity_penalty = torch.zeros(B, V, device=device)\n for k in range(K):\n # [B, V]\n current_beam_score = current_score[:, k]\n if k > 0:\n diversity_penalty.scatter_add_(\n 1, beam_word_id, torch.ones(B, V, device=device))\n current_beam_score -= diversity_lambda * diversity_penalty\n # [B, 1]\n beam_word_id = current_beam_score.argmax(dim=1, keepdim=True)\n\n # [B, K] => [B, K, 1] => [B, K, V]\n score = score.view(B, K, 1) + current_score\n\n # [B, K, K] => [B, K*K]\n score = score.view(B, -1)\n\n # Select top k 'vocab' candidates (range: 0 ~ K*2K-1)\n # [B, K]\n topk_score, topk_idx = score.topk(K, dim=1)\n\n # [B, K]\n # topk_idx = current_score_topk_idx.view(B, K * K).gather(1, topk_idx)\n\n # [B, K], (0 ~ K-1)\n topk_beam_idx = topk_idx // V\n # [B, K], (0 ~ V-1)\n topk_word_id = topk_idx % V\n\n beam.back_pointers.append(topk_beam_idx) # [B, K]\n beam.token_ids.append(topk_word_id) # [B, K]\n beam.scores.append(topk_score) # [B, K]\n\n # Top-k scored sequence index in each batch (which batch + which beam inside batch)\n # batch_indices [B, K]\n # [[0, ... 0 ],\n # [K, ... K ],\n # [K * 2, ... K * 2 ],\n # ...\n # [K * (B-1), ..., K * (B-1)]\n batch_starting_indices = torch.arange(0, B * K, step=K, device=device)\n batch_indices = batch_starting_indices.unsqueeze(1)\n topk_beam_idx_flat = (batch_indices + topk_beam_idx).flatten()\n\n # Prepare next iteration\n # [B*K, hidden_size]\n if self.rnn_type == 'GRU':\n s = s.index_select(0, topk_beam_idx_flat)\n elif self.rnn_type == 'LSTM':\n s = (s[0].index_select(0, topk_beam_idx_flat),\n s[1].index_select(0, topk_beam_idx_flat))\n attention = attention.index_select(0, topk_beam_idx_flat)\n coverage = coverage.index_select(0, topk_beam_idx_flat)\n score = topk_score # [B, K]\n where_EOS = topk_word_id == EOS_ID\n score.masked_fill_(where_EOS, -math.inf)\n\n predicted_word_id = topk_word_id.flatten()\n where_oov = predicted_word_id >= self.vocab_size\n dec_input_word = predicted_word_id.masked_fill(where_oov, UNK_ID)\n\n # [B, K]\n generated_eos = topk_word_id == EOS_ID\n if generated_eos.any():\n # [B]\n n_finished += generated_eos.long().sum(dim=1)\n if n_finished.min().item() >= K:\n break\n\n else:\n if decoding_type == 'greedy':\n # [B]\n log_p_sampled, predicted_word_id = log_p.max(dim=1)\n\n # Hierarchical Neural Story Generation (ACL 2018)\n elif decoding_type == 'topk_sampling':\n topk = 10\n # [B*K, topk]\n log_p_topk, predicted_word_id_topk = log_p.topk(\n topk, dim=1)\n\n temperature_scaled_score = (log_p_topk / temperature).exp()\n\n # [B*K, 1]\n sampled_idx = temperature_scaled_score.multinomial(1)\n\n # [B*K]\n log_p_sampled = temperature_scaled_score.gather(\n 1, sampled_idx).squeeze(1)\n predicted_word_id = predicted_word_id_topk.gather(\n 1, sampled_idx).squeeze(1)\n\n log_p_sampled.masked_fill_(finished, 0)\n score += log_p_sampled\n\n where_oov = predicted_word_id >= self.vocab_size\n dec_input_word = predicted_word_id.masked_fill(\n where_oov, UNK_ID)\n\n output_sentence.append(predicted_word_id)\n\n # [B]\n generated_eos = predicted_word_id == EOS_ID\n if generated_eos.any():\n finished += generated_eos\n finished.clamp_(0, 1)\n\n if finished.min().item() > 0:\n break\n\n # ------ End-of-Decoder! ------#\n\n if train:\n # [B, max_dec_len, V]\n log_p = torch.stack(out_log_p, dim=1)\n\n # [B, max_dec_len]\n coverage_loss = torch.stack(coverage_loss_list, dim=1)\n\n # [B, max_dec_len, V], [B, max_dec_len]\n return log_p, coverage_loss\n\n else:\n if decoding_type in ['beam', 'diverse_beam']:\n # Top-K sentence / score\n output_sentence, score = beam.backtrack() # [B, K, max_dec_len]\n # [B, K, max_dec_len], [B, K]\n return output_sentence, score\n else:\n output_sentence = torch.stack(output_sentence, dim=-1).view(B, 1, -1)\n # [B, 1, max_dec_len], [B, 1]\n return output_sentence, score\n\n\ndef get_spotlight_mask(i,source_WORD_encoding,dec_input_word,focus_mask,K,train = True):\n '''\n Return a mask that predicted output is in focus_mask\n i : int \n index of current predicted word\n source_WORD_encoding : [B,L]\n dec_input_word: [B*K]\n previous predicted words \n focus_mask: [B,L]\n K : int\n beam size\n '''\n if train != True:\n source_WORD_encoding = repeat(source_WORD_encoding,K)\n focus_mask = repeat(focus_mask,K)\n BK , L = source_WORD_encoding.size()\n # if predicted words in source\n idx_mask = source_WORD_encoding==dec_input_word.unsqueeze(1).repeat(1,L)\n # [B*K , L] prev_index is in src = 1\n idx_mask = (idx_mask == True).long() # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ..., 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n \n # joint focus mask and idx_mask\n spotlight_mask = ((idx_mask + focus_mask)==2).long()\n\n \n # # next token mask\n # tmp = torch.zeros(BK,1 , device=focus_mask.device)\n # # concat a zeros token\n # spotlight_mask = torch.cat([tmp,idx_mask],dim = -1)\n # # shift right. [B*K , L]\n # spotlight_mask1 = spotlight_mask[:,:-1]\n # spotlight_mask2 = (focus_mask == 1).long()\n # spotlight_mask = spotlight_mask1 * spotlight_mask2 * lamda + 1.0000\n\n return spotlight_mask\n\n\ndef get_copy_attention(attention,focus_mask):\n '''\n Args:\n attention: B x source_len\n focus_mask: B x source_len\n return:\n copy_attention: B x source_len\n '''\n focus_mask = focus_mask == 1\n copy_attention = attention.masked_fill(focus_mask,0)\n return copy_attention\n\ndef get_dec_focus_mask(source_WORD_encoding,dec_input_word):\n '''\n Args:\n source_WORD_encoding: B x source_len\n dec_input_word: B x 1\n return:\n dec_focus_mask: B x 1\n '''\n\n dec_focus_mask = (source_WORD_encoding==dec_input_word.unsqueeze(1))\n dec_focus_mask = torch.sum(dec_focus_mask,1).long()\n dec_focus_mask[dec_focus_mask!=0] = 1\n return dec_focus_mask"
] |
[
[
"torch.nn.functional.softmax",
"torch.zeros",
"torch.cat",
"torch.sum",
"torch.nn.Embedding",
"torch.tanh",
"torch.where",
"torch.full_like",
"torch.nn.Dropout",
"torch.ones",
"torch.tensor",
"torch.nn.LSTMCell",
"torch.arange",
"torch.nn.GRUCell",
"torch.min",
"torch.zeros_like",
"torch.nn.Linear",
"torch.stack",
"torch.nn.Tanh"
]
] |
YifanLi/SGVCut
|
[
"8fde53d17876fade2bc561dd04c9acea35334a24"
] |
[
"src/Test_plotly.py"
] |
[
"import plotly\nfrom plotly.graph_objs import Scatter, Layout\nimport plotly.plotly as py\nimport plotly.graph_objs as go\n# Create random data with numpy\nimport numpy as np\n\n#plotly.offline.init_notebook_mode()\n\n'''\nurl = plotly.offline.plot({\n \"data\": [Scatter(x=[1, 2, 3, 4], y=[4, 3, 2, 1])],\n \"layout\": Layout(title=\"hello world\")\n}, auto_open = False)\n\nprint url\n'''\n\n\n\nN = 1000\nrandom_x = np.random.randn(N)\nrandom_y = np.random.randn(N)\n\n# Create a trace\ntrace = go.Scatter(\n x = random_x,\n y = random_y,\n mode = 'markers'\n)\n\ndata = [trace]\n\n# Plot and embed in ipython notebook!\npy.iplot(data, filename='basic-scatter')\n\n# or plot with: plot_url = py.plot(data, filename='basic-line')\n\n"
] |
[
[
"numpy.random.randn"
]
] |
JXQI/ModelsGenesis
|
[
"f961288313a78f03bd3045ac27722f791f365bd8"
] |
[
"pytorch/main.py"
] |
[
"import torch\nfrom torch import nn\nimport torch.nn.functional as F\nfrom torch.utils.data import DataLoader\nimport torchvision.transforms as transforms\nimport unet3d\nimport config\nfrom loader import NIIloader\nimport os\nos.environ['KMP_DUPLICATE_LIB_OK']='True'\n\n\n# prepare your own data\npath = '/Users/jinxiaoqiang/jinxiaoqiang/数据集/Bone/ribfrac/ribfrac-val-images'\ntransform =transforms.Compose([transforms.ToTensor()])\ntrain_set=NIIloader(path,dataset='train',transform=transform)\ntrain_loader = DataLoader(train_set, batch_size = config.batch_size, shuffle=True)\n\n# prepare the 3D model\nclass TargetNet(nn.Module):\n def __init__(self, base_model, n_class=2):\n super(TargetNet, self).__init__()\n\n self.base_model = base_model\n self.dense_1 = nn.Linear(512, 1024, bias=True)\n self.dense_2 = nn.Linear(1024, n_class, bias=True)\n\n def forward(self, x):\n self.base_model(x)\n self.base_out = self.base_model.out512\n self.out_glb_avg_pool = F.avg_pool3d(self.base_out, kernel_size=self.base_out.size()[2:]).view(\n self.base_out.size()[0], -1)\n self.linear_out = self.dense_1(self.out_glb_avg_pool)\n final_out = self.dense_2(F.relu(self.linear_out))\n return final_out\n\n\nbase_model = unet3d.UNet3D()\n# Load pre-trained weights\nweight_dir = 'pretrained_weights/Genesis_Chest_CT.pt'\ncheckpoint = torch.load(weight_dir,map_location=torch.device('cpu'))\nstate_dict = checkpoint['state_dict']\nunParalled_state_dict = {}\nfor key in state_dict.keys():\n unParalled_state_dict[key.replace(\"module.\", \"\")] = state_dict[key]\nbase_model.load_state_dict(unParalled_state_dict)\ntarget_model = TargetNet(base_model)\ntarget_model.to(config.device)\ntarget_model = nn.DataParallel(target_model, device_ids=[i for i in range(torch.cuda.device_count())])\ncriterion = nn.BCELoss()\noptimizer = torch.optim.SGD(target_model.parameters(), config.lr, momentum=0.9, weight_decay=0.0, nesterov=False)\n\n# train the model\n\nfor epoch in range(config.intial_epoch, config.nb_epoch):\n target_model.train()\n for batch_ndx, (x, y) in enumerate(train_loader):\n x, y = x.float().to(config.device), y.float().to(config.device)\n pred = F.sigmoid(target_model(x))\n loss = criterion(pred, y)\n optimizer.zero_grad()\n loss.backward()\n optimizer.step()\n print(\"loss:{}\".format(loss))"
] |
[
[
"torch.utils.data.DataLoader",
"torch.nn.BCELoss",
"torch.nn.Linear",
"torch.nn.functional.relu",
"torch.device",
"torch.cuda.device_count"
]
] |
qixinbo/imagepy
|
[
"3c378ebaf72762b94f0826a410897757ebafe689"
] |
[
"sciapp/action/plugin/generalio.py"
] |
[
"from ..advanced import dataio\nfrom skimage.io import imread, imsave\n\nfor i in ('bmp', 'jpg', 'jpeg', 'tif', 'png', 'gif'):\n\tdataio.ReaderManager.add(i, imread, 'img')\n\tdataio.WriterManager.add(i, imsave, 'img')\n\nclass OpenFile(dataio.Reader):\n title = 'Open'\n\n def load(self):\n self.filt = [i for i in sorted(dataio.ReaderManager.names())]\n return True\n\nclass SaveImage(dataio.ImageWriter):\n\ttitle = 'Save Image'\n\n\tdef load(self, ips):\n\t\tself.filt = [i for i in sorted(dataio.WriterManager.names())]\n\t\treturn True\n\nfrom pandas import read_csv, read_excel\nread_csv2 = lambda p:read_csv(p, index_col=0)\nread_excel2 = lambda p:read_excel(p, index_col=0)\n\nsave_csv = lambda path, data:data.to_csv(path)\ndataio.ReaderManager.add('csv', read_csv2, 'tab')\ndataio.WriterManager.add('csv', save_csv, 'tab')\n\n\nsave_excel = lambda path, data:data.to_excel(path)\ndataio.ReaderManager.add('xls', read_excel2, 'tab')\ndataio.WriterManager.add('xls', save_excel, 'tab')\ndataio.ReaderManager.add('xlsx', read_excel2, 'tab')\ndataio.WriterManager.add('xlsx', save_excel, 'tab')\n\nclass OpenTable(dataio.Reader):\n title = 'Excel Open'\n tag = 'tab'\n filt = ['csv', 'xls','xlsx']\n\nclass SaveTable(dataio.TableWriter):\n title = 'Excel Save'\n tag = 'tab'\n filt = ['csv', 'xls', 'xlsx']"
] |
[
[
"pandas.read_excel",
"pandas.read_csv"
]
] |
yatao91/learning_road
|
[
"e88dc43de98e35922bfc71c222ec71766851e618"
] |
[
"coding/learn_numpy/np_sort.py"
] |
[
"# -*- coding: UTF-8 -*-\nimport numpy as np\n\na = np.array([[4, 3, 2], [2, 4, 1]])\n\nprint(np.sort(a))\nprint(np.sort(a, axis=None))\nprint(np.sort(a, axis=0))\nprint(np.sort(a, axis=1))\n"
] |
[
[
"numpy.array",
"numpy.sort"
]
] |
hologerry/pix2pix-flow
|
[
"d512e64bf3539140d8f1295db98f793f1b2b912f"
] |
[
"data_loaders/get_data.py"
] |
[
"import os\nimport tensorflow as tf\nimport numpy as np\nimport glob\n\n_FILES_SHUFFLE = 1024\n_SHUFFLE_FACTOR = 4\n\n\ndef parse_tfrecord_tf(record, res, rnd_crop):\n features = tf.parse_single_example(record, features={\n 'shape': tf.FixedLenFeature([3], tf.int64),\n 'data': tf.FixedLenFeature([], tf.string),\n 'label': tf.FixedLenFeature([1], tf.int64)})\n # label is always 0 if uncondtional\n # to get CelebA attr, add 'attr': tf.FixedLenFeature([40], tf.int64)\n data, label, shape = features['data'], features['label'], features['shape']\n label = tf.cast(tf.reshape(label, shape=[]), dtype=tf.int32)\n img = tf.decode_raw(data, tf.uint8)\n if rnd_crop:\n # For LSUN Realnvp only - random crop\n img = tf.reshape(img, shape)\n img = tf.random_crop(img, [res, res, 3])\n img = tf.reshape(img, [res, res, 3])\n return img, label # to get CelebA attr, also return attr\n\n\ndef input_fn(tfr_file, shards, rank, pmap, fmap, n_batch, resolution, rnd_crop, is_training):\n files = tf.data.Dataset.list_files(tfr_file)\n if ('lsun' not in tfr_file) or is_training:\n # For 'lsun' validation, only one shard and each machine goes over the full dataset\n # each worker works on a subset of the data\n files = files.shard(shards, rank)\n if is_training:\n # shuffle order of files in shard\n files = files.shuffle(buffer_size=_FILES_SHUFFLE)\n dset = files.apply(tf.contrib.data.parallel_interleave(\n tf.data.TFRecordDataset, cycle_length=fmap))\n if is_training:\n dset = dset.shuffle(buffer_size=n_batch * _SHUFFLE_FACTOR)\n dset = dset.repeat()\n dset = dset.map(lambda x: parse_tfrecord_tf(\n x, resolution, rnd_crop), num_parallel_calls=pmap)\n dset = dset.batch(n_batch)\n dset = dset.prefetch(1)\n itr = dset.make_one_shot_iterator()\n return itr\n\n\ndef get_tfr_file(data_dir, split, res_lg2):\n data_dir = os.path.join(data_dir, split)\n tfr_prefix = os.path.join(data_dir, os.path.basename(data_dir))\n tfr_file = tfr_prefix + '-r%02d-s-*-of-*.tfrecords' % (res_lg2)\n files = glob.glob(tfr_file)\n assert len(files) == int(files[0].split(\n \"-\")[-1].split(\".\")[0]), \"Not all tfrecords files present at %s\" % tfr_prefix\n return tfr_file\n\n\ndef get_data(sess, data_dir, shards, rank, pmap, fmap, n_batch_train, n_batch_test, n_batch_init, resolution, rnd_crop):\n assert resolution == 2 ** int(np.log2(resolution))\n\n train_file = get_tfr_file(data_dir, 'train', int(np.log2(resolution)))\n valid_file = get_tfr_file(data_dir, 'validation', int(np.log2(resolution)))\n\n train_itr = input_fn(train_file, shards, rank, pmap,\n fmap, n_batch_train, resolution, rnd_crop, True)\n valid_itr = input_fn(valid_file, shards, rank, pmap,\n fmap, n_batch_test, resolution, rnd_crop, False)\n\n data_init = make_batch(sess, train_itr, n_batch_train, n_batch_init)\n\n return train_itr, valid_itr, data_init\n\n#\n\n\ndef make_batch(sess, itr, itr_batch_size, required_batch_size):\n ib, rb = itr_batch_size, required_batch_size\n # assert rb % ib == 0\n k = int(np.ceil(rb / ib))\n xs, ys = [], []\n data = itr.get_next()\n for i in range(k):\n x, y = sess.run(data)\n xs.append(x)\n ys.append(y)\n x, y = np.concatenate(xs)[:rb], np.concatenate(ys)[:rb]\n return {'x': x, 'y': y}\n"
] |
[
[
"numpy.log2",
"tensorflow.FixedLenFeature",
"tensorflow.decode_raw",
"tensorflow.reshape",
"tensorflow.contrib.data.parallel_interleave",
"tensorflow.random_crop",
"numpy.concatenate",
"numpy.ceil",
"tensorflow.data.Dataset.list_files"
]
] |
liaha/tensorflow-sc-todate
|
[
"1f1c2eb8f30525ddcb819d6fc6941c7a84f33e4c"
] |
[
"tensorflow/python/debug/lib/debug_v2_ops_test.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\"\"\"Test for the internal ops used by tfdbg v2.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\n\nimport numpy as np\n\nfrom tensorflow.core.protobuf import debug_event_pb2\nfrom tensorflow.python.debug.lib import debug_events_reader\nfrom tensorflow.python.debug.lib import debug_events_writer\nfrom tensorflow.python.debug.lib import dumping_callback_test_lib\nfrom tensorflow.python.eager import def_function\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import dtypes\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import tensor_util\nfrom tensorflow.python.framework import test_util\nfrom tensorflow.python.ops import gen_debug_ops\nfrom tensorflow.python.ops import math_ops\nfrom tensorflow.python.platform import googletest\n\n\nclass DebugIdentityV2OpTest(dumping_callback_test_lib.DumpingCallbackTestBase):\n\n def setUp(self):\n super(DebugIdentityV2OpTest, self).setUp()\n # Testing using a small circular-buffer size.\n self.circular_buffer_size = 4\n self.writer = debug_events_writer.DebugEventsWriter(\n self.dump_root, self.circular_buffer_size)\n\n def tearDown(self):\n self.writer.Close()\n super(DebugIdentityV2OpTest, self).tearDown()\n\n @test_util.run_in_graph_and_eager_modes\n def testSingleTensorFullTensorDebugModeWithCircularBufferBehavior(self):\n\n @def_function.function\n def write_debug_trace(x):\n # DebugIdentityV2 is a stateful op. It ought to be included by auto\n # control dependency.\n square = math_ops.square(x)\n gen_debug_ops.debug_identity_v2(\n square,\n tfdbg_context_id=\"deadbeaf\",\n op_name=\"Square\",\n output_slot=0,\n tensor_debug_mode=debug_event_pb2.TensorDebugMode.FULL_TENSOR,\n debug_urls=[\"file://%s\" % self.dump_root])\n\n sqrt = math_ops.sqrt(x)\n gen_debug_ops.debug_identity_v2(\n sqrt,\n tfdbg_context_id=\"beafdead\",\n op_name=\"Sqrt\",\n output_slot=0,\n tensor_debug_mode=debug_event_pb2.TensorDebugMode.FULL_TENSOR,\n debug_urls=[\"file://%s\" % self.dump_root])\n return square + sqrt\n\n x = np.array([3.0, 4.0])\n # Only the graph-execution trace of the last iteration should be written\n # to self.dump_root.\n for _ in range(self.circular_buffer_size // 2 + 1):\n self.assertAllClose(\n write_debug_trace(x), [9.0 + np.sqrt(3.0), 16.0 + 2.0])\n\n with debug_events_reader.DebugEventsReader(self.dump_root) as reader:\n metadata_iter = reader.metadata_iterator()\n # Check that the .metadata DebugEvents data file has been created, even\n # before FlushExecutionFiles() is called.\n debug_event = next(metadata_iter)\n self.assertGreater(debug_event.wall_time, 0)\n self.assertTrue(debug_event.debug_metadata.tensorflow_version)\n self.assertTrue(\n debug_event.debug_metadata.file_version.startswith(\"debug.Event:\"))\n\n graph_trace_iter = reader.graph_execution_traces_iterator()\n # Before FlushExecutionFiles() is called, the .graph_execution_traces file\n # ought to be empty.\n with self.assertRaises(StopIteration):\n next(graph_trace_iter)\n\n # Flush the circular buffer.\n self.writer.FlushExecutionFiles()\n graph_trace_iter = reader.graph_execution_traces_iterator()\n\n # The circular buffer has a size of 4. So only the data from the\n # last two iterations should have been written to self.dump_root.\n for _ in range(2):\n debug_event = next(graph_trace_iter)\n self.assertGreater(debug_event.wall_time, 0)\n trace = debug_event.graph_execution_trace\n self.assertEqual(trace.tfdbg_context_id, \"deadbeaf\")\n self.assertEqual(trace.op_name, \"Square\")\n self.assertEqual(trace.output_slot, 0)\n self.assertEqual(trace.tensor_debug_mode,\n debug_event_pb2.TensorDebugMode.FULL_TENSOR)\n tensor_value = tensor_util.MakeNdarray(trace.tensor_proto)\n self.assertAllClose(tensor_value, [9.0, 16.0])\n\n debug_event = next(graph_trace_iter)\n self.assertGreater(debug_event.wall_time, 0)\n trace = debug_event.graph_execution_trace\n self.assertEqual(trace.tfdbg_context_id, \"beafdead\")\n self.assertEqual(trace.op_name, \"Sqrt\")\n self.assertEqual(trace.output_slot, 0)\n self.assertEqual(trace.tensor_debug_mode,\n debug_event_pb2.TensorDebugMode.FULL_TENSOR)\n tensor_value = tensor_util.MakeNdarray(trace.tensor_proto)\n self.assertAllClose(tensor_value, [np.sqrt(3.0), 2.0])\n\n # Only the graph-execution trace of the last iteration should be written\n # to self.dump_root.\n with self.assertRaises(StopIteration):\n next(graph_trace_iter)\n\n @test_util.run_in_graph_and_eager_modes\n def testControlFlow(self):\n\n @def_function.function\n def collatz(x):\n counter = constant_op.constant(0, dtype=dtypes.int32)\n while math_ops.greater(x, 1):\n counter = counter + 1\n gen_debug_ops.debug_identity_v2(\n x,\n tfdbg_context_id=\"deadbeaf\",\n op_name=\"x\",\n output_slot=0,\n tensor_debug_mode=debug_event_pb2.TensorDebugMode.FULL_TENSOR,\n debug_urls=[\"file://%s\" % self.dump_root])\n if math_ops.equal(x % 2, 0):\n x = math_ops.div(x, 2)\n else:\n x = x * 3 + 1\n return counter\n\n x = constant_op.constant(10, dtype=dtypes.int32)\n self.evaluate(collatz(x))\n\n self.writer.FlushExecutionFiles()\n with debug_events_reader.DebugEventsReader(self.dump_root) as reader:\n graph_trace_iter = reader.graph_execution_traces_iterator()\n try:\n x_values = []\n timestamp = 0\n while True:\n debug_event = next(graph_trace_iter)\n self.assertGreater(debug_event.wall_time, timestamp)\n timestamp = debug_event.wall_time\n trace = debug_event.graph_execution_trace\n self.assertEqual(trace.tfdbg_context_id, \"deadbeaf\")\n self.assertEqual(trace.op_name, \"x\")\n self.assertEqual(trace.output_slot, 0)\n self.assertEqual(trace.tensor_debug_mode,\n debug_event_pb2.TensorDebugMode.FULL_TENSOR)\n x_values.append(int(tensor_util.MakeNdarray(trace.tensor_proto)))\n except StopIteration:\n pass\n\n # Due to the circular buffer, only the last 4 iterations of\n # [10, 5, 16, 8, 4, 2] should have been written.\n self.assertAllEqual(x_values, [16, 8, 4, 2])\n\n @test_util.run_in_graph_and_eager_modes\n def testTwoDumpRoots(self):\n another_dump_root = os.path.join(self.dump_root, \"another\")\n another_debug_url = \"file://%s\" % another_dump_root\n another_writer = debug_events_writer.DebugEventsWriter(another_dump_root)\n\n @def_function.function\n def write_debug_trace(x):\n # DebugIdentityV2 is a stateful op. It ought to be included by auto\n # control dependency.\n square = math_ops.square(x)\n gen_debug_ops.debug_identity_v2(\n square,\n tfdbg_context_id=\"deadbeaf\",\n tensor_debug_mode=debug_event_pb2.TensorDebugMode.FULL_TENSOR,\n debug_urls=[\"file://%s\" % self.dump_root, another_debug_url])\n return square + 1.0\n\n x = np.array([3.0, 4.0])\n self.assertAllClose(write_debug_trace(x), np.array([10.0, 17.0]))\n self.writer.FlushExecutionFiles()\n another_writer.FlushExecutionFiles()\n another_writer.Close()\n\n for debug_root in (self.dump_root, another_dump_root):\n with debug_events_reader.DebugEventsReader(debug_root) as reader:\n graph_trace_iter = reader.graph_execution_traces_iterator()\n\n debug_event = next(graph_trace_iter)\n trace = debug_event.graph_execution_trace\n self.assertEqual(trace.tfdbg_context_id, \"deadbeaf\")\n self.assertEqual(trace.op_name, \"\")\n self.assertEqual(trace.tensor_debug_mode,\n debug_event_pb2.TensorDebugMode.FULL_TENSOR)\n tensor_value = tensor_util.MakeNdarray(trace.tensor_proto)\n self.assertAllClose(tensor_value, [9.0, 16.0])\n\n with self.assertRaises(StopIteration):\n next(graph_trace_iter)\n\n @test_util.run_in_graph_and_eager_modes\n def testDebugNumericSummaryV2OpReduceInfNanTwoSlots(self):\n def debug_summary(x):\n return self.evaluate(gen_debug_ops.debug_numeric_summary_v2(\n x, tensor_debug_mode=(\n debug_event_pb2.TensorDebugMode.REDUCE_INF_NAN_THREE_SLOTS)))\n\n self.assertAllEqual(\n debug_summary(constant_op.constant([])), [0.0, 0.0, 0.0])\n self.assertAllEqual(\n debug_summary(constant_op.constant(42.0)), [0.0, 0.0, 0.0])\n self.assertAllEqual(\n debug_summary(constant_op.constant([3.0, 4.0])), [0.0, 0.0, 0.0])\n self.assertAllEqual(\n debug_summary(constant_op.constant(np.array([3.0, -np.inf]))),\n [-np.inf, 0.0, 0.0])\n self.assertAllEqual(\n debug_summary(constant_op.constant(np.array([[0, 0], [np.nan, 0]]))),\n [0.0, 0.0, np.nan])\n self.assertAllEqual(\n debug_summary(\n constant_op.constant(np.array([[0, 0], [np.nan, np.inf]]))),\n [0.0, np.inf, np.nan])\n self.assertAllEqual(\n debug_summary(\n constant_op.constant(np.array([[0, np.inf], [np.nan, -np.inf]]))),\n [-np.inf, np.inf, np.nan])\n\n x = np.zeros([100, 100], dtype=np.float16)\n x[32, 47] = np.nan\n self.assertAllEqual(\n debug_summary(constant_op.constant(x)), [0.0, 0.0, np.nan])\n x = np.zeros([97, 97], dtype=np.float32)\n x[50, 83] = -np.inf\n self.assertAllEqual(\n debug_summary(constant_op.constant(x)), [-np.inf, 0.0, 0.0])\n x[1, 41] = np.nan\n self.assertAllEqual(\n debug_summary(constant_op.constant(x)), [-np.inf, 0.0, np.nan])\n x = np.zeros([9701], dtype=np.float64)\n x[9700] = np.nan\n self.assertAllEqual(\n debug_summary(constant_op.constant(x)), [0.0, 0.0, np.nan])\n\nif __name__ == \"__main__\":\n ops.enable_eager_execution()\n googletest.main()\n"
] |
[
[
"tensorflow.python.framework.ops.enable_eager_execution",
"tensorflow.python.framework.tensor_util.MakeNdarray",
"numpy.sqrt",
"tensorflow.python.ops.math_ops.square",
"tensorflow.python.debug.lib.debug_events_reader.DebugEventsReader",
"tensorflow.python.ops.math_ops.greater",
"tensorflow.python.ops.gen_debug_ops.debug_identity_v2",
"tensorflow.python.ops.math_ops.equal",
"tensorflow.python.ops.math_ops.div",
"tensorflow.python.ops.math_ops.sqrt",
"tensorflow.python.ops.gen_debug_ops.debug_numeric_summary_v2",
"tensorflow.python.platform.googletest.main",
"tensorflow.python.debug.lib.debug_events_writer.DebugEventsWriter",
"numpy.array",
"numpy.zeros",
"tensorflow.python.framework.constant_op.constant"
]
] |
mmcauliffe/Conch
|
[
"7668612d7a610d0f5ae3332f990e71b26c5e8b34"
] |
[
"conch/analysis/gammatone.py"
] |
[
"from numpy import pi,exp,log,abs,sum,sqrt,array, hanning, arange, zeros,cos,ceil,mean\n\nfrom scipy.signal import filtfilt,butter,hilbert\n\nfrom .helper import preproc,make_erb_cfs,nextpow2,fftfilt\n\n\ndef to_gammatone(path,num_bands,freq_lims):\n sr, proc = preproc(path,alpha=0)\n\n proc = proc / 32768 #hack!! for 16-bit pcm\n cfs = make_erb_cfs(freq_lims,num_bands)\n\n filterOrder = 4 # filter order\n gL = 2**nextpow2(0.128*sr) # gammatone filter length at least 128 ms\n b = 1.019*24.7*(4.37*cfs/1000+1) # rate of decay or bandwidth\n\n tpt=(2*pi)/sr\n gain=((1.019*b*tpt)**filterOrder)/6 # based on integral of impulse\n\n tmp_t = arange(gL)/sr\n\n envelopes = []\n bms = []\n\n # calculate impulse response\n for i in range(num_bands):\n gt = gain[i]*sr**3*tmp_t**(filterOrder-1)*exp(-2*pi*b[i]*tmp_t)*cos(2*pi*cfs[i]*tmp_t)\n bm = fftfilt(gt,proc)\n bms.append(bm)\n env = abs(hilbert(bm))\n envelopes.append(env)\n return array(bms).T,array(envelopes).T\n\n"
] |
[
[
"numpy.arange",
"numpy.cos",
"numpy.array",
"numpy.exp",
"scipy.signal.hilbert"
]
] |
vibhatha/PytorchExamples
|
[
"df356f120d6eef69a94586af93bff75af307582d"
] |
[
"mnist/mnist_dist_rhel7.py"
] |
[
"from __future__ import print_function\n\nimport time\n\nfrom math import ceil\nfrom random import Random\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\n\nimport os\nimport torch\nimport torch.distributed as dist\nfrom torch.multiprocessing import Process\n\nimport numpy as np\n\n\nclass Net(nn.Module):\n def __init__(self):\n super(Net, self).__init__()\n self.conv1 = nn.Conv2d(1, 32, 3, 1)\n self.conv2 = nn.Conv2d(32, 64, 3, 1)\n self.dropout1 = nn.Dropout2d(0.25)\n self.dropout2 = nn.Dropout2d(0.5)\n self.fc1 = nn.Linear(9216, 128)\n self.fc2 = nn.Linear(128, 10)\n\n def forward(self, x):\n x = self.conv1(x)\n x = F.relu(x)\n x = self.conv2(x)\n x = F.max_pool2d(x, 2)\n x = self.dropout1(x)\n x = torch.flatten(x, 1)\n x = self.fc1(x)\n x = F.relu(x)\n x = self.dropout2(x)\n x = self.fc2(x)\n output = F.log_softmax(x, dim=1)\n return output\n\n\n\"\"\" Dataset partitioning helper \"\"\"\n\n\nclass Partition(object):\n\n def __init__(self, data, index):\n self.data = data\n self.index = index\n\n def __len__(self):\n return len(self.index)\n\n def __getitem__(self, index):\n data_idx = self.index[index]\n return self.data[data_idx]\n\n\nclass DataPartitioner(object):\n\n def __init__(self, data, sizes=[0.7, 0.2, 0.1], seed=1234):\n self.data = data\n self.partitions = []\n rng = Random()\n rng.seed(seed)\n data_len = len(data)\n indexes = [x for x in range(0, data_len)]\n rng.shuffle(indexes)\n\n for frac in sizes:\n part_len = int(frac * data_len)\n self.partitions.append(indexes[0:part_len])\n indexes = indexes[part_len:]\n\n def use(self, partition):\n return Partition(self.data, self.partitions[partition])\n\n\ndef partition_numpy_dataset():\n # print(\"Data Loading\")\n dataset = np.load(\"datasets/train_data.npy\")\n targets = np.load(\"datasets/train_target.npy\")\n size = dist.get_world_size()\n bsz = int(128 / float(size))\n partition_sizes = [1.0 / size for _ in range(size)]\n # print(\"Partition Sizes {}\".format(partition_sizes))\n partition_data = DataPartitioner(dataset, partition_sizes)\n partition_data = partition_data.use(dist.get_rank())\n train_set_data = torch.utils.data.DataLoader(partition_data,\n batch_size=bsz,\n shuffle=False)\n partition_target = DataPartitioner(targets, partition_sizes)\n partition_target = partition_target.use(dist.get_rank())\n train_set_target = torch.utils.data.DataLoader(partition_target,\n batch_size=bsz,\n shuffle=False)\n return train_set_data, train_set_target, bsz\n\n\ndef partition_numpy_dataset_test():\n # print(\"Data Loading\")\n dataset = np.load(\"datasets/test_data.npy\")\n targets = np.load(\"datasets/test_target.npy\")\n # print(\"Data Size For Test {} {}\".format(dataset.shape, targets.shape))\n size = dist.get_world_size()\n bsz = int(16 / float(size))\n partition_sizes = [1.0 / size for _ in range(size)]\n # print(\"Partition Sizes {}\".format(partition_sizes))\n partition_data = DataPartitioner(dataset, partition_sizes)\n partition_data = partition_data.use(dist.get_rank())\n train_set_data = torch.utils.data.DataLoader(partition_data,\n batch_size=bsz,\n shuffle=False)\n partition_target = DataPartitioner(targets, partition_sizes)\n partition_target = partition_target.use(dist.get_rank())\n train_set_target = torch.utils.data.DataLoader(partition_target,\n batch_size=bsz,\n shuffle=False)\n\n return train_set_data, train_set_target, bsz\n\n\n\"\"\" Gradient averaging. \"\"\"\n\n\ndef average_gradients(model):\n size = float(dist.get_world_size())\n for param in model.parameters():\n dist.all_reduce(param.grad.data, op=dist.ReduceOp.SUM)\n param.grad.data /= size\n\n\ndef average_accuracy(local_accuracy):\n size = float(dist.get_world_size())\n dist.all_reduce(local_accuracy, op=dist.ReduceOp.SUM)\n global_accuracy = local_accuracy / size\n return global_accuracy\n\n\n\"\"\" Distributed Synchronous SGD Example \"\"\"\n\n\ndef run(rank, size, do_log=False):\n if (rank == 0):\n print(\"Run Fn\")\n\n torch.manual_seed(1234)\n train_set_data, train_set_target, bsz = partition_numpy_dataset()\n if (do_log):\n print(\"Data Points Per Rank {} of Size {}\".format(len(train_set_data.dataset), size))\n model = Net()\n optimizer = optim.SGD(model.parameters(),\n lr=0.01, momentum=0.5)\n\n num_batches = ceil(len(train_set_data.dataset) / float(bsz))\n if (rank == 0):\n print(\"Started Training\")\n total_data = len(train_set_data)\n epochs = 10\n total_steps = epochs * total_data\n local_time_communication = 0\n local_total_time_communication = 0\n for epoch in range(20):\n epoch_loss = 0.0\n count = 0\n for data, target in zip(train_set_data, train_set_target):\n print(\"Before: {} {} {} {} {} {} {}\".format(data.shape, num_batches, len(train_set_data.dataset),\n len(train_set_data), len(train_set_target),\n len(train_set_target.dataset),\n target.shape))\n data = np.reshape(data, (data.shape[0], 1, data.shape[1], data.shape[2])) / 128.0\n print(\"After: {} {} {} {} {} {} {}\".format(data.shape, num_batches, len(train_set_data.dataset),\n len(train_set_data),\n len(train_set_target), len(train_set_target.dataset),\n target.shape))\n # print(\n # \"Data Size {}({},{}) of Rank {} : target {}, {}\".format(data.shape, (data[0].numpy().dtype), type(data),\n # rank, target, len(target)))\n # print(data[0], target[0])\n count = count + 1\n result = '{0:.4g}'.format((count / float(total_steps)) * 100.0)\n if (rank == 0):\n print(\"Progress {}% \\r\".format(result), end='\\r')\n optimizer.zero_grad()\n output = model(data)\n loss = F.nll_loss(output, target)\n epoch_loss += loss.item()\n # print(epoch_loss)\n loss.backward()\n if (rank == 0):\n local_time_communication = time.time()\n average_gradients(model)\n if (rank == 0):\n local_time_communication = time.time() - local_time_communication\n local_total_time_communication = local_total_time_communication + local_time_communication\n optimizer.step()\n if (rank == 0):\n print('Rank ', dist.get_rank(), ', epoch ',\n epoch, ': ', epoch_loss / num_batches, 'count ', count)\n return model, local_total_time_communication\n\n\ndef test(rank, model, device, do_log=False):\n test_set_data, test_set_target, bsz = partition_numpy_dataset_test()\n model.eval()\n test_loss = 0\n correct = 0\n # print(test_set_data)\n total_samples = 0\n val1 = 0\n val2 = 0\n count = 0\n with torch.no_grad():\n for data, target in zip(test_set_data, test_set_target):\n # total_samples = total_samples + 1\n count = count + 1\n val1 = len(data)\n val2 = len(test_set_data)\n total_samples = (val1 * val2)\n data, target = data.to(device), target.to(device)\n data = np.reshape(data, (data.shape[0], 1, data.shape[1], data.shape[2])) / 128.0\n output = model(data)\n test_loss += F.nll_loss(output, target, reduction='sum').item() # sum up batch loss\n pred = output.argmax(dim=1, keepdim=True) # get the index of the max log-probability\n correct += pred.eq(target.view_as(pred)).sum().item()\n if (rank == 0 and do_log):\n print(rank, count, len(data), len(test_set_data), data.shape, output.shape, correct, total_samples)\n\n test_loss /= (total_samples)\n local_accuracy = 100.0 * correct / total_samples\n global_accuracy = average_accuracy(torch.tensor(local_accuracy))\n if (rank == 0):\n print('\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n test_loss, correct, total_samples,\n global_accuracy.numpy()))\n\n\ndef save_log(file_path=None, stat=\"\"):\n fp = open(file_path, mode=\"a+\")\n fp.write(stat + \"\\n\")\n fp.close()\n\n\ndef init_processes(rank, size, fn, backend='tcp', do_log=False):\n \"\"\" Initialize the distributed environment. \"\"\"\n dist.init_process_group(backend, rank=rank, world_size=size)\n use_cuda = torch.cuda.is_available()\n # device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n device = torch.device(\"cpu\")\n # model1 = Net()\n # test(rank, model1, device)\n total_communication_time = 0\n local_training_time = 0\n local_testing_time = 0\n if (rank == 0):\n local_training_time = time.time()\n model, total_communication_time = fn(rank, size)\n if (rank == 0):\n local_training_time = time.time() - local_training_time\n if (rank == 0):\n local_testing_time = time.time()\n test(rank, model, device, do_log=do_log)\n if (rank == 0):\n local_testing_time = time.time() - local_testing_time\n print(\"Total Training Time : {}\".format(local_training_time))\n print(\"Total Testing Time : {}\".format(local_testing_time))\n save_log(\"stats.csv\",\n stat=\"{},{},{},{}\".format(size, local_training_time, total_communication_time, local_testing_time))\n\n\nif __name__ == \"__main__\":\n do_log = False\n world_size = int(os.environ['OMPI_COMM_WORLD_SIZE'])\n world_rank = int(os.environ['OMPI_COMM_WORLD_RANK'])\n # print(world_rank, world_size)\n init_processes(world_rank, world_size, run, backend='mpi', do_log=do_log)\n"
] |
[
[
"torch.nn.Dropout2d",
"torch.nn.functional.nll_loss",
"torch.utils.data.DataLoader",
"torch.no_grad",
"torch.cuda.is_available",
"torch.flatten",
"torch.device",
"torch.distributed.get_rank",
"torch.distributed.init_process_group",
"numpy.reshape",
"torch.tensor",
"torch.nn.functional.relu",
"numpy.load",
"torch.nn.functional.max_pool2d",
"torch.nn.Conv2d",
"torch.nn.Linear",
"torch.distributed.get_world_size",
"torch.nn.functional.log_softmax",
"torch.manual_seed",
"torch.distributed.all_reduce"
]
] |
Brauntt/One-Pixel-New
|
[
"6017441f2d476f9c6c568dd886da43c6c0fd89bd"
] |
[
"networks/capsulenet/capsule_net.py"
] |
[
"from keras.layers import (\n Input,\n Conv2D,\n Activation,\n Dense,\n Flatten,\n Reshape,\n Dropout\n)\nfrom keras.layers.merge import add\nfrom keras.regularizers import l2\nfrom keras.models import Model\nfrom keras.layers.normalization import BatchNormalization\nimport keras.backend as K\nfrom keras import optimizers\nimport numpy as np\n\nfrom networks.capsulenet.capsule_layers import CapsuleLayer, PrimaryCapsule, Length,Mask\nfrom networks.capsulenet.capsulenet import CapsNet as CapsNetv1\nfrom networks.capsulenet.helper_function import load_cifar_10,load_cifar_100\n\n\ndef convolution_block(input,kernel_size=8,filters=16,kernel_regularizer=l2(1.e-4)):\n conv2 = Conv2D(filters=filters,kernel_size=kernel_size,kernel_regularizer=kernel_regularizer,\n kernel_initializer=\"he_normal\",padding=\"same\")(input)\n norm = BatchNormalization(axis=3)(conv2)\n activation = Activation(\"relu\")(norm)\n return activation \n\ndef CapsNet(input_shape,n_class,n_route,n_prime_caps=32,dense_size = (512,1024)):\n conv_filter = 256\n n_kernel = 24\n primary_channel =64\n primary_vector = 9\n vector_dim = 9\n\n target_shape = input_shape\n\n input = Input(shape=input_shape)\n\n # TODO: try leaky relu next time\n conv1 = Conv2D(filters=conv_filter,kernel_size=n_kernel, strides=1, padding='valid', activation='relu',name='conv1',kernel_initializer=\"he_normal\")(input)\n\n primary_cap = PrimaryCapsule(conv1,dim_vector=8, n_channels=64,kernel_size=9,strides=2,padding='valid')\n\n routing_layer = CapsuleLayer(num_capsule=n_class, dim_vector=vector_dim, num_routing=n_route,name='routing_layer')(primary_cap)\n\n output = Length(name='output')(routing_layer)\n\n y = Input(shape=(n_class,))\n masked = Mask()([routing_layer,y])\n \n x_recon = Dense(dense_size[0],activation='relu')(masked)\n\n for i in range(1,len(dense_size)):\n x_recon = Dense(dense_size[i],activation='relu')(x_recon)\n # Is there any other way to do \n x_recon = Dense(target_shape[0]*target_shape[1]*target_shape[2],activation='relu')(x_recon)\n x_recon = Reshape(target_shape=target_shape,name='output_recon')(x_recon)\n\n return Model([input,y],[output,x_recon])\n\n# why using 512, 1024 Maybe to mimic original 10M params?\ndef CapsNetv2(input_shape,n_class,n_route,n_prime_caps=32,dense_size = (512,1024)):\n conv_filter = 64\n n_kernel = 16\n primary_channel =64\n primary_vector = 12\n capsule_dim_size = 8\n\n target_shape = input_shape\n\n input = Input(shape=input_shape)\n\n # TODO: try leaky relu next time\n conv_block_1 = convolution_block(input,kernel_size=16,filters=64)\n primary_cap = PrimaryCapsule(conv_block_1,dim_vector=capsule_dim_size,n_channels=primary_channel,kernel_size=9,strides=2,padding='valid') \n # Suppose this act like a max pooling \n routing_layer = CapsuleLayer(num_capsule=n_class,dim_vector=capsule_dim_size*2,num_routing=n_route,name='routing_layer_1')(primary_cap)\n output = Length(name='output')(routing_layer)\n\n y = Input(shape=(n_class,))\n masked = Mask()([routing_layer,y])\n \n x_recon = Dense(dense_size[0],activation='relu')(masked)\n\n for i in range(1,len(dense_size)):\n x_recon = Dense(dense_size[i],activation='relu')(x_recon)\n # Is there any other way to do \n x_recon = Dense(np.prod(target_shape),activation='relu')(x_recon)\n x_recon = Reshape(target_shape=target_shape,name='output_recon')(x_recon)\n\n # conv_block_2 = convolution_block(routing_layer)\n # b12_sum = add([conv_block_2,conv_block_1])\n\n return Model([input,y],[output,x_recon])\n\ndef margin_loss(y_true, y_pred):\n \"\"\"\n Margin loss for Eq.(4). When y_true[i, :] contains not just one `1`, this loss should work too. Not test it.\n :param y_true: [None, n_classes]\n :param y_pred: [None, num_capsule]\n :return: a scalar loss value.\n \"\"\"\n L = y_true * K.square(K.maximum(0., 0.9 - y_pred)) + \\\n 0.5 * (1 - y_true) * K.square(K.maximum(0., y_pred - 0.1))\n\n return K.mean(K.sum(L, 1))\n\ndef train(epochs=50,batch_size=64,mode=1):\n import numpy as np\n import os\n from keras import callbacks\n from keras.utils.vis_utils import plot_model\n if mode==1:\n num_classes = 10\n (x_train,y_train),(x_test,y_test) = load_cifar_10()\n else:\n num_classes = 100\n (x_train,y_train),(x_test,y_test) = load_cifar_100()\n model = CapsNetv1(input_shape=[32, 32, 3],\n n_class=num_classes,\n n_route=3)\n print('x_train shape:', x_train.shape)\n print(x_train.shape[0], 'train samples')\n print(x_test.shape[0], 'test samples')\n\n model.summary()\n log = callbacks.CSVLogger('networks/models/results/capsule-cifar-'+str(num_classes)+'-log.csv')\n tb = callbacks.TensorBoard(log_dir='networks/models/results/tensorboard-capsule-cifar-'+str(num_classes)+'-logs',\n batch_size=batch_size, histogram_freq=True)\n checkpoint = callbacks.ModelCheckpoint('networks/models/capsnet.h5',\n save_best_only=True, verbose=1)\n lr_decay = callbacks.LearningRateScheduler(schedule=lambda epoch: 0.001 * np.exp(-epoch / 10.))\n\n # plot_model(model, to_file='models/capsule-cifar-'+str(num_classes)+'.png', show_shapes=True)\n\n model.compile(optimizer=optimizers.Adam(lr=0.001),\n loss=[margin_loss, 'mse'],\n loss_weights=[1., 0.1],\n metrics={'output_recon':'accuracy','output':'accuracy'})\n from networks.capsulenet.helper_function import data_generator\n\n generator = data_generator(x_train,y_train,batch_size)\n # Image generator significantly increase the accuracy and reduce validation loss\n model.fit_generator(generator,\n steps_per_epoch=x_train.shape[0] // batch_size,\n validation_data=([x_test, y_test], [y_test, x_test]),\n epochs=epochs, verbose=1, max_q_size=100,\n callbacks=[log,tb,checkpoint,lr_decay])\n \n return model\n\ndef test(epoch, mode=1):\n import matplotlib.pyplot as plt\n from PIL import Image\n from networks.capsulenet.helper_function import combine_images\n\n if mode == 1:\n num_classes =10\n _,(x_test,y_test) = load_cifar_10()\n else:\n num_classes = 100\n _,(x_test,y_test) = load_cifar_100()\n \n model = CapsNetv2(input_shape=[32, 32, 3],\n n_class=num_classes,\n n_route=3)\n model.load_weights('weights/capsule_weights/capsule-cifar-'+str(num_classes)+'weights-{:02d}.h5'.format(epoch)) \n print(\"Weights loaded, start validation\") \n # model.load_weights('weights/capsule-weights-{:02d}.h5'.format(epoch)) \n y_pred, x_recon = model.predict([x_test, y_test], batch_size=100)\n print('-'*50)\n # Test acc: 0.7307\n print('Test acc:', np.sum(np.argmax(y_pred, 1) == np.argmax(y_test, 1))/y_test.shape[0])\n\n img = combine_images(np.concatenate([x_test[:50],x_recon[:50]]))\n image = img*255\n Image.fromarray(image.astype(np.uint8)).save(\"results/real_and_recon.png\")\n print('Reconstructed images are saved to ./results/real_and_recon.png')\n print('-'*50)\n plt.imshow(plt.imread(\"results/real_and_recon.png\", ))\n plt.show()\n"
] |
[
[
"matplotlib.pyplot.imread",
"numpy.concatenate",
"numpy.argmax",
"numpy.prod",
"numpy.exp",
"matplotlib.pyplot.show"
]
] |
bstee615/ReVeal
|
[
"ca31b783384b4cdb09b69950e48f79fa0748ef1d",
"ca31b783384b4cdb09b69950e48f79fa0748ef1d"
] |
[
"Vuld_SySe/code_data.py",
"Vuld_SySe/representation_learning/trainer.py"
] |
[
"import copy\n\nimport sys\n\nimport numpy as np\nimport torch\nfrom gensim.models import Word2Vec\n\n\nclass DataEntry:\n def __init__(self, dataset, sentence, label, meta_data=None, parser=None):\n self.dataset = dataset\n assert isinstance(self.dataset, DataSet)\n self.sentence = sentence\n self.label = label\n if parser is not None:\n self.words = parser.parse(self.sentence)\n else:\n self.words = self.sentence.split()\n self.meta_data = meta_data\n pass\n\n def init_word_index(self):\n assert self.dataset.vocab is not None, 'Initialize Dataset Vocabulary First'\n self.word_indices = [self.dataset.vocab.start_token]\n for word in self.words:\n self.word_indices.append(self.dataset.vocab.get_token_id(word))\n self.word_indices.append(self.dataset.vocab.end_token)\n\n def __repr__(self):\n return str(self.word_indices) + '\\t' + str(self.label)\n\n def __hash__(self):\n return str(self.sentence).__hash__\n\n\nclass DataSet:\n class Vocabulary:\n def __init__(self):\n self.start_token = 0\n self.end_token = 1\n self.pad_token = 2\n self.unk = 3\n self.index_to_token = {0: \"<START>\", 1:\"<END>\", 2:\"<PAD>\", 3: \"<UNK>\"}\n self.token_to_index = {\"<START>\": 0, \"<END>\": 1, \"<PAD>\": 2, \"<UNK>\": 3}\n self.count = 4\n pass\n\n def get_token_id(self, token):\n if token in self.token_to_index.keys():\n return self.token_to_index[token]\n else:\n return self.unk\n\n def get_token(self, id):\n if id >= self.count:\n return \"<UNK>\"\n return self.index_to_token[id]\n\n def add_token(self, token):\n index = self.get_token_id(token)\n if index != self.unk:\n return index\n else:\n index = self.count\n self.count += 1\n self.index_to_token[index] = token\n self.token_to_index[token] = index\n return index\n\n def __init__(self, initial_embedding_path=None, min_seq_len=-1, intra_dataset=False):\n self.train_entries = []\n self.test_entries = []\n self.dev_entries = []\n self.vocab = None\n self.min_seq_len = min_seq_len\n self.initial_embedding_present = (initial_embedding_path is not None)\n if self.initial_embedding_present:\n self.initial_emddings = Word2Vec.load(initial_embedding_path)\n self.intra_dataset = intra_dataset\n\n def add_data_entry(self, entry, part='train'):\n assert isinstance(entry, DataEntry)\n if self.initial_embedding_present:\n entry.wvmodel = self.initial_emddings\n if part == 'train':\n if self.intra_dataset:\n if entry in self.train_entries:\n return False\n self.train_entries.append(entry)\n elif part == 'test':\n self.test_entries.append(entry)\n else:\n self.dev_entries.append(entry)\n return True\n\n def split_using_fidx(self, p, balance=None):\n print(\"Splitting based on function\", file=sys.stderr)\n fidx_to_entries = {}\n for entry in self.train_entries:\n assert isinstance(entry, DataEntry)\n fidx = entry.meta_data\n if fidx not in fidx_to_entries.keys():\n fidx_to_entries[fidx] = []\n fidx_to_entries[fidx].append(entry)\n findices = list(fidx_to_entries.keys())\n np.random.shuffle(findices)\n test_len = int(len(findices) * p)\n test_findices = findices[:test_len]\n train_findices = findices[test_len:]\n train_entries = []\n self.test_entries = []\n for fidx in train_findices:\n train_entries.extend(fidx_to_entries[fidx])\n for fidx in test_findices:\n self.test_entries.extend(fidx_to_entries[fidx])\n if balance is None:\n self.train_entries = train_entries\n else:\n final_train_entries = []\n positive_entries = []\n negative_entries = []\n for e in train_entries:\n if e.label == 1:\n positive_entries.append(e)\n else:\n negative_entries.append(e)\n usample_ratio = balance[0]\n osample_multi = balance[1]\n for e in negative_entries:\n if np.random.uniform(0, 1) <= usample_ratio:\n final_train_entries.append(e)\n for e in positive_entries:\n for _ in range(osample_multi):\n final_train_entries.append(e)\n self.train_entries = final_train_entries\n pass\n\n def split_test_data(self, p, balance=None):\n if self.train_entries[0].meta_data is not None:\n self.split_using_fidx(p, balance=balance)\n else:\n np.random.shuffle(self.train_entries)\n test_len = int(p * len(self.train_entries))\n self.test_entries = self.train_entries[:test_len]\n entries = self.train_entries[test_len:]\n if balance is None:\n self.train_entries = entries\n else:\n final_train_entries = []\n positive_entries = []\n negative_entries = []\n for e in entries:\n if e.label == 1:\n positive_entries.append(e)\n else:\n negative_entries.append(e)\n usample_ratio = balance[0]\n osample_multi = balance[1]\n for e in negative_entries:\n if np.random.uniform(0, 1) <= usample_ratio:\n final_train_entries.append(e)\n for e in positive_entries:\n for _ in range(osample_multi):\n final_train_entries.append(e)\n self.train_entries = final_train_entries\n pass\n\n def get_random_positive_example(self, max_code_len=99999999):\n positive_indices = []\n for eidx, entry in enumerate(self.train_entries):\n if entry.label == 1:\n positive_indices.append(eidx)\n pidx = np.random.choice(positive_indices)\n entry = self.train_entries[pidx]\n while len(entry.word_indices) >= max_code_len:\n pidx = np.random.choice(positive_indices)\n entry = self.train_entries[pidx]\n return entry.word_indices, entry.label, pidx\n\n def write_examples(self):\n def prepare_code(code):\n if isinstance(code, list):\n code = ' '.join(code)\n tokens = code.split()\n new_tokens = []\n for t in tokens:\n t = t.strip()\n if t.startswith('F') and t.endswith('('):\n new_tokens.append(t[:-1])\n else:\n new_tokens.append(t)\n return ' '.join(new_tokens)\n\n import os\n from tqdm import tqdm\n d = \"for-bert\"\n if not os.path.exists(d):\n os.mkdir(d)\n train_file = open(os.path.join(d, 'train.tsv'), 'w')\n test_file = open(os.path.join(d, 'test.tsv'), 'w')\n for eidx, e in enumerate(tqdm(self.train_entries)):\n assert isinstance(e, DataEntry)\n code = prepare_code(e.sentence)\n line = str(eidx) + '\\t' + str(e.label) + '\\t' + str(e.meta_data) + '\\t' + code + '\\n'\n train_file.write(line)\n for eidx, e in enumerate(tqdm(self.dev_entries)):\n assert isinstance(e, DataEntry)\n code = prepare_code(e.sentence)\n line = str(eidx) + '\\t' + str(e.label) + '\\t' + str(e.meta_data) + '\\t' + code + '\\n'\n train_file.write(line)\n train_file.close()\n for eidx, e in enumerate(tqdm(self.test_entries)):\n assert isinstance(e, DataEntry)\n code = prepare_code(e.sentence)\n line = str(eidx) + '\\t' + str(e.label) + '\\t' + str(e.meta_data) + '\\t' + code + '\\n'\n test_file.write(line)\n test_file.close()\n\n\n def get_random_negative_example(self, max_code_len=99999999):\n negative_indices = []\n for eidx, entry in enumerate(self.train_entries):\n if entry.label == 0:\n negative_indices.append(eidx)\n nidx = np.random.choice(negative_indices)\n entry = self.train_entries[nidx]\n while len(entry.word_indices) >= max_code_len:\n pidx = np.random.choice(negative_indices)\n entry = self.train_entries[pidx]\n return entry.word_indices, entry.label, nidx\n\n def get_random_positive_test_example(self, max_code_len=99999999):\n positive_indices = []\n for eidx, entry in enumerate(self.test_entries):\n if entry.label == 1:\n positive_indices.append(eidx)\n pidx = np.random.choice(positive_indices)\n entry = self.test_entries[pidx]\n while len(entry.word_indices) >= max_code_len:\n pidx = np.random.choice(positive_indices)\n entry = self.test_entries[pidx]\n return entry.word_indices, entry.label, pidx\n\n def get_random_negative_test_example(self,max_code_len=99999999):\n negative_indices = []\n for eidx, entry in enumerate(self.test_entries):\n if entry.label == 0:\n negative_indices.append(eidx)\n nidx = np.random.choice(negative_indices)\n entry = self.test_entries[nidx]\n while len(entry.word_indices) >= max_code_len:\n pidx = np.random.choice(negative_indices)\n entry = self.test_entries[pidx]\n return entry.word_indices, entry.label, nidx\n\n def convert_word_indices_to_feature_matric(self, word_indices):\n max_seq_len = len(word_indices)\n indices = [self.vocab.pad_token] * max_seq_len\n if self.initial_embedding_present:\n vectors = [np.zeros(shape=self.initial_emddings.vector_size)] * max_seq_len\n for i, w_index in enumerate(word_indices):\n indices[i] = w_index\n if self.initial_embedding_present:\n token = self.vocab.get_token(w_index)\n if token in self.initial_emddings.wv:\n vectors[i] = self.initial_emddings.wv[token]\n elif '<UNK>' in self.initial_emddings.wv:\n vectors[i] = self.initial_emddings.wv['<UNK>']\n if self.initial_embedding_present:\n return torch.FloatTensor(np.asarray(vectors))\n else:\n return torch.LongTensor(np.asarray(indices))\n pass\n\n def init_data_set(self, batch_size=32):\n if len(self.dev_entries) == 0:\n self.dev_entries = self.train_entries[:int(0.1 * len(self.train_entries))]\n self.train_entries = self.train_entries[int(0.1 * len(self.train_entries)):]\n self.build_vocabulary()\n for entry in self.train_entries:\n entry.init_word_index()\n for entry in self.dev_entries:\n entry.init_word_index()\n for entry in self.test_entries:\n entry.init_word_index()\n self.batch_size = batch_size\n self.initialize_batch()\n\n def build_vocabulary(self):\n self.vocab = DataSet.Vocabulary()\n words = {}\n total_words = 0\n for entry in self.train_entries:\n for word in entry.words:\n if word in words.keys():\n words[word] += 1\n else:\n words[word] = 1\n total_words += 1\n for entry in self.test_entries:\n for word in entry.words:\n if word in words.keys():\n words[word] += 1\n else:\n words[word] = 1\n total_words += 1\n for entry in self.dev_entries:\n for word in entry.words:\n if word in words.keys():\n words[word] += 1\n else:\n words[word] = 1\n total_words += 1\n word_freq = [[key, words[key]] for key in words.keys()]\n word_freq = sorted(word_freq, key=lambda x:x[1], reverse=True)\n accepted_words = word_freq\n for word, count in accepted_words:\n self.vocab.add_token(word)\n # print('Total Number of Words', total_words)\n # print('Unique Words : ', len(words.keys()))\n # print('Vocab Size : ', len(accepted_words))\n # print('=' * 100)\n print('Total Number of Words', total_words, file=sys.stderr)\n print('Unique Words : ', len(words.keys()), file=sys.stderr)\n print('Vocab Size : ', len(accepted_words), file=sys.stderr)\n print('=' * 100, file=sys.stderr)\n\n def get_data_entries_by_id(self, dataset, ids):\n max_seq_len = max([len(dataset[id].word_indices) for id in ids])\n if self.min_seq_len != -1:\n max_seq_len = max(max_seq_len, self.min_seq_len)\n token_indices = []\n masks = []\n labels = []\n token_vectors = []\n for index in ids:\n indices = [self.vocab.pad_token] * max_seq_len\n if self.initial_embedding_present:\n vectors = [np.zeros(shape=self.initial_emddings.vector_size)] * max_seq_len\n mask = [1] * max_seq_len\n for i, w_index in enumerate(dataset[index].word_indices):\n indices[i] = w_index\n mask[i] = 0\n if self.initial_embedding_present:\n token = self.vocab.get_token(w_index)\n if token in self.initial_emddings.wv:\n vectors[i] = self.initial_emddings.wv[token]\n elif '<UNK>' in self.initial_emddings.wv:\n vectors[i] = self.initial_emddings.wv['<UNK>']\n token_indices.append(indices)\n masks.append(mask)\n if self.initial_embedding_present:\n token_vectors.append(vectors)\n labels.append(dataset[index].label)\n if not self.initial_embedding_present:\n return torch.LongTensor(np.asarray(token_indices)), \\\n torch.IntTensor(np.asarray(masks)), \\\n torch.LongTensor(np.asarray(labels))\n else:\n return torch.FloatTensor(np.asarray(token_vectors)), \\\n torch.IntTensor(np.asarray(masks)), \\\n torch.LongTensor(np.asarray(labels))\n\n def get_train_dataset_by_ids(self, ids):\n return self.get_data_entries_by_id(self.train_entries, ids)\n\n def get_test_dataset_by_ids(self, ids):\n return self.get_data_entries_by_id(self.test_entries, ids)\n\n def get_dev_dataset_by_ids(self, ids):\n return self.get_data_entries_by_id(self.dev_entries, ids)\n\n def initialize_batch(self):\n total = len(self.train_entries)\n indices = np.arange(0,total-1, 1)\n np.random.shuffle(indices)\n self.batch_indices = []\n start = 0\n end = len(indices)\n curr = start\n while curr < end:\n c_end = curr + self.batch_size\n if c_end > end:\n c_end = end\n self.batch_indices.append(indices[curr:c_end])\n curr = c_end\n\n def get_all_test_examples(self):\n dataset = [None] * len(self.test_entries)\n for i in range(len(self.test_entries)):\n dataset[i] = [self.test_entries[i].meta_data if self.test_entries[i].meta_data is not None else i]\n dataset[i].extend(list(self.get_test_dataset_by_ids([i])))\n return dataset\n\n def get_all_train_examples(self):\n dataset = [None] * len(self.train_entries)\n for i in range(len(self.train_entries)):\n dataset[i] = [self.train_entries[i].meta_data if self.train_entries[i].meta_data is not None else i]\n dataset[i].extend(list(self.get_train_dataset_by_ids([i])))\n return dataset\n\n def get_all_dev_examples(self):\n dataset = [None] * len(self.dev_entries)\n for i in range(len(self.dev_entries)):\n dataset[i] = [self.dev_entries[i].meta_data if self.dev_entries[i].meta_data is not None else i]\n dataset[i].extend(list(self.get_dev_dataset_by_ids([i])))\n return dataset\n\n def get_all_test_batches(self, batch_size=32):\n dataset = []\n indices = [i for i in range(len(self.test_entries))]\n batch_indices = []\n start = 0\n end = len(indices)\n curr = start\n while curr < end:\n c_end = curr + batch_size\n if c_end > end:\n c_end = end\n batch_indices.append(indices[curr:c_end])\n curr = c_end\n for indices in batch_indices:\n dataset.append(self.get_test_dataset_by_ids(indices))\n return dataset\n\n def get_next_batch_train_data(self):\n if len(self.batch_indices) == 0:\n self.initialize_batch()\n indices = self.batch_indices[0]\n self.batch_indices = self.batch_indices[1:]\n return self.get_train_dataset_by_ids(indices)\n\n def get_batch_count(self):\n return len(self.batch_indices)\n\n def get_all_batches(self):\n dataset = []\n np.random.shuffle(self.train_entries)\n self.initialize_batch()\n for indices in self.batch_indices:\n dataset.append(self.get_train_dataset_by_ids(indices))\n return dataset\n\n def get_selective_batches(self, selection=20):\n dataset = []\n self.initialize_batch()\n for idx, indices in enumerate(self.batch_indices):\n dataset.append(self.get_train_dataset_by_ids(indices))\n if idx == selection:\n break\n return dataset\n\n def get_test_data(self):\n return self.get_data_entries_by_id(self.test_entries, list(range(len(self.test_entries))))\n\n def get_complete_train_data(self):\n return self.get_data_entries_by_id(self.train_entries, list(range(len(self.train_entries))))\n\n def get_sentence(self, entries, i):\n return ' '.join(entries[i].words)\n pass\n\n",
"import copy\n\nimport numpy as np\nimport sys\nimport torch\nfrom graph_dataset import DataSet\nfrom sklearn.metrics import accuracy_score as acc, precision_score as pr, recall_score as rc, f1_score as f1\nfrom tqdm import tqdm\nfrom tsne import plot_embedding\n\nfrom models import MetricLearningModel\n\n\ndef train(model, dataset, optimizer, num_epochs, max_patience=5,\n valid_every=1, cuda_device=-1, output_buffer=sys.stderr):\n if output_buffer is not None:\n print('Start Training', file=output_buffer)\n assert isinstance(model, MetricLearningModel) and isinstance(dataset, DataSet)\n best_f1 = 0\n best_model = None\n patience_counter = 0\n train_losses = []\n try:\n for epoch_count in range(num_epochs):\n batch_losses = []\n num_batches = dataset.initialize_train_batches()\n output_batches_generator = range(num_batches)\n if output_buffer is not None:\n output_batches_generator = tqdm(output_batches_generator)\n for _ in output_batches_generator:\n model.train()\n model.zero_grad()\n optimizer.zero_grad()\n features, targets, same_class_features, diff_class_features = dataset.get_next_train_batch()\n if cuda_device != -1:\n features = features.cuda(device=cuda_device)\n targets = targets.cuda(device=cuda_device)\n same_class_features = same_class_features.cuda(device=cuda_device)\n diff_class_features = diff_class_features.cuda(device=cuda_device)\n probabilities, representation, batch_loss = model(\n example_batch=features, targets=targets,\n positive_batch=same_class_features, negative_batch=diff_class_features\n )\n batch_losses.append(batch_loss.detach().cpu().item())\n batch_loss.backward()\n optimizer.step()\n epoch_loss = np.sum(batch_losses).item()\n train_losses.append(epoch_loss)\n if output_buffer is not None:\n print('=' * 100, file=output_buffer)\n print('After epoch %2d Train loss : %10.4f' % (epoch_count, epoch_loss), file=output_buffer)\n print('=' * 100, file=output_buffer)\n if epoch_count % valid_every == 0:\n valid_batch_count = dataset.initialize_valid_batches()\n vacc, vpr, vrc, vf1 = evaluate(\n model, dataset.get_next_valid_batch, valid_batch_count, cuda_device, output_buffer)\n if vf1 > best_f1:\n best_f1 = vf1\n patience_counter = 0\n best_model = copy.deepcopy(model.state_dict())\n else:\n patience_counter += 1\n if dataset.initialize_test_batches() != 0:\n tacc, tpr, trc, tf1 = evaluate(\n model, dataset.get_next_test_batch, dataset.initialize_test_batches(), cuda_device,\n output_buffer=output_buffer\n )\n if output_buffer is not None:\n print('Test Set: Acc: %6.3f\\tPr: %6.3f\\tRc %6.3f\\tF1: %6.3f' % \\\n (tacc, tpr, trc, tf1), file=output_buffer)\n print('=' * 100, file=output_buffer)\n if output_buffer is not None:\n print('Validation Set: Acc: %6.3f\\tPr: %6.3f\\tRc %6.3f\\tF1: %6.3f\\tPatience: %2d' % \\\n (vacc, vpr, vrc, vf1, patience_counter), file=output_buffer)\n print('-' * 100, file=output_buffer)\n if patience_counter == max_patience:\n if best_model is not None:\n model.load_state_dict(best_model)\n if cuda_device != -1:\n model.cuda(device=cuda_device)\n break\n except KeyboardInterrupt:\n if output_buffer is not None:\n print('Training Interrupted by User!')\n if best_model is not None:\n model.load_state_dict(best_model)\n if cuda_device != -1:\n model.cuda(device=cuda_device)\n if dataset.initialize_test_batches() != 0:\n tacc, tpr, trc, tf1 = evaluate(\n model, dataset.get_next_test_batch, dataset.initialize_test_batches(), cuda_device)\n if output_buffer is not None:\n print('*' * 100, file=output_buffer)\n print('*' * 100, file=output_buffer)\n print('Test Set: Acc: %6.3f\\tPr: %6.3f\\tRc %6.3f\\tF1: %6.3f' % \\\n (tacc, tpr, trc, tf1), file=output_buffer)\n print('%f\\t%f\\t%f\\t%f' % (tacc, tpr, trc, tf1))\n print('*' * 100, file=output_buffer)\n print('*' * 100, file=output_buffer)\n\n\ndef predict(model, iterator_function, _batch_count, cuda_device):\n probs = predict_proba(model, iterator_function, _batch_count, cuda_device)\n return np.argmax(probs, axis=-1)\n\n\ndef predict_proba(model, iterator_function, _batch_count, cuda_device):\n model.eval()\n with torch.no_grad():\n predictions = []\n for _ in tqdm(range(_batch_count)):\n features, targets = iterator_function()\n if cuda_device != -1:\n features = features.cuda(device=cuda_device)\n probs, _, _ = model(example_batch=features)\n predictions.extend(probs)\n model.train()\n return np.array(predictions)\n\n\ndef evaluate(model, iterator_function, _batch_count, cuda_device, output_buffer=sys.stderr):\n if output_buffer is not None:\n print(_batch_count, file=output_buffer)\n model.eval()\n with torch.no_grad():\n predictions = []\n expectations = []\n batch_generator = range(_batch_count)\n if output_buffer is not None:\n batch_generator = tqdm(batch_generator)\n for _ in batch_generator:\n features, targets = iterator_function()\n if cuda_device != -1:\n features = features.cuda(device=cuda_device)\n probs, _, _ = model(example_batch=features)\n batch_pred = np.argmax(probs.detach().cpu().numpy(), axis=-1).tolist()\n batch_tgt = targets.detach().cpu().numpy().tolist()\n predictions.extend(batch_pred)\n expectations.extend(batch_tgt)\n model.train()\n return acc(expectations, predictions) * 100, \\\n pr(expectations, predictions) * 100, \\\n rc(expectations, predictions) * 100, \\\n f1(expectations, predictions) * 100,\n\n\ndef show_representation(model, iterator_function, _batch_count, cuda_device, name, output_buffer=sys.stderr):\n model.eval()\n with torch.no_grad():\n representations = []\n expected_targets = []\n batch_generator = range(_batch_count)\n if output_buffer is not None:\n batch_generator = tqdm(batch_generator)\n for _ in batch_generator:\n iterator_values = iterator_function()\n features, targets = iterator_values[0], iterator_values[1]\n if cuda_device != -1:\n features = features.cuda(device=cuda_device)\n _, repr, _ = model(example_batch=features)\n repr = repr.detach().cpu().numpy()\n print(repr.shape)\n representations.extend(repr.tolist())\n expected_targets.extend(targets.numpy().tolist())\n model.train()\n print(np.array(representations).shape)\n print(np.array(expected_targets).shape)\n plot_embedding(representations, expected_targets, title=name)\n"
] |
[
[
"numpy.random.choice",
"numpy.asarray",
"numpy.arange",
"numpy.random.shuffle",
"numpy.random.uniform",
"numpy.zeros"
],
[
"sklearn.metrics.precision_score",
"numpy.argmax",
"torch.no_grad",
"sklearn.metrics.f1_score",
"numpy.array",
"sklearn.metrics.recall_score",
"numpy.sum",
"sklearn.metrics.accuracy_score"
]
] |
kyri-petrou/windpowerlib
|
[
"11907880634970fd20ccf403e92f61ebdeae4022"
] |
[
"windpowerlib/power_output.py"
] |
[
"\"\"\"\nThe ``power_output`` module contains functions to calculate the power output\nof a wind turbine.\n\nSPDX-FileCopyrightText: 2019 oemof developer group <[email protected]>\nSPDX-License-Identifier: MIT\n\"\"\"\nimport numpy as np\nimport pandas as pd\n\n\ndef power_coefficient_curve(\n wind_speed,\n power_coefficient_curve_wind_speeds,\n power_coefficient_curve_values,\n rotor_diameter,\n density,\n):\n r\"\"\"\n Calculates the turbine power output using a power coefficient curve.\n\n This function is carried out when the parameter `power_output_model` of an\n instance of the :class:`~.modelchain.ModelChain` class is\n 'power_coefficient_curve'.\n\n Parameters\n ----------\n wind_speed : :pandas:`pandas.Series<series>` or numpy.array\n Wind speed at hub height in m/s.\n power_coefficient_curve_wind_speeds : :pandas:`pandas.Series<series>` or numpy.array\n Wind speeds in m/s for which the power coefficients are provided in\n `power_coefficient_curve_values`.\n power_coefficient_curve_values : :pandas:`pandas.Series<series>` or numpy.array\n Power coefficients corresponding to wind speeds in\n `power_coefficient_curve_wind_speeds`.\n rotor_diameter : float\n Rotor diameter in m.\n density : :pandas:`pandas.Series<series>` or numpy.array\n Density of air at hub height in kg/m³.\n\n Returns\n -------\n :pandas:`pandas.Series<series>` or numpy.array\n Electrical power output of the wind turbine in W.\n Data type depends on type of `wind_speed`.\n\n Notes\n -----\n The following equation is used [1]_ [2]_:\n\n .. math:: P=\\frac{1}{8}\\cdot\\rho_{hub}\\cdot d_{rotor}^{2}\n \\cdot\\pi\\cdot v_{wind}^{3}\\cdot cp\\left(v_{wind}\\right)\n\n with:\n P: power [W], :math:`\\rho`: density [kg/m³], d: diameter [m],\n v: wind speed [m/s], cp: power coefficient\n\n It is assumed that the power output for wind speeds above the maximum\n and below the minimum wind speed given in the power coefficient curve is\n zero.\n\n References\n ----------\n .. [1] Gasch, R., Twele, J.: \"Windkraftanlagen\". 6. Auflage, Wiesbaden,\n Vieweg + Teubner, 2010, pages 35ff, 208\n .. [2] Hau, E.: \"Windkraftanlagen - Grundlagen, Technik, Einsatz,\n Wirtschaftlichkeit\". 4. Auflage, Springer-Verlag, 2008, p. 542\n\n \"\"\"\n power_coefficient_time_series = np.interp(\n wind_speed,\n power_coefficient_curve_wind_speeds,\n power_coefficient_curve_values,\n left=0,\n right=0,\n )\n power_output = (\n 1\n / 8\n * density\n * rotor_diameter ** 2\n * np.pi\n * np.power(wind_speed, 3)\n * power_coefficient_time_series\n )\n # Power_output as pd.Series if wind_speed is pd.Series (else: np.array)\n if isinstance(wind_speed, pd.Series):\n power_output = pd.Series(\n data=power_output,\n index=wind_speed.index,\n name=\"feedin_power_plant\",\n )\n else:\n power_output = np.array(power_output)\n return power_output\n\n\ndef power_curve(\n wind_speed,\n power_curve_wind_speeds,\n power_curve_values,\n density=None,\n density_correction=False,\n):\n r\"\"\"\n Calculates the turbine power output using a power curve.\n\n This function is carried out when the parameter `power_output_model` of an\n instance of the :class:`~.modelchain.ModelChain` class is 'power_curve'. If\n the parameter `density_correction` is True the density corrected power\n curve (see :py:func:`~.power_curve_density_correction`) is used.\n\n Parameters\n ----------\n wind_speed : :pandas:`pandas.Series<series>` or numpy.array\n Wind speed at hub height in m/s.\n power_curve_wind_speeds : :pandas:`pandas.Series<series>` or numpy.array\n Wind speeds in m/s for which the power curve values are provided in\n `power_curve_values`.\n power_curve_values : pandas.Series or numpy.array\n Power curve values corresponding to wind speeds in\n `power_curve_wind_speeds`.\n density : :pandas:`pandas.Series<series>` or numpy.array\n Density of air at hub height in kg/m³. This parameter is needed\n if `density_correction` is True. Default: None.\n density_correction : bool\n If the parameter is True the density corrected power curve (see\n :py:func:`~.power_curve_density_correction`) is used for the\n calculation of the turbine power output. In this case `density`\n cannot be None. Default: False.\n\n Returns\n -------\n :pandas:`pandas.Series<series>` or numpy.array\n Electrical power output of the wind turbine in W.\n Data type depends on type of `wind_speed`.\n\n Notes\n -------\n It is assumed that the power output for wind speeds above the maximum\n and below the minimum wind speed given in the power curve is zero.\n\n \"\"\"\n if density_correction is False:\n power_output = np.interp(\n wind_speed,\n power_curve_wind_speeds,\n power_curve_values,\n left=0,\n right=0,\n )\n # Power_output as pd.Series if wind_speed is pd.Series (else: np.array)\n if isinstance(wind_speed, pd.Series):\n power_output = pd.Series(\n data=power_output,\n index=wind_speed.index,\n name=\"feedin_power_plant\",\n )\n else:\n power_output = np.array(power_output)\n elif density_correction is True:\n power_output = power_curve_density_correction(\n wind_speed, power_curve_wind_speeds, power_curve_values, density\n )\n else:\n raise TypeError(\n \"'{0}' is an invalid type. \".format(type(density_correction))\n + \"`density_correction` must \"\n + \"be Boolean (True or False).\"\n )\n return power_output\n\n\ndef power_curve_density_correction(\n wind_speed, power_curve_wind_speeds, power_curve_values, density\n):\n r\"\"\"\n Calculates the turbine power output using a density corrected power curve.\n This function is carried out when the parameter `density_correction` of an\n instance of the :class:`~.modelchain.ModelChain` class is True.\n Parameters\n ----------\n wind_speed : :pandas:`pandas.Series<series>` or numpy.array\n Wind speed at hub height in m/s.\n power_curve_wind_speeds : :pandas:`pandas.Series<series>` or numpy.array\n Wind speeds in m/s for which the power curve values are provided in\n `power_curve_values`.\n power_curve_values : :pandas:`pandas.Series<series>` or numpy.array\n Power curve values corresponding to wind speeds in\n `power_curve_wind_speeds`.\n density : :pandas:`pandas.Series<series>` or numpy.array\n Density of air at hub height in kg/m³.\n Returns\n -------\n :pandas:`pandas.Series<series>` or numpy.array\n Electrical power output of the wind turbine in W.\n Data type depends on type of `wind_speed`.\n Notes\n -----\n The following equation is used for the site specific power curve wind\n speeds [1]_ [2]_ [3]_:\n .. math:: v_{site}=v_{std}\\cdot\\left(\\frac{\\rho_0}\n {\\rho_{site}}\\right)^{p(v)}\n with:\n .. math:: p=\\begin{cases}\n \\frac{1}{3} & v_{std} \\leq 7.5\\text{ m/s}\\\\\n \\frac{1}{15}\\cdot v_{std}-\\frac{1}{6} & 7.5\n \\text{ m/s}<v_{std}<12.5\\text{ m/s}\\\\\n \\frac{2}{3} & \\geq 12.5 \\text{ m/s}\n \\end{cases},\n v: wind speed [m/s], :math:`\\rho`: density [kg/m³]\n :math:`v_{std}` is the standard wind speed in the power curve\n (:math:`v_{std}`, :math:`P_{std}`),\n :math:`v_{site}` is the density corrected wind speed for the power curve\n (:math:`v_{site}`, :math:`P_{std}`),\n :math:`\\rho_0` is the ambient density (1.225 kg/m³)\n and :math:`\\rho_{site}` the density at site conditions (and hub height).\n It is assumed that the power output for wind speeds above the maximum\n and below the minimum wind speed given in the power curve is zero.\n References\n ----------\n .. [1] Svenningsen, L.: \"Power Curve Air Density Correction And Other\n Power Curve Options in WindPRO\". 1st edition, Aalborg,\n EMD International A/S , 2010, p. 4\n .. [2] Svenningsen, L.: \"Proposal of an Improved Power Curve Correction\".\n EMD International A/S , 2010\n .. [3] Biank, M.: \"Methodology, Implementation and Validation of a\n Variable Scale Simulation Model for Windpower based on the\n Georeferenced Installation Register of Germany\". Master's Thesis\n at Reiner Lemoine Institute, 2014, p. 13\n \"\"\"\n if density is None:\n raise TypeError(\n \"`density` is None. For the calculation with a \"\n + \"density corrected power curve density at hub \"\n + \"height is needed.\"\n )\n\n # Convert pd.Series to a numpy array to speed up the interpolation below.\n if isinstance(wind_speed, pd.Series):\n # save the indexes for later conversion to pd.Series\n wind_speed_indexes = wind_speed.index\n # change the wind speed Series to numpy array\n wind_speed = wind_speed.values\n # Set the panda series flag True\n panda_series = True\n else:\n panda_series = False\n\n power_output = [\n (\n np.interp(\n wind_speed[i],\n power_curve_wind_speeds\n * (1.225 / density[i])\n ** (\n np.interp(\n power_curve_wind_speeds, [7.5, 12.5], [1 / 3, 2 / 3]\n )\n ),\n power_curve_values,\n left=0,\n right=0,\n )\n )\n for i in range(len(wind_speed))\n ]\n\n # Convert results to the data type of the input data\n if panda_series:\n power_output = pd.Series(\n data=power_output,\n index=wind_speed_indexes, # Use previously saved wind speed index\n name=\"feedin_power_plant\",\n )\n else:\n power_output = np.array(power_output)\n return power_output\n"
] |
[
[
"numpy.array",
"numpy.interp",
"pandas.Series",
"numpy.power"
]
] |
SCCH-KVS/NuclearSegmentationPipeline
|
[
"5b4a37b74890e0a6fb767061c60a9f2a880d370d"
] |
[
"DeepLearningArchitectures/MaskRCNN/config.py"
] |
[
"\"\"\"\r\nMask R-CNN\r\nBase Configurations class.\r\n\r\nCopyright (c) 2017 Matterport, Inc.\r\nLicensed under the MIT License (see LICENSE for details)\r\nWritten by Waleed Abdulla\r\n\"\"\"\r\n\r\nimport math\r\nimport numpy as np\r\n\r\n\r\n# Base Configuration Class\r\n# Don't use this class directly. Instead, sub-class it and override\r\n# the configurations you need to change.\r\n\r\nclass Config(object):\r\n \"\"\"Base configuration class. For custom configurations, create a\r\n sub-class that inherits from this one and override properties\r\n that need to be changed.\r\n \"\"\"\r\n # Name the configurations. For example, 'COCO', 'Experiment 3', ...etc.\r\n # Useful if your code needs to do things differently depending on which\r\n # experiment is running.\r\n NAME = None # Override in sub-classes\r\n\r\n # NUMBER OF GPUs to use. For CPU training, use 1\r\n GPU_COUNT = 1\r\n\r\n # Number of images to train with on each GPU. A 12GB GPU can typically\r\n # handle 2 images of 1024x1024px.\r\n # Adjust based on your GPU memory and image sizes. Use the highest\r\n # number that your GPU can handle for best performance.\r\n IMAGES_PER_GPU = 2\r\n\r\n # Number of training steps per epoch\r\n # This doesn't need to match the size of the training set. Tensorboard\r\n # updates are saved at the end of each epoch, so setting this to a\r\n # smaller number means getting more frequent TensorBoard updates.\r\n # Validation stats are also calculated at each epoch end and they\r\n # might take a while, so don't set this too small to avoid spending\r\n # a lot of time on validation stats.\r\n STEPS_PER_EPOCH = 1000\r\n\r\n # Number of validation steps to run at the end of every training epoch.\r\n # A bigger number improves accuracy of validation stats, but slows\r\n # down the training.\r\n VALIDATION_STEPS = 50\r\n\r\n # The strides of each layer of the FPN Pyramid. These values\r\n # are based on a Resnet101 backbone.\r\n BACKBONE_STRIDES = [4, 8, 16, 32, 64]\r\n\r\n # Number of classification classes (including background)\r\n NUM_CLASSES = 1 # Override in sub-classes\r\n\r\n # Length of square anchor side in pixels\r\n RPN_ANCHOR_SCALES = (32, 64, 128, 256, 512)\r\n\r\n # Ratios of anchors at each cell (width/height)\r\n # A value of 1 represents a square anchor, and 0.5 is a wide anchor\r\n RPN_ANCHOR_RATIOS = [0.5, 1, 2]\r\n\r\n # Anchor stride\r\n # If 1 then anchors are created for each cell in the backbone feature map.\r\n # If 2, then anchors are created for every other cell, and so on.\r\n RPN_ANCHOR_STRIDE = 1\r\n\r\n # Non-max suppression threshold to filter RPN proposals.\r\n # You can reduce this during training to generate more propsals.\r\n RPN_NMS_THRESHOLD = 0.7\r\n\r\n # How many anchors per image to use for RPN training\r\n RPN_TRAIN_ANCHORS_PER_IMAGE = 256\r\n\r\n # ROIs kept after non-maximum supression (training and inference)\r\n POST_NMS_ROIS_TRAINING = 2000\r\n POST_NMS_ROIS_INFERENCE = 1000\r\n\r\n # If enabled, resizes instance masks to a smaller size to reduce\r\n # memory load. Recommended when using high-resolution images.\r\n USE_MINI_MASK = False\r\n MINI_MASK_SHAPE = (56, 56) # (height, width) of the mini-mask\r\n\r\n # Input image resing\r\n # Images are resized such that the smallest side is >= IMAGE_MIN_DIM and\r\n # the longest side is <= IMAGE_MAX_DIM. In case both conditions can't\r\n # be satisfied together the IMAGE_MAX_DIM is enforced.\r\n IMAGE_MIN_DIM = 800\r\n IMAGE_MAX_DIM = 1024\r\n # If True, pad images with zeros such that they're (max_dim by max_dim)\r\n IMAGE_PADDING = True # currently, the False option is not supported\r\n\r\n # Image mean (RGB)\r\n MEAN_PIXEL = np.array([123.7, 116.8, 103.9])\r\n\r\n # Number of ROIs per image to feed to classifier/mask heads\r\n # The Mask RCNN paper uses 512 but often the RPN doesn't generate\r\n # enough positive proposals to fill this and keep a positive:negative\r\n # ratio of 1:3. You can increase the number of proposals by adjusting\r\n # the RPN NMS threshold.\r\n TRAIN_ROIS_PER_IMAGE = 200\r\n\r\n # Percent of positive ROIs used to train classifier/mask heads\r\n ROI_POSITIVE_RATIO = 0.33\r\n\r\n # Pooled ROIs\r\n POOL_SIZE = 7\r\n MASK_POOL_SIZE = 14\r\n MASK_SHAPE = [28, 28]\r\n\r\n # Maximum number of ground truth instances to use in one image\r\n MAX_GT_INSTANCES = 100\r\n\r\n # Bounding box refinement standard deviation for RPN and final detections.\r\n RPN_BBOX_STD_DEV = np.array([0.1, 0.1, 0.2, 0.2])\r\n BBOX_STD_DEV = np.array([0.1, 0.1, 0.2, 0.2])\r\n\r\n # Max number of final detections\r\n DETECTION_MAX_INSTANCES = 100\r\n\r\n # Minimum probability value to accept a detected instance\r\n # ROIs below this threshold are skipped\r\n DETECTION_MIN_CONFIDENCE = 0.9 # For nuclei, 0.7\r\n\r\n # Non-maximum suppression threshold for detection\r\n DETECTION_NMS_THRESHOLD = 0.3 #For nuclei, 0.3\r\n\r\n # Learning rate and momentum\r\n # The Mask RCNN paper uses lr=0.02, but on TensorFlow it causes\r\n # weights to explode. Likely due to differences in optimzer\r\n # implementation.\r\n LEARNING_RATE = 0.001\r\n LEARNING_MOMENTUM = 0.9\r\n\r\n # Weight decay regularization\r\n WEIGHT_DECAY = 0.0001\r\n\r\n # Use RPN ROIs or externally generated ROIs for training\r\n # Keep this True for most situations. Set to False if you want to train\r\n # the head branches on ROI generated by code rather than the ROIs from\r\n # the RPN. For example, to debug the classifier head without having to\r\n # train the RPN.\r\n USE_RPN_ROIS = True\r\n\r\n def __init__(self):\r\n \"\"\"Set values of computed attributes.\"\"\"\r\n # Effective batch size\r\n self.BATCH_SIZE = self.IMAGES_PER_GPU * self.GPU_COUNT\r\n\r\n # Input image size\r\n self.IMAGE_SHAPE = np.array(\r\n [self.IMAGE_MAX_DIM, self.IMAGE_MAX_DIM, 3])\r\n\r\n # Compute backbone size from input image size\r\n self.BACKBONE_SHAPES = np.array(\r\n [[int(math.ceil(self.IMAGE_SHAPE[0] / stride)),\r\n int(math.ceil(self.IMAGE_SHAPE[1] / stride))]\r\n for stride in self.BACKBONE_STRIDES])\r\n\r\n def display(self):\r\n \"\"\"Display Configuration values.\"\"\"\r\n print(\"\\nConfigurations:\")\r\n for a in dir(self):\r\n if not a.startswith(\"__\") and not callable(getattr(self, a)):\r\n print(\"{:30} {}\".format(a, getattr(self, a)))\r\n print(\"\\n\")\r\n"
] |
[
[
"numpy.array"
]
] |
lianghongzhuo/PointNetGPD
|
[
"c61ab1111d08007ecb41972142acdb67ed6a496d"
] |
[
"PointNetGPD/model/dataset.py"
] |
[
"import os\nimport glob\nimport pickle\nimport torch\nimport torch.utils.data\nimport torch.nn as nn\nimport numpy as np\n\n\nclass PointGraspDataset(torch.utils.data.Dataset):\n def __init__(self, obj_points_num, grasp_points_num, pc_file_used_num, grasp_amount_per_file, thresh_good,\n thresh_bad, path, tag, with_obj=False, projection=False, project_chann=3, project_size=60):\n self.obj_points_num = obj_points_num\n self.grasp_points_num = grasp_points_num\n self.pc_file_used_num = pc_file_used_num\n self.grasp_amount_per_file = grasp_amount_per_file\n self.path = path\n self.tag = tag\n self.thresh_good = thresh_good\n self.thresh_bad = thresh_bad\n self.with_obj = with_obj\n self.min_point_limit = 50\n\n # projection related\n self.projection = projection\n self.project_chann = project_chann\n if self.project_chann not in [3, 12]:\n raise NotImplementedError\n self.project_size = project_size\n if self.project_size != 60:\n raise NotImplementedError\n self.normal_K = 10\n self.voxel_point_num = 50\n self.projection_margin = 1\n\n self.transform = pickle.load(open(os.path.join(self.path, 'google2cloud.pkl'), 'rb'))\n fl_grasp = glob.glob(os.path.join(path, 'ycb_grasp', self.tag, '*.npy'))\n fl_pc = glob.glob(os.path.join(path, 'ycb_rgbd', '*', 'clouds', '*.npy'))\n\n self.d_pc, self.d_grasp = {}, {}\n for i in fl_pc:\n k = i.split('/')[-3]\n if k in self.d_pc.keys():\n self.d_pc[k].append(i)\n else:\n self.d_pc[k] = [i]\n\n for i in fl_grasp:\n k = i.split('/')[-1].split('.')[0]\n self.d_grasp[k] = i\n object1 = set(self.d_grasp.keys())\n object2 = set(self.transform.keys())\n self.object = list(object1.intersection(object2))\n self.amount = len(self.object) * self.grasp_amount_per_file\n\n def collect_pc(self, grasp, pc, transform):\n center = grasp[0:3]\n axis = grasp[3:6] # binormal\n width = grasp[6]\n angle = grasp[7]\n\n axis = axis / np.linalg.norm(axis)\n binormal = axis\n # cal approach\n cos_t = np.cos(angle)\n sin_t = np.sin(angle)\n R1 = np.c_[[cos_t, 0, sin_t], [0, 1, 0], [-sin_t, 0, cos_t]]\n axis_y = axis\n axis_x = np.array([axis_y[1], -axis_y[0], 0])\n if np.linalg.norm(axis_x) == 0:\n axis_x = np.array([1, 0, 0])\n axis_x = axis_x / np.linalg.norm(axis_x)\n axis_y = axis_y / np.linalg.norm(axis_y)\n axis_z = np.cross(axis_x, axis_y)\n R2 = np.c_[axis_x, np.c_[axis_y, axis_z]]\n approach = R2.dot(R1)[:, 0]\n approach = approach / np.linalg.norm(approach)\n minor_normal = np.cross(axis, approach)\n\n left = center - width * axis / 2\n right = center + width * axis / 2\n # bottom = center - width*approach\n left = (np.dot(transform, np.array([left[0], left[1], left[2], 1])))[:3]\n right = (np.dot(transform, np.array([right[0], right[1], right[2], 1])))[:3]\n # bottom = (transform @ np.array([bottom[0], bottom[1], bottom[2], 1]))[:3]\n center = (np.dot(transform, np.array([center[0], center[1], center[2], 1])))[:3]\n binormal = (np.dot(transform, np.array([binormal[0], binormal[1], binormal[2], 0])))[:3].reshape(3, 1)\n approach = (np.dot(transform, np.array([approach[0], approach[1], approach[2], 0])))[:3].reshape(3, 1)\n minor_normal = (np.dot(transform, np.array([minor_normal[0], minor_normal[1], minor_normal[2], 0])))[\n :3].reshape(3, 1)\n matrix = np.hstack([approach, binormal, minor_normal]).T\n # pc_t/left_t/right_t is in local coordinate(with center as origin)\n # other(include pc) are in pc coordinate\n pc_t = (np.dot(matrix, (pc - center).T)).T\n left_t = (-width * np.array([0, 1, 0]) / 2).squeeze()\n right_t = (width * np.array([0, 1, 0]) / 2).squeeze()\n\n x_limit = width / 4\n z_limit = width / 4\n y_limit = width / 2\n\n x1 = pc_t[:, 0] > -x_limit\n x2 = pc_t[:, 0] < x_limit\n y1 = pc_t[:, 1] > -y_limit\n y2 = pc_t[:, 1] < y_limit\n z1 = pc_t[:, 2] > -z_limit\n z2 = pc_t[:, 2] < z_limit\n\n a = np.vstack([x1, x2, y1, y2, z1, z2])\n self.in_ind = np.where(np.sum(a, axis=0) == len(a))[0]\n\n if len(self.in_ind) < self.min_point_limit:\n return None\n if self.projection:\n return self.project_pc(pc_t, width)\n else:\n return pc_t[self.in_ind]\n\n def check_square(self, point, points_g):\n dirs = np.array([[-1, 1, 1], [1, 1, 1], [-1, -1, 1], [1, -1, 1],\n [-1, 1, -1], [1, 1, -1], [-1, -1, -1], [1, -1, -1]])\n p = dirs * 0.5 + point # here res * 0.5 means get half of a pixel width\n a1 = p[2][1] < points_g[:, 1]\n a2 = p[0][1] > points_g[:, 1]\n a3 = p[0][2] > points_g[:, 2]\n a4 = p[4][2] < points_g[:, 2]\n a5 = p[1][0] > points_g[:, 0]\n a6 = p[0][0] < points_g[:, 0]\n\n a = np.vstack([a1, a2, a3, a4, a5, a6])\n points_in_area = np.where(np.sum(a, axis=0) == len(a))[0]\n\n if len(points_in_area) == 0:\n has_p = False\n else:\n has_p = True\n return points_in_area\n\n def cal_projection(self, point_cloud_voxel, m_width_of_pic, margin, surface_normal, order, gripper_width):\n occupy_pic = np.zeros([m_width_of_pic, m_width_of_pic, 1])\n norm_pic = np.zeros([m_width_of_pic, m_width_of_pic, 3])\n norm_pic_num = np.zeros([m_width_of_pic, m_width_of_pic, 1])\n\n max_x = point_cloud_voxel[:, order[0]].max()\n min_x = point_cloud_voxel[:, order[0]].min()\n max_y = point_cloud_voxel[:, order[1]].max()\n min_y = point_cloud_voxel[:, order[1]].min()\n min_z = point_cloud_voxel[:, order[2]].min()\n\n tmp = max((max_x - min_x), (max_y - min_y))\n if tmp == 0:\n print(\"WARNING : the num of input points seems only have one, no possilbe to do learning on\"\n \"such data, please throw it away. -- Hongzhuo\")\n return occupy_pic, norm_pic\n # Here, we use the gripper width to cal the res:\n res = gripper_width / (m_width_of_pic - margin)\n\n voxel_points_square_norm = []\n x_coord_r = ((point_cloud_voxel[:, order[0]]) / res + m_width_of_pic / 2)\n y_coord_r = ((point_cloud_voxel[:, order[1]]) / res + m_width_of_pic / 2)\n z_coord_r = ((point_cloud_voxel[:, order[2]]) / res + m_width_of_pic / 2)\n x_coord_r = np.floor(x_coord_r).astype(int)\n y_coord_r = np.floor(y_coord_r).astype(int)\n z_coord_r = np.floor(z_coord_r).astype(int)\n voxel_index = np.array([x_coord_r, y_coord_r, z_coord_r]).T # all point in grid\n coordinate_buffer = np.unique(voxel_index, axis=0) # get a list of points without duplication\n K = len(coordinate_buffer)\n # [K, 1] store number of points in each voxel grid\n number_buffer = np.zeros(shape=K, dtype=np.int64)\n feature_buffer = np.zeros(shape=(K, self.voxel_point_num, 6), dtype=np.float32)\n index_buffer = {}\n for i in range(K):\n index_buffer[tuple(coordinate_buffer[i])] = i # got index of coordinate\n\n for voxel, point, normal in zip(voxel_index, point_cloud_voxel, surface_normal):\n index = index_buffer[tuple(voxel)]\n number = number_buffer[index]\n if number < self.voxel_point_num:\n feature_buffer[index, number, :3] = point\n feature_buffer[index, number, 3:6] = normal\n number_buffer[index] += 1\n\n voxel_points_square_norm = np.sum(feature_buffer[..., -3:], axis=1) / number_buffer[:, np.newaxis]\n voxel_points_square = coordinate_buffer\n\n if len(voxel_points_square) == 0:\n return occupy_pic, norm_pic\n x_coord_square = voxel_points_square[:, 0]\n y_coord_square = voxel_points_square[:, 1]\n norm_pic[x_coord_square, y_coord_square, :] = voxel_points_square_norm\n occupy_pic[x_coord_square, y_coord_square] = number_buffer[:, np.newaxis]\n occupy_max = occupy_pic.max()\n assert (occupy_max > 0)\n occupy_pic = occupy_pic / occupy_max\n return occupy_pic, norm_pic\n\n def project_pc(self, pc, gripper_width):\n \"\"\"\n for gpd baseline, only support input_chann == [3, 12]\n \"\"\"\n pc = pc.astype(np.float32)\n pc = pcl.PointCloud(pc)\n norm = pc.make_NormalEstimation()\n norm.set_KSearch(self.normal_K)\n normals = norm.compute()\n surface_normal = normals.to_array()\n surface_normal = surface_normal[:, 0:3]\n pc = pc.to_array()\n grasp_pc = pc[self.in_ind]\n grasp_pc_norm = surface_normal[self.in_ind]\n bad_check = (grasp_pc_norm != grasp_pc_norm)\n if np.sum(bad_check) != 0:\n bad_ind = np.where(bad_check == True)\n grasp_pc = np.delete(grasp_pc, bad_ind[0], axis=0)\n grasp_pc_norm = np.delete(grasp_pc_norm, bad_ind[0], axis=0)\n assert (np.sum(grasp_pc_norm != grasp_pc_norm) == 0)\n m_width_of_pic = self.project_size\n margin = self.projection_margin\n order = np.array([0, 1, 2])\n occupy_pic1, norm_pic1 = self.cal_projection(grasp_pc, m_width_of_pic, margin, grasp_pc_norm,\n order, gripper_width)\n if self.project_chann == 3:\n output = norm_pic1\n elif self.project_chann == 12:\n order = np.array([1, 2, 0])\n occupy_pic2, norm_pic2 = self.cal_projection(grasp_pc, m_width_of_pic, margin, grasp_pc_norm,\n order, gripper_width)\n order = np.array([0, 2, 1])\n occupy_pic3, norm_pic3 = self.cal_projection(grasp_pc, m_width_of_pic, margin, grasp_pc_norm,\n order, gripper_width)\n output = np.dstack([occupy_pic1, norm_pic1, occupy_pic2, norm_pic2, occupy_pic3, norm_pic3])\n else:\n raise NotImplementedError\n\n return output\n\n def __getitem__(self, index):\n # try:\n obj_ind, grasp_ind = np.unravel_index(index, (len(self.object), self.grasp_amount_per_file))\n obj_grasp = self.object[obj_ind]\n obj_pc = self.transform[obj_grasp][0]\n f_grasp = self.d_grasp[obj_grasp]\n fl_pc = np.array(self.d_pc[obj_pc])\n fl_pc = fl_pc[np.random.choice(len(fl_pc), size=self.pc_file_used_num)]\n\n grasp = np.load(f_grasp)[grasp_ind]\n pc = np.vstack([np.load(i) for i in fl_pc])\n pc = pc[np.random.choice(len(pc), size=self.obj_points_num)]\n t = self.transform[obj_grasp][1]\n\n grasp_pc = self.collect_pc(grasp, pc, t)\n if grasp_pc is None:\n return None\n level_score, refine_score = grasp[-2:]\n\n if not self.projection:\n if len(grasp_pc) > self.grasp_points_num:\n grasp_pc = grasp_pc[np.random.choice(len(grasp_pc), size=self.grasp_points_num,\n replace=False)].T\n else:\n grasp_pc = grasp_pc[np.random.choice(len(grasp_pc), size=self.grasp_points_num,\n replace=True)].T\n else:\n grasp_pc = grasp_pc.transpose((2, 1, 0))\n score = level_score + refine_score * 0.01\n if score >= self.thresh_bad:\n label = 0\n elif score <= self.thresh_good:\n label = 1\n else:\n return None\n\n if self.with_obj:\n return grasp_pc, label, obj_grasp\n else:\n return grasp_pc, label\n\n def __len__(self):\n return self.amount\n\n\nclass PointGraspMultiClassDataset(torch.utils.data.Dataset):\n def __init__(self, obj_points_num, grasp_points_num, pc_file_used_num, grasp_amount_per_file, thresh_good,\n thresh_bad, path, tag, with_obj=False, projection=False, project_chann=3, project_size=60):\n self.obj_points_num = obj_points_num\n self.grasp_points_num = grasp_points_num\n self.pc_file_used_num = pc_file_used_num\n self.grasp_amount_per_file = grasp_amount_per_file\n self.path = path\n self.tag = tag\n self.thresh_good = thresh_good\n self.thresh_bad = thresh_bad\n self.with_obj = with_obj\n self.min_point_limit = 50\n\n # projection related\n self.projection = projection\n self.project_chann = project_chann\n if self.project_chann not in [3, 12]:\n raise NotImplementedError\n self.project_size = project_size\n if self.project_size != 60:\n raise NotImplementedError\n self.normal_K = 10\n self.voxel_point_num = 50\n self.projection_margin = 1\n\n self.transform = pickle.load(open(os.path.join(self.path, 'google2cloud.pkl'), 'rb'))\n fl_grasp = glob.glob(os.path.join(path, 'ycb_grasp', self.tag, '*.npy'))\n fl_pc = glob.glob(os.path.join(path, 'ycb_rgbd', '*', 'clouds', '*.npy'))\n\n self.d_pc, self.d_grasp = {}, {}\n for i in fl_pc:\n k = i.split('/')[-3]\n if k in self.d_pc.keys():\n self.d_pc[k].append(i)\n else:\n self.d_pc[k] = [i]\n\n for i in fl_grasp:\n k = i.split('/')[-1].split('.')[0]\n self.d_grasp[k] = i\n object1 = set(self.d_grasp.keys())\n object2 = set(self.transform.keys())\n self.object = list(object1.intersection(object2))\n self.amount = len(self.object) * self.grasp_amount_per_file\n\n def collect_pc(self, grasp, pc, transform):\n center = grasp[0:3]\n axis = grasp[3:6] # binormal\n width = grasp[6]\n angle = grasp[7]\n\n axis = axis / np.linalg.norm(axis)\n binormal = axis\n # cal approach\n cos_t = np.cos(angle)\n sin_t = np.sin(angle)\n R1 = np.c_[[cos_t, 0, sin_t], [0, 1, 0], [-sin_t, 0, cos_t]]\n axis_y = axis\n axis_x = np.array([axis_y[1], -axis_y[0], 0])\n if np.linalg.norm(axis_x) == 0:\n axis_x = np.array([1, 0, 0])\n axis_x = axis_x / np.linalg.norm(axis_x)\n axis_y = axis_y / np.linalg.norm(axis_y)\n axis_z = np.cross(axis_x, axis_y)\n R2 = np.c_[axis_x, np.c_[axis_y, axis_z]]\n approach = R2.dot(R1)[:, 0]\n approach = approach / np.linalg.norm(approach)\n minor_normal = np.cross(axis, approach)\n\n left = center - width * axis / 2\n right = center + width * axis / 2\n # bottom = center - width*approach\n left = (np.dot(transform, np.array([left[0], left[1], left[2], 1])))[:3]\n right = (np.dot(transform, np.array([right[0], right[1], right[2], 1])))[:3]\n # bottom = (transform @ np.array([bottom[0], bottom[1], bottom[2], 1]))[:3]\n center = (np.dot(transform, np.array([center[0], center[1], center[2], 1])))[:3]\n binormal = (np.dot(transform, np.array([binormal[0], binormal[1], binormal[2], 0])))[:3].reshape(3, 1)\n approach = (np.dot(transform, np.array([approach[0], approach[1], approach[2], 0])))[:3].reshape(3, 1)\n minor_normal = (np.dot(transform, np.array([minor_normal[0], minor_normal[1], minor_normal[2], 0])))[\n :3].reshape(3, 1)\n matrix = np.hstack([approach, binormal, minor_normal]).T\n # pc_t/left_t/right_t is in local coordinate(with center as origin)\n # other(include pc) are in pc coordinate\n pc_t = (np.dot(matrix, (pc - center).T)).T\n left_t = (-width * np.array([0, 1, 0]) / 2).squeeze()\n right_t = (width * np.array([0, 1, 0]) / 2).squeeze()\n\n x_limit = width / 4\n z_limit = width / 4\n y_limit = width / 2\n\n x1 = pc_t[:, 0] > -x_limit\n x2 = pc_t[:, 0] < x_limit\n y1 = pc_t[:, 1] > -y_limit\n y2 = pc_t[:, 1] < y_limit\n z1 = pc_t[:, 2] > -z_limit\n z2 = pc_t[:, 2] < z_limit\n\n a = np.vstack([x1, x2, y1, y2, z1, z2])\n self.in_ind = np.where(np.sum(a, axis=0) == len(a))[0]\n\n if len(self.in_ind) < self.min_point_limit:\n return None\n if self.projection:\n return self.project_pc(pc_t, width)\n else:\n return pc_t[self.in_ind]\n\n def check_square(self, point, points_g):\n dirs = np.array([[-1, 1, 1], [1, 1, 1], [-1, -1, 1], [1, -1, 1],\n [-1, 1, -1], [1, 1, -1], [-1, -1, -1], [1, -1, -1]])\n p = dirs * 0.5 + point # here res * 0.5 means get half of a pixel width\n a1 = p[2][1] < points_g[:, 1]\n a2 = p[0][1] > points_g[:, 1]\n a3 = p[0][2] > points_g[:, 2]\n a4 = p[4][2] < points_g[:, 2]\n a5 = p[1][0] > points_g[:, 0]\n a6 = p[0][0] < points_g[:, 0]\n\n a = np.vstack([a1, a2, a3, a4, a5, a6])\n points_in_area = np.where(np.sum(a, axis=0) == len(a))[0]\n\n if len(points_in_area) == 0:\n has_p = False\n else:\n has_p = True\n return points_in_area\n\n def cal_projection(self, point_cloud_voxel, m_width_of_pic, margin, surface_normal, order, gripper_width):\n occupy_pic = np.zeros([m_width_of_pic, m_width_of_pic, 1])\n norm_pic = np.zeros([m_width_of_pic, m_width_of_pic, 3])\n norm_pic_num = np.zeros([m_width_of_pic, m_width_of_pic, 1])\n\n max_x = point_cloud_voxel[:, order[0]].max()\n min_x = point_cloud_voxel[:, order[0]].min()\n max_y = point_cloud_voxel[:, order[1]].max()\n min_y = point_cloud_voxel[:, order[1]].min()\n min_z = point_cloud_voxel[:, order[2]].min()\n\n tmp = max((max_x - min_x), (max_y - min_y))\n if tmp == 0:\n print(\"WARNING : the num of input points seems only have one, no possilbe to do learning on\"\n \"such data, please throw it away. -- Hongzhuo\")\n return occupy_pic, norm_pic\n # Here, we use the gripper width to cal the res:\n res = gripper_width / (m_width_of_pic - margin)\n\n voxel_points_square_norm = []\n x_coord_r = ((point_cloud_voxel[:, order[0]]) / res + m_width_of_pic / 2)\n y_coord_r = ((point_cloud_voxel[:, order[1]]) / res + m_width_of_pic / 2)\n z_coord_r = ((point_cloud_voxel[:, order[2]]) / res + m_width_of_pic / 2)\n x_coord_r = np.floor(x_coord_r).astype(int)\n y_coord_r = np.floor(y_coord_r).astype(int)\n z_coord_r = np.floor(z_coord_r).astype(int)\n voxel_index = np.array([x_coord_r, y_coord_r, z_coord_r]).T # all point in grid\n coordinate_buffer = np.unique(voxel_index, axis=0) # get a list of points without duplication\n K = len(coordinate_buffer)\n # [K, 1] store number of points in each voxel grid\n number_buffer = np.zeros(shape=K, dtype=np.int64)\n feature_buffer = np.zeros(shape=(K, self.voxel_point_num, 6), dtype=np.float32)\n index_buffer = {}\n for i in range(K):\n index_buffer[tuple(coordinate_buffer[i])] = i # got index of coordinate\n\n for voxel, point, normal in zip(voxel_index, point_cloud_voxel, surface_normal):\n index = index_buffer[tuple(voxel)]\n number = number_buffer[index]\n if number < self.voxel_point_num:\n feature_buffer[index, number, :3] = point\n feature_buffer[index, number, 3:6] = normal\n number_buffer[index] += 1\n\n voxel_points_square_norm = np.sum(feature_buffer[..., -3:], axis=1) / number_buffer[:, np.newaxis]\n voxel_points_square = coordinate_buffer\n\n if len(voxel_points_square) == 0:\n return occupy_pic, norm_pic\n x_coord_square = voxel_points_square[:, 0]\n y_coord_square = voxel_points_square[:, 1]\n norm_pic[x_coord_square, y_coord_square, :] = voxel_points_square_norm\n occupy_pic[x_coord_square, y_coord_square] = number_buffer[:, np.newaxis]\n occupy_max = occupy_pic.max()\n assert (occupy_max > 0)\n occupy_pic = occupy_pic / occupy_max\n return occupy_pic, norm_pic\n\n def project_pc(self, pc, gripper_width):\n \"\"\"\n for gpd baseline, only support input_chann == [3, 12]\n \"\"\"\n pc = pc.astype(np.float32)\n pc = pcl.PointCloud(pc)\n norm = pc.make_NormalEstimation()\n norm.set_KSearch(self.normal_K)\n normals = norm.compute()\n surface_normal = normals.to_array()\n surface_normal = surface_normal[:, 0:3]\n pc = pc.to_array()\n grasp_pc = pc[self.in_ind]\n grasp_pc_norm = surface_normal[self.in_ind]\n bad_check = (grasp_pc_norm != grasp_pc_norm)\n if np.sum(bad_check) != 0:\n bad_ind = np.where(bad_check == True)\n grasp_pc = np.delete(grasp_pc, bad_ind[0], axis=0)\n grasp_pc_norm = np.delete(grasp_pc_norm, bad_ind[0], axis=0)\n assert (np.sum(grasp_pc_norm != grasp_pc_norm) == 0)\n m_width_of_pic = self.project_size\n margin = self.projection_margin\n order = np.array([0, 1, 2])\n occupy_pic1, norm_pic1 = self.cal_projection(grasp_pc, m_width_of_pic, margin, grasp_pc_norm,\n order, gripper_width)\n if self.project_chann == 3:\n output = norm_pic1\n elif self.project_chann == 12:\n order = np.array([1, 2, 0])\n occupy_pic2, norm_pic2 = self.cal_projection(grasp_pc, m_width_of_pic, margin, grasp_pc_norm,\n order, gripper_width)\n order = np.array([0, 2, 1])\n occupy_pic3, norm_pic3 = self.cal_projection(grasp_pc, m_width_of_pic, margin, grasp_pc_norm,\n order, gripper_width)\n output = np.dstack([occupy_pic1, norm_pic1, occupy_pic2, norm_pic2, occupy_pic3, norm_pic3])\n else:\n raise NotImplementedError\n\n return output\n\n def __getitem__(self, index):\n # try:\n obj_ind, grasp_ind = np.unravel_index(index, (len(self.object), self.grasp_amount_per_file))\n obj_grasp = self.object[obj_ind]\n obj_pc = self.transform[obj_grasp][0]\n f_grasp = self.d_grasp[obj_grasp]\n fl_pc = np.array(self.d_pc[obj_pc])\n fl_pc = fl_pc[np.random.choice(len(fl_pc), size=self.pc_file_used_num)]\n\n grasp = np.load(f_grasp)[grasp_ind]\n pc = np.vstack([np.load(i) for i in fl_pc])\n pc = pc[np.random.choice(len(pc), size=self.obj_points_num)]\n t = self.transform[obj_grasp][1]\n\n grasp_pc = self.collect_pc(grasp, pc, t)\n if grasp_pc is None:\n return None\n level_score, refine_score = grasp[-2:]\n\n if not self.projection:\n if len(grasp_pc) > self.grasp_points_num:\n grasp_pc = grasp_pc[np.random.choice(len(grasp_pc), size=self.grasp_points_num,\n replace=False)].T\n else:\n grasp_pc = grasp_pc[np.random.choice(len(grasp_pc), size=self.grasp_points_num,\n replace=True)].T\n else:\n grasp_pc = grasp_pc.transpose((2, 1, 0))\n score = level_score + refine_score * 0.01\n if score >= self.thresh_bad:\n label = 0\n elif score <= self.thresh_good:\n label = 2\n else:\n label = 1\n\n if self.with_obj:\n return grasp_pc, label, obj_grasp\n else:\n return grasp_pc, label\n\n def __len__(self):\n return self.amount\n\n\nclass PointGraspOneViewDataset(torch.utils.data.Dataset):\n def __init__(self, grasp_points_num, grasp_amount_per_file, thresh_good,\n thresh_bad, path, tag, with_obj=False, projection=False, project_chann=3, project_size=60):\n self.grasp_points_num = grasp_points_num\n self.grasp_amount_per_file = grasp_amount_per_file\n self.path = path\n self.tag = tag\n self.thresh_good = thresh_good\n self.thresh_bad = thresh_bad\n self.with_obj = with_obj\n self.min_point_limit = 50\n\n # projection related\n self.projection = projection\n self.project_chann = project_chann\n if self.project_chann not in [3, 12]:\n raise NotImplementedError\n self.project_size = project_size\n if self.project_size != 60:\n raise NotImplementedError\n self.normal_K = 10\n self.voxel_point_num = 50\n self.projection_margin = 1\n self.minimum_point_amount = 150\n\n self.transform = pickle.load(open(os.path.join(self.path, 'google2cloud.pkl'), 'rb'))\n fl_grasp = glob.glob(os.path.join(path, 'ycb_grasp', self.tag, '*.npy'))\n fl_pc = glob.glob(os.path.join(path, 'ycb_rgbd', '*', 'clouds', 'pc_NP3_NP5*.npy'))\n\n self.d_pc, self.d_grasp = {}, {}\n for i in fl_pc:\n k = i.split('/')[-3]\n if k in self.d_pc.keys():\n self.d_pc[k].append(i)\n else:\n self.d_pc[k] = [i]\n for k in self.d_pc.keys():\n self.d_pc[k].sort()\n\n for i in fl_grasp:\n k = i.split('/')[-1].split('.')[0]\n self.d_grasp[k] = i\n object1 = set(self.d_grasp.keys())\n object2 = set(self.transform.keys())\n self.object = list(object1.intersection(object2))\n self.amount = len(self.object) * self.grasp_amount_per_file\n\n def collect_pc(self, grasp, pc, transform):\n center = grasp[0:3]\n axis = grasp[3:6] # binormal\n width = grasp[6]\n angle = grasp[7]\n\n axis = axis / np.linalg.norm(axis)\n binormal = axis\n # cal approach\n cos_t = np.cos(angle)\n sin_t = np.sin(angle)\n R1 = np.c_[[cos_t, 0, sin_t], [0, 1, 0], [-sin_t, 0, cos_t]]\n axis_y = axis\n axis_x = np.array([axis_y[1], -axis_y[0], 0])\n if np.linalg.norm(axis_x) == 0:\n axis_x = np.array([1, 0, 0])\n axis_x = axis_x / np.linalg.norm(axis_x)\n axis_y = axis_y / np.linalg.norm(axis_y)\n axis_z = np.cross(axis_x, axis_y)\n R2 = np.c_[axis_x, np.c_[axis_y, axis_z]]\n approach = R2.dot(R1)[:, 0]\n approach = approach / np.linalg.norm(approach)\n minor_normal = np.cross(axis, approach)\n\n left = center - width * axis / 2\n right = center + width * axis / 2\n # bottom = center - width*approach\n left = (np.dot(transform, np.array([left[0], left[1], left[2], 1])))[:3]\n right = (np.dot(transform, np.array([right[0], right[1], right[2], 1])))[:3]\n # bottom = (transform @ np.array([bottom[0], bottom[1], bottom[2], 1]))[:3]\n center = (np.dot(transform, np.array([center[0], center[1], center[2], 1])))[:3]\n binormal = (np.dot(transform, np.array([binormal[0], binormal[1], binormal[2], 0])))[:3].reshape(3, 1)\n approach = (np.dot(transform, np.array([approach[0], approach[1], approach[2], 0])))[:3].reshape(3, 1)\n minor_normal = (np.dot(transform, np.array([minor_normal[0], minor_normal[1], minor_normal[2], 0])))[\n :3].reshape(3, 1)\n matrix = np.hstack([approach, binormal, minor_normal]).T\n # pc_t/left_t/right_t is in local coordinate(with center as origin)\n # other(include pc) are in pc coordinate\n pc_t = (np.dot(matrix, (pc - center).T)).T\n left_t = (-width * np.array([0, 1, 0]) / 2).squeeze()\n right_t = (width * np.array([0, 1, 0]) / 2).squeeze()\n\n x_limit = width / 4\n z_limit = width / 4\n y_limit = width / 2\n\n x1 = pc_t[:, 0] > -x_limit\n x2 = pc_t[:, 0] < x_limit\n y1 = pc_t[:, 1] > -y_limit\n y2 = pc_t[:, 1] < y_limit\n z1 = pc_t[:, 2] > -z_limit\n z2 = pc_t[:, 2] < z_limit\n\n a = np.vstack([x1, x2, y1, y2, z1, z2])\n self.in_ind = np.where(np.sum(a, axis=0) == len(a))[0]\n\n if len(self.in_ind) < self.min_point_limit:\n return None\n if self.projection:\n return self.project_pc(pc_t, width)\n else:\n return pc_t[self.in_ind]\n\n def check_square(self, point, points_g):\n dirs = np.array([[-1, 1, 1], [1, 1, 1], [-1, -1, 1], [1, -1, 1],\n [-1, 1, -1], [1, 1, -1], [-1, -1, -1], [1, -1, -1]])\n p = dirs * 0.5 + point # here res * 0.5 means get half of a pixel width\n a1 = p[2][1] < points_g[:, 1]\n a2 = p[0][1] > points_g[:, 1]\n a3 = p[0][2] > points_g[:, 2]\n a4 = p[4][2] < points_g[:, 2]\n a5 = p[1][0] > points_g[:, 0]\n a6 = p[0][0] < points_g[:, 0]\n\n a = np.vstack([a1, a2, a3, a4, a5, a6])\n points_in_area = np.where(np.sum(a, axis=0) == len(a))[0]\n\n if len(points_in_area) == 0:\n has_p = False\n else:\n has_p = True\n return points_in_area\n\n def cal_projection(self, point_cloud_voxel, m_width_of_pic, margin, surface_normal, order, gripper_width):\n occupy_pic = np.zeros([m_width_of_pic, m_width_of_pic, 1])\n norm_pic = np.zeros([m_width_of_pic, m_width_of_pic, 3])\n norm_pic_num = np.zeros([m_width_of_pic, m_width_of_pic, 1])\n\n max_x = point_cloud_voxel[:, order[0]].max()\n min_x = point_cloud_voxel[:, order[0]].min()\n max_y = point_cloud_voxel[:, order[1]].max()\n min_y = point_cloud_voxel[:, order[1]].min()\n min_z = point_cloud_voxel[:, order[2]].min()\n\n tmp = max((max_x - min_x), (max_y - min_y))\n if tmp == 0:\n print(\"WARNING : the num of input points seems only have one, no possilbe to do learning on\"\n \"such data, please throw it away. -- Hongzhuo\")\n return occupy_pic, norm_pic\n # Here, we use the gripper width to cal the res:\n res = gripper_width / (m_width_of_pic - margin)\n\n voxel_points_square_norm = []\n x_coord_r = ((point_cloud_voxel[:, order[0]]) / res + m_width_of_pic / 2)\n y_coord_r = ((point_cloud_voxel[:, order[1]]) / res + m_width_of_pic / 2)\n z_coord_r = ((point_cloud_voxel[:, order[2]]) / res + m_width_of_pic / 2)\n x_coord_r = np.floor(x_coord_r).astype(int)\n y_coord_r = np.floor(y_coord_r).astype(int)\n z_coord_r = np.floor(z_coord_r).astype(int)\n voxel_index = np.array([x_coord_r, y_coord_r, z_coord_r]).T # all point in grid\n coordinate_buffer = np.unique(voxel_index, axis=0) # get a list of points without duplication\n K = len(coordinate_buffer)\n # [K, 1] store number of points in each voxel grid\n number_buffer = np.zeros(shape=K, dtype=np.int64)\n feature_buffer = np.zeros(shape=(K, self.voxel_point_num, 6), dtype=np.float32)\n index_buffer = {}\n for i in range(K):\n index_buffer[tuple(coordinate_buffer[i])] = i # got index of coordinate\n\n for voxel, point, normal in zip(voxel_index, point_cloud_voxel, surface_normal):\n index = index_buffer[tuple(voxel)]\n number = number_buffer[index]\n if number < self.voxel_point_num:\n feature_buffer[index, number, :3] = point\n feature_buffer[index, number, 3:6] = normal\n number_buffer[index] += 1\n\n voxel_points_square_norm = np.sum(feature_buffer[..., -3:], axis=1) / number_buffer[:, np.newaxis]\n voxel_points_square = coordinate_buffer\n\n if len(voxel_points_square) == 0:\n return occupy_pic, norm_pic\n x_coord_square = voxel_points_square[:, 0]\n y_coord_square = voxel_points_square[:, 1]\n norm_pic[x_coord_square, y_coord_square, :] = voxel_points_square_norm\n occupy_pic[x_coord_square, y_coord_square] = number_buffer[:, np.newaxis]\n occupy_max = occupy_pic.max()\n assert (occupy_max > 0)\n occupy_pic = occupy_pic / occupy_max\n return occupy_pic, norm_pic\n\n def project_pc(self, pc, gripper_width):\n \"\"\"\n for gpd baseline, only support input_chann == [3, 12]\n \"\"\"\n pc = pc.astype(np.float32)\n pc = pcl.PointCloud(pc)\n norm = pc.make_NormalEstimation()\n norm.set_KSearch(self.normal_K)\n normals = norm.compute()\n surface_normal = normals.to_array()\n surface_normal = surface_normal[:, 0:3]\n pc = pc.to_array()\n grasp_pc = pc[self.in_ind]\n grasp_pc_norm = surface_normal[self.in_ind]\n bad_check = (grasp_pc_norm != grasp_pc_norm)\n if np.sum(bad_check) != 0:\n bad_ind = np.where(bad_check == True)\n grasp_pc = np.delete(grasp_pc, bad_ind[0], axis=0)\n grasp_pc_norm = np.delete(grasp_pc_norm, bad_ind[0], axis=0)\n assert (np.sum(grasp_pc_norm != grasp_pc_norm) == 0)\n m_width_of_pic = self.project_size\n margin = self.projection_margin\n order = np.array([0, 1, 2])\n occupy_pic1, norm_pic1 = self.cal_projection(grasp_pc, m_width_of_pic, margin, grasp_pc_norm,\n order, gripper_width)\n if self.project_chann == 3:\n output = norm_pic1\n elif self.project_chann == 12:\n order = np.array([1, 2, 0])\n occupy_pic2, norm_pic2 = self.cal_projection(grasp_pc, m_width_of_pic, margin, grasp_pc_norm,\n order, gripper_width)\n order = np.array([0, 2, 1])\n occupy_pic3, norm_pic3 = self.cal_projection(grasp_pc, m_width_of_pic, margin, grasp_pc_norm,\n order, gripper_width)\n output = np.dstack([occupy_pic1, norm_pic1, occupy_pic2, norm_pic2, occupy_pic3, norm_pic3])\n else:\n raise NotImplementedError\n\n return output\n\n def __getitem__(self, index):\n # try:\n obj_ind, grasp_ind = np.unravel_index(index, (len(self.object), self.grasp_amount_per_file))\n\n obj_grasp = self.object[obj_ind]\n obj_pc = self.transform[obj_grasp][0]\n f_grasp = self.d_grasp[obj_grasp]\n fl_pc = np.array(self.d_pc[obj_pc])\n np.random.shuffle(fl_pc)\n\n grasp = np.load(f_grasp)[grasp_ind]\n pc = np.load(fl_pc[-1])\n t = self.transform[obj_grasp][1]\n\n grasp_pc = self.collect_pc(grasp, pc, t)\n if grasp_pc is None:\n return None\n level_score, refine_score = grasp[-2:]\n\n if not self.projection:\n if len(grasp_pc) > self.grasp_points_num:\n grasp_pc = grasp_pc[np.random.choice(len(grasp_pc), size=self.grasp_points_num,\n replace=False)].T\n else:\n grasp_pc = grasp_pc[np.random.choice(len(grasp_pc), size=self.grasp_points_num,\n replace=True)].T\n else:\n grasp_pc = grasp_pc.transpose((2, 1, 0))\n score = level_score + refine_score * 0.01\n if score >= self.thresh_bad:\n label = 0\n elif score <= self.thresh_good:\n label = 1\n else:\n return None\n\n if self.with_obj:\n return grasp_pc, label, obj_grasp\n else:\n return grasp_pc, label\n\n def __len__(self):\n return self.amount\n\n\nclass PointGraspOneViewMultiClassDataset(torch.utils.data.Dataset):\n def __init__(self, grasp_points_num, grasp_amount_per_file, thresh_good,\n thresh_bad, path, tag, with_obj=False, projection=False, project_chann=3, project_size=60):\n self.grasp_points_num = grasp_points_num\n self.grasp_amount_per_file = grasp_amount_per_file\n self.path = path\n self.tag = tag\n self.thresh_good = thresh_good\n self.thresh_bad = thresh_bad\n self.with_obj = with_obj\n self.min_point_limit = 50\n\n # projection related\n self.projection = projection\n self.project_chann = project_chann\n if self.project_chann not in [3, 12]:\n raise NotImplementedError\n self.project_size = project_size\n if self.project_size != 60:\n raise NotImplementedError\n self.normal_K = 10\n self.voxel_point_num = 50\n self.projection_margin = 1\n self.minimum_point_amount = 150\n\n self.transform = pickle.load(open(os.path.join(self.path, 'google2cloud.pkl'), 'rb'))\n fl_grasp = glob.glob(os.path.join(path, 'ycb_grasp', self.tag, '*.npy'))\n fl_pc = glob.glob(os.path.join(path, 'ycb_rgbd', '*', 'clouds', 'pc_NP3_NP5*.npy'))\n\n self.d_pc, self.d_grasp = {}, {}\n for i in fl_pc:\n k = i.split('/')[-3]\n if k in self.d_pc.keys():\n self.d_pc[k].append(i)\n else:\n self.d_pc[k] = [i]\n for k in self.d_pc.keys():\n self.d_pc[k].sort()\n\n for i in fl_grasp:\n k = i.split('/')[-1].split('.')[0]\n self.d_grasp[k] = i\n object1 = set(self.d_grasp.keys())\n object2 = set(self.transform.keys())\n self.object = list(object1.intersection(object2))\n self.amount = len(self.object) * self.grasp_amount_per_file\n\n def collect_pc(self, grasp, pc, transform):\n center = grasp[0:3]\n axis = grasp[3:6] # binormal\n width = grasp[6]\n angle = grasp[7]\n\n axis = axis / np.linalg.norm(axis)\n binormal = axis\n # cal approach\n cos_t = np.cos(angle)\n sin_t = np.sin(angle)\n R1 = np.c_[[cos_t, 0, sin_t], [0, 1, 0], [-sin_t, 0, cos_t]]\n axis_y = axis\n axis_x = np.array([axis_y[1], -axis_y[0], 0])\n if np.linalg.norm(axis_x) == 0:\n axis_x = np.array([1, 0, 0])\n axis_x = axis_x / np.linalg.norm(axis_x)\n axis_y = axis_y / np.linalg.norm(axis_y)\n axis_z = np.cross(axis_x, axis_y)\n R2 = np.c_[axis_x, np.c_[axis_y, axis_z]]\n approach = R2.dot(R1)[:, 0]\n approach = approach / np.linalg.norm(approach)\n minor_normal = np.cross(axis, approach)\n\n left = center - width * axis / 2\n right = center + width * axis / 2\n left = (np.dot(transform, np.array([left[0], left[1], left[2], 1])))[:3]\n right = (np.dot(transform, np.array([right[0], right[1], right[2], 1])))[:3]\n center = (np.dot(transform, np.array([center[0], center[1], center[2], 1])))[:3]\n binormal = (np.dot(transform, np.array([binormal[0], binormal[1], binormal[2], 0])))[:3].reshape(3, 1)\n approach = (np.dot(transform, np.array([approach[0], approach[1], approach[2], 0])))[:3].reshape(3, 1)\n minor_normal = (np.dot(transform, np.array([minor_normal[0], minor_normal[1], minor_normal[2], 0])))[\n :3].reshape(3, 1)\n matrix = np.hstack([approach, binormal, minor_normal]).T\n pc_t = (np.dot(matrix, (pc - center).T)).T\n left_t = (-width * np.array([0, 1, 0]) / 2).squeeze()\n right_t = (width * np.array([0, 1, 0]) / 2).squeeze()\n\n x_limit = width / 4\n z_limit = width / 4\n y_limit = width / 2\n\n x1 = pc_t[:, 0] > -x_limit\n x2 = pc_t[:, 0] < x_limit\n y1 = pc_t[:, 1] > -y_limit\n y2 = pc_t[:, 1] < y_limit\n z1 = pc_t[:, 2] > -z_limit\n z2 = pc_t[:, 2] < z_limit\n\n a = np.vstack([x1, x2, y1, y2, z1, z2])\n self.in_ind = np.where(np.sum(a, axis=0) == len(a))[0]\n\n if len(self.in_ind) < self.min_point_limit:\n return None\n if self.projection:\n return self.project_pc(pc_t, width)\n else:\n return pc_t[self.in_ind]\n\n def check_square(self, point, points_g):\n dirs = np.array([[-1, 1, 1], [1, 1, 1], [-1, -1, 1], [1, -1, 1],\n [-1, 1, -1], [1, 1, -1], [-1, -1, -1], [1, -1, -1]])\n p = dirs * 0.5 + point # here res * 0.5 means get half of a pixel width\n a1 = p[2][1] < points_g[:, 1]\n a2 = p[0][1] > points_g[:, 1]\n a3 = p[0][2] > points_g[:, 2]\n a4 = p[4][2] < points_g[:, 2]\n a5 = p[1][0] > points_g[:, 0]\n a6 = p[0][0] < points_g[:, 0]\n\n a = np.vstack([a1, a2, a3, a4, a5, a6])\n points_in_area = np.where(np.sum(a, axis=0) == len(a))[0]\n\n if len(points_in_area) == 0:\n has_p = False\n else:\n has_p = True\n return points_in_area\n\n def cal_projection(self, point_cloud_voxel, m_width_of_pic, margin, surface_normal, order, gripper_width):\n occupy_pic = np.zeros([m_width_of_pic, m_width_of_pic, 1])\n norm_pic = np.zeros([m_width_of_pic, m_width_of_pic, 3])\n norm_pic_num = np.zeros([m_width_of_pic, m_width_of_pic, 1])\n\n max_x = point_cloud_voxel[:, order[0]].max()\n min_x = point_cloud_voxel[:, order[0]].min()\n max_y = point_cloud_voxel[:, order[1]].max()\n min_y = point_cloud_voxel[:, order[1]].min()\n min_z = point_cloud_voxel[:, order[2]].min()\n\n tmp = max((max_x - min_x), (max_y - min_y))\n if tmp == 0:\n print(\"WARNING : the num of input points seems only have one, no possilbe to do learning on\"\n \"such data, please throw it away. -- Hongzhuo\")\n return occupy_pic, norm_pic\n # Here, we use the gripper width to cal the res:\n res = gripper_width / (m_width_of_pic - margin)\n\n voxel_points_square_norm = []\n x_coord_r = ((point_cloud_voxel[:, order[0]]) / res + m_width_of_pic / 2)\n y_coord_r = ((point_cloud_voxel[:, order[1]]) / res + m_width_of_pic / 2)\n z_coord_r = ((point_cloud_voxel[:, order[2]]) / res + m_width_of_pic / 2)\n x_coord_r = np.floor(x_coord_r).astype(int)\n y_coord_r = np.floor(y_coord_r).astype(int)\n z_coord_r = np.floor(z_coord_r).astype(int)\n voxel_index = np.array([x_coord_r, y_coord_r, z_coord_r]).T # all point in grid\n coordinate_buffer = np.unique(voxel_index, axis=0) # get a list of points without duplication\n K = len(coordinate_buffer)\n # [K, 1] store number of points in each voxel grid\n number_buffer = np.zeros(shape=K, dtype=np.int64)\n feature_buffer = np.zeros(shape=(K, self.voxel_point_num, 6), dtype=np.float32)\n index_buffer = {}\n for i in range(K):\n index_buffer[tuple(coordinate_buffer[i])] = i # got index of coordinate\n\n for voxel, point, normal in zip(voxel_index, point_cloud_voxel, surface_normal):\n index = index_buffer[tuple(voxel)]\n number = number_buffer[index]\n if number < self.voxel_point_num:\n feature_buffer[index, number, :3] = point\n feature_buffer[index, number, 3:6] = normal\n number_buffer[index] += 1\n\n voxel_points_square_norm = np.sum(feature_buffer[..., -3:], axis=1) / number_buffer[:, np.newaxis]\n voxel_points_square = coordinate_buffer\n\n if len(voxel_points_square) == 0:\n return occupy_pic, norm_pic\n x_coord_square = voxel_points_square[:, 0]\n y_coord_square = voxel_points_square[:, 1]\n norm_pic[x_coord_square, y_coord_square, :] = voxel_points_square_norm\n occupy_pic[x_coord_square, y_coord_square] = number_buffer[:, np.newaxis]\n occupy_max = occupy_pic.max()\n assert (occupy_max > 0)\n occupy_pic = occupy_pic / occupy_max\n return occupy_pic, norm_pic\n\n def project_pc(self, pc, gripper_width):\n \"\"\"\n for gpd baseline, only support input_chann == [3, 12]\n \"\"\"\n pc = pc.astype(np.float32)\n pc = pcl.PointCloud(pc)\n norm = pc.make_NormalEstimation()\n norm.set_KSearch(self.normal_K)\n normals = norm.compute()\n surface_normal = normals.to_array()\n surface_normal = surface_normal[:, 0:3]\n pc = pc.to_array()\n grasp_pc = pc[self.in_ind]\n grasp_pc_norm = surface_normal[self.in_ind]\n bad_check = (grasp_pc_norm != grasp_pc_norm)\n if np.sum(bad_check) != 0:\n bad_ind = np.where(bad_check == True)\n grasp_pc = np.delete(grasp_pc, bad_ind[0], axis=0)\n grasp_pc_norm = np.delete(grasp_pc_norm, bad_ind[0], axis=0)\n assert (np.sum(grasp_pc_norm != grasp_pc_norm) == 0)\n m_width_of_pic = self.project_size\n margin = self.projection_margin\n order = np.array([0, 1, 2])\n occupy_pic1, norm_pic1 = self.cal_projection(grasp_pc, m_width_of_pic, margin, grasp_pc_norm,\n order, gripper_width)\n if self.project_chann == 3:\n output = norm_pic1\n elif self.project_chann == 12:\n order = np.array([1, 2, 0])\n occupy_pic2, norm_pic2 = self.cal_projection(grasp_pc, m_width_of_pic, margin, grasp_pc_norm,\n order, gripper_width)\n order = np.array([0, 2, 1])\n occupy_pic3, norm_pic3 = self.cal_projection(grasp_pc, m_width_of_pic, margin, grasp_pc_norm,\n order, gripper_width)\n output = np.dstack([occupy_pic1, norm_pic1, occupy_pic2, norm_pic2, occupy_pic3, norm_pic3])\n else:\n raise NotImplementedError\n\n return output\n\n def __getitem__(self, index):\n # try:\n obj_ind, grasp_ind = np.unravel_index(index, (len(self.object), self.grasp_amount_per_file))\n\n obj_grasp = self.object[obj_ind]\n obj_pc = self.transform[obj_grasp][0]\n f_grasp = self.d_grasp[obj_grasp]\n fl_pc = np.array(self.d_pc[obj_pc])\n np.random.shuffle(fl_pc)\n\n grasp = np.load(f_grasp)[grasp_ind]\n pc = np.load(fl_pc[-1])\n t = self.transform[obj_grasp][1]\n\n grasp_pc = self.collect_pc(grasp, pc, t)\n if grasp_pc is None:\n return None\n level_score, refine_score = grasp[-2:]\n\n if not self.projection:\n if len(grasp_pc) > self.grasp_points_num:\n grasp_pc = grasp_pc[np.random.choice(len(grasp_pc), size=self.grasp_points_num,\n replace=False)].T\n else:\n grasp_pc = grasp_pc[np.random.choice(len(grasp_pc), size=self.grasp_points_num,\n replace=True)].T\n else:\n grasp_pc = grasp_pc.transpose((2, 1, 0))\n score = level_score + refine_score * 0.01\n if score >= self.thresh_bad:\n label = 0\n elif score <= self.thresh_good:\n label = 2\n else:\n label = 1\n\n if self.with_obj:\n return grasp_pc, label, obj_grasp\n else:\n return grasp_pc, label\n\n def __len__(self):\n return self.amount\n\n\ndef test_dataset():\n grasp_points_num = 1000\n obj_points_num = 50000\n pc_file_used_num = 20\n thresh_good = 0.6\n thresh_bad = 0.6\n\n input_size = 60\n input_chann = 12 # 12\n a = PointGraspDataset(\n obj_points_num=obj_points_num,\n grasp_points_num=grasp_points_num,\n pc_file_used_num=pc_file_used_num,\n path=\"../data\",\n tag='train',\n grasp_amount_per_file=6500,\n thresh_good=thresh_good,\n thresh_bad=thresh_bad,\n projection=True,\n project_chann=input_chann,\n project_size=input_size,\n )\n c, d = a.__getitem__(0)\n\n\nif __name__ == '__main__':\n test_dataset()\n"
] |
[
[
"numpy.hstack",
"numpy.dot",
"numpy.unique",
"numpy.cos",
"numpy.random.shuffle",
"numpy.sin",
"numpy.linalg.norm",
"numpy.dstack",
"numpy.delete",
"numpy.where",
"numpy.floor",
"numpy.cross",
"numpy.load",
"numpy.array",
"numpy.zeros",
"numpy.sum",
"numpy.vstack"
]
] |
jigneshoo7/AlgoBook
|
[
"8aecc9698447c0ee561a1c90d5c5ab87c4a07b79"
] |
[
"ml/Perceptrons/softmax.py"
] |
[
"# Softmax function\n\nimport numpy as np\n\ndef Softmax(z): \n # The input for function sofmax is a vector\n \n return np.exp(z)/np.sum(np.exp(z),axis=0)"
] |
[
[
"numpy.exp"
]
] |
zzzeus/simple-faster-rcnn-pytorch
|
[
"e0aca1c6105ae6452faa2bff2441c05345be911e"
] |
[
"trainer.py"
] |
[
"from __future__ import absolute_import\nimport os\nfrom collections import namedtuple\nimport time\nfrom torch.nn import functional as F\nfrom model.utils.creator_tool import AnchorTargetCreator, ProposalTargetCreator\n\nfrom torch import nn\nimport torch as t\nfrom utils import array_tool as at\n# from utils.vis_tool import Visualizer\n\nfrom utils.config import opt\nfrom torchnet.meter import ConfusionMeter, AverageValueMeter\n\nLossTuple = namedtuple('LossTuple',\n ['rpn_loc_loss',\n 'rpn_cls_loss',\n 'roi_loc_loss',\n 'roi_cls_loss',\n 'total_loss'\n ])\n\n\nclass FasterRCNNTrainer(nn.Module):\n \"\"\"wrapper for conveniently training. return losses\n\n The losses include:\n\n * :obj:`rpn_loc_loss`: The localization loss for \\\n Region Proposal Network (RPN).\n * :obj:`rpn_cls_loss`: The classification loss for RPN.\n * :obj:`roi_loc_loss`: The localization loss for the head module.\n * :obj:`roi_cls_loss`: The classification loss for the head module.\n * :obj:`total_loss`: The sum of 4 loss above.\n\n Args:\n faster_rcnn (model.FasterRCNN):\n A Faster R-CNN model that is going to be trained.\n \"\"\"\n\n def __init__(self, faster_rcnn):\n super(FasterRCNNTrainer, self).__init__()\n\n self.faster_rcnn = faster_rcnn\n self.rpn_sigma = opt.rpn_sigma\n self.roi_sigma = opt.roi_sigma\n\n # target creator create gt_bbox gt_label etc as training targets. \n self.anchor_target_creator = AnchorTargetCreator()\n self.proposal_target_creator = ProposalTargetCreator()\n\n self.loc_normalize_mean = faster_rcnn.loc_normalize_mean\n self.loc_normalize_std = faster_rcnn.loc_normalize_std\n\n self.optimizer = self.faster_rcnn.get_optimizer()\n # visdom wrapper\n # self.vis = Visualizer(env=opt.env)\n\n # indicators for training status\n self.rpn_cm = ConfusionMeter(2)\n self.roi_cm = ConfusionMeter(21)\n self.meters = {k: AverageValueMeter() for k in LossTuple._fields} # average loss\n\n def forward(self, imgs, bboxes, labels, scale):\n \"\"\"Forward Faster R-CNN and calculate losses.\n\n Here are notations used.\n\n * :math:`N` is the batch size.\n * :math:`R` is the number of bounding boxes per image.\n\n Currently, only :math:`N=1` is supported.\n\n Args:\n imgs (~torch.autograd.Variable): A variable with a batch of images.\n bboxes (~torch.autograd.Variable): A batch of bounding boxes.\n Its shape is :math:`(N, R, 4)`.\n labels (~torch.autograd..Variable): A batch of labels.\n Its shape is :math:`(N, R)`. The background is excluded from\n the definition, which means that the range of the value\n is :math:`[0, L - 1]`. :math:`L` is the number of foreground\n classes.\n scale (float): Amount of scaling applied to\n the raw image during preprocessing.\n\n Returns:\n namedtuple of 5 losses\n \"\"\"\n n = bboxes.shape[0]\n if n != 1:\n raise ValueError('Currently only batch size 1 is supported.')\n\n _, _, H, W = imgs.shape\n img_size = (H, W)\n\n features = self.faster_rcnn.extractor(imgs)\n\n rpn_locs, rpn_scores, rois, roi_indices, anchor = \\\n self.faster_rcnn.rpn(features, img_size, scale)\n\n # Since batch size is one, convert variables to singular form\n bbox = bboxes[0]\n label = labels[0]\n rpn_score = rpn_scores[0]\n rpn_loc = rpn_locs[0]\n roi = rois\n\n # Sample RoIs and forward\n # it's fine to break the computation graph of rois, \n # consider them as constant input\n sample_roi, gt_roi_loc, gt_roi_label = self.proposal_target_creator(\n roi,\n at.tonumpy(bbox),\n at.tonumpy(label),\n self.loc_normalize_mean,\n self.loc_normalize_std)\n # NOTE it's all zero because now it only support for batch=1 now\n sample_roi_index = t.zeros(len(sample_roi))\n roi_cls_loc, roi_score = self.faster_rcnn.head(\n features,\n sample_roi,\n sample_roi_index)\n\n # ------------------ RPN losses -------------------#\n gt_rpn_loc, gt_rpn_label = self.anchor_target_creator(\n at.tonumpy(bbox),\n anchor,\n img_size)\n gt_rpn_label = at.totensor(gt_rpn_label).long()\n gt_rpn_loc = at.totensor(gt_rpn_loc)\n rpn_loc_loss = _fast_rcnn_loc_loss(\n rpn_loc,\n gt_rpn_loc,\n gt_rpn_label.data,\n self.rpn_sigma)\n\n # NOTE: default value of ignore_index is -100 ...\n rpn_cls_loss = F.cross_entropy(rpn_score, gt_rpn_label.cuda(), ignore_index=-1)\n _gt_rpn_label = gt_rpn_label[gt_rpn_label > -1]\n _rpn_score = at.tonumpy(rpn_score)[at.tonumpy(gt_rpn_label) > -1]\n self.rpn_cm.add(at.totensor(_rpn_score, False), _gt_rpn_label.data.long())\n\n # ------------------ ROI losses (fast rcnn loss) -------------------#\n n_sample = roi_cls_loc.shape[0]\n roi_cls_loc = roi_cls_loc.view(n_sample, -1, 4)\n roi_loc = roi_cls_loc[t.arange(0, n_sample).long().cuda(), \\\n at.totensor(gt_roi_label).long()]\n gt_roi_label = at.totensor(gt_roi_label).long()\n gt_roi_loc = at.totensor(gt_roi_loc)\n\n roi_loc_loss = _fast_rcnn_loc_loss(\n roi_loc.contiguous(),\n gt_roi_loc,\n gt_roi_label.data,\n self.roi_sigma)\n\n roi_cls_loss = nn.CrossEntropyLoss()(roi_score, gt_roi_label.cuda())\n\n self.roi_cm.add(at.totensor(roi_score, False), gt_roi_label.data.long())\n\n losses = [rpn_loc_loss, rpn_cls_loss, roi_loc_loss, roi_cls_loss]\n losses = losses + [sum(losses)]\n\n return LossTuple(*losses)\n\n def train_step(self, imgs, bboxes, labels, scale):\n self.optimizer.zero_grad()\n losses = self.forward(imgs, bboxes, labels, scale)\n losses.total_loss.backward()\n self.optimizer.step()\n self.update_meters(losses)\n return losses\n\n def save(self, save_optimizer=False, save_path=None, **kwargs):\n \"\"\"serialize models include optimizer and other info\n return path where the model-file is stored.\n\n Args:\n save_optimizer (bool): whether save optimizer.state_dict().\n save_path (string): where to save model, if it's None, save_path\n is generate using time str and info from kwargs.\n \n Returns:\n save_path(str): the path to save models.\n \"\"\"\n save_dict = dict()\n\n save_dict['model'] = self.faster_rcnn.state_dict()\n save_dict['config'] = opt._state_dict()\n save_dict['other_info'] = kwargs\n save_dict['vis_info'] = self.vis.state_dict()\n\n if save_optimizer:\n save_dict['optimizer'] = self.optimizer.state_dict()\n\n if save_path is None:\n timestr = time.strftime('%m%d%H%M')\n save_path = 'checkpoints/fasterrcnn_%s' % timestr\n for k_, v_ in kwargs.items():\n save_path += '_%s' % v_\n\n save_dir = os.path.dirname(save_path)\n if not os.path.exists(save_dir):\n os.makedirs(save_dir)\n\n t.save(save_dict, save_path)\n # self.vis.save([self.vis.env])\n return save_path\n\n def load(self, path, load_optimizer=True, parse_opt=False, ):\n state_dict = t.load(path)\n if 'model' in state_dict:\n self.faster_rcnn.load_state_dict(state_dict['model'])\n else: # legacy way, for backward compatibility\n self.faster_rcnn.load_state_dict(state_dict)\n return self\n if parse_opt:\n opt._parse(state_dict['config'])\n if 'optimizer' in state_dict and load_optimizer:\n self.optimizer.load_state_dict(state_dict['optimizer'])\n return self\n\n def update_meters(self, losses):\n loss_d = {k: at.scalar(v) for k, v in losses._asdict().items()}\n for key, meter in self.meters.items():\n meter.add(loss_d[key])\n\n def reset_meters(self):\n for key, meter in self.meters.items():\n meter.reset()\n self.roi_cm.reset()\n self.rpn_cm.reset()\n\n def get_meter_data(self):\n return {k: v.value()[0] for k, v in self.meters.items()}\n\n\ndef _smooth_l1_loss(x, t, in_weight, sigma):\n sigma2 = sigma ** 2\n diff = in_weight * (x - t)\n abs_diff = diff.abs()\n flag = (abs_diff.data < (1. / sigma2)).float()\n y = (flag * (sigma2 / 2.) * (diff ** 2) +\n (1 - flag) * (abs_diff - 0.5 / sigma2))\n return y.sum()\n\n\ndef _fast_rcnn_loc_loss(pred_loc, gt_loc, gt_label, sigma):\n in_weight = t.zeros(gt_loc.shape).cuda()\n # Localization loss is calculated only for positive rois.\n # NOTE: unlike origin implementation, \n # we don't need inside_weight and outside_weight, they can calculate by gt_label\n in_weight[(gt_label > 0).view(-1, 1).expand_as(in_weight).cuda()] = 1\n loc_loss = _smooth_l1_loss(pred_loc, gt_loc, in_weight.detach(), sigma)\n # Normalize by total number of negtive and positive rois.\n loc_loss /= ((gt_label >= 0).sum().float()) # ignore gt_label==-1 for rpn_loss\n return loc_loss\n"
] |
[
[
"torch.nn.CrossEntropyLoss",
"torch.zeros",
"torch.load",
"torch.arange",
"torch.save"
]
] |
gedeschaines/CS206_2017_Ludobots
|
[
"cb0c5a830222def0ca6221a9b78113be0da9b2b9"
] |
[
"refactoring/randomSearch.py"
] |
[
"#!/usr/bin/env python2\n\"\"\" CS206 Spring 2017 ludobots -- Project Random Search\n https://www.reddit.com/r/ludobots/wiki/pyrosim/randomsearch\n\"\"\"\nfrom individual import INDIVIDUAL\nfrom random import seed\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pickle\n\nplay_blind = True\nsave_best_individual = True\nrandom_seed = 21212121\n\ntlim = 1000 # upper limit of simulation time steps\nnlim = 1001 # upper limit of individual iterations\nn = [i for i in range(nlim)]\n\nif random_seed is not None:\n seed(random_seed)\n\ngenomes = np.ndarray((1,nlim))\nfitness = np.ndarray((1,nlim))\n\n# Random Search to find an individual with the best fitness.\n\nbest_fitness = -99999.0\n\nprint(\" i Genome Fitness \")\nprint(\"---- ------------ ----------\")\n\nfor i in range(0,nlim):\n individual = INDIVIDUAL()\n individual.Evaluate(tlim, play_blind)\n genomes[0,i] = individual.genome\n fitness[0,i] = individual.fitness\n print(\"%3d %12.8f %9.5f\" % (i,genomes[0,i],fitness[0,i]))\n if fitness[0,i] > best_fitness:\n best_genome = genomes[0,i]\n best_fitness = fitness[0,i]\n del individual\n\nprint(\"---- ------------ ----------\")\nprint(\"best %12.8f %9.5f\" % (best_genome,best_fitness))\n\nif save_best_individual:\n f = open('robot.p', 'w')\n individual = INDIVIDUAL(best_genome)\n individual.Evaluate(tlim, play_blind)\n pickle.dump(individual, f)\n f.close()\n\n# Searched points in fitness landscape.\n\nxmin = float(int(np.amin(genomes[0,:])*10))/10.0 - 1.0 \nxmax = float(int(np.amax(genomes[0,:])*10))/10.0 + 1.0 \nymin = float(int(np.amin(fitness[0,:])*10))/10.0 - 1.0\nymax = float(int(np.amax(fitness[0,:])*10))/10.0 + 1.0\n \nfig = plt.figure(figsize=(8, 6))\nfig.suptitle('Random Search Project - Fitness Landscape', fontsize=15)\npanel = fig.add_subplot(111)\npanel.set_xlabel('Genome')\npanel.set_ylabel('Fitness')\npanel.set_xlim(xmin, xmax)\npanel.set_ylim(ymin, ymax)\npanel.plot(genomes[0,:], fitness[0,:], '.r')\nplt.savefig('randomSearch_fitness_landscape.png', format='png')\nplt.show()\n"
] |
[
[
"numpy.amax",
"numpy.amin",
"numpy.ndarray",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.show",
"matplotlib.pyplot.figure"
]
] |
kozistr/naver-ai-hackathon-2018
|
[
"b38b3a24c25402317d9409c2cab9a9205ab12f4c"
] |
[
"kin/b_residual_concept/main.py"
] |
[
"# -*- coding: utf-8 -*-\n\n\"\"\"\nCopyright 2018 NAVER Corp.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and\nassociated documentation files (the \"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial\nportions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,\nINCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A\nPARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT\nHOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF\nCONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE\nOR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\"\"\"\n\n\nimport argparse\nimport os\n\nimport numpy as np\nimport tensorflow as tf\n\nimport nsml\nfrom nsml import DATASET_PATH, HAS_DATASET, IS_ON_NSML\nfrom dataset import KinQueryDataset, preprocess\n\n\n# DONOTCHANGE: They are reserved for nsml\n# This is for nsml leaderboard\ndef bind_model(sess, config):\n # 학습한 모델을 저장하는 함수입니다.\n def save(dir_name, *args):\n # directory\n os.makedirs(dir_name, exist_ok=True)\n saver = tf.train.Saver()\n saver.save(sess, os.path.join(dir_name, 'model'))\n\n # 저장한 모델을 불러올 수 있는 함수입니다.\n def load(dir_name, *args):\n saver = tf.train.Saver()\n # find checkpoint\n ckpt = tf.train.get_checkpoint_state(dir_name)\n if ckpt and ckpt.model_checkpoint_path:\n checkpoint = os.path.basename(ckpt.model_checkpoint_path)\n saver.restore(sess, os.path.join(dir_name, checkpoint))\n else:\n raise NotImplemented('No checkpoint!')\n print('Model loaded')\n\n def infer(raw_data, **kwargs):\n \"\"\"\n :param raw_data: raw input (여기서는 문자열)을 입력받습니다\n :param kwargs:\n :return:\n \"\"\"\n # dataset.py에서 작성한 preprocess 함수를 호출하여, 문자열을 벡터로 변환합니다\n preprocessed_data = preprocess(raw_data, config.strmaxlen)\n # 저장한 모델에 입력값을 넣고 prediction 결과를 리턴받습니다\n pred = sess.run(prob, feed_dict={x: preprocessed_data})\n clipped = np.array(pred > config.threshold, dtype=np.int)\n # DONOTCHANGE: They are reserved for nsml\n # 리턴 결과는 [(확률, 0 or 1)] 의 형태로 보내야만 리더보드에 올릴 수 있습니다. 리더보드 결과에 확률의 값은 영향을 미치지 않습니다\n return list(zip(pred.flatten(), clipped.flatten()))\n\n # DONOTCHANGE: They are reserved for nsml\n # nsml에서 지정한 함수에 접근할 수 있도록 하는 함수입니다.\n nsml.bind(save=save, load=load, infer=infer)\n\n\ndef _batch_loader(iterable, n=1):\n length = len(iterable)\n for n_idx in range(0, length, n):\n yield iterable[n_idx:min(n_idx + n, length)]\n\n\ndef conv2d(x, f=64, k=3, s=1, pad='SAME', name=\"conv2d\"):\n return tf.layers.conv2d(x,\n filters=f, kernel_size=k, strides=s,\n kernel_initializer=tf.contrib.layers.variance_scaling_initializer(),\n kernel_regularizer=tf.contrib.layers.l2_regularizer(5e-4),\n bias_initializer=tf.zeros_initializer(),\n padding=pad,\n name=name)\n\n\ndef dense(x, units, name='fc'):\n return tf.layers.dense(x, units,\n kernel_initializer=tf.contrib.layers.variance_scaling_initializer(),\n kernel_regularizer=tf.contrib.layers.l2_regularizer(5e-4),\n bias_initializer=tf.zeros_initializer(),\n name=name)\n\n\ndef batch_norm(x, momentum=0.9, eps=1e-5, is_train=True, name=\"bn\"):\n return tf.layers.batch_normalization(inputs=x,\n momentum=momentum,\n epsilon=eps,\n scale=True,\n trainable=is_train,\n name=name)\n\n\ndef instance_norm(x, name=\"ibn\"):\n epsilon = 1e-9\n\n mean, var = tf.nn.moments(x, [1, 2], keep_dims=True, name=name)\n\n return tf.div(tf.subtract(x, mean), tf.sqrt(tf.add(var, epsilon)))\n\n\nif __name__ == '__main__':\n args = argparse.ArgumentParser()\n\n # DONOTCHANGE: They are reserved for nsml\n args.add_argument('--mode', type=str, default='train')\n args.add_argument('--pause', type=int, default=0)\n args.add_argument('--iteration', type=str, default='0')\n\n # User options\n args.add_argument('--output', type=int, default=1)\n args.add_argument('--epochs', type=int, default=151)\n args.add_argument('--batch', type=int, default=256)\n args.add_argument('--strmaxlen', type=int, default=400)\n args.add_argument('--embedding', type=int, default=32)\n args.add_argument('--threshold', type=float, default=0.5)\n args.add_argument('--bn', type=bool, default=False)\n args.add_argument('--lr', type=float, default=1e-4)\n config = args.parse_args()\n\n if not HAS_DATASET and not IS_ON_NSML: # It is not running on nsml\n DATASET_PATH = '../sample_data/kin/'\n\n # model's specification (hyper-parameters)\n input_size = config.embedding * config.strmaxlen\n output_size = 1\n fc_unit = 1024\n conv_filters = 64\n learning_rate = config.lr\n character_size = 251\n\n x = tf.placeholder(tf.int32, [None, config.strmaxlen])\n y_ = tf.placeholder(tf.float32, [None, output_size])\n\n # embeddings\n char_embedding = tf.get_variable('char_embedding', [character_size, config.embedding])\n embedded = tf.nn.embedding_lookup(char_embedding, x)\n embedded = tf.reshape(embedded, (-1, 40, 40, 8)) # to 4-D\n\n print(\"[+] embedded size : \", embedded.get_shape().as_list()) # (batch_size, 40, 40, 8)\n\n def residual_block(x_, f, k, s, bn=True, name=\"\"):\n x__ = conv2d(x_, f, k=k, s=s, name=name + 'conv2d-0')\n\n if bn:\n x__ = batch_norm(x__, name=name + 'bn', is_train=bn)\n else:\n x__ = instance_norm(x__, name=name + 'ibn')\n x__ = tf.nn.leaky_relu(x__)\n # x__ = tf.nn.dropout(x_, .5, name=name + 'do')\n\n return x__\n\n x_ = conv2d(embedded, conv_filters, name='conv1')\n x_ = tf.nn.leaky_relu(x_)\n\n x_f_backup = x_\n\n for i in range(1, 4):\n xx_ = residual_block(x_, f=conv_filters, k=1, s=1, bn=config.bn, name='b-residual-1-%d-' % i)\n xx_ = tf.add(x_, xx_)\n x_ = xx_\n\n x_ = conv2d(x_, conv_filters, name='conv2')\n x_ = tf.add(x_f_backup, x_)\n\n for i in range(1, 4):\n x_ = residual_block(x_, f=conv_filters * (2 ** i), k=1, s=2, bn=config.bn, name='residual-2-%d-' % i)\n\n # (-1, 5, 5, 512)\n x_ = tf.layers.flatten(x_) # (-1, 5 * 5 * 512)\n\n x_ = dense(x_, fc_unit, name='fc-1')\n x_ = batch_norm(x_, name='bn-1', is_train=config.bn)\n x_ = tf.nn.leaky_relu(x_)\n x_ = tf.nn.dropout(x_, .5, name='do-1')\n\n logits = dense(x_, output_size, name='fc-2')\n prob = tf.nn.sigmoid(logits)\n\n # logistic loss\n bce_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=logits, labels=y_))\n\n # Adam Optimizer\n train_step = tf.train.AdamOptimizer(learning_rate).minimize(bce_loss)\n # RMSProp Optimizer\n # train_step = tf.train.RMSPropOptimizer(learning_rate, momentum=0.9).minimize(bce_loss)\n\n sess = tf.Session()\n sess.run(tf.global_variables_initializer())\n\n # DONOTCHANGE: Reserved for nsml\n bind_model(sess=sess, config=config)\n\n # DONOTCHANGE: Reserved for nsml\n if config.pause:\n nsml.paused(scope=locals())\n\n if config.mode == 'train':\n dataset = KinQueryDataset(DATASET_PATH, config.strmaxlen)\n\n dataset_len = len(dataset)\n one_batch_size = dataset_len // config.batch\n if dataset_len % config.batch != 0:\n one_batch_size += 1\n\n for epoch in range(config.epochs):\n avg_loss = 0.\n for i, (data, labels) in enumerate(_batch_loader(dataset, config.batch)):\n _, loss = sess.run([train_step, bce_loss],\n feed_dict={\n x: data,\n y_: labels\n })\n\n print('Batch : ', i + 1, '/', one_batch_size, ', BCE in this minibatch: ', float(loss))\n avg_loss += float(loss)\n\n print('epoch:', epoch, ' train_loss:', float(avg_loss / one_batch_size))\n\n min_loss = avg_loss\n\n nsml.report(summary=True, scope=locals(), epoch=epoch, epoch_total=config.epochs,\n train__loss=float(avg_loss / one_batch_size), step=epoch)\n\n # DONOTCHANGE (You can decide how often you want to save the model)\n nsml.save(epoch)\n\n # [(0.3, 0), (0.7, 1), ... ]\n elif config.mode == 'test_local':\n with open(os.path.join(DATASET_PATH, 'train/train_data'), 'rt', encoding='utf-8') as f:\n queries = f.readlines()\n res = []\n for batch in _batch_loader(queries, config.batch):\n temp_res = nsml.infer(batch)\n res += temp_res\n\n print(res)\n"
] |
[
[
"tensorflow.get_variable",
"tensorflow.nn.sigmoid_cross_entropy_with_logits",
"tensorflow.train.AdamOptimizer",
"tensorflow.layers.batch_normalization",
"tensorflow.contrib.layers.variance_scaling_initializer",
"tensorflow.nn.moments",
"tensorflow.subtract",
"tensorflow.add",
"tensorflow.Session",
"tensorflow.train.Saver",
"tensorflow.nn.dropout",
"tensorflow.nn.sigmoid",
"tensorflow.zeros_initializer",
"tensorflow.placeholder",
"tensorflow.global_variables_initializer",
"numpy.array",
"tensorflow.nn.embedding_lookup",
"tensorflow.nn.leaky_relu",
"tensorflow.train.get_checkpoint_state",
"tensorflow.layers.flatten",
"tensorflow.reshape",
"tensorflow.contrib.layers.l2_regularizer"
]
] |
payal006/Movie-Review-Sentiment-Analysis
|
[
"2e1c9e2d82fe878bbf4ece7c64f39263f3855423"
] |
[
"Sentiment Analysis /classifyUpdateLabelsInDataset.py"
] |
[
"import collections\nfrom collections import deque\nimport nltk.classify.util, nltk.metrics\nfrom nltk.classify import NaiveBayesClassifier\nfrom nltk.corpus import CategorizedPlaintextCorpusReader\nfrom nltk.corpus import PlaintextCorpusReader\nfrom sklearn import svm\nfrom sklearn.svm import LinearSVC\n\nimport string\nimport csv\n\ncorpus_root1='/Users/tianhan/Dropbox/Advanced_big_data_Project/aclImdb/train'\ntrain=CategorizedPlaintextCorpusReader(corpus_root1,r'(pos|neg)/.*\\.txt',cat_pattern=r'(pos|neg)/.*\\.txt')\ncorpus_root2='/Users/tianhan/Documents/ColumbiaU/Spring15/Adv_Big_Data_Analytics/Project/Reviews'\ntest=PlaintextCorpusReader(corpus_root2,'.*\\.txt')\n\ndef classify(featx):\n train_negids = train.fileids('neg')\n train_posids = train.fileids('pos')\n train_negfeats = [(featx(train.words(fileids=[f])), 'neg') for f in train_negids]\n train_posfeats = [(featx(train.words(fileids=[f])), 'pos') for f in train_posids]\n test_feats = [(featx(test.words(fileids=[f]))) for f in test._fileids]\n trainfeats = train_negfeats + train_posfeats\n NaiveBayes_classifier = NaiveBayesClassifier.train(trainfeats)\n classifier = nltk.classify.SklearnClassifier(LinearSVC())\n SVM_classifier = classifier.train(trainfeats)\n testsets = collections.defaultdict(set)\n labelallNaiveBayes = list()\n labelallSVM = list()\n\n for i, feats in enumerate(test_feats):\n observed = NaiveBayes_classifier.classify(feats)\n labelallNaiveBayes.append(observed)\n \n for i, feats in enumerate(test_feats):\n observed = classifier.classify(feats)\n labelallSVM.append(observed)\n \n with open('/Users/tianhan/Documents/ColumbiaU/Spring15/Adv_Big_Data_Analytics/Project/criticsnew.csv', 'wb') as f:\n writer = csv.writer(f)\n writer.writerow(['critic','date','fresh','imdb','original_score','publication','quote','review_date','rt_id','title','label_NaiveBayes','label_SVM'])\n with open('/Users/tianhan/Documents/ColumbiaU/Spring15/Adv_Big_Data_Analytics/Project/critics.csv','rU') as readfile: # input csv file\n reader = csv.reader(readfile, delimiter=',')\n next(reader) # Ignore first row\n\n for row in reader:\n row[10]=labelallNaiveBayes.pop(0)\n row[11]=labelallSVM.pop(0) \n writer.writerow(row)\n \n #print classifier.most_informative_features()\n NaiveBayes_classifier.show_most_informative_features(50)\n\n\ndef word_feats(words):\n return dict([(word, True) for word in words])\n\nclassify(word_feats)\n\nimport itertools\nfrom nltk.collocations import BigramCollocationFinder\nfrom nltk.metrics import BigramAssocMeasures\n\ndef bigram_word_feats(words, score_fn=BigramAssocMeasures.chi_sq, n=200):\n words_nopunc = [word for word in words if word not in string.punctuation]\n bigram_finder = BigramCollocationFinder.from_words(words_nopunc)\n bigrams = bigram_finder.nbest(score_fn, n)\n return dict([(ngram, True) for ngram in itertools.chain(words_nopunc, bigrams)])\n\nclassify(bigram_word_feats)\n\n"
] |
[
[
"sklearn.svm.LinearSVC"
]
] |
cranberrymuffin/ASAR-Deep-Loglizer
|
[
"2472cd971bc5241e72606f63401129532bf74a64"
] |
[
"data_preprocess/preprocess_intrepid_ras.py"
] |
[
"import os\nimport re\nimport pickle\nimport argparse\nimport pandas as pd\nimport numpy as np\nfrom utils import decision, json_pretty_dump\nfrom collections import OrderedDict, defaultdict\n\n\nseed = 42\nnp.random.seed(seed)\n\nparser = argparse.ArgumentParser()\n# TODO: Not accurate\nparser.add_argument(\"--train_anomaly_ratio\", default=0.2, type=float)\n\nparams = vars(parser.parse_args())\n\ndata_name = f'intrepid_ras_{params[\"train_anomaly_ratio\"]}_tar'\ndata_dir = \"../data/processed/Intrepid_RAS_Binary_Labels\"\n\nparams = {\n # \"log_file\": \"../data/HDFS/HDFS.log_structured.csv\",\n \"log_file\": \"/Users/artjiang/Documents/2470/Parser-N-Analyzer-for-Intrepid-RAS-log-Dataset/Intrepid_RAS_0901_0908_structured.csv\",\n \"label_file\": \"/Users/artjiang/Documents/2470/Parser-N-Analyzer-for-Intrepid-RAS-log-Dataset/Intrepid_RAS_0901_0908_binary_labels.csv\",\n \"test_ratio\": 0.2,\n \"random_sessions\": True, # shuffle sessions\n \"train_anomaly_ratio\": params[\"train_anomaly_ratio\"],\n}\n\ndata_dir = os.path.join(data_dir, data_name)\nos.makedirs(data_dir, exist_ok=True)\n\n\ndef preprocess_hdfs(\n log_file,\n label_file,\n test_ratio=None,\n train_anomaly_ratio=1,\n random_sessions=False,\n **kwargs\n):\n \"\"\"Load HDFS structured log into train and test data\n\n Arguments\n ---------\n TODO\n\n Returns\n -------\n TODO\n \"\"\"\n print(\"Loading HDFS logs from {}.\".format(log_file))\n struct_log = pd.read_csv(log_file, engine=\"c\", na_filter=True, memory_map=True)\n # struct_log.sort_values(by=[\"Date\", \"Time\"], inplace=True)\n struct_log.fillna('N/A', inplace=True)\n # assign labels\n label_data = pd.read_csv(label_file, engine=\"c\", na_filter=True, memory_map=True)\n label_data.fillna('N/A', inplace=True)\n label_data[\"Label\"] = label_data[\"label\"].map(lambda x: int(x == \"['Abnormal']\"))\n label_data_dict = dict(zip(label_data[\"BLOCK_TIME_UNIQUE_ID\"], label_data[\"Label\"]))\n\n session_dict = OrderedDict()\n column_idx = {col: idx for idx, col in enumerate(struct_log.columns)}\n for _, row in enumerate(struct_log.values):\n # blkId_list = re.findall(r\"(blk_-?\\d+)\", row[column_idx[\"Content\"]])\n blkId_list = row[column_idx['BLOCK_TIME_UNIQUE_ID']]\n blkId_set = set([blkId_list])\n for blk_Id in blkId_set:\n if blk_Id not in session_dict:\n session_dict[blk_Id] = defaultdict(list)\n session_dict[blk_Id][\"templates\"].append(row[column_idx[\"EventTemplate\"]])\n\n # TODO: Corner Case\n label_data_dict['N/A'] = 0\n for k in session_dict.keys():\n session_dict[k][\"label\"] = label_data_dict[k]\n\n session_idx = list(range(len(session_dict)))\n # split data\n if random_sessions:\n print(\"Using random partition.\")\n np.random.shuffle(session_idx)\n\n session_ids = np.array(list(session_dict.keys()))\n session_labels = np.array(list(map(lambda x: label_data_dict[x], session_ids)))\n\n train_lines = int((1 - test_ratio) * len(session_idx))\n test_lines = int(test_ratio * len(session_idx))\n\n session_idx_train = session_idx[0:train_lines]\n session_idx_test = session_idx[-test_lines:]\n\n session_id_train = session_ids[session_idx_train]\n session_id_test = session_ids[session_idx_test]\n session_labels_train = session_labels[session_idx_train]\n session_labels_test = session_labels[session_idx_test]\n\n print(\"Total # sessions: {}\".format(len(session_ids)))\n\n session_train = {\n k: session_dict[k]\n for k in session_id_train\n if (session_dict[k][\"label\"] == 0)\n or (session_dict[k][\"label\"] == 1 and decision(train_anomaly_ratio))\n }\n\n session_test = {k: session_dict[k] for k in session_id_test}\n\n session_labels_train = [v[\"label\"] for k, v in session_train.items()]\n session_labels_test = [v[\"label\"] for k, v in session_test.items()]\n\n train_anomaly = 100 * sum(session_labels_train) / len(session_labels_train)\n test_anomaly = 100 * sum(session_labels_test) / len(session_labels_test)\n\n print(\"# train sessions: {} ({:.2f}%)\".format(len(session_train), train_anomaly))\n print(\"# test sessions: {} ({:.2f}%)\".format(len(session_test), test_anomaly))\n\n with open(os.path.join(data_dir, \"session_train.pkl\"), \"wb\") as fw:\n pickle.dump(session_train, fw)\n with open(os.path.join(data_dir, \"session_test.pkl\"), \"wb\") as fw:\n pickle.dump(session_test, fw)\n json_pretty_dump(params, os.path.join(data_dir, \"data_desc.json\"))\n\n print(\"Saved to {}\".format(data_dir))\n return session_train, session_test\n\n\nif __name__ == \"__main__\":\n preprocess_hdfs(**params)\n"
] |
[
[
"numpy.random.shuffle",
"pandas.read_csv",
"numpy.random.seed"
]
] |
hendraet/IIC
|
[
"a5bab915eda133b0ecfd42eaacd60c7b26807cb6"
] |
[
"src/scripts/cluster/cluster_sobel.py"
] |
[
"from __future__ import print_function\n\nimport argparse\nimport itertools\nimport os\nimport pickle\nimport sys\nfrom datetime import datetime\n\nimport matplotlib\nimport numpy as np\nimport torch\n\nmatplotlib.use('Agg')\nimport matplotlib.pyplot as plt\n\nimport src.archs as archs\nfrom src.utils.cluster.general import config_to_str, get_opt, update_lr, nice\nfrom src.utils.cluster.transforms import sobel_process\nfrom src.utils.cluster.data import cluster_create_dataloaders\nfrom src.utils.cluster.IID_losses import IID_loss\nfrom src.utils.cluster.cluster_eval import cluster_eval\n\n\"\"\"\n Semisupervised overclustering (\"IIC+\" = \"IID+\")\n Note network is trained entirely unsupervised, as labels are found for \n evaluation only and do not affect the network.\n Train and test script (coloured datasets).\n Network has one output head only.\n\"\"\"\n\n# Options ----------------------------------------------------------------------\nassert False, \"This code is deprecated. Use cluster.py instead\"\n\nparser = argparse.ArgumentParser()\nparser.add_argument(\"--model_ind\", type=int, required=True)\nparser.add_argument(\"--arch\", type=str, required=True)\nparser.add_argument(\"--opt\", type=str, default=\"Adam\")\nparser.add_argument(\"--mode\", type=str, default=\"IID+\")\n\nparser.add_argument(\"--dataset\", type=str, required=True)\nparser.add_argument(\"--dataset_root\", type=str, required=True)\n\nparser.add_argument(\"--gt_k\", type=int, required=True)\nparser.add_argument(\"--output_k\", type=int, required=True)\nparser.add_argument(\"--lamb\", type=float, default=1.0)\nparser.add_argument(\"--lr\", type=float, default=0.01)\nparser.add_argument(\"--lr_schedule\", type=int, nargs=\"+\", default=[])\nparser.add_argument(\"--lr_mult\", type=float, default=0.1)\n\nparser.add_argument(\"--num_epochs\", type=int, default=1000)\nparser.add_argument(\"--batch_sz\", type=int, required=True) # num pairs\nparser.add_argument(\"--num_dataloaders\", type=int, default=3)\nparser.add_argument(\"--num_subheads\", \"--num_sub_heads\", type=int, default=5, dest=\"num_subheads\")\n\nparser.add_argument(\"--out_root\", type=str, default=\"/scratch/shared/slow/xuji/iid_private\")\nparser.add_argument(\"--restart\", default=False, action=\"store_true\")\nparser.add_argument(\"--restart_from_best\", dest=\"restart_from_best\", default=False, action=\"store_true\")\nparser.add_argument(\"--test_code\", default=False, action=\"store_true\")\n\nparser.add_argument(\"--save_freq\", type=int, default=10)\n\nparser.add_argument(\"--batchnorm_track\", default=False, action=\"store_true\")\n\n# transforms\nparser.add_argument(\"--mix_train\", default=False, action=\"store_true\")\nparser.add_argument(\"--include_rgb\", default=False, action=\"store_true\")\nparser.add_argument(\"--demean\", default=False, action=\"store_true\")\nparser.add_argument(\"--per_img_demean\", dest=\"per_img_demean\", default=False, action=\"store_true\")\nparser.add_argument(\"--data_mean\", type=float, nargs=\"+\", default=[])\nparser.add_argument(\"--data_std\", type=float, nargs=\"+\", default=[])\n\nparser.add_argument(\"--crop_orig\", default=False, action=\"store_true\")\nparser.add_argument(\"--rand_crop_sz\", type=int, default=84)\nparser.add_argument(\"--input_sz\", type=int, default=96)\nparser.add_argument(\"--fluid_warp\", default=False, action=\"store_true\")\nparser.add_argument(\"--rand_crop_szs_tf\", type=int, nargs=\"+\", default=[]) # only used if fluid warp true\nparser.add_argument(\"--rot_val\", type=float, default=0.) # only used if fluid warp true\n\nparser.add_argument(\"--cutout\", default=False, action=\"store_true\")\nparser.add_argument(\"--cutout_p\", type=float, default=0.5)\nparser.add_argument(\"--cutout_max_box\", type=float, default=0.5)\n\nconfig = parser.parse_args()\n\n# Setup ------------------------------------------------------------------------\n\nconfig.twohead = False\nif not config.include_rgb:\n config.in_channels = 2\nelse:\n config.in_channels = 5\n\nconfig.out_dir = os.path.join(config.out_root, str(config.model_ind))\nconfig.dataloader_batch_sz = int(config.batch_sz / config.num_dataloaders)\n\nassert (config.mode == \"IID+\")\nassert (config.output_k >= config.gt_k)\nconfig.eval_mode = \"orig\"\nconfig.double_eval = False\n\nif not os.path.exists(config.out_dir):\n os.makedirs(config.out_dir)\n\nif config.restart:\n config_name = \"config.pickle\"\n net_name = \"latest_net.pytorch\"\n opt_name = \"latest_optimiser.pytorch\"\n\n if config.restart_from_best:\n config_name = \"best_config.pickle\"\n net_name = \"best_net.pytorch\"\n opt_name = \"best_optimiser.pytorch\"\n\n given_config = config\n reloaded_config_path = os.path.join(given_config.out_dir, config_name)\n print(\"Loading restarting config from: %s\" % reloaded_config_path)\n with open(reloaded_config_path, \"rb\") as config_f:\n config = pickle.load(config_f)\n assert (config.model_ind == given_config.model_ind)\n config.restart = True\n config.restart_from_best = given_config.restart_from_best\n\n # copy over new num_epochs and lr schedule\n config.num_epochs = given_config.num_epochs\n config.lr_schedule = given_config.lr_schedule\n\nelse:\n print(\"Config: %s\" % config_to_str(config))\n\n# Model ------------------------------------------------------------------------\n\ndataloaders, mapping_assignment_dataloader, mapping_test_dataloader = \\\n cluster_create_dataloaders(config)\n\nnet = archs.__dict__[config.arch](config)\nif config.restart:\n model_path = os.path.join(config.out_dir, net_name)\n net.load_state_dict(torch.load(model_path, map_location=lambda storage, loc: storage))\nnet.cuda()\nnet = torch.nn.DataParallel(net)\nnet.train()\n\noptimiser = get_opt(config.opt)(net.module.parameters(), lr=config.lr)\nif config.restart:\n optimiser.load_state_dict(torch.load(os.path.join(config.out_dir, opt_name)))\n\n# Results ----------------------------------------------------------------------\n\nif config.restart:\n if not config.restart_from_best:\n next_epoch = config.last_epoch + 1 # corresponds to last saved model\n else:\n next_epoch = np.argmax(np.array(config.epoch_acc)) + 1\n print(\"starting from epoch %d\" % next_epoch)\n\n config.epoch_acc = config.epoch_acc[:next_epoch] # in case we overshot\n config.epoch_avg_subhead_acc = config.epoch_avg_subhead_acc[:next_epoch]\n config.epoch_stats = config.epoch_stats[:next_epoch]\n\n config.epoch_loss = config.epoch_loss[:(next_epoch - 1)]\n config.epoch_loss_no_lamb = config.epoch_loss_no_lamb[:(next_epoch - 1)]\nelse:\n config.epoch_acc = []\n config.epoch_avg_subhead_acc = []\n config.epoch_stats = []\n\n config.epoch_loss = []\n config.epoch_loss_no_lamb = []\n\n _ = cluster_eval(config, net,\n mapping_assignment_dataloader=mapping_assignment_dataloader,\n mapping_test_dataloader=mapping_test_dataloader,\n sobel=True)\n\n print(\"Pre: time %s: \\n %s\" % (datetime.now(), nice(config.epoch_stats[-1])))\n sys.stdout.flush()\n next_epoch = 1\n\nfig, axarr = plt.subplots(4, sharex=False, figsize=(20, 20))\n\n# Train ------------------------------------------------------------------------\n\nfor e_i in xrange(next_epoch, config.num_epochs):\n print(\"Starting e_i: %d\" % e_i)\n sys.stdout.flush()\n\n iterators = (d for d in dataloaders)\n\n b_i = 0\n if e_i in config.lr_schedule:\n optimiser = update_lr(optimiser, lr_mult=config.lr_mult)\n\n avg_loss = 0.\n avg_loss_no_lamb = 0.\n avg_loss_count = 0\n\n for tup in itertools.izip(*iterators):\n net.module.zero_grad()\n\n # one less because this is before sobel\n all_imgs = torch.zeros(config.batch_sz, config.in_channels - 1,\n config.input_sz,\n config.input_sz).cuda()\n all_imgs_tf = torch.zeros(config.batch_sz, config.in_channels - 1,\n config.input_sz,\n config.input_sz).cuda()\n\n imgs_curr = tup[0][0] # always the first\n curr_batch_sz = imgs_curr.size(0)\n for d_i in xrange(config.num_dataloaders):\n imgs_tf_curr = tup[1 + d_i][0] # from 2nd to last\n assert (curr_batch_sz == imgs_tf_curr.size(0))\n\n actual_batch_start = d_i * curr_batch_sz\n actual_batch_end = actual_batch_start + curr_batch_sz\n all_imgs[actual_batch_start:actual_batch_end, :, :, :] = imgs_curr.cuda()\n all_imgs_tf[actual_batch_start:actual_batch_end, :, :, :] = imgs_tf_curr.cuda()\n\n if not (curr_batch_sz == config.dataloader_batch_sz):\n print(\"last batch sz %d\" % curr_batch_sz)\n\n curr_total_batch_sz = curr_batch_sz * config.num_dataloaders\n all_imgs = all_imgs[:curr_total_batch_sz, :, :, :]\n all_imgs_tf = all_imgs_tf[:curr_total_batch_sz, :, :, :]\n\n all_imgs = sobel_process(all_imgs, config.include_rgb)\n all_imgs_tf = sobel_process(all_imgs_tf, config.include_rgb)\n\n x_outs = net(all_imgs)\n x_tf_outs = net(all_imgs_tf)\n\n avg_loss_batch = None # avg over the heads\n avg_loss_no_lamb_batch = None\n for i in xrange(config.num_subheads):\n loss, loss_no_lamb = IID_loss(x_outs[i], x_tf_outs[i], lamb=config.lamb)\n if avg_loss_batch is None:\n avg_loss_batch = loss\n avg_loss_no_lamb_batch = loss_no_lamb\n else:\n avg_loss_batch += loss\n avg_loss_no_lamb_batch += loss_no_lamb\n\n avg_loss_batch /= config.num_subheads\n avg_loss_no_lamb_batch /= config.num_subheads\n\n if ((b_i % 100) == 0) or (e_i == next_epoch):\n print(\"Model ind %d epoch %d batch: %d avg loss %f avg loss no lamb %f \"\n \"time %s\" % \\\n (config.model_ind, e_i, b_i, avg_loss_batch.item(),\n avg_loss_no_lamb_batch.item(), datetime.now()))\n sys.stdout.flush()\n\n if not np.isfinite(avg_loss_batch.item()):\n print(\"Loss is not finite... %s:\" % str(avg_loss_batch))\n exit(1)\n\n avg_loss += avg_loss_batch.item()\n avg_loss_no_lamb += avg_loss_no_lamb_batch.item()\n avg_loss_count += 1\n\n avg_loss_batch.backward()\n optimiser.step()\n\n b_i += 1\n if b_i == 2 and config.test_code:\n break\n\n avg_loss = float(avg_loss / avg_loss_count)\n avg_loss_no_lamb = float(avg_loss_no_lamb / avg_loss_count)\n\n config.epoch_loss.append(avg_loss)\n config.epoch_loss_no_lamb.append(avg_loss_no_lamb)\n\n # Eval -----------------------------------------------------------------------\n\n is_best = cluster_eval(config, net,\n mapping_assignment_dataloader=mapping_assignment_dataloader,\n mapping_test_dataloader=mapping_test_dataloader,\n sobel=True)\n\n print(\"Pre: time %s: \\n %s\" % (datetime.now(), nice(config.epoch_stats[-1])))\n sys.stdout.flush()\n\n axarr[0].clear()\n axarr[0].plot(config.epoch_acc)\n axarr[0].set_title(\"acc (best), top: %f\" % max(config.epoch_acc))\n\n axarr[1].clear()\n axarr[1].plot(config.epoch_avg_subhead_acc)\n axarr[1].set_title(\"acc (avg), top: %f\" % max(config.epoch_avg_subhead_acc))\n\n axarr[2].clear()\n axarr[2].plot(config.epoch_loss)\n axarr[2].set_title(\"Loss\")\n\n axarr[3].clear()\n axarr[3].plot(config.epoch_loss_no_lamb)\n axarr[3].set_title(\"Loss no lamb\")\n\n fig.tight_layout()\n fig.canvas.draw_idle()\n fig.savefig(os.path.join(config.out_dir, \"plots.png\"))\n\n if is_best or (e_i % config.save_freq == 0):\n net.module.cpu()\n\n if e_i % config.save_freq == 0:\n torch.save(net.module.state_dict(), os.path.join(config.out_dir, \"latest_net.pytorch\"))\n torch.save(optimiser.state_dict(), os.path.join(config.out_dir, \"latest_optimiser.pytorch\"))\n config.last_epoch = e_i # for last saved version\n\n if is_best:\n torch.save(net.module.state_dict(), os.path.join(config.out_dir, \"best_net.pytorch\"))\n torch.save(optimiser.state_dict(), os.path.join(config.out_dir, \"best_optimiser.pytorch\"))\n\n with open(os.path.join(config.out_dir, \"best_config.pickle\"), 'wb') as outfile:\n pickle.dump(config, outfile)\n\n with open(os.path.join(config.out_dir, \"best_config.txt\"), \"w\") as text_file:\n text_file.write(\"%s\" % config)\n\n net.module.cuda()\n\n with open(os.path.join(config.out_dir, \"config.pickle\"), 'wb') as outfile:\n pickle.dump(config, outfile)\n\n with open(os.path.join(config.out_dir, \"config.txt\"), \"w\") as text_file:\n text_file.write(\"%s\" % config)\n\n if config.test_code:\n exit(0)\n"
] |
[
[
"torch.load",
"torch.zeros",
"matplotlib.use",
"matplotlib.pyplot.subplots",
"torch.nn.DataParallel",
"numpy.array"
]
] |
hshen14/Paddle
|
[
"0962be9c800d29e0804fc3135163bdfba1564c61"
] |
[
"python/paddle/fluid/tests/unittests/test_imperative_optimizer.py"
] |
[
"# Copyright (c) 2018 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 contextlib\nimport unittest\nimport numpy as np\nimport six\n\nimport paddle\nimport paddle.fluid as fluid\nfrom paddle.fluid import core\nfrom paddle.fluid.optimizer import SGDOptimizer\nfrom paddle.fluid.imperative.nn import Conv2D, Pool2D, FC\nfrom paddle.fluid.imperative.base import to_variable\nfrom test_imperative_base import new_program_scope\n\n\nclass SimpleImgConvPool(fluid.imperative.Layer):\n def __init__(self,\n num_channels,\n num_filters,\n filter_size,\n pool_size,\n pool_stride,\n pool_padding=0,\n pool_type='max',\n global_pooling=False,\n conv_stride=1,\n conv_padding=0,\n conv_dilation=1,\n conv_groups=1,\n act=None,\n use_cudnn=False,\n param_attr=None,\n bias_attr=None):\n super(SimpleImgConvPool, self).__init__()\n\n self._conv2d = Conv2D(\n num_channels=num_channels,\n num_filters=num_filters,\n filter_size=filter_size,\n stride=conv_stride,\n padding=conv_padding,\n dilation=conv_dilation,\n groups=conv_groups,\n param_attr=None,\n bias_attr=None,\n use_cudnn=use_cudnn)\n\n self._pool2d = Pool2D(\n pool_size=pool_size,\n pool_type=pool_type,\n pool_stride=pool_stride,\n pool_padding=pool_padding,\n global_pooling=global_pooling,\n use_cudnn=use_cudnn)\n\n def forward(self, inputs):\n x = self._conv2d(inputs)\n x = self._pool2d(x)\n return x\n\n\nclass MNIST(fluid.imperative.Layer):\n def __init__(self, param_attr=None, bias_attr=None):\n super(MNIST, self).__init__()\n\n self._simple_img_conv_pool_1 = SimpleImgConvPool(\n 1, 20, 5, 2, 2, act=\"relu\")\n\n self._simple_img_conv_pool_2 = SimpleImgConvPool(\n 20, 50, 5, 2, 2, act=\"relu\")\n\n pool_2_shape = 50 * 4 * 4\n SIZE = 10\n scale = (2.0 / (pool_2_shape**2 * SIZE))**0.5\n self._fc = FC(10,\n param_attr=fluid.param_attr.ParamAttr(\n initializer=fluid.initializer.NormalInitializer(\n loc=0.0, scale=scale)),\n act=\"softmax\")\n\n def forward(self, inputs):\n x = self._simple_img_conv_pool_1(inputs)\n x = self._simple_img_conv_pool_2(x)\n x = self._fc(x)\n return x\n\n\nclass TestImperativeMnist(unittest.TestCase):\n def test_mnist_float32(self):\n seed = 90\n batch_num = 2\n with fluid.imperative.guard():\n fluid.default_startup_program().random_seed = seed\n fluid.default_main_program().random_seed = seed\n\n mnist = MNIST()\n sgd = SGDOptimizer(learning_rate=1e-3)\n train_reader = paddle.batch(\n paddle.dataset.mnist.train(), batch_size=128)\n\n dy_param_init_value = {}\n for batch_id, data in enumerate(train_reader()):\n if batch_id >= batch_num:\n break\n\n dy_x_data = np.array(\n [x[0].reshape(1, 28, 28) for x in data]).astype('float32')\n y_data = np.array([x[1] for x in data]).astype('int64').reshape(\n 128, 1)\n\n img = to_variable(dy_x_data)\n label = to_variable(y_data)\n label._stop_gradient = True\n\n cost = mnist(img)\n loss = fluid.layers.cross_entropy(cost, label)\n avg_loss = fluid.layers.mean(loss)\n dy_out = avg_loss._numpy()\n\n if batch_id == 0:\n for param in fluid.default_main_program().global_block(\n ).all_parameters():\n dy_param_init_value[param.name] = param._numpy()\n\n avg_loss._backward()\n sgd.minimize(avg_loss)\n mnist.clear_gradients()\n dy_param_value = {}\n for param in fluid.default_main_program().global_block(\n ).all_parameters():\n dy_param_value[param.name] = param._numpy()\n\n with new_program_scope():\n fluid.default_startup_program().random_seed = seed\n fluid.default_main_program().random_seed = seed\n\n exe = fluid.Executor(fluid.CPUPlace(\n ) if not core.is_compiled_with_cuda() else fluid.CUDAPlace(0))\n\n mnist = MNIST()\n sgd = SGDOptimizer(learning_rate=1e-3)\n train_reader = paddle.batch(\n paddle.dataset.mnist.train(), batch_size=128)\n\n img = fluid.layers.data(\n name='pixel', shape=[1, 28, 28], dtype='float32')\n label = fluid.layers.data(name='label', shape=[1], dtype='int64')\n cost = mnist(img)\n loss = fluid.layers.cross_entropy(cost, label)\n avg_loss = fluid.layers.mean(loss)\n sgd.minimize(avg_loss)\n\n # initialize params and fetch them\n static_param_init_value = {}\n static_param_name_list = []\n for param in fluid.default_startup_program().global_block(\n ).all_parameters():\n static_param_name_list.append(param.name)\n\n out = exe.run(fluid.default_startup_program(),\n fetch_list=static_param_name_list)\n\n for i in range(len(static_param_name_list)):\n static_param_init_value[static_param_name_list[i]] = out[i]\n\n for batch_id, data in enumerate(train_reader()):\n if batch_id >= batch_num:\n break\n\n static_x_data = np.array(\n [x[0].reshape(1, 28, 28) for x in data]).astype('float32')\n y_data = np.array([x[1] for x in data]).astype('int64').reshape(\n [128, 1])\n\n fetch_list = [avg_loss.name]\n fetch_list.extend(static_param_name_list)\n out = exe.run(fluid.default_main_program(),\n feed={\"pixel\": static_x_data,\n \"label\": y_data},\n fetch_list=fetch_list)\n\n static_param_value = {}\n static_out = out[0]\n for i in range(1, len(out)):\n static_param_value[static_param_name_list[i - 1]] = out[i]\n\n for key, value in six.iteritems(static_param_init_value):\n self.assertTrue(np.allclose(value, dy_param_init_value[key]))\n\n self.assertTrue(np.allclose(static_out, dy_out))\n\n for key, value in six.iteritems(static_param_value):\n self.assertTrue(np.allclose(value, dy_param_value[key]))\n\n\nif __name__ == '__main__':\n unittest.main()\n"
] |
[
[
"numpy.array",
"numpy.allclose"
]
] |
victor-iyiola/deep-learning-with-tensorflow
|
[
"4d8e9b1054a24c92023f7e1c24c2911d6c30b59a"
] |
[
"inception/inception.py"
] |
[
"########################################################################\n#\n# The Inception Model v3 for TensorFlow.\n#\n# This is a pre-trained Deep Neural Network for classifying images.\n# You provide an image or filename for a jpeg-file which will be\n# loaded and input to the Inception model, which will then output\n# an array of numbers indicating how likely it is that the\n# input-image is of each class.\n#\n# See the example code at the bottom of this file or in the\n# accompanying Python Notebooks.\n#\n# Tutorial #07 shows how to use the Inception model.\n# Tutorial #08 shows how to use it for Transfer Learning.\n#\n# What is Transfer Learning?\n#\n# Transfer Learning is the use of a Neural Network for classifying\n# images from another data-set than it was trained on. For example,\n# the Inception model was trained on the ImageNet data-set using\n# a very powerful and expensive computer. But the Inception model\n# can be re-used on data-sets it was not trained on without having\n# to re-train the entire model, even though the number of classes\n# are different for the two data-sets. This allows you to use the\n# Inception model on your own data-sets without the need for a\n# very powerful and expensive computer to train it.\n#\n# The last layer of the Inception model before the softmax-classifier\n# is called the Transfer Layer because the output of that layer will\n# be used as the input in your new softmax-classifier (or as the\n# input for another neural network), which will then be trained on\n# your own data-set.\n#\n# The output values of the Transfer Layer are called Transfer Values.\n# These are the actual values that will be input to your new\n# softmax-classifier or to another neural network that you create.\n#\n# The word 'bottleneck' is also sometimes used to refer to the\n# Transfer Layer or Transfer Values, but it is a confusing word\n# that is not used here.\n#\n# Implemented in Python 3.5 with TensorFlow v0.10.0rc0\n#\n########################################################################\n#\n# This file is part of the TensorFlow Tutorials available at:\n#\n# https://github.com/Hvass-Labs/TensorFlow-Tutorials\n#\n# Published under the MIT License. See the file LICENSE for details.\n#\n# Copyright 2016 by Magnus Erik Hvass Pedersen\n#\n########################################################################\n\nimport os\nimport sys\n\nimport download\nimport numpy as np\nimport tensorflow as tf\nfrom cache import cache\n\n########################################################################\n# Various directories and file-names.\n\n# Internet URL for the tar-file with the Inception model.\n# Note that this might change in the future and will need to be updated.\ndata_url = \"http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz\"\n\n# Directory to store the downloaded data.\ndata_dir = \"inception/\"\n\n# File containing the mappings between class-number and uid. (Downloaded)\npath_uid_to_cls = \"imagenet_2012_challenge_label_map_proto.pbtxt\"\n\n# File containing the mappings between uid and string. (Downloaded)\npath_uid_to_name = \"imagenet_synset_to_human_label_map.txt\"\n\n# File containing the TensorFlow graph definition. (Downloaded)\npath_graph_def = \"classify_image_graph_def.pb\"\n\n\n########################################################################\n\n\ndef maybe_download():\n \"\"\"\n Download the Inception model from the internet if it does not already\n exist in the data_dir. The file is about 85 MB.\n \"\"\"\n\n print(\"Downloading Inception v3 Model ...\")\n download.maybe_download_and_extract(url=data_url, download_dir=data_dir)\n\n\n########################################################################\n\n\nclass NameLookup:\n \"\"\"\n Used for looking up the name associated with a class-number.\n This is used to print the name of a class instead of its number,\n e.g. \"plant\" or \"horse\".\n\n Maps between:\n - cls is the class-number as an integer between 1 and 1000 (inclusive).\n - uid is a class-id as a string from the ImageNet data-set, e.g. \"n00017222\".\n - name is the class-name as a string, e.g. \"plant, flora, plant life\"\n\n There are actually 1008 output classes of the Inception model\n but there are only 1000 named classes in these mapping-files.\n The remaining 8 output classes of the model should not be used.\n \"\"\"\n\n def __init__(self):\n # Mappings between uid, cls and name are dicts, where insertions and\n # lookup have O(1) time-usage on average, but may be O(n) in worst case.\n self._uid_to_cls = {} # Map from uid to cls.\n self._uid_to_name = {} # Map from uid to name.\n self._cls_to_uid = {} # Map from cls to uid.\n\n # Read the uid-to-name mappings from file.\n path = os.path.join(data_dir, path_uid_to_name)\n with open(file=path, mode='r') as file:\n # Read all lines from the file.\n lines = file.readlines()\n\n for line in lines:\n # Remove newlines.\n line = line.replace(\"\\n\", \"\")\n\n # Split the line on tabs.\n elements = line.split(\"\\t\")\n\n # Get the uid.\n uid = elements[0]\n\n # Get the class-name.\n name = elements[1]\n\n # Insert into the lookup-dict.\n self._uid_to_name[uid] = name\n\n # Read the uid-to-cls mappings from file.\n path = os.path.join(data_dir, path_uid_to_cls)\n with open(file=path, mode='r') as file:\n # Read all lines from the file.\n lines = file.readlines()\n\n for line in lines:\n # We assume the file is in the proper format,\n # so the following lines come in pairs. Other lines are ignored.\n\n if line.startswith(\" target_class: \"):\n # This line must be the class-number as an integer.\n\n # Split the line.\n elements = line.split(\": \")\n\n # Get the class-number as an integer.\n cls = int(elements[1])\n\n elif line.startswith(\" target_class_string: \"):\n # This line must be the uid as a string.\n\n # Split the line.\n elements = line.split(\": \")\n\n # Get the uid as a string e.g. \"n01494475\"\n uid = elements[1]\n\n # Remove the enclosing \"\" from the string.\n uid = uid[1:-2]\n\n # Insert into the lookup-dicts for both ways between uid and cls.\n self._uid_to_cls[uid] = cls\n self._cls_to_uid[cls] = uid\n\n def uid_to_cls(self, uid):\n \"\"\"\n Return the class-number as an integer for the given uid-string.\n \"\"\"\n\n return self._uid_to_cls[uid]\n\n def uid_to_name(self, uid, only_first_name=False):\n \"\"\"\n Return the class-name for the given uid string.\n\n Some class-names are lists of names, if you only want the first name,\n then set only_first_name=True.\n \"\"\"\n\n # Lookup the name from the uid.\n name = self._uid_to_name[uid]\n\n # Only use the first name in the list?\n if only_first_name:\n name = name.split(\",\")[0]\n\n return name\n\n def cls_to_name(self, cls, only_first_name=False):\n \"\"\"\n Return the class-name from the integer class-number.\n\n Some class-names are lists of names, if you only want the first name,\n then set only_first_name=True.\n \"\"\"\n\n # Lookup the uid from the cls.\n uid = self._cls_to_uid[cls]\n\n # Lookup the name from the uid.\n name = self.uid_to_name(uid=uid, only_first_name=only_first_name)\n\n return name\n\n\n########################################################################\n\n\nclass Inception:\n \"\"\"\n The Inception model is a Deep Neural Network which has already been\n trained for classifying images into 1000 different categories.\n\n When you create a new instance of this class, the Inception model\n will be loaded and can be used immediately without training.\n\n The Inception model can also be used for Transfer Learning.\n \"\"\"\n\n # Name of the tensor for feeding the input image as jpeg.\n tensor_name_input_jpeg = \"DecodeJpeg/contents:0\"\n\n # Name of the tensor for feeding the decoded input image.\n # Use this for feeding images in other formats than jpeg.\n tensor_name_input_image = \"DecodeJpeg:0\"\n\n # Name of the tensor for the resized input image.\n # This is used to retrieve the image after it has been resized.\n tensor_name_resized_image = \"ResizeBilinear:0\"\n\n # Name of the tensor for the output of the softmax-classifier.\n # This is used for classifying images with the Inception model.\n tensor_name_softmax = \"softmax:0\"\n\n # Name of the tensor for the unscaled outputs of the softmax-classifier (aka. logits).\n tensor_name_softmax_logits = \"softmax/logits:0\"\n\n # Name of the tensor for the output of the Inception model.\n # This is used for Transfer Learning.\n tensor_name_transfer_layer = \"pool_3:0\"\n\n def __init__(self):\n # Mappings between class-numbers and class-names.\n # Used to print the class-name as a string e.g. \"horse\" or \"plant\".\n self.name_lookup = NameLookup()\n\n # Now load the Inception model from file. The way TensorFlow\n # does this is confusing and requires several steps.\n\n # Create a new TensorFlow computational graph.\n self.graph = tf.Graph()\n\n # Set the new graph as the default.\n with self.graph.as_default():\n # TensorFlow graphs are saved to disk as so-called Protocol Buffers\n # aka. proto-bufs which is a file-format that works on multiple\n # platforms. In this case it is saved as a binary file.\n\n # Open the graph-def file for binary reading.\n path = os.path.join(data_dir, path_graph_def)\n with tf.gfile.FastGFile(path, 'rb') as file:\n # The graph-def is a saved copy of a TensorFlow graph.\n # First we need to create an empty graph-def.\n graph_def = tf.GraphDef()\n\n # Then we load the proto-buf file into the graph-def.\n graph_def.ParseFromString(file.read())\n\n # Finally we import the graph-def to the default TensorFlow graph.\n tf.import_graph_def(graph_def, name='')\n\n # Now self.graph holds the Inception model from the proto-buf file.\n\n # Get the output of the Inception model by looking up the tensor\n # with the appropriate name for the output of the softmax-classifier.\n self.y_pred = self.graph.get_tensor_by_name(self.tensor_name_softmax)\n\n # Get the unscaled outputs for the Inception model (aka. softmax-logits).\n self.y_logits = self.graph.get_tensor_by_name(self.tensor_name_softmax_logits)\n\n # Get the tensor for the resized image that is input to the neural network.\n self.resized_image = self.graph.get_tensor_by_name(self.tensor_name_resized_image)\n\n # Get the tensor for the last layer of the graph, aka. the transfer-layer.\n self.transfer_layer = self.graph.get_tensor_by_name(self.tensor_name_transfer_layer)\n\n # Get the number of elements in the transfer-layer.\n self.transfer_len = self.transfer_layer.get_shape()[3]\n\n # Create a TensorFlow session for executing the graph.\n self.session = tf.Session(graph=self.graph)\n\n def close(self):\n \"\"\"\n Call this function when you are done using the Inception model.\n It closes the TensorFlow session to release its resources.\n \"\"\"\n\n self.session.close()\n\n def _write_summary(self, logdir='summary/'):\n \"\"\"\n Write graph to summary-file so it can be shown in TensorBoard.\n\n This function is used for debugging and may be changed or removed in the future.\n\n :param logdir:\n Directory for writing the summary-files.\n\n :return:\n Nothing.\n \"\"\"\n\n writer = tf.train.SummaryWriter(logdir=logdir, graph=self.graph)\n writer.close()\n\n def _create_feed_dict(self, image_path=None, image=None):\n \"\"\"\n Create and return a feed-dict with an image.\n\n :param image_path:\n The input image is a jpeg-file with this file-path.\n\n :param image:\n The input image is a 3-dim array which is already decoded.\n The pixels MUST be values between 0 and 255 (float or int).\n\n :return:\n Dict for feeding to the Inception graph in TensorFlow.\n \"\"\"\n\n if image is not None:\n # Image is passed in as a 3-dim array that is already decoded.\n feed_dict = {self.tensor_name_input_image: image}\n\n elif image_path is not None:\n # Read the jpeg-image as an array of bytes.\n image_data = tf.gfile.FastGFile(image_path, 'rb').read()\n\n # Image is passed in as a jpeg-encoded image.\n feed_dict = {self.tensor_name_input_jpeg: image_data}\n\n else:\n raise ValueError(\"Either image or image_path must be set.\")\n\n return feed_dict\n\n def classify(self, image_path=None, image=None):\n \"\"\"\n Use the Inception model to classify a single image.\n\n The image will be resized automatically to 299 x 299 pixels,\n see the discussion in the Python Notebook for Tutorial #07.\n\n :param image_path:\n The input image is a jpeg-file with this file-path.\n\n :param image:\n The input image is a 3-dim array which is already decoded.\n The pixels MUST be values between 0 and 255 (float or int).\n\n :return:\n Array of floats (aka. softmax-array) indicating how likely\n the Inception model thinks the image is of each given class.\n \"\"\"\n\n # Create a feed-dict for the TensorFlow graph with the input image.\n feed_dict = self._create_feed_dict(image_path=image_path, image=image)\n\n # Execute the TensorFlow session to get the predicted labels.\n pred = self.session.run(self.y_pred, feed_dict=feed_dict)\n\n # Reduce the array to a single dimension.\n pred = np.squeeze(pred)\n\n return pred\n\n def get_resized_image(self, image_path=None, image=None):\n \"\"\"\n Input an image to the Inception model and return\n the resized image. The resized image can be plotted so\n we can see what the neural network sees as its input.\n\n :param image_path:\n The input image is a jpeg-file with this file-path.\n\n :param image:\n The input image is a 3-dim array which is already decoded.\n The pixels MUST be values between 0 and 255 (float or int).\n\n :return:\n A 3-dim array holding the image.\n \"\"\"\n\n # Create a feed-dict for the TensorFlow graph with the input image.\n feed_dict = self._create_feed_dict(image_path=image_path, image=image)\n\n # Execute the TensorFlow session to get the predicted labels.\n resized_image = self.session.run(self.resized_image, feed_dict=feed_dict)\n\n # Remove the 1st dimension of the 4-dim tensor.\n resized_image = resized_image.squeeze(axis=0)\n\n # Scale pixels to be between 0.0 and 1.0\n resized_image = resized_image.astype(float) / 255.0\n\n return resized_image\n\n def print_scores(self, pred, k=10, only_first_name=True):\n \"\"\"\n Print the scores (or probabilities) for the top-k predicted classes.\n\n :param pred:\n Predicted class-labels returned from the predict() function.\n\n :param k:\n How many classes to print.\n\n :param only_first_name:\n Some class-names are lists of names, if you only want the first name,\n then set only_first_name=True.\n\n :return:\n Nothing.\n \"\"\"\n\n # Get a sorted index for the pred-array.\n idx = pred.argsort()\n\n # The index is sorted lowest-to-highest values. Take the last k.\n top_k = idx[-k:]\n\n # Iterate the top-k classes in reversed order (i.e. highest first).\n for cls in reversed(top_k):\n # Lookup the class-name.\n name = self.name_lookup.cls_to_name(cls=cls, only_first_name=only_first_name)\n\n # Predicted score (or probability) for this class.\n score = pred[cls]\n\n # Print the score and class-name.\n print(\"{0:>6.2%} : {1}\".format(score, name))\n\n def transfer_values(self, image_path=None, image=None):\n \"\"\"\n Calculate the transfer-values for the given image.\n These are the values of the last layer of the Inception model before\n the softmax-layer, when inputting the image to the Inception model.\n\n The transfer-values allow us to use the Inception model in so-called\n Transfer Learning for other data-sets and different classifications.\n\n It may take several hours or more to calculate the transfer-values\n for all images in a data-set. It is therefore useful to cache the\n results using the function transfer_values_cache() below.\n\n :param image_path:\n The input image is a jpeg-file with this file-path.\n\n :param image:\n The input image is a 3-dim array which is already decoded.\n The pixels MUST be values between 0 and 255 (float or int).\n\n :return:\n The transfer-values for those images.\n \"\"\"\n\n # Create a feed-dict for the TensorFlow graph with the input image.\n feed_dict = self._create_feed_dict(image_path=image_path, image=image)\n\n # Use TensorFlow to run the graph for the Inception model.\n # This calculates the values for the last layer of the Inception model\n # prior to the softmax-classification, which we call transfer-values.\n transfer_values = self.session.run(self.transfer_layer, feed_dict=feed_dict)\n\n # Reduce to a 1-dim array.\n transfer_values = np.squeeze(transfer_values)\n\n return transfer_values\n\n\n########################################################################\n# Batch-processing.\n\n\ndef process_images(fn, images=None, image_paths=None):\n \"\"\"\n Call the function fn() for each image, e.g. transfer_values() from\n the Inception model above. All the results are concatenated and returned.\n\n :param fn:\n Function to be called for each image.\n\n :param images:\n List of images to process.\n\n :param image_paths:\n List of file-paths for the images to process.\n\n :return:\n Numpy array with the results.\n \"\"\"\n\n # Are we using images or image_paths?\n using_images = images is not None\n\n # Number of images.\n if using_images:\n num_images = len(images)\n else:\n num_images = len(image_paths)\n\n # Pre-allocate list for the results.\n # This holds references to other arrays. Initially the references are None.\n result = [None] * num_images\n\n # For each input image.\n for i in range(num_images):\n # Status-message. Note the \\r which means the line should overwrite itself.\n msg = \"\\r- Processing image: {0:>6} / {1}\".format(i + 1, num_images)\n\n # Print the status message.\n sys.stdout.write(msg)\n sys.stdout.flush()\n\n # Process the image and store the result for later use.\n if using_images:\n result[i] = fn(image=images[i])\n else:\n result[i] = fn(image_path=image_paths[i])\n\n # Print newline.\n print()\n\n # Convert the result to a numpy array.\n result = np.array(result)\n\n return result\n\n\n########################################################################\n\n\ndef transfer_values_cache(cache_path, model, images=None, image_paths=None):\n \"\"\"\n This function either loads the transfer-values if they have\n already been calculated, otherwise it calculates the values\n and saves them to a file that can be re-loaded again later.\n\n Because the transfer-values can be expensive to compute, it can\n be useful to cache the values through this function instead\n of calling transfer_values() directly on the Inception model.\n\n See Tutorial #08 for an example on how to use this function.\n\n :param cache_path:\n File containing the cached transfer-values for the images.\n\n :param model:\n Instance of the Inception model.\n\n :param images:\n 4-dim array with images. [image_number, height, width, colour_channel]\n\n :param image_paths:\n Array of file-paths for images (must be jpeg-format).\n\n :return:\n The transfer-values from the Inception model for those images.\n \"\"\"\n\n # Helper-function for processing the images if the cache-file does not exist.\n # This is needed because we cannot supply both fn=process_images\n # and fn=model.transfer_values to the cache()-function.\n def fn():\n return process_images(fn=model.transfer_values, images=images, image_paths=image_paths)\n\n # Read the transfer-values from a cache-file, or calculate them if the file does not exist.\n transfer_values = cache(cache_path=cache_path, fn=fn)\n\n return transfer_values\n\n\n########################################################################\n# Example usage.\n\nif __name__ == '__main__':\n print(tf.__version__)\n\n # Download Inception model if not already done.\n maybe_download()\n\n # Load the Inception model so it is ready for classifying images.\n model = Inception()\n\n # Path for a jpeg-image that is included in the downloaded data.\n image_path = os.path.join(data_dir, 'cropped_panda.jpg')\n\n # Use the Inception model to classify the image.\n pred = model.classify(image_path=image_path)\n\n # Print the scores and names for the top-10 predictions.\n model.print_scores(pred=pred, k=10)\n\n # Close the TensorFlow session.\n model.close()\n\n # Transfer Learning is demonstrated in Tutorial #08.\n\n########################################################################\n"
] |
[
[
"tensorflow.Graph",
"tensorflow.import_graph_def",
"numpy.squeeze",
"tensorflow.train.SummaryWriter",
"tensorflow.Session",
"tensorflow.GraphDef",
"numpy.array",
"tensorflow.gfile.FastGFile"
]
] |
lstorchi/molsuperimpose
|
[
"c6129e676b287040b17a7e5d5680176e2db361b6"
] |
[
"modules/xyzutil.py"
] |
[
"import re\nimport numpy\nimport math\n\n#####################################################################\n\ndef read_ncxyz (filename, trans = True):\n\n filep = open(filename, \"r\")\n \n filep.readline()\n filep.readline()\n \n xlist = []\n ylist = []\n zlist = []\n atoms = []\n \n for line in filep:\n p = re.compile(r'\\s+')\n line = p.sub(' ', line)\n line = line.lstrip()\n line = line.rstrip()\n \n plist = line.split(\" \")\n \n if (len(plist) == 4):\n atomname = plist[0]\n x = plist[1]\n y = plist[2]\n z = plist[3]\n \n xlist.append(float(x))\n ylist.append(float(y))\n zlist.append(float(z))\n atoms.append(atomname)\n \n filep.close()\n \n if trans:\n xc = numpy.mean(xlist)\n yc = numpy.mean(ylist)\n zc = numpy.mean(zlist)\n \n for i in range(len(xlist)):\n xlist[i] = xlist[i] - xc\n ylist[i] = ylist[i] - yc\n zlist[i] = zlist[i] - zc\n \n return xlist, ylist, zlist, atoms\n\n#####################################################################\n\ndef write_ncxyz (filename, xl, yl, zl, al):\n\n filep = open(filename, \"w\")\n \n filep.write(\"%6d\\n\"%(len(al)))\n filep.write(\"\\n\")\n for i in range(0, len(al)):\n filep.write(\"%3s %10.5f %10.5f %10.5f\\n\"%(al[i], xl[i], \\\n yl[i], zl[i]))\n \n#####################################################################\n"
] |
[
[
"numpy.mean"
]
] |
dendisuhubdy/newma-md
|
[
"723d1e5ae46397c867079e9e615a12d7df0c008b"
] |
[
"newma_coronavirus_DESRES.py"
] |
[
"# -*- coding: utf-8 -*-\n\n\n\"\"\"\nScript to recover the results for detecting the conformational changes of\nSARS-CoV-2. Is it possible to choose\nbetween real opu (to use it contact lighton at\n https://www.lighton.ai/contact-us/) and its synthetic version.\n\"\"\"\n\nimport argparse\n\nimport numpy as np\nimport time\n\nimport onlinecp.algos as algos\nimport onlinecp.utils.feature_functions as feat\nimport onlinecp.utils.fastfood as ff\n\nfrom MDAnalysis.lib.formats.libdcd import DCDFile\n\nfrom lightonml.encoding.base import MultiThresholdEncoder, BinaryThresholdEncoder\nfrom lightonml.projections.sklearn import OPUMap\n\ndef str2bool(v):\n if isinstance(v, bool):\n return v\n if v.lower() in ('yes', 'true', 't', 'y', '1'):\n return True\n elif v.lower() in ('no', 'false', 'f', 'n', '0'):\n return False\n else:\n raise argparse.ArgumentTypeError('Boolean value expected.')\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument('-nmax', type=int,\n default=7)\n #Trajectory studied: closed = trajectory1, opened = trajectory 2\n parser.add_argument('-trajclosed', type=str2bool, nargs='?',\n const=True,default=True,\n help='True for exploring traj (a), false for (b)')\n parser.add_argument('-repeat', type=int, default=0,\n help='Augment the data to avoid artifacts at the '\n 'start')\n parser.add_argument('-full', type=str2bool, nargs='?',\n const=True,default=False,\n help='True for exploring all-inclusive traj')\n parser.add_argument('-ff', type=str2bool, nargs='?',\n const=True, default=True,\n help='True for performing NEWMA on CPU')\n args = parser.parse_args()\n\n nrepeat = args.repeat\n tc = args.trajclosed\n full = args.full\n newmaff = args.ff\n\n # If we study a trajectory including all atoms, a pyramid sketch is\n # needed on the OPU\n pyramid = full\n\n loadingtimestart = time.time()\n if tc:\n print('Exploring closed trajectory')\n else:\n print('Exploring open trajectory')\n\n # Path of the file containing the trajectories\n pathtraj = \"/data/mldata/DESRES-Trajectory_\"\n\n # Trajectory (a): initially closed\n nametraj1 = \"sarscov2-10897136-no-water-no-ion-glueCA\"\n\n # Trajectory (b): initially opened\n nametraj2 = \"sarscov2-10897850-no-water-no-ion-glueCA\"\n # Trajectory (b): all atoms\n namefull = \"sarscov2-10897850-all-glueCA\"\n pathtraj1 = pathtraj + nametraj1 + \"/\" + nametraj1 + \"/\" + nametraj1\n pathtraj2 = pathtraj + nametraj2 + \"/\" + nametraj2 + \"/\" + nametraj2\n pathfull = pathtraj + namefull + \"/\" + namefull + \"/\" + namefull\n\n # Initialize\n n0 = 0\n nmax = args.nmax\n\n if tc:\n path = pathtraj1\n print('Exploring closed trajectory')\n else:\n if full:\n path = pathfull\n print('Exploring opened trajectory - all')\n else:\n path = pathtraj2\n print('Exploring opened trajectory - no water no ion')\n\n traj0 = DCDFile(\n path + '-{:04d}'.format(n0) + \".dcd\").readframes().xyz\n\n n_frames = traj0.shape[0]\n n_atoms = traj0.shape[1]\n n_feat = n_atoms * 3\n\n print(f\"Number of time steps: {n_frames}. \\nNumber of atoms: {n_atoms}.\" \\\n f\" \\nFeatures: {n_feat}.\")\n traj0 = traj0.reshape(n_frames, -1)\n\n traj = traj0\n\n if nrepeat > 0:\n print(f'Augmenting data {nrepeat} times.')\n for n in range(nrepeat):\n traj = np.concatenate((traj, traj0))\n\n for n in range(n0+1, nmax+1):\n print(n)\n pathfile = path + '-{:04d}'.format(n) + '.dcd'\n trajectory = DCDFile(pathfile).readframes().xyz\n trajectory = trajectory.reshape(n_frames, -1)\n traj = np.concatenate((traj, trajectory))\n\n\n tf = np.arange(1200 * ( 1 + n_frames * n0 ),\n (nmax + 1) * 1200 * n_frames + 1, step=1200)\n\n print(f\"Loading data took f{time.time() - loadingtimestart:.2f}s. \")\n\n # ----------\n # NEWMA RP OPU\n startingtime = time.time()\n\n # Pararameters for the NEWMA algorithm\n B = 250 # window size\n d = n_feat\n\n # Forget factors chosen with heuristic in the paper\n big_Lambda, small_lambda = algos.select_optimal_parameters(B)\n thres_ff = small_lambda\n # Number of random features is set automatically with this criterion\n m = int((1 / 4) / (small_lambda + big_Lambda) ** 2)\n m_OPU = 10 * m\n print(f'{m_OPU} random features.')\n\n\n if pyramid:\n # Pyramid sketch\n nc = 60000\n # Opening the OPU\n opu_mapping = OPUMap(n_components=nc)\n\n # First encoding\n encoder = BinaryThresholdEncoder(threshold_enc=10)\n minX, maxX = np.min(traj), np.max(traj)\n length_simulation = traj.shape[0]\n trajprojection = np.zeros((length_simulation, 3 * nc))\n\n for i in range(3):\n print(f\"First sketch of the data... Step {i + 1} out of 3.\")\n cut = n_atoms\n X = traj[:, cut * i:cut * (i + 1)]\n X = 255 * ((X - minX) / (maxX - minX))\n X = X.astype('uint8')\n Xencode = encoder.transform(X)\n del X\n\n X = opu_mapping.transform(Xencode)\n del Xencode\n trajprojection[:, i * nc: (i + 1) * nc] = X[:, :]\n del X\n\n print(\"Starting second sketch.\")\n\n opu_mapping = OPUMap(n_components=m_OPU)\n n_levels = 38\n minX, maxX = np.min(trajprojection), np.max(trajprojection)\n print('Rescaling X')\n X = 255 * ((trajprojection - minX) / (maxX - minX))\n X = X.astype('uint8')\n\n print('Encoding X with the multi threshold encoder')\n thresholds = np.arange(n_levels, step=8)\n thresholds += 10\n encoderm = MultiThresholdEncoder(thresholds=thresholds)\n Xencode = encoderm.transform(X)\n del X\n\n X = opu_mapping.transform(Xencode)\n del Xencode\n else:\n # Regular sketch\n opu_mapping = OPUMap(n_components=m_OPU)\n n_levels = 38\n minX, maxX = np.min(traj), np.max(traj)\n print('Rescaling X')\n X = 255 * ((traj - minX) / (maxX - minX))\n X = X.astype('uint8')\n\n print('Encoding X with the multi threshold encoder')\n thresholds = np.arange(n_levels, step=8)\n thresholds += 10\n encoder = MultiThresholdEncoder(thresholds=thresholds)\n Xencode = encoder.transform(X)\n del X\n\n X = opu_mapping.transform(Xencode)\n del Xencode\n\n print(f\"NEWMA OPU: Sketch took {time.time() - startingtime:.2f}s.\")\n\n mult = 1.5\n detector = algos.NEWMA(X[0], forget_factor=big_Lambda,\n feat_func=lambda x: x.astype('float32'),\n forget_factor2=small_lambda,\n adapt_forget_factor=thres_ff * mult,\n thresholding_quantile=0.95,\n dist_func=lambda z1, z2: np.linalg.norm(z1 - z2))\n detector.apply_to_data(X)\n\n n = 0\n detection_stat = np.array([i[0] for i in detector.stat_stored])[\n int(10 * n):] # padding\n online_th = np.array([i[1] for i in detector.stat_stored])[int(10 * n):]\n\n computation_duration = time.time() - startingtime\n print(f'NEWMA RP on OPU took {computation_duration:.2f}s.')\n\n # ----------\n # NEWMA FF on CPU\n if newmaff:\n startingtime = time.time()\n X = traj\n\n # Pararameters for the NEWMA algorithm\n B = 250\n d = n_feat\n\n # Forget factors chosen with heuristic in the paper\n big_Lambda, small_lambda = algos.select_optimal_parameters(B)\n thres_ff = small_lambda\n\n # number of random features is set automatically with this criterion\n m = 10 * int((1 / 4) / (small_lambda + big_Lambda) ** 2)\n\n choice_sigma = 'median'\n numel = 100\n data_sigma_estimate = X[:numel]\n\n W, sigmasq = feat.generate_frequencies(m, d, data=data_sigma_estimate,\n choice_sigma=choice_sigma)\n\n FF = ff.Fastfood(sigma=np.sqrt(sigmasq), n_components=m)\n FF.fit(X)\n X = FF.transform(X)\n\n detectorff = algos.NEWMA(X[0], forget_factor=big_Lambda,\n forget_factor2=small_lambda,\n adapt_forget_factor=0.5 * thres_ff)\n detectorff.apply_to_data(X)\n\n n = 0\n detection_statff = np.array([i[0] for i in detectorff.stat_stored])[\n int(10 * n):] # padding\n online_thff = np.array([i[1] for i in detectorff.stat_stored])[int(10 *\n n):]\n\n computation_duration = time.time() - startingtime\n print(f'NEWMA FF on CPU took {computation_duration:.2f}s.')\n\n\n detection_stat = detection_stat[nrepeat * n_frames:]\n online_th = online_th[nrepeat * n_frames:]\n\n tot_frame = n_frames * (nmax + nrepeat + 1)\n\n\n namefile = f\"computetime_corona_totframe_{tot_frame}_natoms_{n_atoms}\"\n\n # Save data for analysis in jupyter notebook.\n filename = f'newmaopu_totframe_{tot_frame}_natoms_{n_atoms}_closed_{tc}'\n np.savez_compressed(filename + f'_repeat{nrepeat}' + '.npz',\n time=tf, detection_stat=detection_stat,\n online_th=online_th)\n\n"
] |
[
[
"numpy.sqrt",
"numpy.min",
"numpy.arange",
"numpy.linalg.norm",
"numpy.concatenate",
"numpy.max",
"numpy.savez_compressed",
"numpy.array",
"numpy.zeros"
]
] |
goedge-dev/dropt-example
|
[
"fbddc6a95edf28de69c303c2e4084367350b5f20"
] |
[
"trials/mnist-pytorch/mnist.py"
] |
[
"'''\nReference\n---\nhttps://github.com/pytorch/examples/tree/master/mnist\n'''\n\nfrom __future__ import print_function\nimport logging\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nfrom argparse import ArgumentParser\nfrom torchvision import datasets, transforms\nfrom torch.optim.lr_scheduler import StepLR\nfrom pathlib import Path\nfrom dropt.util.log import UserLogger\nfrom variable import LOG_DIR, DATA_PREFIX\n\n\n# logger\nname = Path(__file__).stem\nlogger = UserLogger(name)\nlogger.add_console_handler(logging.INFO)\nlogger.add_file_handler(logging.INFO, filename=LOG_DIR.joinpath(f'{name}.log'))\n\n\nclass Net(nn.Module):\n '''Define an NN model.'''\n def __init__(self, hidden_size):\n super(Net, self).__init__()\n self.conv1 = nn.Conv2d(1, 32, 3, 1)\n self.conv2 = nn.Conv2d(32, 64, 3, 1)\n self.dropout1 = nn.Dropout2d(0.25)\n self.dropout2 = nn.Dropout2d(0.5)\n self.fc1 = nn.Linear(9216, hidden_size)\n self.fc2 = nn.Linear(hidden_size, 10)\n\n def forward(self, x):\n x = self.conv1(x)\n x = F.relu(x)\n x = self.conv2(x)\n x = F.relu(x)\n x = F.max_pool2d(x, 2)\n x = self.dropout1(x)\n x = torch.flatten(x, 1)\n x = self.fc1(x)\n x = F.relu(x)\n x = self.dropout2(x)\n x = self.fc2(x)\n output = F.log_softmax(x, dim=1)\n return output\n\n\n\ndef train(args, model, device, train_loader, optimizer, epoch):\n '''Model training.'''\n model.train()\n for batch_idx, (data, target) in enumerate(train_loader):\n data, target = data.to(device), target.to(device)\n optimizer.zero_grad()\n output = model(data)\n loss = F.nll_loss(output, target)\n loss.backward()\n optimizer.step()\n if batch_idx % args['log_interval'] == 0:\n print((f'[{batch_idx*len(data):5d}/{len(train_loader.dataset)} '\n f'({100.*batch_idx/len(train_loader):3.0f}%)]\\t'\n f'Loss: {loss.item():10.6f}'))\n\n\ndef test(args, model, device, test_loader):\n '''Model testing.'''\n model.eval()\n test_loss = 0\n correct = 0\n with torch.no_grad():\n for data, target in test_loader:\n data, target = data.to(device), target.to(device)\n output = model(data)\n test_loss += F.nll_loss(output, target, reduction='sum').item() # sum up batch loss\n pred = output.argmax(dim=1, keepdim=True) # get the index of the max log-probability\n correct += pred.eq(target.view_as(pred)).sum().item()\n\n test_loss /= len(test_loader.dataset)\n\n print((f'\\nTest set: '\n f'Average loss: {test_loss:8.4f}, '\n f'Accuracy: {correct}/{len(test_loader.dataset):.3f} '\n f'({100.*correct/len(test_loader.dataset):2.0f}%)\\n'))\n\n return test_loss\n\n\ndef run(args):\n '''Evaluate performance of the model with the given parameters.'''\n use_cuda = not args['no_cuda'] and torch.cuda.is_available()\n\n torch.manual_seed(args['seed'])\n\n device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n\n kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}\n train_loader = torch.utils.data.DataLoader(\n datasets.MNIST(DATA_PREFIX,\n train=True,\n download=True,\n transform=transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.1307,), (0.3081,))])\n ),\n batch_size=args['batch_size'],\n shuffle=True,\n **kwargs)\n test_loader = torch.utils.data.DataLoader(\n datasets.MNIST(DATA_PREFIX,\n train=False,\n transform=transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize((0.1307,), (0.3081,))])\n ),\n batch_size=args['test_batch_size'],\n shuffle=True,\n **kwargs)\n\n model = Net(hidden_size=args['hidden_size']).to(device)\n optimizer = optim.Adadelta(model.parameters(), lr=args['lr'])\n\n scheduler = StepLR(optimizer, step_size=1, gamma=args['gamma'])\n for epoch in range(1, args['epochs'] + 1):\n logger.info(f'training epoch: {epoch:3d}/{args[\"epochs\"]}')\n train(args, model, device, train_loader, optimizer, epoch)\n loss = test(args, model, device, test_loader)\n scheduler.step()\n\n if args['save_model']:\n torch.save(model.state_dict(), 'mnist_cnn.pt')\n\n logger.info(f'loss: (loss:10.6f)')\n return loss\n\n\ndef param_loader():\n '''Get parameters.'''\n parser = ArgumentParser(description='PyTorch MNIST Example')\n parser.add_argument('--batch-size', type=int, metavar='N', default=64,\n help='input batch size for training (default: 64)')\n parser.add_argument('--hidden-size', type=int, metavar='N', default=128,\n help='hidden layer size (default: 128)')\n parser.add_argument('--test-batch-size', type=int, metavar='N', default=1000,\n help='input batch size for testing (default: 1000)')\n parser.add_argument('--epochs', type=int, metavar='N', default=14,\n help='number of epochs to train (default: 14)')\n parser.add_argument('--lr', type=float, metavar='LR', default=1.0,\n help='learning rate (default: 1.0)')\n parser.add_argument('--gamma', type=float, metavar='M', default=0.7,\n help='Learning rate step gamma (default: 0.7)')\n parser.add_argument('--no-cuda', action='store_true',\n help='disables CUDA training')\n parser.add_argument('--seed', type=int, metavar='S', default=1,\n help='random seed (default: 1)')\n parser.add_argument('--log-interval', type=int, metavar='N', default=10,\n help='how many batches to wait before logging training status')\n parser.add_argument('--save-model', action='store_true',\n help='For Saving the current Model')\n\n args, _ = parser.parse_known_args()\n return vars(args)\n\n\nif __name__ == '__main__':\n params = param_loader()\n logger.info(f'parameters = {params}')\n print(run(params))\n"
] |
[
[
"torch.nn.Dropout2d",
"torch.nn.functional.log_softmax",
"torch.nn.functional.nll_loss",
"torch.manual_seed",
"torch.nn.Conv2d",
"torch.nn.Linear",
"torch.nn.functional.relu",
"torch.no_grad",
"torch.cuda.is_available",
"torch.flatten",
"torch.device",
"torch.nn.functional.max_pool2d",
"torch.optim.lr_scheduler.StepLR"
]
] |
flaviostutz/datascience-snippets
|
[
"768083c4eda972bc1f6548baa86751e0405bda9b"
] |
[
"kaggle-sea-lion/modules/cnn.py"
] |
[
"import h5py\n\nimport tensorflow as tf\nimport tflearn\nfrom sklearn import metrics\nfrom sklearn import preprocessing\nimport itertools\nimport matplotlib.pyplot as plt\nimport numpy as np\n\nfrom modules.logging import logger\nimport modules.logging\nimport modules.utils as utils\nfrom modules.utils import Timer\n\nimport keras\n\n_model = None\n\nclass LoggingLogger(keras.callbacks.Callback):\n\n def __init__(self):\n super(LoggingLogger,self).__init__()\n self.epoch = 0\n\n def on_train_begin(self, logs={}):\n self.verbose = self.params['verbose']\n self.epochs = self.params['epochs']\n\n def on_epoch_begin(self, epoch, logs={}):\n self.epoch = epoch\n self.target = self.params['steps']\n\n def on_batch_end(self, batch, logs={}):\n logger.debug('batch ' + str(batch) + '/' + str(self.target) + ' - epoch ' + str(self.epoch) + '/' + str(self.epochs) + ' - ' + str(logs))\n \n def on_epoch_end(self, epoch, logs={}):\n logger.debug('epoch end ' + str(epoch) + '/' + str(self.epochs) + ' - ' + str(logs))\n\ndef show_predictions(xy_generator, qtty, model, is_bgr=True, group_by_label=False, size=1.4):\n x, y = utils.dump_xy_to_array(xy_generator, qtty, x=True, y=True)\n y_pred = model.predict(x)\n\n yl = utils.onehot_to_label(np.array(y))\n ylp = utils.onehot_to_label(np.array(y_pred))\n\n labels = [(lambda a,b: str(a) + '/' + str(b))(y,yp) for y,yp in zip(yl,ylp)]\n\n utils.show_images(x, image_labels=labels, cols=12, is_bgr=is_bgr, group_by_label=group_by_label, size=size)\n \n \nclass YAcumGenerator:\n \n def __init__(self):\n self.y_ds = None\n \n def generator(self,xy_generator):\n for xs,ys in xy_generator:\n if(self.y_ds==None):\n self.y_ds = ys\n else:\n self.y_ds = np.concatenate((self.y_ds, ys))\n \n yield xs,ys\n\ndef evaluate_dataset_keras(xy_generator, nr_batches, nr_samples, model, detailed=True, class_labels=None):\n logger.info('Evaluating model performance (' + str(nr_samples) + ' samples)...')\n acc = model.evaluate_generator(xy_generator, nr_batches)\n logger.info('Accuracy: ' + str(acc[1]) + ' - Loss: ' + str(acc[0]))\n\n if(detailed):\n logger.info('Predicting Y for detailed analysis...')\n acum = YAcumGenerator()\n \n Y_pred = model.predict_generator(acum.generator(xy_generator), nr_batches+1)\n #sometimes predict_generator returns more samples than nr_batches*batch_size\n Y_pred = np.array(np.split(Y_pred, [nr_samples]))[0]\n \n #we only need the highest probability guess\n Y_pred = np.argmax(Y_pred, axis=1)\n \n Y = acum.y_ds\n Y = np.array(np.split(Y, [nr_samples]))[0]\n if(len(Y)>0):\n #convert from categorical to label\n lb = preprocessing.LabelBinarizer()\n lb.fit(np.array(range(np.shape(Y[0])[0])))\n Y = lb.inverse_transform(Y)\n utils.evaluate_predictions(Y, Y_pred, detailed=detailed, class_labels=class_labels)\n \n else:\n logger.info('No samples found in xy_generator')\n \n \ndef evaluate_dataset_tflearn(X, Y, model, batch_size=24, detailed=True, class_labels=None):\n acc = model.evaluate(X, Y, batch_size=batch_size)\n logger.info('Loss: ' + str(acc))\n\n if(detailed):\n Y_pred = model.predict(X, batch_size=batch_size, verbose=1)\n\n #we only need the highest probability guess\n Y_pred = np.flip(Y_pred, 1)\n Y_pred = Y_pred[:,0]\n\n #convert from categorical to label\n lb = preprocessing.LabelBinarizer()\n lb.fit(np.array(range(5)))\n Y = lb.inverse_transform(Y)\n\n logger.info('Nr test samples: ' + str(len(X)))\n \n logger.info('\\nKappa score (was this luck?): ' + str(metrics.cohen_kappa_score(Y, Y_pred)) + '\\n')\n \n cm = metrics.confusion_matrix(Y, Y_pred)\n logger.info('Confusion matrix:')\n logger.info(cm)\n \n utils.plot_confusion_matrix(cm)\n\n\ndef get_callbacks_keras(model, weights_dir, tf_logs_dir):\n weights_file = weights_dir + 'weights-{epoch:02d}-{val_acc:.2f}.h5'\n tensorboard_callback = keras.callbacks.TensorBoard(log_dir=tf_logs_dir, histogram_freq=1, write_graph=True, write_images=True)\n tensorboard_callback.set_model(model)\n checkpoint_callback = keras.callbacks.ModelCheckpoint(weights_file, monitor='val_acc', verbose=1, save_best_only=True, mode='max')\n progbar_callback = keras.callbacks.ProgbarLogger(count_mode='steps')\n logger_callback = LoggingLogger()\n return [tensorboard_callback,checkpoint_callback,progbar_callback,logger_callback]\n\n \ndef prepare_model_dirs_tflearn(output_dir):\n dir_tflogs = output_dir + 'tf-logs'\n dir_checkpoints = output_dir + 'tf-checkpoint'\n dir_checkpoint_best = output_dir + 'tf-checkpoint-best'\n \n logger.info('Preparing output dir')\n utils.mkdirs(output_dir, dirs=['tf-logs'], recreate=False)\n\n return dir_tflogs, dir_checkpoints, dir_checkpoint_best\n\ndef prepare_cnn_model_tflearn(network, output_dir, model_file=None):\n global _model\n \n if(_model == None):\n \n logger.info('Prepare CNN')\n dir_tflogs, dir_checkpoints, dir_checkpoint_best = prepare_model_dirs(output_dir)\n\n logger.info('Initializing network...')\n _model = tflearn.models.dnn.DNN(network, tensorboard_verbose=3, \n tensorboard_dir=dir_tflogs,\n checkpoint_path=dir_checkpoints,\n best_checkpoint_path=dir_checkpoint_best)\n logger.info('Network initialized')\n\n if(model_file!=None):\n logger.info('Load previous training...')\n _model.load(model_file)\n logger.info('Model loaded')\n \n else:\n logger.info('CNN model already loaded. Reusing it.')\n \n return _model\n\ndef show_training_info_keras(history):\n fig = plt.figure()\n fig.set_size_inches(8, 3)\n\n plt.subplot(121)\n plt.plot(history.history['acc'])\n plt.plot(history.history['val_acc'])\n plt.title('model accuracy')\n #plt.ylabel('accuracy')\n plt.xlabel('epoch')\n plt.legend(['train', 'validate'], loc='upper left')\n \n # summarize history for loss\n plt.subplot(122)\n plt.plot(history.history['loss'])\n plt.plot(history.history['val_loss'])\n plt.title('model loss')\n #plt.ylabel('loss')\n plt.xlabel('epoch')\n plt.legend(['train', 'validate'], loc='upper left')\n \n plt.show()\n "
] |
[
[
"matplotlib.pyplot.legend",
"numpy.split",
"matplotlib.pyplot.title",
"sklearn.metrics.cohen_kappa_score",
"sklearn.metrics.confusion_matrix",
"matplotlib.pyplot.plot",
"numpy.concatenate",
"matplotlib.pyplot.subplot",
"numpy.argmax",
"numpy.shape",
"sklearn.preprocessing.LabelBinarizer",
"matplotlib.pyplot.xlabel",
"numpy.array",
"matplotlib.pyplot.show",
"numpy.flip",
"matplotlib.pyplot.figure"
]
] |
ShubhamAnandJain/MWP-CS229
|
[
"ce86233504fdb37e104a3944fd81d4606fbfa621"
] |
[
"mwptoolkit/module/Graph/gcn.py"
] |
[
"# -*- encoding: utf-8 -*-\n# @Author: Yihuai Lan\n# @Time: 2021/08/29 21:49:49\n# @File: gcn.py\n\n\nimport torch\nfrom torch import nn\nfrom torch.nn import functional as F\n\nfrom mwptoolkit.module.Layer.graph_layers import GraphConvolution\n\n\nclass GCN(nn.Module):\n def __init__(self, in_feat_dim, nhid, out_feat_dim, dropout):\n super(GCN, self).__init__()\n self.gc1 = GraphConvolution(in_feat_dim, nhid)\n self.gc2 = GraphConvolution(nhid, out_feat_dim)\n self.dropout = dropout\n\n def forward(self, x, adj):\n \"\"\"\n Args:\n x (torch.Tensor): input features, shape [batch_size, node_num, in_feat_dim]\n adj (torch.Tensor): adjacency matrix, shape [batch_size, node_num, node_num]\n \n Returns:\n torch.Tensor: gcn_enhance_feature, shape [batch_size, node_num, out_feat_dim]\n \"\"\"\n x = F.relu(self.gc1(x, adj))\n x = F.dropout(x, self.dropout, training=self.training)\n x = self.gc2(x, adj)\n return x\n "
] |
[
[
"torch.nn.functional.dropout"
]
] |
pradeepkr12/text
|
[
"97e6d1d64b82ff91899b9083350951d8619e5914"
] |
[
"torchtext/nn/modules/multiheadattention.py"
] |
[
"import torch\nfrom typing import Tuple, Optional\n\n\nclass MultiheadAttentionContainer(torch.nn.Module):\n def __init__(self, nhead, in_proj_container, attention_layer, out_proj, batch_first=False):\n r\"\"\" A multi-head attention container\n\n Args:\n nhead: the number of heads in the multiheadattention model\n in_proj_container: A container of multi-head in-projection linear layers (a.k.a nn.Linear).\n attention_layer: The custom attention layer. The input sent from MHA container to the attention layer\n is in the shape of `(..., L, N * H, E / H)` for query and `(..., S, N * H, E / H)` for key/value\n while the output shape of the attention layer is expected to be `(..., L, N * H, E / H)`.\n The attention_layer needs to support broadcast if users want the overall MultiheadAttentionContainer\n with broadcast.\n out_proj: The multi-head out-projection layer (a.k.a nn.Linear).\n batch_first: If ``True``, then the input and output tensors are provided\n as `(..., N, L, E)`. Default: ``False``\n\n Examples::\n >>> import torch\n >>> embed_dim, num_heads, bsz = 10, 5, 64\n >>> in_proj_container = InProjContainer(torch.nn.Linear(embed_dim, embed_dim),\n torch.nn.Linear(embed_dim, embed_dim),\n torch.nn.Linear(embed_dim, embed_dim))\n >>> MHA = MultiheadAttentionContainer(num_heads,\n in_proj_container,\n ScaledDotProduct(),\n torch.nn.Linear(embed_dim, embed_dim))\n >>> query = torch.rand((21, bsz, embed_dim))\n >>> key = value = torch.rand((16, bsz, embed_dim))\n >>> attn_output, attn_weights = MHA(query, key, value)\n >>> print(attn_output.shape)\n >>> torch.Size([21, 64, 10])\n \"\"\"\n super(MultiheadAttentionContainer, self).__init__()\n self.nhead = nhead\n self.in_proj_container = in_proj_container\n self.attention_layer = attention_layer\n self.out_proj = out_proj\n self.batch_first = batch_first\n\n def forward(self, query: torch.Tensor, key: torch.Tensor, value: torch.Tensor,\n attn_mask: Optional[torch.Tensor] = None,\n bias_k: Optional[torch.Tensor] = None,\n bias_v: Optional[torch.Tensor] = None) -> Tuple[torch.Tensor, torch.Tensor]:\n r\"\"\"\n\n Args:\n query, key, value (Tensor): map a query and a set of key-value pairs to an output.\n See \"Attention Is All You Need\" for more details.\n attn_mask, bias_k and bias_v (Tensor, optional): keyword arguments passed to the attention layer.\n See the definitions in the attention.\n\n Shape:\n - Inputs:\n - query: :math:`(..., L, N, E)`\n - key: :math:`(..., S, N, E)`\n - value: :math:`(..., S, N, E)`\n - attn_mask, bias_k and bias_v: same with the shape of the corresponding args in attention layer.\n\n - Outputs:\n - attn_output: :math:`(..., L, N, E)`\n - attn_output_weights: :math:`(N * H, L, S)`\n\n Note: It's optional to have the query/key/value inputs with more than three dimensions (for broadcast purpose).\n The MultiheadAttentionContainer module will operate on the last three dimensions.\n\n where where L is the target length, S is the sequence length, H is the number of attention heads,\n N is the batch size, and E is the embedding dimension.\n \"\"\"\n if self.batch_first:\n query, key, value = query.transpose(-3, -2), key.transpose(-3, -2), value.transpose(-3, -2)\n\n tgt_len, src_len, bsz, embed_dim = query.size(-3), key.size(-3), query.size(-2), query.size(-1)\n q, k, v = self.in_proj_container(query, key, value)\n assert q.size(-1) % self.nhead == 0, \"query's embed_dim must be divisible by the number of heads\"\n head_dim = q.size(-1) // self.nhead\n q = q.reshape(tgt_len, bsz * self.nhead, head_dim)\n\n assert k.size(-1) % self.nhead == 0, \"key's embed_dim must be divisible by the number of heads\"\n head_dim = k.size(-1) // self.nhead\n k = k.reshape(src_len, bsz * self.nhead, head_dim)\n\n assert v.size(-1) % self.nhead == 0, \"value's embed_dim must be divisible by the number of heads\"\n head_dim = v.size(-1) // self.nhead\n v = v.reshape(src_len, bsz * self.nhead, head_dim)\n\n attn_output, attn_output_weights = self.attention_layer(q, k, v, attn_mask=attn_mask,\n bias_k=bias_k, bias_v=bias_v)\n attn_output = attn_output.reshape(tgt_len, bsz, embed_dim)\n attn_output = self.out_proj(attn_output)\n\n if self.batch_first:\n attn_output = attn_output.transpose(-3, -2)\n\n return attn_output, attn_output_weights\n\n\nclass ScaledDotProduct(torch.nn.Module):\n\n def __init__(self, dropout=0.0, batch_first=False):\n r\"\"\"Processes a projected query and key-value pair to apply\n scaled dot product attention.\n\n Args:\n dropout (float): probability of dropping an attention weight.\n batch_first: If ``True``, then the input and output tensors are provided\n as `(batch, seq, feature)`. Default: ``False``\n\n Examples::\n >>> SDP = torchtext.nn.ScaledDotProduct(dropout=0.1)\n >>> q = torch.randn(21, 256, 3)\n >>> k = v = torch.randn(21, 256, 3)\n >>> attn_output, attn_weights = SDP(q, k, v)\n >>> print(attn_output.shape, attn_weights.shape)\n torch.Size([21, 256, 3]) torch.Size([256, 21, 21])\n \"\"\"\n super(ScaledDotProduct, self).__init__()\n self.dropout = dropout\n self.batch_first = batch_first\n\n def forward(self, query: torch.Tensor, key: torch.Tensor, value: torch.Tensor,\n attn_mask: Optional[torch.Tensor] = None,\n bias_k: Optional[torch.Tensor] = None,\n bias_v: Optional[torch.Tensor] = None) -> Tuple[torch.Tensor, torch.Tensor]:\n r\"\"\"Uses a scaled dot product with the projected key-value pair to update\n the projected query.\n\n Args:\n query (Tensor): Projected query\n key (Tensor): Projected key\n value (Tensor): Projected value\n attn_mask (BoolTensor, optional): 3D mask that prevents attention to certain positions.\n bias_k and bias_v: (Tensor, optional): one more key and value sequence to be added at\n sequence dim (dim=-3). Those are used for incremental decoding. Users should provide\n non-None to both arguments in order to activate them.\n\n Shape:\n - query: :math:`(..., L, N * H, E / H)`\n - key: :math:`(..., S, N * H, E / H)`\n - value: :math:`(..., S, N * H, E / H)`\n - attn_mask: :math:`(N * H, L, S)`, positions with ``True`` are not allowed to attend\n while ``False`` values will be unchanged.\n - bias_k and bias_v:bias: :math:`(1, N * H, E / H)`\n\n - Output: :math:`(..., L, N * H, E / H)`, :math:`(N * H, L, S)`\n\n Note: It's optional to have the query/key/value inputs with more than three dimensions (for broadcast purpose).\n The ScaledDotProduct module will operate on the last three dimensions.\n\n where L is the target length, S is the source length, H is the number\n of attention heads, N is the batch size, and E is the embedding dimension.\n \"\"\"\n if self.batch_first:\n query, key, value = query.transpose(-3, -2), key.transpose(-3, -2), value.transpose(-3, -2)\n\n if bias_k is not None and bias_v is not None:\n assert key.size(-1) == bias_k.size(-1) and key.size(-2) == bias_k.size(-2) and bias_k.size(-3) == 1, \\\n \"Shape of bias_k is not supported\"\n assert value.size(-1) == bias_v.size(-1) and value.size(-2) == bias_v.size(-2) and bias_v.size(-3) == 1, \\\n \"Shape of bias_v is not supported\"\n key = torch.cat([key, bias_k])\n value = torch.cat([value, bias_v])\n if attn_mask is not None:\n attn_mask = torch.nn.functional.pad(attn_mask, (0, 1))\n\n tgt_len, head_dim = query.size(-3), query.size(-1)\n assert query.size(-1) == key.size(-1) == value.size(-1), \"The feature dim of query, key, value must be equal.\"\n assert key.size() == value.size(), \"Shape of key, value must match\"\n src_len = key.size(-3)\n batch_heads = max(query.size(-2), key.size(-2))\n\n # Scale query\n query, key, value = query.transpose(-2, -3), key.transpose(-2, -3), value.transpose(-2, -3)\n query = query * (float(head_dim) ** -0.5)\n if attn_mask is not None:\n if attn_mask.dim() != 3:\n raise RuntimeError('attn_mask must be a 3D tensor.')\n if (attn_mask.size(-1) != src_len) or (attn_mask.size(-2) != tgt_len) or \\\n (attn_mask.size(-3) != 1 and attn_mask.size(-3) != batch_heads):\n raise RuntimeError('The size of the attn_mask is not correct.')\n if attn_mask.dtype != torch.bool:\n raise RuntimeError('Only bool tensor is supported for attn_mask')\n\n # Dot product of q, k\n attn_output_weights = torch.matmul(query, key.transpose(-2, -1))\n if attn_mask is not None:\n attn_output_weights.masked_fill_(attn_mask, -1e8,)\n attn_output_weights = torch.nn.functional.softmax(attn_output_weights, dim=-1)\n attn_output_weights = torch.nn.functional.dropout(attn_output_weights, p=self.dropout, training=self.training)\n attn_output = torch.matmul(attn_output_weights, value)\n\n if self.batch_first:\n return attn_output, attn_output_weights\n else:\n return attn_output.transpose(-3, -2), attn_output_weights\n\n\nclass InProjContainer(torch.nn.Module):\n def __init__(self, query_proj, key_proj, value_proj):\n r\"\"\"A in-proj container to process inputs.\n\n Args:\n query_proj: a proj layer for query.\n key_proj: a proj layer for key.\n value_proj: a proj layer for value.\n\n \"\"\"\n\n super(InProjContainer, self).__init__()\n self.query_proj = query_proj\n self.key_proj = key_proj\n self.value_proj = value_proj\n\n def forward(self,\n query: torch.Tensor,\n key: torch.Tensor,\n value: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:\n r\"\"\"Projects the input sequences using in-proj layers.\n\n Args:\n query, key, value (Tensors): sequence to be projected\n\n Shape:\n - query, key, value: :math:`(S, N, E)`\n - Output: :math:`(S, N, E)`.\n\n Note: S is the sequence length, N is the batch size, and E is the embedding dimension.\n\n \"\"\"\n return self.query_proj(query), self.key_proj(key), self.value_proj(value)\n\n\ndef generate_square_subsequent_mask(nbatch, sz):\n r\"\"\"Generate a square mask for the sequence. The masked positions are filled with True.\n Unmasked positions are filled with False.\n\n Args:\n nbatch: the number of batch size\n sz: the size of square mask\n \"\"\"\n mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1).repeat(nbatch, 1, 1)\n return mask\n"
] |
[
[
"torch.nn.functional.softmax",
"torch.ones",
"torch.cat",
"torch.nn.functional.dropout",
"torch.matmul",
"torch.nn.functional.pad"
]
] |
Geunwoo-Jeon/iclr_17_compression
|
[
"a28746b1f1c518d91125d8f289d9511cde488c77"
] |
[
"models/Joint_baseline.py"
] |
[
"from compressai.models.priors import JointAutoregressiveHierarchicalPriors as Joint\nimport torch\nimport math\n\nclass JointCompressor(Joint):\n def __init__(self, N=192, M=192, **kwargs):\n super().__init__(N=N, M=M, **kwargs)\n\n def forward(self, x):\n y = self.g_a(x)\n z = self.h_a(y)\n z_hat, z_likelihoods = self.entropy_bottleneck(z)\n params = self.h_s(z_hat)\n\n y_hat = self.gaussian_conditional.quantize(\n y, \"noise\" if self.training else \"dequantize\"\n )\n ctx_params = self.context_prediction(y_hat)\n gaussian_params = self.entropy_parameters(\n torch.cat((params, ctx_params), dim=1)\n )\n scales_hat, means_hat = gaussian_params.chunk(2, 1)\n _, y_likelihoods = self.gaussian_conditional(y, scales_hat, means=means_hat)\n x_hat = self.g_s(y_hat)\n\n mse_loss = torch.mean((x_hat - x).pow(2))\n\n def estimate_bits(likelihoods):\n likelihoods = likelihoods.clamp(1e-5, 1)\n pixel_bits = torch.log(likelihoods) / -math.log(2.0)\n total_bits = pixel_bits.sum()\n return total_bits\n z_bits = estimate_bits(z_likelihoods)\n y_bits = estimate_bits(y_likelihoods)\n n, _, h, w = x.size()\n num_pixels = n * h * w\n bpp_loss = (z_bits + y_bits) / num_pixels\n\n return x_hat, mse_loss, bpp_loss\n"
] |
[
[
"torch.log",
"torch.cat"
]
] |
marx-alex/Morphelia
|
[
"809278b07f1a535789455d54df3cbddc850d609c"
] |
[
"morphelia/preprocessing/normalize.py"
] |
[
"import numpy as np\nfrom sklearn.preprocessing import MinMaxScaler, StandardScaler, RobustScaler\nfrom morphelia.tools import RobustMAD\nfrom morphelia.preprocessing import drop_nan as drop_nan_feats\n\n\ndef normalize(adata,\n by=(\"BatchNumber\", \"PlateNumber\"),\n method=\"standard\",\n pop_var=\"Metadata_Treatment\",\n norm_pop=None,\n clip=None,\n drop_nan=True,\n verbose=False,\n **kwargs):\n \"\"\"\n Normalizes features of an experiment with one ore more batches and\n one or more plates.\n Several methods are available for normalization such as standard scaling,\n robust scaling, robust MAD scaling and min-max scaling.\n If a normalization population is given scaling statistics are calculated only\n in this population, i.g. negative controls.\n\n Args:\n adata (anndata.AnnData): Multidimensional morphological data.\n by (iterable, str or None): Groups to apply function to.\n If None, apply to whole anndata.AnnData object.\n method (str): One of the following method to use for scaling:\n standard: removing the mean and scaling to unit variance.\n robust: removing the median and scaling according to the IQR (interquartile range).\n mad_robust: removing the median and scaling to MAD (meand absolute deviation).\n min_max: scaling features to given range (typically 0 to 1).\n pop_var (str): Variable that denotes populations.\n norm_pop (str): Population to use for calculation of statistics.\n This is not used if norm_pop is None.\n drop_nan (bool): Drop feature containing nan values after transformation.\n clip (int): Clip (truncate) to this value after scaling. If None, do not clip.\n verbose (bool)\n ** kwargs: Arguments passed to scaler.\n \"\"\"\n # check that variables in by are in anndata\n if by:\n if isinstance(by, str):\n by = [by]\n elif isinstance(by, tuple):\n by = list(by)\n\n if not all(var in adata.obs.columns for var in by):\n raise KeyError(f\"Variables defined in 'by' are not in annotations: {by}\")\n\n if norm_pop is not None:\n if pop_var not in adata.obs.columns:\n raise KeyError(f\"Population variable not found in annotations: {pop_var}\")\n\n # define scaler\n method = method.lower()\n\n avail_methods = ['standard', 'robust', 'mad_robust', 'min_max']\n assert method in avail_methods, f\"Method must be one of {avail_methods}, \" \\\n f\"instead got {method}\"\n\n if method == \"standard\":\n scaler = StandardScaler(**kwargs)\n elif method == \"robust\":\n scaler = RobustScaler(**kwargs)\n elif method == \"mad_robust\":\n scaler = RobustMAD(**kwargs)\n elif method == \"min_max\":\n scaler = MinMaxScaler(**kwargs)\n\n # iterate over adata with grouping variables\n if by is not None:\n for groups, sub_df in adata.obs.groupby(by):\n # cache indices of group\n group_ix = sub_df.index\n # transform group with scaler\n if norm_pop is not None:\n norm_ix = sub_df[sub_df[pop_var] == norm_pop].index\n scaler.fit(adata[norm_ix, :].X.copy())\n else:\n scaler.fit(adata[group_ix, :].X.copy())\n # transform\n adata[group_ix, :].X = scaler.transform(adata[group_ix, :].X.copy())\n\n else:\n scaler.fit(adata.X.copy())\n adata.X = scaler.transform(adata.X.copy())\n\n if clip is not None:\n assert (clip > 0), f'Value for clip should be above 0, instead got {clip}'\n adata.X[adata.X > clip] = clip\n adata.X[adata.X < -clip] = clip\n\n if drop_nan:\n adata = drop_nan_feats(adata, verbose=verbose)\n\n return adata\n"
] |
[
[
"sklearn.preprocessing.RobustScaler",
"sklearn.preprocessing.StandardScaler",
"sklearn.preprocessing.MinMaxScaler"
]
] |
ipab-rad/softgym
|
[
"eeee770d8720c2cebaa9c5f72408b3340b07d367"
] |
[
"softgym/utils/generate_font_img.py"
] |
[
"from PIL import Image, ImageDraw, ImageFont\nimport numpy as np\nimport cv2\nimport pickle\n\ndef find_skeleton(arr, start_point, threshold=45):\n tmp_arr = arr.copy()\n queue = []\n res = []\n queue.append(start_point)\n res.append(start_point)\n head = start_point\n while len(queue) > 0:\n point = queue.pop()\n x, y = point\n # print(x, y)\n # print(tmp_arr[218, 737])\n tmp_arr[x, y, :] = 0\n for dx in [1, -1]:\n for dy in [1, -1]:\n # print(x, y)\n new_point = [min(x + dx, 899), y + dy]\n\n cont = False\n for r in res[:-1]:\n if np.linalg.norm(np.array(r) - np.array(new_point)) < threshold * 0.8:\n cont = True\n break\n if cont:\n continue\n\n # print(new_point, tmp_arr[new_point])\n if tmp_arr[new_point[0]][new_point[1]][0] == 255 and tmp_arr[new_point[0]][new_point[1]][1] == 255 and \\\n tmp_arr[new_point[0]][new_point[1]][2] == 255:\n \n # print(new_point)\n if np.linalg.norm(np.array(head) - np.array(new_point)) > threshold:\n # print(new_point)\n head = new_point\n res.append(new_point)\n for ele in queue:\n tmp_arr[ele[0], ele[1], :] = 0\n queue = []\n\n queue.append(new_point)\n\n # print(len(res))\n # print(res)\n return res\n\ndef get_character_image(character, start_point, erosion, threshold, division):\n # sample text and font\n unicode_text = character\n font = ImageFont.truetype(\"/usr/share/fonts/truetype/freefont/FreeSans.ttf\", 1000, encoding=\"unic\")\n\n # get the line size\n text_width, text_height = font.getsize(unicode_text)\n print(text_width, text_height)\n\n # create a blank canvas with extra space between lines\n canvas = Image.new('RGB', (text_width, text_height), \"black\")\n\n # draw the text onto the text canvas, and use black as the text color\n draw = ImageDraw.Draw(canvas)\n draw.text((0, 0), character, 'white', font)\n\n # save the blank canvas to a file\n # canvas.save(\"unicode-text.png\", \"PNG\")\n # canvas.show()\n\n arr = np.asarray(canvas)\n arr = cv2.erode(arr, kernel=np.ones((erosion, erosion), dtype=np.uint8))\n cv2.imshow('arr', arr)\n cv2.waitKey()\n\n x = y = 0\n res = find_skeleton(arr, start_point, threshold=threshold)\n x = [p[0] / division for p in res]\n y = [p[1] / division for p in res]\n print(len(res))\n\n for p in res:\n arr[p[0]][p[1]][0] = 0\n arr[p[0]][p[1]][1] = 0\n arr[p[0]][p[1]][2] = 255\n cv2.imshow('chosen arr', arr)\n cv2.waitKey()\n \n # loc = {\n # character: (x, y)\n # }\n # with open('softgym/envs/rope_configuration.pkl', 'wb') as handle:\n # pickle.dump(loc, handle, protocol=pickle.HIGHEST_PROTOCOL)\n\n return x, y\n\n\nif __name__ == '__main__':\n import matplotlib.pyplot as plt\n\n characters = ['S', 'O', 'M', 'C', 'U']\n start_point = [[350, 550], [200, 390], [875, 120], [360, 600], [200, 125]]\n erosion = [55, 55, 58, 55, 60]\n threshold = [46, 46, 46, 42, 42]\n division = [46, 46, 46, 42, 42]\n\n characters = ['M']\n start_point = [[875, 120]]\n erosion = [58]\n threshold = [36]\n division = [36]\n\n locs = {}\n for idx in range(len(characters)):\n x, y = get_character_image(characters[idx], start_point[idx], erosion[idx], threshold[idx], division[idx])\n locs[characters[idx]] = [x, y]\n\n # with open('softgym/envs/rope_configuration-longer.pkl', 'wb') as handle:\n # pickle.dump(locs, handle, protocol=pickle.HIGHEST_PROTOCOL)\n \n "
] |
[
[
"numpy.asarray",
"numpy.array",
"numpy.ones"
]
] |
IngiOrn/pymc
|
[
"8f3636daf7d9946f6eca4717f3bb0c6d77d9c6e9"
] |
[
"pymc/distributions/discrete.py"
] |
[
"# Copyright 2020 The PyMC Developers\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.\nimport aesara.tensor as at\nimport numpy as np\n\nfrom aeppl.logprob import _logprob\nfrom aesara.tensor.random.basic import (\n RandomVariable,\n bernoulli,\n betabinom,\n binomial,\n categorical,\n geometric,\n hypergeometric,\n nbinom,\n poisson,\n)\nfrom scipy import stats\n\nimport pymc as pm\n\nfrom pymc.aesaraf import floatX, intX, take_along_axis\nfrom pymc.distributions.dist_math import (\n betaln,\n binomln,\n bound,\n factln,\n log_diff_normal_cdf,\n logpow,\n normal_lccdf,\n normal_lcdf,\n)\nfrom pymc.distributions.distribution import Discrete\nfrom pymc.distributions.logprob import _logcdf\nfrom pymc.distributions.shape_utils import rv_size_is_none\nfrom pymc.math import sigmoid\n\n__all__ = [\n \"Binomial\",\n \"BetaBinomial\",\n \"Bernoulli\",\n \"DiscreteWeibull\",\n \"Poisson\",\n \"NegativeBinomial\",\n \"Constant\",\n \"ZeroInflatedPoisson\",\n \"ZeroInflatedBinomial\",\n \"ZeroInflatedNegativeBinomial\",\n \"DiscreteUniform\",\n \"Geometric\",\n \"HyperGeometric\",\n \"Categorical\",\n \"OrderedLogistic\",\n \"OrderedProbit\",\n]\n\n\nclass Binomial(Discrete):\n R\"\"\"\n Binomial log-likelihood.\n\n The discrete probability distribution of the number of successes\n in a sequence of n independent yes/no experiments, each of which\n yields success with probability p.\n The pmf of this distribution is\n\n .. math:: f(x \\mid n, p) = \\binom{n}{x} p^x (1-p)^{n-x}\n\n .. plot::\n\n import matplotlib.pyplot as plt\n import numpy as np\n import scipy.stats as st\n import arviz as az\n plt.style.use('arviz-darkgrid')\n x = np.arange(0, 22)\n ns = [10, 17]\n ps = [0.5, 0.7]\n for n, p in zip(ns, ps):\n pmf = st.binom.pmf(x, n, p)\n plt.plot(x, pmf, '-o', label='n = {}, p = {}'.format(n, p))\n plt.xlabel('x', fontsize=14)\n plt.ylabel('f(x)', fontsize=14)\n plt.legend(loc=1)\n plt.show()\n\n ======== ==========================================\n Support :math:`x \\in \\{0, 1, \\ldots, n\\}`\n Mean :math:`n p`\n Variance :math:`n p (1 - p)`\n ======== ==========================================\n\n Parameters\n ----------\n n: int\n Number of Bernoulli trials (n >= 0).\n p: float\n Probability of success in each trial (0 < p < 1).\n \"\"\"\n rv_op = binomial\n\n @classmethod\n def dist(cls, n, p, *args, **kwargs):\n n = at.as_tensor_variable(intX(n))\n p = at.as_tensor_variable(floatX(p))\n # mode = at.cast(tround(n * p), self.dtype)\n return super().dist([n, p], **kwargs)\n\n def logp(value, n, p):\n r\"\"\"\n Calculate log-probability of Binomial distribution at specified value.\n\n Parameters\n ----------\n value: numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor\n\n Returns\n -------\n TensorVariable\n \"\"\"\n return bound(\n binomln(n, value) + logpow(p, value) + logpow(1 - p, n - value),\n 0 <= value,\n value <= n,\n 0 <= p,\n p <= 1,\n )\n\n def logcdf(value, n, p):\n \"\"\"\n Compute the log of the cumulative distribution function for Binomial distribution\n at the specified value.\n\n Parameters\n ----------\n value: numeric or np.ndarray or aesara.tensor\n Value(s) for which log CDF is calculated. If the log CDF for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor.\n\n Returns\n -------\n TensorVariable\n \"\"\"\n value = at.floor(value)\n\n return bound(\n at.switch(\n at.lt(value, n),\n at.log(at.betainc(n - value, value + 1, 1 - p)),\n 0,\n ),\n 0 <= value,\n 0 < n,\n 0 <= p,\n p <= 1,\n )\n\n\nclass BetaBinomial(Discrete):\n R\"\"\"\n Beta-binomial log-likelihood.\n\n Equivalent to binomial random variable with success probability\n drawn from a beta distribution.\n The pmf of this distribution is\n\n .. math::\n\n f(x \\mid \\alpha, \\beta, n) =\n \\binom{n}{x}\n \\frac{B(x + \\alpha, n - x + \\beta)}{B(\\alpha, \\beta)}\n\n .. plot::\n\n import matplotlib.pyplot as plt\n import numpy as np\n import scipy.stats as st\n from scipy import special\n import arviz as az\n plt.style.use('arviz-darkgrid')\n\n def BetaBinom(a, b, n, x):\n pmf = special.binom(n, x) * (special.beta(x+a, n-x+b) / special.beta(a, b))\n return pmf\n\n x = np.arange(0, 11)\n alphas = [0.5, 1, 2.3]\n betas = [0.5, 1, 2]\n n = 10\n for a, b in zip(alphas, betas):\n pmf = BetaBinom(a, b, n, x)\n plt.plot(x, pmf, '-o', label=r'$\\alpha$ = {}, $\\beta$ = {}, n = {}'.format(a, b, n))\n plt.xlabel('x', fontsize=12)\n plt.ylabel('f(x)', fontsize=12)\n plt.ylim(0)\n plt.legend(loc=9)\n plt.show()\n\n ======== =================================================================\n Support :math:`x \\in \\{0, 1, \\ldots, n\\}`\n Mean :math:`n \\dfrac{\\alpha}{\\alpha + \\beta}`\n Variance :math:`n \\dfrac{\\alpha \\beta}{(\\alpha+\\beta)^2 (\\alpha+\\beta+1)}`\n ======== =================================================================\n\n Parameters\n ----------\n n: int\n Number of Bernoulli trials (n >= 0).\n alpha: float\n alpha > 0.\n beta: float\n beta > 0.\n \"\"\"\n\n rv_op = betabinom\n\n @classmethod\n def dist(cls, alpha, beta, n, *args, **kwargs):\n alpha = at.as_tensor_variable(floatX(alpha))\n beta = at.as_tensor_variable(floatX(beta))\n n = at.as_tensor_variable(intX(n))\n return super().dist([n, alpha, beta], **kwargs)\n\n def logp(value, n, alpha, beta):\n r\"\"\"\n Calculate log-probability of BetaBinomial distribution at specified value.\n\n Parameters\n ----------\n value: numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor\n\n Returns\n -------\n TensorVariable\n \"\"\"\n return bound(\n binomln(n, value) + betaln(value + alpha, n - value + beta) - betaln(alpha, beta),\n value >= 0,\n value <= n,\n alpha > 0,\n beta > 0,\n )\n\n def logcdf(value, n, alpha, beta):\n \"\"\"\n Compute the log of the cumulative distribution function for BetaBinomial distribution\n at the specified value.\n\n Parameters\n ----------\n value: numeric\n Value for which log CDF is calculated.\n\n Returns\n -------\n TensorVariable\n \"\"\"\n # logcdf can only handle scalar values at the moment\n if np.ndim(value):\n raise TypeError(\n f\"BetaBinomial.logcdf expects a scalar value but received a {np.ndim(value)}-dimensional object.\"\n )\n\n safe_lower = at.switch(at.lt(value, 0), value, 0)\n\n return bound(\n at.switch(\n at.lt(value, n),\n at.logsumexp(\n BetaBinomial.logp(at.arange(safe_lower, value + 1), n, alpha, beta),\n keepdims=False,\n ),\n 0,\n ),\n 0 <= value,\n 0 <= n,\n 0 < alpha,\n 0 < beta,\n )\n\n\nclass Bernoulli(Discrete):\n R\"\"\"Bernoulli log-likelihood\n\n The Bernoulli distribution describes the probability of successes\n (x=1) and failures (x=0).\n The pmf of this distribution is\n\n .. math:: f(x \\mid p) = p^{x} (1-p)^{1-x}\n\n .. plot::\n\n import matplotlib.pyplot as plt\n import numpy as np\n import scipy.stats as st\n import arviz as az\n plt.style.use('arviz-darkgrid')\n x = [0, 1]\n for p in [0, 0.5, 0.8]:\n pmf = st.bernoulli.pmf(x, p)\n plt.plot(x, pmf, '-o', label='p = {}'.format(p))\n plt.xlabel('x', fontsize=12)\n plt.ylabel('f(x)', fontsize=12)\n plt.ylim(0)\n plt.legend(loc=9)\n plt.show()\n\n ======== ======================\n Support :math:`x \\in \\{0, 1\\}`\n Mean :math:`p`\n Variance :math:`p (1 - p)`\n ======== ======================\n\n The bernoulli distribution can be parametrized either in terms of p or logit_p.\n The link between the parametrizations is given by\n\n .. math:: logit(p) = ln(\\frac{p}{1-p})\n\n Parameters\n ----------\n p: float\n Probability of success (0 < p < 1).\n logit_p: float\n Alternative log odds for the probability of success.\n \"\"\"\n rv_op = bernoulli\n\n @classmethod\n def dist(cls, p=None, logit_p=None, *args, **kwargs):\n if p is not None and logit_p is not None:\n raise ValueError(\"Incompatible parametrization. Can't specify both p and logit_p.\")\n elif p is None and logit_p is None:\n raise ValueError(\"Incompatible parametrization. Must specify either p or logit_p.\")\n\n if logit_p is not None:\n p = at.sigmoid(logit_p)\n\n p = at.as_tensor_variable(floatX(p))\n return super().dist([p], **kwargs)\n\n def get_moment(rv, size, p):\n if not rv_size_is_none(size):\n p = at.full(size, p)\n return at.switch(p < 0.5, 0, 1)\n\n def logp(value, p):\n r\"\"\"\n Calculate log-probability of Bernoulli distribution at specified value.\n\n Parameters\n ----------\n value: numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor\n\n Returns\n -------\n TensorVariable\n \"\"\"\n\n return bound(\n at.switch(value, at.log(p), at.log1p(-p)),\n value >= 0,\n value <= 1,\n p >= 0,\n p <= 1,\n )\n\n def logcdf(value, p):\n \"\"\"\n Compute the log of the cumulative distribution function for Bernoulli distribution\n at the specified value.\n\n Parameters\n ----------\n value: numeric or np.ndarray or aesara.tensor\n Value(s) for which log CDF is calculated. If the log CDF for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor.\n\n Returns\n -------\n TensorVariable\n \"\"\"\n\n return bound(\n at.switch(\n at.lt(value, 1),\n at.log1p(-p),\n 0,\n ),\n 0 <= value,\n 0 <= p,\n p <= 1,\n )\n\n\nclass DiscreteWeibullRV(RandomVariable):\n name = \"discrete_weibull\"\n ndim_supp = 0\n ndims_params = [0, 0]\n dtype = \"int64\"\n _print_name = (\"dWeibull\", \"\\\\operatorname{dWeibull}\")\n\n @classmethod\n def rng_fn(cls, rng, q, beta, size):\n p = rng.uniform(size=size)\n return np.ceil(np.power(np.log(1 - p) / np.log(q), 1.0 / beta)) - 1\n\n\ndiscrete_weibull = DiscreteWeibullRV()\n\n\nclass DiscreteWeibull(Discrete):\n R\"\"\"Discrete Weibull log-likelihood\n\n The discrete Weibull distribution is a flexible model of count data that\n can handle both over- and under-dispersion.\n The pmf of this distribution is\n\n .. math:: f(x \\mid q, \\beta) = q^{x^{\\beta}} - q^{(x + 1)^{\\beta}}\n\n .. plot::\n\n import matplotlib.pyplot as plt\n import numpy as np\n import scipy.stats as st\n from scipy import special\n import arviz as az\n plt.style.use('arviz-darkgrid')\n\n def DiscreteWeibull(q, b, x):\n return q**(x**b) - q**((x + 1)**b)\n\n x = np.arange(0, 10)\n qs = [0.1, 0.9, 0.9]\n betas = [0.3, 1.3, 3]\n for q, b in zip(qs, betas):\n pmf = DiscreteWeibull(q, b, x)\n plt.plot(x, pmf, '-o', label=r'q = {}, $\\beta$ = {}'.format(q, b))\n plt.xlabel('x', fontsize=12)\n plt.ylabel('f(x)', fontsize=12)\n plt.ylim(0)\n plt.legend(loc=1)\n plt.show()\n\n ======== ======================\n Support :math:`x \\in \\mathbb{N}_0`\n Mean :math:`\\mu = \\sum_{x = 1}^{\\infty} q^{x^{\\beta}}`\n Variance :math:`2 \\sum_{x = 1}^{\\infty} x q^{x^{\\beta}} - \\mu - \\mu^2`\n ======== ======================\n \"\"\"\n rv_op = discrete_weibull\n\n @classmethod\n def dist(cls, q, beta, *args, **kwargs):\n q = at.as_tensor_variable(floatX(q))\n beta = at.as_tensor_variable(floatX(beta))\n return super().dist([q, beta], **kwargs)\n\n def logp(value, q, beta):\n r\"\"\"\n Calculate log-probability of DiscreteWeibull distribution at specified value.\n\n Parameters\n ----------\n value: numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor\n\n Returns\n -------\n TensorVariable\n \"\"\"\n return bound(\n at.log(at.power(q, at.power(value, beta)) - at.power(q, at.power(value + 1, beta))),\n 0 <= value,\n 0 < q,\n q < 1,\n 0 < beta,\n )\n\n def logcdf(value, q, beta):\n \"\"\"\n Compute the log of the cumulative distribution function for Discrete Weibull distribution\n at the specified value.\n\n Parameters\n ----------\n value: numeric or np.ndarray or aesara.tensor\n Value(s) for which log CDF is calculated. If the log CDF for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor.\n\n Returns\n -------\n TensorVariable\n \"\"\"\n return bound(\n at.log1p(-at.power(q, at.power(value + 1, beta))),\n 0 <= value,\n 0 < q,\n q < 1,\n 0 < beta,\n )\n\n\nclass Poisson(Discrete):\n R\"\"\"\n Poisson log-likelihood.\n\n Often used to model the number of events occurring in a fixed period\n of time when the times at which events occur are independent.\n The pmf of this distribution is\n\n .. math:: f(x \\mid \\mu) = \\frac{e^{-\\mu}\\mu^x}{x!}\n\n .. plot::\n\n import matplotlib.pyplot as plt\n import numpy as np\n import scipy.stats as st\n import arviz as az\n plt.style.use('arviz-darkgrid')\n x = np.arange(0, 15)\n for m in [0.5, 3, 8]:\n pmf = st.poisson.pmf(x, m)\n plt.plot(x, pmf, '-o', label='$\\mu$ = {}'.format(m))\n plt.xlabel('x', fontsize=12)\n plt.ylabel('f(x)', fontsize=12)\n plt.ylim(0)\n plt.legend(loc=1)\n plt.show()\n\n ======== ==========================\n Support :math:`x \\in \\mathbb{N}_0`\n Mean :math:`\\mu`\n Variance :math:`\\mu`\n ======== ==========================\n\n Parameters\n ----------\n mu: float\n Expected number of occurrences during the given interval\n (mu >= 0).\n\n Notes\n -----\n The Poisson distribution can be derived as a limiting case of the\n binomial distribution.\n \"\"\"\n rv_op = poisson\n\n @classmethod\n def dist(cls, mu, *args, **kwargs):\n mu = at.as_tensor_variable(floatX(mu))\n # mode = intX(at.floor(mu))\n return super().dist([mu], *args, **kwargs)\n\n def logp(value, mu):\n r\"\"\"\n Calculate log-probability of Poisson distribution at specified value.\n\n Parameters\n ----------\n value: numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor\n\n Returns\n -------\n TensorVariable\n \"\"\"\n log_prob = bound(logpow(mu, value) - factln(value) - mu, mu >= 0, value >= 0)\n # Return zero when mu and value are both zero\n return at.switch(at.eq(mu, 0) * at.eq(value, 0), 0, log_prob)\n\n def logcdf(value, mu):\n \"\"\"\n Compute the log of the cumulative distribution function for Poisson distribution\n at the specified value.\n\n Parameters\n ----------\n value: numeric or np.ndarray or aesara.tensor\n Value(s) for which log CDF is calculated. If the log CDF for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor.\n\n Returns\n -------\n TensorVariable\n \"\"\"\n value = at.floor(value)\n # Avoid C-assertion when the gammaincc function is called with invalid values (#4340)\n safe_mu = at.switch(at.lt(mu, 0), 0, mu)\n safe_value = at.switch(at.lt(value, 0), 0, value)\n\n return bound(\n at.log(at.gammaincc(safe_value + 1, safe_mu)),\n 0 <= value,\n 0 <= mu,\n )\n\n\nclass NegativeBinomial(Discrete):\n R\"\"\"\n Negative binomial log-likelihood.\n\n The negative binomial distribution describes a Poisson random variable\n whose rate parameter is gamma distributed.\n The pmf of this distribution is\n\n .. math::\n\n f(x \\mid \\mu, \\alpha) =\n \\binom{x + \\alpha - 1}{x}\n (\\alpha/(\\mu+\\alpha))^\\alpha (\\mu/(\\mu+\\alpha))^x\n\n .. plot::\n\n import matplotlib.pyplot as plt\n import numpy as np\n import scipy.stats as st\n from scipy import special\n import arviz as az\n plt.style.use('arviz-darkgrid')\n\n def NegBinom(a, m, x):\n pmf = special.binom(x + a - 1, x) * (a / (m + a))**a * (m / (m + a))**x\n return pmf\n\n x = np.arange(0, 22)\n alphas = [0.9, 2, 4]\n mus = [1, 2, 8]\n for a, m in zip(alphas, mus):\n pmf = NegBinom(a, m, x)\n plt.plot(x, pmf, '-o', label=r'$\\alpha$ = {}, $\\mu$ = {}'.format(a, m))\n plt.xlabel('x', fontsize=12)\n plt.ylabel('f(x)', fontsize=12)\n plt.legend(loc=1)\n plt.show()\n\n ======== ==========================\n Support :math:`x \\in \\mathbb{N}_0`\n Mean :math:`\\mu`\n ======== ==========================\n\n The negative binomial distribution can be parametrized either in terms of mu or p,\n and either in terms of alpha or n. The link between the parametrizations is given by\n\n .. math::\n\n \\mu &= \\frac{n(1-p)}{p} \\\\\n \\alpha &= n\n\n Parameters\n ----------\n mu: float\n Poission distribution parameter (mu > 0).\n alpha: float\n Gamma distribution parameter (alpha > 0).\n p: float\n Alternative probability of success in each trial (0 < p < 1).\n n: float\n Alternative number of target success trials (n > 0)\n \"\"\"\n rv_op = nbinom\n\n @classmethod\n def dist(cls, mu=None, alpha=None, p=None, n=None, *args, **kwargs):\n n, p = cls.get_n_p(mu=mu, alpha=alpha, p=p, n=n)\n n = at.as_tensor_variable(floatX(n))\n p = at.as_tensor_variable(floatX(p))\n return super().dist([n, p], *args, **kwargs)\n\n @classmethod\n def get_n_p(cls, mu=None, alpha=None, p=None, n=None):\n if n is None:\n if alpha is not None:\n n = alpha\n else:\n raise ValueError(\"Incompatible parametrization. Must specify either alpha or n.\")\n elif alpha is not None:\n raise ValueError(\"Incompatible parametrization. Can't specify both alpha and n.\")\n\n if p is None:\n if mu is not None:\n p = n / (mu + n)\n else:\n raise ValueError(\"Incompatible parametrization. Must specify either mu or p.\")\n elif mu is not None:\n raise ValueError(\"Incompatible parametrization. Can't specify both mu and p.\")\n\n return n, p\n\n def logp(value, n, p):\n r\"\"\"\n Calculate log-probability of NegativeBinomial distribution at specified value.\n\n Parameters\n ----------\n value: numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor\n\n Returns\n -------\n TensorVariable\n \"\"\"\n alpha = n\n mu = alpha * (1 - p) / p\n negbinom = bound(\n binomln(value + alpha - 1, value)\n + logpow(mu / (mu + alpha), value)\n + logpow(alpha / (mu + alpha), alpha),\n value >= 0,\n mu > 0,\n alpha > 0,\n )\n\n # Return Poisson when alpha gets very large.\n return at.switch(at.gt(alpha, 1e10), Poisson.logp(value, mu), negbinom)\n\n def logcdf(value, n, p):\n \"\"\"\n Compute the log of the cumulative distribution function for NegativeBinomial distribution\n at the specified value.\n\n Parameters\n ----------\n value: numeric or np.ndarray or aesara.tensor\n Value(s) for which log CDF is calculated. If the log CDF for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor.\n\n Returns\n -------\n TensorVariable\n \"\"\"\n return bound(\n at.log(at.betainc(n, at.floor(value) + 1, p)),\n 0 <= value,\n 0 < n,\n 0 <= p,\n p <= 1,\n )\n\n\nclass Geometric(Discrete):\n R\"\"\"\n Geometric log-likelihood.\n\n The probability that the first success in a sequence of Bernoulli\n trials occurs on the x'th trial.\n The pmf of this distribution is\n\n .. math:: f(x \\mid p) = p(1-p)^{x-1}\n\n .. plot::\n\n import matplotlib.pyplot as plt\n import numpy as np\n import scipy.stats as st\n import arviz as az\n plt.style.use('arviz-darkgrid')\n x = np.arange(1, 11)\n for p in [0.1, 0.25, 0.75]:\n pmf = st.geom.pmf(x, p)\n plt.plot(x, pmf, '-o', label='p = {}'.format(p))\n plt.xlabel('x', fontsize=12)\n plt.ylabel('f(x)', fontsize=12)\n plt.legend(loc=1)\n plt.show()\n\n ======== =============================\n Support :math:`x \\in \\mathbb{N}_{>0}`\n Mean :math:`\\dfrac{1}{p}`\n Variance :math:`\\dfrac{1 - p}{p^2}`\n ======== =============================\n\n Parameters\n ----------\n p: float\n Probability of success on an individual trial (0 < p <= 1).\n \"\"\"\n\n rv_op = geometric\n\n @classmethod\n def dist(cls, p, *args, **kwargs):\n p = at.as_tensor_variable(floatX(p))\n return super().dist([p], *args, **kwargs)\n\n def logp(value, p):\n r\"\"\"\n Calculate log-probability of Geometric distribution at specified value.\n\n Parameters\n ----------\n value: numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor\n\n Returns\n -------\n TensorVariable\n \"\"\"\n return bound(\n at.log(p) + logpow(1 - p, value - 1),\n 0 <= p,\n p <= 1,\n value >= 1,\n )\n\n def logcdf(value, p):\n \"\"\"\n Compute the log of the cumulative distribution function for Geometric distribution\n at the specified value.\n\n Parameters\n ----------\n value: numeric or np.ndarray or aesara.tensor\n Value(s) for which log CDF is calculated. If the log CDF for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor.\n\n Returns\n -------\n TensorVariable\n \"\"\"\n\n return bound(\n at.log1mexp(at.log1p(-p) * value),\n 0 <= value,\n 0 <= p,\n p <= 1,\n )\n\n\nclass HyperGeometric(Discrete):\n R\"\"\"\n Discrete hypergeometric distribution.\n\n The probability of :math:`x` successes in a sequence of :math:`n` bernoulli\n trials taken without replacement from a population of :math:`N` objects,\n containing :math:`k` good (or successful or Type I) objects.\n The pmf of this distribution is\n\n .. math:: f(x \\mid N, n, k) = \\frac{\\binom{k}{x}\\binom{N-k}{n-x}}{\\binom{N}{n}}\n\n .. plot::\n\n import matplotlib.pyplot as plt\n import numpy as np\n import scipy.stats as st\n import arviz as az\n plt.style.use('arviz-darkgrid')\n x = np.arange(1, 15)\n N = 50\n k = 10\n for n in [20, 25]:\n pmf = st.hypergeom.pmf(x, N, k, n)\n plt.plot(x, pmf, '-o', label='n = {}'.format(n))\n plt.plot(x, pmf, '-o', label='N = {}'.format(N))\n plt.plot(x, pmf, '-o', label='k = {}'.format(k))\n plt.xlabel('x', fontsize=12)\n plt.ylabel('f(x)', fontsize=12)\n plt.legend(loc=1)\n plt.show()\n\n ======== =============================\n Support :math:`x \\in \\left[\\max(0, n - N + k), \\min(k, n)\\right]`\n Mean :math:`\\dfrac{nk}{N}`\n Variance :math:`\\dfrac{(N-n)nk(N-k)}{(N-1)N^2}`\n ======== =============================\n\n Parameters\n ----------\n N : integer\n Total size of the population\n k : integer\n Number of successful individuals in the population\n n : integer\n Number of samples drawn from the population\n \"\"\"\n\n rv_op = hypergeometric\n\n @classmethod\n def dist(cls, N, k, n, *args, **kwargs):\n good = at.as_tensor_variable(intX(k))\n bad = at.as_tensor_variable(intX(N - k))\n n = at.as_tensor_variable(intX(n))\n return super().dist([good, bad, n], *args, **kwargs)\n\n def logp(value, good, bad, n):\n r\"\"\"\n Calculate log-probability of HyperGeometric distribution at specified value.\n\n Parameters\n ----------\n value : numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor\n\n Returns\n -------\n TensorVariable\n \"\"\"\n\n tot = good + bad\n result = (\n betaln(good + 1, 1)\n + betaln(bad + 1, 1)\n + betaln(tot - n + 1, n + 1)\n - betaln(value + 1, good - value + 1)\n - betaln(n - value + 1, bad - n + value + 1)\n - betaln(tot + 1, 1)\n )\n # value in [max(0, n - N + k), min(k, n)]\n lower = at.switch(at.gt(n - tot + good, 0), n - tot + good, 0)\n upper = at.switch(at.lt(good, n), good, n)\n return bound(result, lower <= value, value <= upper)\n\n def logcdf(value, good, bad, n):\n \"\"\"\n Compute the log of the cumulative distribution function for HyperGeometric distribution\n at the specified value.\n\n Parameters\n ----------\n value: numeric\n Value for which log CDF is calculated.\n\n Returns\n -------\n TensorVariable\n \"\"\"\n # logcdf can only handle scalar values at the moment\n if np.ndim(value):\n raise TypeError(\n f\"HyperGeometric.logcdf expects a scalar value but received a {np.ndim(value)}-dimensional object.\"\n )\n\n N = good + bad\n # TODO: Use lower upper in locgdf for smarter logsumexp?\n safe_lower = at.switch(at.lt(value, 0), value, 0)\n\n return bound(\n at.switch(\n at.lt(value, n),\n at.logsumexp(\n HyperGeometric.logp(at.arange(safe_lower, value + 1), good, bad, n),\n keepdims=False,\n ),\n 0,\n ),\n 0 <= value,\n 0 < N,\n 0 <= good,\n 0 <= n,\n good <= N,\n n <= N,\n )\n\n\nclass DiscreteUniformRV(RandomVariable):\n name = \"discrete_uniform\"\n ndim_supp = 0\n ndims_params = [0, 0]\n dtype = \"int64\"\n _print_name = (\"DiscreteUniform\", \"\\\\operatorname{DiscreteUniform}\")\n\n @classmethod\n def rng_fn(cls, rng, lower, upper, size=None):\n return stats.randint.rvs(lower, upper + 1, size=size, random_state=rng)\n\n\ndiscrete_uniform = DiscreteUniformRV()\n\n\nclass DiscreteUniform(Discrete):\n R\"\"\"\n Discrete uniform distribution.\n The pmf of this distribution is\n\n .. math:: f(x \\mid lower, upper) = \\frac{1}{upper-lower+1}\n\n .. plot::\n\n import matplotlib.pyplot as plt\n import numpy as np\n import scipy.stats as st\n import arviz as az\n plt.style.use('arviz-darkgrid')\n ls = [1, -2]\n us = [6, 2]\n for l, u in zip(ls, us):\n x = np.arange(l, u+1)\n pmf = [1.0 / (u - l + 1)] * len(x)\n plt.plot(x, pmf, '-o', label='lower = {}, upper = {}'.format(l, u))\n plt.xlabel('x', fontsize=12)\n plt.ylabel('f(x)', fontsize=12)\n plt.ylim(0, 0.4)\n plt.legend(loc=1)\n plt.show()\n\n ======== ===============================================\n Support :math:`x \\in {lower, lower + 1, \\ldots, upper}`\n Mean :math:`\\dfrac{lower + upper}{2}`\n Variance :math:`\\dfrac{(upper - lower)^2}{12}`\n ======== ===============================================\n\n Parameters\n ----------\n lower: int\n Lower limit.\n upper: int\n Upper limit (upper > lower).\n \"\"\"\n\n rv_op = discrete_uniform\n\n @classmethod\n def dist(cls, lower, upper, *args, **kwargs):\n lower = intX(at.floor(lower))\n upper = intX(at.floor(upper))\n return super().dist([lower, upper], **kwargs)\n\n def logp(value, lower, upper):\n r\"\"\"\n Calculate log-probability of DiscreteUniform distribution at specified value.\n\n Parameters\n ----------\n value: numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor\n\n Returns\n -------\n TensorVariable\n \"\"\"\n return bound(\n at.fill(value, -at.log(upper - lower + 1)),\n lower <= value,\n value <= upper,\n )\n\n def logcdf(value, lower, upper):\n \"\"\"\n Compute the log of the cumulative distribution function for Discrete uniform distribution\n at the specified value.\n\n Parameters\n ----------\n value: numeric or np.ndarray or aesara.tensor\n Value(s) for which log CDF is calculated. If the log CDF for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor.\n\n Returns\n -------\n TensorVariable\n \"\"\"\n\n return bound(\n at.switch(\n at.lt(value, upper),\n at.log(at.minimum(at.floor(value), upper) - lower + 1) - at.log(upper - lower + 1),\n 0,\n ),\n lower <= value,\n lower <= upper,\n )\n\n\nclass Categorical(Discrete):\n R\"\"\"\n Categorical log-likelihood.\n\n The most general discrete distribution. The pmf of this distribution is\n\n .. math:: f(x \\mid p) = p_x\n\n .. plot::\n\n import matplotlib.pyplot as plt\n import numpy as np\n import scipy.stats as st\n import arviz as az\n plt.style.use('arviz-darkgrid')\n ps = [[0.1, 0.6, 0.3], [0.3, 0.1, 0.1, 0.5]]\n for p in ps:\n x = range(len(p))\n plt.plot(x, p, '-o', label='p = {}'.format(p))\n plt.xlabel('x', fontsize=12)\n plt.ylabel('f(x)', fontsize=12)\n plt.ylim(0)\n plt.legend(loc=1)\n plt.show()\n\n ======== ===================================\n Support :math:`x \\in \\{0, 1, \\ldots, |p|-1\\}`\n ======== ===================================\n\n Parameters\n ----------\n p: array of floats\n p > 0 and the elements of p must sum to 1. They will be automatically\n rescaled otherwise.\n \"\"\"\n rv_op = categorical\n\n @classmethod\n def dist(cls, p, **kwargs):\n\n p = at.as_tensor_variable(floatX(p))\n\n # mode = at.argmax(p, axis=-1)\n # if mode.ndim == 1:\n # mode = at.squeeze(mode)\n\n return super().dist([p], **kwargs)\n\n def logp(value, p):\n r\"\"\"\n Calculate log-probability of Categorical distribution at specified value.\n\n Parameters\n ----------\n value: numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or `TensorVariable`\n\n \"\"\"\n k = at.shape(p)[-1]\n p_ = p\n p = p_ / at.sum(p_, axis=-1, keepdims=True)\n value_clip = at.clip(value, 0, k - 1)\n\n if p.ndim > 1:\n if p.ndim > value_clip.ndim:\n value_clip = at.shape_padleft(value_clip, p_.ndim - value_clip.ndim)\n elif p.ndim < value_clip.ndim:\n p = at.shape_padleft(p, value_clip.ndim - p_.ndim)\n pattern = (p.ndim - 1,) + tuple(range(p.ndim - 1))\n a = at.log(\n take_along_axis(\n p.dimshuffle(pattern),\n value_clip,\n )\n )\n else:\n a = at.log(p[value_clip])\n\n return bound(\n a,\n value >= 0,\n value <= (k - 1),\n at.all(p_ >= 0, axis=-1),\n at.all(p <= 1, axis=-1),\n )\n\n\nclass ConstantRV(RandomVariable):\n name = \"constant\"\n ndim_supp = 0\n ndims_params = [0]\n dtype = \"floatX\" # Should be treated as a discrete variable!\n _print_name = (\"Constant\", \"\\\\operatorname{Constant}\")\n\n @classmethod\n def rng_fn(cls, rng, c, size=None):\n if size is None:\n return c.copy()\n return np.full(size, c)\n\n\nconstant = ConstantRV()\n\n\nclass Constant(Discrete):\n r\"\"\"\n Constant log-likelihood.\n\n Parameters\n ----------\n value: float or int\n Constant parameter.\n \"\"\"\n\n rv_op = constant\n\n @classmethod\n def dist(cls, c, *args, **kwargs):\n c = at.as_tensor_variable(floatX(c))\n return super().dist([c], **kwargs)\n\n def logp(value, c):\n r\"\"\"\n Calculate log-probability of Constant distribution at specified value.\n\n Parameters\n ----------\n value: numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor\n\n Returns\n -------\n TensorVariable\n \"\"\"\n return bound(\n at.zeros_like(value),\n at.eq(value, c),\n )\n\n\nclass ZeroInflatedPoissonRV(RandomVariable):\n name = \"zero_inflated_poisson\"\n ndim_supp = 0\n ndims_params = [0, 0]\n dtype = \"int64\"\n _print_name = (\"ZeroInflatedPois\", \"\\\\operatorname{ZeroInflatedPois}\")\n\n @classmethod\n def rng_fn(cls, rng, psi, lam, size):\n return rng.poisson(lam, size=size) * (rng.random(size=size) < psi)\n\n\nzero_inflated_poisson = ZeroInflatedPoissonRV()\n\n\nclass ZeroInflatedPoisson(Discrete):\n R\"\"\"\n Zero-inflated Poisson log-likelihood.\n\n Often used to model the number of events occurring in a fixed period\n of time when the times at which events occur are independent.\n The pmf of this distribution is\n\n .. math::\n\n f(x \\mid \\psi, \\theta) = \\left\\{ \\begin{array}{l}\n (1-\\psi) + \\psi e^{-\\theta}, \\text{if } x = 0 \\\\\n \\psi \\frac{e^{-\\theta}\\theta^x}{x!}, \\text{if } x=1,2,3,\\ldots\n \\end{array} \\right.\n\n .. plot::\n\n import matplotlib.pyplot as plt\n import numpy as np\n import scipy.stats as st\n import arviz as az\n plt.style.use('arviz-darkgrid')\n x = np.arange(0, 22)\n psis = [0.7, 0.4]\n thetas = [8, 4]\n for psi, theta in zip(psis, thetas):\n pmf = st.poisson.pmf(x, theta)\n pmf[0] = (1 - psi) + pmf[0]\n pmf[1:] = psi * pmf[1:]\n pmf /= pmf.sum()\n plt.plot(x, pmf, '-o', label='$\\\\psi$ = {}, $\\\\theta$ = {}'.format(psi, theta))\n plt.xlabel('x', fontsize=12)\n plt.ylabel('f(x)', fontsize=12)\n plt.legend(loc=1)\n plt.show()\n\n ======== ==========================\n Support :math:`x \\in \\mathbb{N}_0`\n Mean :math:`\\psi\\theta`\n Variance :math:`\\theta + \\frac{1-\\psi}{\\psi}\\theta^2`\n ======== ==========================\n\n Parameters\n ----------\n psi: float\n Expected proportion of Poisson variates (0 < psi < 1)\n theta: float\n Expected number of occurrences during the given interval\n (theta >= 0).\n \"\"\"\n\n rv_op = zero_inflated_poisson\n\n @classmethod\n def dist(cls, psi, theta, *args, **kwargs):\n psi = at.as_tensor_variable(floatX(psi))\n theta = at.as_tensor_variable(floatX(theta))\n return super().dist([psi, theta], *args, **kwargs)\n\n def logp(value, psi, theta):\n r\"\"\"\n Calculate log-probability of ZeroInflatedPoisson distribution at specified value.\n\n Parameters\n ----------\n value: numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor\n\n Returns\n -------\n TensorVariable\n \"\"\"\n\n logp_val = at.switch(\n at.gt(value, 0),\n at.log(psi) + _logprob(poisson, [value], None, None, None, theta),\n at.logaddexp(at.log1p(-psi), at.log(psi) - theta),\n )\n\n return bound(\n logp_val,\n 0 <= value,\n 0 <= psi,\n psi <= 1,\n 0 <= theta,\n )\n\n def logcdf(value, psi, theta):\n \"\"\"\n Compute the log of the cumulative distribution function for ZeroInflatedPoisson distribution\n at the specified value.\n\n Parameters\n ----------\n value: numeric or np.ndarray or aesara.tensor\n Value(s) for which log CDF is calculated. If the log CDF for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor.\n\n Returns\n -------\n TensorVariable\n \"\"\"\n\n return bound(\n at.logaddexp(\n at.log1p(-psi),\n at.log(psi) + _logcdf(poisson, value, {}, theta),\n ),\n 0 <= value,\n 0 <= psi,\n psi <= 1,\n 0 <= theta,\n )\n\n\nclass ZeroInflatedBinomialRV(RandomVariable):\n name = \"zero_inflated_binomial\"\n ndim_supp = 0\n ndims_params = [0, 0, 0]\n dtype = \"int64\"\n _print_name = (\"ZeroInflatedBinom\", \"\\\\operatorname{ZeroInflatedBinom}\")\n\n @classmethod\n def rng_fn(cls, rng, psi, n, p, size):\n return rng.binomial(n=n, p=p, size=size) * (rng.random(size=size) < psi)\n\n\nzero_inflated_binomial = ZeroInflatedBinomialRV()\n\n\nclass ZeroInflatedBinomial(Discrete):\n R\"\"\"\n Zero-inflated Binomial log-likelihood.\n\n The pmf of this distribution is\n\n .. math::\n\n f(x \\mid \\psi, n, p) = \\left\\{ \\begin{array}{l}\n (1-\\psi) + \\psi (1-p)^{n}, \\text{if } x = 0 \\\\\n \\psi {n \\choose x} p^x (1-p)^{n-x}, \\text{if } x=1,2,3,\\ldots,n\n \\end{array} \\right.\n\n .. plot::\n\n import matplotlib.pyplot as plt\n import numpy as np\n import scipy.stats as st\n import arviz as az\n plt.style.use('arviz-darkgrid')\n x = np.arange(0, 25)\n ns = [10, 20]\n ps = [0.5, 0.7]\n psis = [0.7, 0.4]\n for n, p, psi in zip(ns, ps, psis):\n pmf = st.binom.pmf(x, n, p)\n pmf[0] = (1 - psi) + pmf[0]\n pmf[1:] = psi * pmf[1:]\n pmf /= pmf.sum()\n plt.plot(x, pmf, '-o', label='n = {}, p = {}, $\\\\psi$ = {}'.format(n, p, psi))\n plt.xlabel('x', fontsize=12)\n plt.ylabel('f(x)', fontsize=12)\n plt.legend(loc=1)\n plt.show()\n\n ======== ==========================\n Support :math:`x \\in \\mathbb{N}_0`\n Mean :math:`(1 - \\psi) n p`\n Variance :math:`(1-\\psi) n p [1 - p(1 - \\psi n)].`\n ======== ==========================\n\n Parameters\n ----------\n psi: float\n Expected proportion of Binomial variates (0 < psi < 1)\n n: int\n Number of Bernoulli trials (n >= 0).\n p: float\n Probability of success in each trial (0 < p < 1).\n\n \"\"\"\n\n rv_op = zero_inflated_binomial\n\n @classmethod\n def dist(cls, psi, n, p, *args, **kwargs):\n psi = at.as_tensor_variable(floatX(psi))\n n = at.as_tensor_variable(intX(n))\n p = at.as_tensor_variable(floatX(p))\n return super().dist([psi, n, p], *args, **kwargs)\n\n def logp(value, psi, n, p):\n r\"\"\"\n Calculate log-probability of ZeroInflatedBinomial distribution at specified value.\n\n Parameters\n ----------\n value: numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor\n\n Returns\n -------\n TensorVariable\n \"\"\"\n\n logp_val = at.switch(\n at.gt(value, 0),\n at.log(psi) + _logprob(binomial, [value], None, None, None, n, p),\n at.logaddexp(at.log1p(-psi), at.log(psi) + n * at.log1p(-p)),\n )\n\n return bound(\n logp_val,\n 0 <= value,\n value <= n,\n 0 <= psi,\n psi <= 1,\n 0 <= p,\n p <= 1,\n )\n\n def logcdf(value, psi, n, p):\n \"\"\"\n Compute the log of the cumulative distribution function for ZeroInflatedBinomial distribution\n at the specified value.\n\n Parameters\n ----------\n value: numeric or np.ndarray or aesara.tensor\n Value(s) for which log CDF is calculated. If the log CDF for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor.\n\n Returns\n -------\n TensorVariable\n \"\"\"\n\n return bound(\n at.logaddexp(\n at.log1p(-psi),\n at.log(psi) + _logcdf(binomial, value, {}, n, p),\n ),\n 0 <= value,\n value <= n,\n 0 <= psi,\n psi <= 1,\n 0 <= p,\n p <= 1,\n )\n\n\nclass ZeroInflatedNegBinomialRV(RandomVariable):\n name = \"zero_inflated_neg_binomial\"\n ndim_supp = 0\n ndims_params = [0, 0, 0]\n dtype = \"int64\"\n _print_name = (\n \"ZeroInflatedNegBinom\",\n \"\\\\operatorname{ZeroInflatedNegBinom}\",\n )\n\n @classmethod\n def rng_fn(cls, rng, psi, n, p, size):\n return rng.negative_binomial(n=n, p=p, size=size) * (rng.random(size=size) < psi)\n\n\nzero_inflated_neg_binomial = ZeroInflatedNegBinomialRV()\n\n\nclass ZeroInflatedNegativeBinomial(Discrete):\n R\"\"\"\n Zero-Inflated Negative binomial log-likelihood.\n\n The Zero-inflated version of the Negative Binomial (NB).\n The NB distribution describes a Poisson random variable\n whose rate parameter is gamma distributed.\n The pmf of this distribution is\n\n .. math::\n\n f(x \\mid \\psi, \\mu, \\alpha) = \\left\\{\n \\begin{array}{l}\n (1-\\psi) + \\psi \\left (\n \\frac{\\alpha}{\\alpha+\\mu}\n \\right) ^\\alpha, \\text{if } x = 0 \\\\\n \\psi \\frac{\\Gamma(x+\\alpha)}{x! \\Gamma(\\alpha)} \\left (\n \\frac{\\alpha}{\\mu+\\alpha}\n \\right)^\\alpha \\left(\n \\frac{\\mu}{\\mu+\\alpha}\n \\right)^x, \\text{if } x=1,2,3,\\ldots\n \\end{array}\n \\right.\n\n .. plot::\n\n import matplotlib.pyplot as plt\n import numpy as np\n import scipy.stats as st\n from scipy import special\n import arviz as az\n plt.style.use('arviz-darkgrid')\n\n def ZeroInfNegBinom(a, m, psi, x):\n pmf = special.binom(x + a - 1, x) * (a / (m + a))**a * (m / (m + a))**x\n pmf[0] = (1 - psi) + pmf[0]\n pmf[1:] = psi * pmf[1:]\n pmf /= pmf.sum()\n return pmf\n\n x = np.arange(0, 25)\n alphas = [2, 4]\n mus = [2, 8]\n psis = [0.7, 0.7]\n for a, m, psi in zip(alphas, mus, psis):\n pmf = ZeroInfNegBinom(a, m, psi, x)\n plt.plot(x, pmf, '-o', label=r'$\\alpha$ = {}, $\\mu$ = {}, $\\psi$ = {}'.format(a, m, psi))\n plt.xlabel('x', fontsize=12)\n plt.ylabel('f(x)', fontsize=12)\n plt.legend(loc=1)\n plt.show()\n\n ======== ==========================\n Support :math:`x \\in \\mathbb{N}_0`\n Mean :math:`\\psi\\mu`\n Var :math:`\\psi\\mu + \\left (1 + \\frac{\\mu}{\\alpha} + \\frac{1-\\psi}{\\mu} \\right)`\n ======== ==========================\n\n Parameters\n ----------\n psi: float\n Expected proportion of NegativeBinomial variates (0 < psi < 1)\n mu: float\n Poission distribution parameter (mu > 0).\n alpha: float\n Gamma distribution parameter (alpha > 0).\n\n \"\"\"\n\n rv_op = zero_inflated_neg_binomial\n\n @classmethod\n def dist(cls, psi, mu, alpha, *args, **kwargs):\n psi = at.as_tensor_variable(floatX(psi))\n n, p = NegativeBinomial.get_n_p(mu=mu, alpha=alpha)\n n = at.as_tensor_variable(floatX(n))\n p = at.as_tensor_variable(floatX(p))\n return super().dist([psi, n, p], *args, **kwargs)\n\n def logp(value, psi, n, p):\n r\"\"\"\n Calculate log-probability of ZeroInflatedNegativeBinomial distribution at specified value.\n\n Parameters\n ----------\n value: numeric\n Value(s) for which log-probability is calculated. If the log probabilities for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor\n\n Returns\n -------\n TensorVariable\n \"\"\"\n\n return bound(\n at.switch(\n at.gt(value, 0),\n at.log(psi) + _logprob(nbinom, [value], None, None, None, n, p),\n at.logaddexp(at.log1p(-psi), at.log(psi) + n * at.log(p)),\n ),\n 0 <= value,\n 0 <= psi,\n psi <= 1,\n 0 < n,\n 0 <= p,\n p <= 1,\n )\n\n def logcdf(value, psi, n, p):\n \"\"\"\n Compute the log of the cumulative distribution function for ZeroInflatedNegativeBinomial distribution\n at the specified value.\n\n Parameters\n ----------\n value: numeric or np.ndarray or aesara.tensor\n Value(s) for which log CDF is calculated. If the log CDF for multiple\n values are desired the values must be provided in a numpy array or Aesara tensor.\n\n Returns\n -------\n TensorVariable\n \"\"\"\n return bound(\n at.logaddexp(at.log1p(-psi), at.log(psi) + _logcdf(nbinom, value, {}, n, p)),\n 0 <= value,\n 0 <= psi,\n psi <= 1,\n 0 < p,\n p <= 1,\n )\n\n\nclass _OrderedLogistic(Categorical):\n r\"\"\"\n Underlying class for ordered logistic distributions.\n See docs for the OrderedLogistic wrapper class for more details on how to use it in models.\n \"\"\"\n rv_op = categorical\n\n @classmethod\n def dist(cls, eta, cutpoints, *args, **kwargs):\n eta = at.as_tensor_variable(floatX(eta))\n cutpoints = at.as_tensor_variable(cutpoints)\n\n pa = sigmoid(cutpoints - at.shape_padright(eta))\n p_cum = at.concatenate(\n [\n at.zeros_like(at.shape_padright(pa[..., 0])),\n pa,\n at.ones_like(at.shape_padright(pa[..., 0])),\n ],\n axis=-1,\n )\n p = p_cum[..., 1:] - p_cum[..., :-1]\n\n return super().dist(p, *args, **kwargs)\n\n\nclass OrderedLogistic:\n R\"\"\"\n Wrapper class for Ordered Logistic distributions.\n\n Useful for regression on ordinal data values whose values range\n from 1 to K as a function of some predictor, :math:`\\eta`. The\n cutpoints, :math:`c`, separate which ranges of :math:`\\eta` are\n mapped to which of the K observed dependent variables. The number\n of cutpoints is K - 1. It is recommended that the cutpoints are\n constrained to be ordered.\n\n .. math::\n\n f(k \\mid \\eta, c) = \\left\\{\n \\begin{array}{l}\n 1 - \\text{logit}^{-1}(\\eta - c_1)\n \\,, \\text{if } k = 0 \\\\\n \\text{logit}^{-1}(\\eta - c_{k - 1}) -\n \\text{logit}^{-1}(\\eta - c_{k})\n \\,, \\text{if } 0 < k < K \\\\\n \\text{logit}^{-1}(\\eta - c_{K - 1})\n \\,, \\text{if } k = K \\\\\n \\end{array}\n \\right.\n\n Parameters\n ----------\n eta: float\n The predictor.\n cutpoints: array\n The length K - 1 array of cutpoints which break :math:`\\eta` into\n ranges. Do not explicitly set the first and last elements of\n :math:`c` to negative and positive infinity.\n compute_p: boolean, default True\n Whether to compute and store in the trace the inferred probabilities of each categories,\n based on the cutpoints' values. Defaults to True.\n Might be useful to disable it if memory usage is of interest.\n\n Examples\n --------\n\n .. code-block:: python\n\n # Generate data for a simple 1 dimensional example problem\n n1_c = 300; n2_c = 300; n3_c = 300\n cluster1 = np.random.randn(n1_c) + -1\n cluster2 = np.random.randn(n2_c) + 0\n cluster3 = np.random.randn(n3_c) + 2\n\n x = np.concatenate((cluster1, cluster2, cluster3))\n y = np.concatenate((1*np.ones(n1_c),\n 2*np.ones(n2_c),\n 3*np.ones(n3_c))) - 1\n\n # Ordered logistic regression\n with pm.Model() as model:\n cutpoints = pm.Normal(\"cutpoints\", mu=[-1,1], sigma=10, shape=2,\n transform=pm.distributions.transforms.ordered)\n y_ = pm.OrderedLogistic(\"y\", cutpoints=cutpoints, eta=x, observed=y)\n idata = pm.sample()\n\n # Plot the results\n plt.hist(cluster1, 30, alpha=0.5);\n plt.hist(cluster2, 30, alpha=0.5);\n plt.hist(cluster3, 30, alpha=0.5);\n posterior = idata.posterior.stack(sample=(\"chain\", \"draw\"))\n plt.hist(posterior[\"cutpoints\"][0], 80, alpha=0.2, color='k');\n plt.hist(posterior[\"cutpoints\"][1], 80, alpha=0.2, color='k');\n \"\"\"\n\n def __new__(cls, name, *args, compute_p=True, **kwargs):\n out_rv = _OrderedLogistic(name, *args, **kwargs)\n if compute_p:\n pm.Deterministic(f\"{name}_probs\", out_rv.owner.inputs[3], dims=kwargs.get(\"dims\"))\n return out_rv\n\n @classmethod\n def dist(cls, *args, **kwargs):\n return _OrderedLogistic.dist(*args, **kwargs)\n\n\nclass _OrderedProbit(Categorical):\n r\"\"\"\n Underlying class for ordered probit distributions.\n See docs for the OrderedProbit wrapper class for more details on how to use it in models.\n \"\"\"\n rv_op = categorical\n\n @classmethod\n def dist(cls, eta, cutpoints, *args, **kwargs):\n eta = at.as_tensor_variable(floatX(eta))\n cutpoints = at.as_tensor_variable(cutpoints)\n\n probits = at.shape_padright(eta) - cutpoints\n _log_p = at.concatenate(\n [\n at.shape_padright(normal_lccdf(0, 1, probits[..., 0])),\n log_diff_normal_cdf(0, 1, probits[..., :-1], probits[..., 1:]),\n at.shape_padright(normal_lcdf(0, 1, probits[..., -1])),\n ],\n axis=-1,\n )\n _log_p = at.as_tensor_variable(floatX(_log_p))\n p = at.exp(_log_p)\n\n return super().dist(p, *args, **kwargs)\n\n\nclass OrderedProbit:\n R\"\"\"\n Wrapper class for Ordered Probit distributions.\n\n Useful for regression on ordinal data values whose values range\n from 1 to K as a function of some predictor, :math:`\\eta`. The\n cutpoints, :math:`c`, separate which ranges of :math:`\\eta` are\n mapped to which of the K observed dependent variables. The number\n of cutpoints is K - 1. It is recommended that the cutpoints are\n constrained to be ordered.\n\n In order to stabilize the computation, log-likelihood is computed\n in log space using the scaled error function `erfcx`.\n\n .. math::\n\n f(k \\mid \\eta, c) = \\left\\{\n \\begin{array}{l}\n 1 - \\text{normal_cdf}(0, \\sigma, \\eta - c_1)\n \\,, \\text{if } k = 0 \\\\\n \\text{normal_cdf}(0, \\sigma, \\eta - c_{k - 1}) -\n \\text{normal_cdf}(0, \\sigma, \\eta - c_{k})\n \\,, \\text{if } 0 < k < K \\\\\n \\text{normal_cdf}(0, \\sigma, \\eta - c_{K - 1})\n \\,, \\text{if } k = K \\\\\n \\end{array}\n \\right.\n\n Parameters\n ----------\n eta: float\n The predictor.\n cutpoints: array\n The length K - 1 array of cutpoints which break :math:`\\eta` into\n ranges. Do not explicitly set the first and last elements of\n :math:`c` to negative and positive infinity.\n compute_p: boolean, default True\n Whether to compute and store in the trace the inferred probabilities of each categories,\n based on the cutpoints' values. Defaults to True.\n Might be useful to disable it if memory usage is of interest.\n sigma: float\n The standard deviation of probit function.\n Example\n --------\n .. code:: python\n\n # Generate data for a simple 1 dimensional example problem\n n1_c = 300; n2_c = 300; n3_c = 300\n cluster1 = np.random.randn(n1_c) + -1\n cluster2 = np.random.randn(n2_c) + 0\n cluster3 = np.random.randn(n3_c) + 2\n\n x = np.concatenate((cluster1, cluster2, cluster3))\n y = np.concatenate((1*np.ones(n1_c),\n 2*np.ones(n2_c),\n 3*np.ones(n3_c))) - 1\n\n # Ordered probit regression\n with pm.Model() as model:\n cutpoints = pm.Normal(\"cutpoints\", mu=[-1,1], sigma=10, shape=2,\n transform=pm.distributions.transforms.ordered)\n y_ = pm.OrderedProbit(\"y\", cutpoints=cutpoints, eta=x, observed=y)\n idata = pm.sample()\n\n # Plot the results\n plt.hist(cluster1, 30, alpha=0.5);\n plt.hist(cluster2, 30, alpha=0.5);\n plt.hist(cluster3, 30, alpha=0.5);\n posterior = idata.posterior.stack(sample=(\"chain\", \"draw\"))\n plt.hist(posterior[\"cutpoints\"][0], 80, alpha=0.2, color='k');\n plt.hist(posterior[\"cutpoints\"][1], 80, alpha=0.2, color='k');\n \"\"\"\n\n def __new__(cls, name, *args, compute_p=True, **kwargs):\n out_rv = _OrderedProbit(name, *args, **kwargs)\n if compute_p:\n pm.Deterministic(f\"{name}_probs\", out_rv.owner.inputs[3], dims=kwargs.get(\"dims\"))\n return out_rv\n\n @classmethod\n def dist(cls, *args, **kwargs):\n return _OrderedProbit.dist(*args, **kwargs)\n"
] |
[
[
"numpy.ndim",
"numpy.log",
"scipy.stats.randint.rvs",
"numpy.full"
]
] |
utda/piranesi
|
[
"28c41334fdc7df44bd1b892542eb0423edd13013"
] |
[
"batch/create_print_collection.py"
] |
[
"import pandas as pd\nfrom rdflib import URIRef, BNode, Literal, Graph\nfrom rdflib.namespace import RDF, RDFS, FOAF, XSD\nfrom rdflib import Namespace\nimport numpy as np\nimport math\nimport sys\nimport argparse\nimport json\nimport html\n\n\ndef read_excel(path):\n df = pd.read_excel(path, sheet_name=0, header=None, index_col=None)\n\n r_count = len(df.index)\n c_count = len(df.columns)\n\n map = {}\n\n for i in range(0, c_count):\n label = df.iloc[0, i]\n map[i] = label\n\n data = {}\n\n for j in range(1, r_count):\n id = df.iloc[j, 0]\n data[id] = []\n\n for i in map:\n value = df.iloc[j, i]\n\n if not pd.isnull(value) and value != 0:\n data[int(id)].append({\n \"label\": map[i],\n \"value\": html.unescape(str(value))\n })\n\n return data\n\n\ndef read_excel2(path):\n df = pd.read_excel(path, sheet_name=0, header=None, index_col=None)\n\n r_count = len(df.index)\n\n map = {}\n\n for j in range(2, r_count):\n\n value = df.iloc[j, 25]\n if not pd.isnull(value) and value != 0:\n uuid = df.iloc[j, 56]\n\n map[int(value)] = {\n \"uuid\": uuid,\n \"thumbnail\": df.iloc[j, 60]\n }\n\n return map\n\n\npath = \"data/sougouwebcp.xlsx\"\ndata1 = read_excel(path)\n\n# print(data1)\ndata2 = read_excel2(\"data/data.xlsx\")\n\nmanifests = []\n\nfor key in data2:\n\n uuid = data2[key][\"uuid\"]\n\n manifests.append(\n {\n \"@id\": \"https://iiif.dl.itc.u-tokyo.ac.jp/repo/iiif/\"+uuid+\"/manifest\",\n \"@type\": \"sc:Manifest\",\n \"label\": str(key),\n \"license\": \"http://creativecommons.org/publicdomain/zero/1.0/\",\n \"thumbnail\": data2[key][\"thumbnail\"],\n \"metadata\" : data1[key]\n }\n )\n\ncollection = {\n \"@context\": \"http://iiif.io/api/presentation/2/context.json\",\n \"@id\": \"https://nakamura196.github.io/piranesi/print/iiif/top.json\",\n \"label\": \"ピラネージ\",\n \"@type\": \"sc:Collection\",\n \"manifests\": manifests\n}\n\nwith open(\"../docs/print/iiif/top.json\", 'w') as f:\n json.dump(collection, f, ensure_ascii=False, indent=4,\n sort_keys=True, separators=(',', ': '))"
] |
[
[
"pandas.read_excel",
"pandas.isnull"
]
] |
r7vme/sdsandbox
|
[
"701646f542ae1f55fa68198b8600e872e7497810"
] |
[
"src/donkey_gym/donkey_gym/envs/donkey_sim.py"
] |
[
"'''\r\nfile: donkey_sim.py\r\nauthor: Tawn Kramer\r\ndate: 2018-08-31\r\n'''\r\n\r\nimport os\r\nimport json\r\nimport shutil\r\nimport base64\r\nimport random\r\nimport time\r\nfrom io import BytesIO\r\nimport math\r\nfrom threading import Thread\r\n\r\nimport numpy as np\r\nfrom PIL import Image\r\nfrom io import BytesIO\r\nimport base64\r\nimport datetime\r\nimport asyncore\r\n\r\nfrom donkey_gym.core.fps import FPSTimer\r\nfrom donkey_gym.core.tcp_server import IMesgHandler, SimServer\r\n\r\n\r\nclass DonkeyUnitySimContoller():\r\n\r\n #cross track error max\r\n CTE_MAX_ERR = 5.0\r\n\r\n def __init__(self, level, time_step=0.05, port=9090):\r\n self.level = level\r\n self.time_step = time_step\r\n self.verbose = False\r\n self.wait_time_for_obs = 0.1\r\n\r\n # sensor size - height, width, depth\r\n self.camera_img_size=(80, 160, 3)\r\n\r\n self.address = ('0.0.0.0', port)\r\n\r\n self.handler = DonkeyUnitySimHandler(level, time_step=time_step)\r\n self.server = SimServer(self.address, self.handler)\r\n\r\n self.thread = Thread(target=asyncore.loop)\r\n self.thread.daemon = True\r\n self.thread.start()\r\n\r\n def wait_until_loaded(self):\r\n while not self.handler.loaded:\r\n print(\"waiting to load..\")\r\n time.sleep(3.0)\r\n\r\n def reset(self):\r\n self.handler.reset()\r\n\r\n def get_sensor_size(self):\r\n return self.handler.get_sensor_size()\r\n\r\n def take_action(self, action):\r\n self.handler.take_action(action)\r\n\r\n def observe(self):\r\n return self.handler.observe()\r\n\r\n def quit(self):\r\n pass\r\n\r\n def render(self, mode):\r\n pass\r\n\r\n def is_game_over(self):\r\n return self.handler.is_game_over()\r\n\r\n def calc_reward(self, done):\r\n return self.handler.calc_reward(done)\r\n\r\n\r\nclass DonkeyUnitySimHandler(IMesgHandler):\r\n\r\n #cross track error max\r\n CTE_MAX_ERR = 5.0\r\n FPS = 60.0\r\n\r\n def __init__(self, level, time_step=0.05):\r\n self.iSceneToLoad = level\r\n self.time_step = time_step\r\n self.wait_time_for_obs = 0.1\r\n self.sock = None\r\n self.loaded = False\r\n self.verbose = False\r\n self.timer = FPSTimer()\r\n\r\n # sensor size - height, width, depth\r\n self.camera_img_size=(80, 160, 3)\r\n self.image_array = np.zeros(self.camera_img_size)\r\n self.last_obs = None\r\n self.last_throttle = None\r\n self.hit = \"none\"\r\n self.cte = 0.0\r\n self.x = 0.0\r\n self.y = 0.0\r\n self.z = 0.0\r\n\r\n self.fns = {'telemetry' : self.on_telemetry,\r\n \"scene_selection_ready\" : self.on_scene_selection_ready,\r\n \"scene_names\": self.on_recv_scene_names,\r\n \"car_loaded\" : self.on_car_loaded }\r\n\r\n def on_connect(self, socketHandler):\r\n self.sock = socketHandler\r\n\r\n def on_disconnect(self):\r\n self.sock = None\r\n\r\n def on_recv_message(self, message):\r\n if not 'msg_type' in message:\r\n print('expected msg_type field')\r\n return\r\n\r\n msg_type = message['msg_type']\r\n if msg_type in self.fns:\r\n self.fns[msg_type](message)\r\n else:\r\n print('unknown message type', msg_type)\r\n\r\n ## ------- Env interface ---------- ##\r\n\r\n def reset(self):\r\n if self.verbose:\r\n print(\"reseting\")\r\n self.image_array = np.zeros(self.camera_img_size)\r\n self.last_obs = None\r\n self.hit = \"none\"\r\n self.cte = 0.0\r\n self.x = 0.0\r\n self.y = 0.0\r\n self.z = 0.0\r\n self.send_reset_car()\r\n time.sleep(1.0)\r\n self.timer.reset()\r\n\r\n def get_sensor_size(self):\r\n return self.camera_img_size\r\n\r\n def take_action(self, action):\r\n if self.verbose:\r\n print(\"take_action\")\r\n\r\n # Static throttle\r\n action[1] = 0.5\r\n self.last_throttle = action[1]\r\n\r\n self.send_control(action[0], action[1])\r\n\r\n def observe(self):\r\n while self.last_obs is self.image_array:\r\n time.sleep(1.0 / 120.0)\r\n\r\n self.last_obs = self.image_array\r\n observation = self.image_array\r\n done = self.is_game_over()\r\n reward = self.calc_reward(done)\r\n info = {}\r\n\r\n self.timer.on_frame()\r\n\r\n return observation, reward, done, info\r\n\r\n\r\n def is_game_over(self):\r\n return self.hit != \"none\" or math.fabs(self.cte) > self.CTE_MAX_ERR\r\n\r\n ## ------ RL interface ----------- ##\r\n\r\n # Use velocity (m/s) as reward for every step,\r\n # except when episode done (failed).\r\n def calc_reward(self, done):\r\n if done:\r\n return 0.0\r\n\r\n velocity = self.last_throttle * (1.0 / self.FPS)\r\n return velocity\r\n\r\n\r\n ## ------ Socket interface ----------- ##\r\n\r\n def on_telemetry(self, data):\r\n imgString = data[\"image\"]\r\n image = Image.open(BytesIO(base64.b64decode(imgString)))\r\n # Crop to the zone of interest - remove top third.\r\n # Crop image to size 80x160x3.\r\n self.image_array = np.delete(np.asarray(image), np.s_[0:40:], axis=0)\r\n\r\n #name of object we just hit. \"none\" if nothing.\r\n if self.hit == \"none\":\r\n self.hit = data[\"hit\"]\r\n\r\n self.x = data[\"pos_x\"]\r\n self.y = data[\"pos_y\"]\r\n self.z = data[\"pos_z\"]\r\n\r\n #Cross track error not always present.\r\n #Will be missing if path is not setup in the given scene.\r\n #It should be setup in the 3 scenes available now.\r\n try:\r\n self.cte = data[\"cte\"]\r\n except:\r\n pass\r\n\r\n def on_scene_selection_ready(self, data):\r\n print(\"SceneSelectionReady \")\r\n self.send_get_scene_names()\r\n\r\n def on_car_loaded(self, data):\r\n if self.verbose:\r\n print(\"car loaded\")\r\n self.loaded = True\r\n\r\n def on_recv_scene_names(self, data):\r\n if data:\r\n names = data['scene_names']\r\n if self.verbose:\r\n print(\"SceneNames:\", names)\r\n self.send_load_scene(names[self.iSceneToLoad])\r\n\r\n def send_control(self, steer, throttle):\r\n if not self.loaded:\r\n return\r\n msg = { 'msg_type' : 'control', 'steering': steer.__str__(), 'throttle':throttle.__str__(), 'brake': '0.0' }\r\n self.queue_message(msg) \r\n \r\n def send_reset_car(self):\r\n msg = { 'msg_type' : 'reset_car' }\r\n self.queue_message(msg)\r\n\r\n def send_get_scene_names(self):\r\n msg = { 'msg_type' : 'get_scene_names' }\r\n self.queue_message(msg)\r\n\r\n def send_load_scene(self, scene_name):\r\n msg = { 'msg_type' : 'load_scene', 'scene_name' : scene_name }\r\n self.queue_message(msg)\r\n\r\n def queue_message(self, msg):\r\n if self.sock is None:\r\n if self.verbose:\r\n print('skiping:', msg)\r\n return\r\n \r\n if self.verbose:\r\n print('sending', msg)\r\n self.sock.queue_message(msg)\r\n"
] |
[
[
"numpy.asarray",
"numpy.zeros"
]
] |
LonelyQuantum/SQuADPractice
|
[
"3c2d3c47bce08079d60596dc76668b2b458f0a48"
] |
[
"models.py"
] |
[
"\"\"\"Top-level model classes.\n\nAuthor:\n Chris Chute ([email protected])\n\"\"\"\n\nimport layers\nimport torch\nimport torch.nn as nn\n\n\nclass BiDAF_CW(nn.Module):\n \"\"\"BiDAF model with Character Embedding for SQuAD.\n\n Based on the paper:\n \"Bidirectional Attention Flow for Machine Comprehension\"\n by Minjoon Seo, Aniruddha Kembhavi, Ali Farhadi, Hannaneh Hajishirzi\n (https://arxiv.org/abs/1611.01603).\n\n Follows a high-level structure commonly found in SQuAD models:\n - Embedding layer: Embed word and character indices to get word vectors.\n - Encoder layer: Encode the embedded sequence.\n - Attention layer: Apply an attention mechanism to the encoded sequence.\n - Model encoder layer: Encode the sequence again.\n - Output layer: Simple layer (e.g., fc + softmax) to get final outputs.\n\n Args:\n word_vectors (torch.Tensor): Pre-trained word vectors.\n char_vectors (torch.Tensor): Pre-trained character vectors.\n hidden_size (int): Number of features in the hidden state at each layer.\n drop_prob (float): Dropout probability.\n \"\"\"\n def __init__(self, word_vectors, char_vectors, char_cnn_output_size, hidden_size, drop_prob=0.):\n super(BiDAF_CW, self).__init__()\n self.emb = layers.Embedding_CW(word_vectors=word_vectors,\n char_vectors=char_vectors,\n char_cnn_output_size=char_cnn_output_size,\n hidden_size=hidden_size,\n drop_prob=drop_prob)\n\n self.enc = layers.RNNEncoder(input_size=hidden_size,\n hidden_size=hidden_size,\n num_layers=1,\n drop_prob=drop_prob)\n\n self.att = layers.BiDAFAttention(hidden_size=2 * hidden_size,\n drop_prob=drop_prob)\n\n self.mod = layers.RNNEncoder(input_size=8 * hidden_size,\n hidden_size=hidden_size,\n num_layers=2,\n drop_prob=drop_prob)\n\n self.out = layers.BiDAFOutput(hidden_size=hidden_size,\n drop_prob=drop_prob)\n\n def forward(self, cw_idxs, cc_idxs, qw_idxs, qc_idxs):\n c_mask = torch.zeros_like(cw_idxs) != cw_idxs\n q_mask = torch.zeros_like(qw_idxs) != qw_idxs\n c_len, q_len = c_mask.sum(-1), q_mask.sum(-1)\n\n c_emb = self.emb(cw_idxs, cc_idxs) # (batch_size, c_len, hidden_size)\n q_emb = self.emb(qw_idxs, qc_idxs) # (batch_size, q_len, hidden_size)\n\n c_enc = self.enc(c_emb, c_len) # (batch_size, c_len, 2 * hidden_size)\n q_enc = self.enc(q_emb, q_len) # (batch_size, q_len, 2 * hidden_size)\n\n att = self.att(c_enc, q_enc,\n c_mask, q_mask) # (batch_size, c_len, 8 * hidden_size)\n\n mod = self.mod(att, c_len) # (batch_size, c_len, 2 * hidden_size)\n\n out = self.out(att, mod, c_mask) # 2 tensors, each (batch_size, c_len)\n\n return out\n\nclass BiDAF_W(nn.Module):\n \"\"\"Baseline BiDAF model for SQuAD.\n\n Based on the paper:\n \"Bidirectional Attention Flow for Machine Comprehension\"\n by Minjoon Seo, Aniruddha Kembhavi, Ali Farhadi, Hannaneh Hajishirzi\n (https://arxiv.org/abs/1611.01603).\n\n Follows a high-level structure commonly found in SQuAD models:\n - Embedding layer: Embed word and character indices to get word vectors.\n - Encoder layer: Encode the embedded sequence.\n - Attention layer: Apply an attention mechanism to the encoded sequence.\n - Model encoder layer: Encode the sequence again.\n - Output layer: Simple layer (e.g., fc + softmax) to get final outputs.\n\n Args:\n word_vectors (torch.Tensor): Pre-trained word vectors.\n hidden_size (int): Number of features in the hidden state at each layer.\n drop_prob (float): Dropout probability.\n \"\"\"\n def __init__(self, word_vectors, hidden_size, drop_prob=0.):\n super(BiDAF_W, self).__init__()\n self.emb = layers.Embedding_W(word_vectors=word_vectors,\n hidden_size=hidden_size,\n drop_prob=drop_prob)\n\n self.enc = layers.RNNEncoder(input_size=hidden_size,\n hidden_size=hidden_size,\n num_layers=1,\n drop_prob=drop_prob)\n\n self.att = layers.BiDAFAttention(hidden_size=2 * hidden_size,\n drop_prob=drop_prob)\n\n self.mod = layers.RNNEncoder(input_size=8 * hidden_size,\n hidden_size=hidden_size,\n num_layers=2,\n drop_prob=drop_prob)\n\n self.out = layers.BiDAFOutput(hidden_size=hidden_size,\n drop_prob=drop_prob)\n\n def forward(self, cw_idxs, cc_idxs, qw_idxs, qc_idxs):\n c_mask = torch.zeros_like(cw_idxs) != cw_idxs\n q_mask = torch.zeros_like(qw_idxs) != qw_idxs\n c_len, q_len = c_mask.sum(-1), q_mask.sum(-1)\n\n c_emb = self.emb(cw_idxs) # (batch_size, c_len, hidden_size)\n q_emb = self.emb(qw_idxs) # (batch_size, q_len, hidden_size)\n\n c_enc = self.enc(c_emb, c_len) # (batch_size, c_len, 2 * hidden_size)\n q_enc = self.enc(q_emb, q_len) # (batch_size, q_len, 2 * hidden_size)\n\n att = self.att(c_enc, q_enc,\n c_mask, q_mask) # (batch_size, c_len, 8 * hidden_size)\n\n mod = self.mod(att, c_len) # (batch_size, c_len, 2 * hidden_size)\n\n out = self.out(att, mod, c_mask) # 2 tensors, each (batch_size, c_len)\n\n return out\n\nclass DCN_W(nn.Module):\n \"\"\"Baseline DCN model for SQuAD.\n\n Based on the paper:\n \"Dynamic Coattention Networks For Question Answering\"\n by Caiming Xiong, Victor Zhong, Richard Socher\n (https://arxiv.org/abs/1611.01604).\n\n Follows a high-level structure commonly found in SQuAD models:\n - Embedding layer: Embed word and character indices to get word vectors.\n - Encoder layer: Encode the embedded sequence.\n - Attention layer: Apply an attention mechanism to the encoded sequence.\n - Model encoder layer: Encode the sequence again.\n - Output layer: Simple layer (e.g., fc + softmax) to get final outputs.\n\n Args:\n word_vectors (torch.Tensor): Pre-trained word vectors.\n hidden_size (int): Number of features in the hidden state at each layer.\n drop_prob (float): Dropout probability.\n \"\"\"\n def __init__(self, word_vectors, hidden_size, drop_prob=0.):\n super(DCN_W, self).__init__()\n self.emb = layers.Embedding_W(word_vectors=word_vectors,\n hidden_size=hidden_size,\n drop_prob=drop_prob)\n\n self.enc = layers.RNNEncoder(input_size=hidden_size,\n hidden_size=hidden_size,\n num_layers=1,\n drop_prob=drop_prob)\n\n self.att = layers.CoAttention(hidden_size=2 * hidden_size,\n drop_prob=drop_prob)\n\n self.mod = layers.RNNEncoder(input_size=8 * hidden_size,\n hidden_size=hidden_size,\n num_layers=2,\n drop_prob=drop_prob)\n\n self.out = layers.BiDAFOutput(hidden_size=hidden_size,\n drop_prob=drop_prob)\n\n def forward(self, cw_idxs, cc_idxs, qw_idxs, qc_idxs):\n c_mask = torch.zeros_like(cw_idxs) != cw_idxs\n q_mask = torch.zeros_like(qw_idxs) != qw_idxs\n c_len, q_len = c_mask.sum(-1), q_mask.sum(-1)\n\n c_emb = self.emb(cw_idxs) # (batch_size, c_len, hidden_size)\n q_emb = self.emb(qw_idxs) # (batch_size, q_len, hidden_size)\n\n c_enc = self.enc(c_emb, c_len) # (batch_size, c_len, 2 * hidden_size)\n q_enc = self.enc(q_emb, q_len) # (batch_size, q_len, 2 * hidden_size)\n\n att = self.att(c_enc, q_enc,\n c_mask, q_mask) # (batch_size, c_len, 8 * hidden_size)\n\n mod = self.mod(att, c_len) # (batch_size, c_len, 2 * hidden_size)\n\n out = self.out(att, mod, c_mask) # 2 tensors, each (batch_size, c_len)\n\n return out"
] |
[
[
"torch.zeros_like"
]
] |
MatthiasJReisinger/addnn
|
[
"1d68648e81faf478cfb1f7d9a3f944a014fa3867"
] |
[
"src/addnn/dataset.py"
] |
[
"import functools\nimport multiprocessing\nimport os\nimport torch\nimport torchvision\nimport torchvision.datasets\nimport torch.utils.data\nfrom torch.utils.data import DataLoader\nfrom torchvision import transforms\nfrom typing import Callable, Iterable, List, Optional, Tuple\n\n\nclass Dataset:\n def __init__(self,\n train_set_constructor: Callable[..., torch.utils.data.Dataset],\n test_set_constructor: Callable[..., torch.utils.data.Dataset],\n input_size: Iterable[int],\n num_classes: int,\n train_set_subfolder: str = \"\",\n test_set_subfolder: str = \"\",\n train_set_transforms: Iterable[torch.nn.Module] = None,\n test_set_transforms: Iterable[torch.nn.Module] = None,\n mean: Optional[Iterable[float]] = None,\n std: Optional[Iterable[float]] = None,\n downloadable: bool = False):\n self._train_set_constructor = train_set_constructor\n self._test_set_constructor = test_set_constructor\n self._input_size = input_size\n self._num_classes = num_classes\n self._train_set_subfolder = train_set_subfolder\n self._test_set_subfolder = test_set_subfolder\n self._train_set_transforms = train_set_transforms\n self._test_set_transforms = test_set_transforms\n self._mean = mean\n self._std = std\n self._downloadable = downloadable\n\n test_set_normalization_transforms: List[torch.nn.Module] = []\n if self._test_set_transforms is not None:\n test_set_normalization_transforms.extend(self._test_set_transforms)\n test_set_normalization_transforms.append(transforms.ToTensor())\n test_set_normalization_transforms.append(transforms.Normalize(mean=self._mean, std=self._std))\n self._test_set_normalization = transforms.Compose(test_set_normalization_transforms)\n\n def load(self, path: str, batch_size: int, download: bool = False, num_workers: Optional[int] = None, shuffle: bool = True) -> Tuple[DataLoader, DataLoader]:\n if num_workers is None:\n num_workers = multiprocessing.cpu_count()\n\n # normalize the dataset based on the obtained mean and standard deviation\n train_set_path = os.path.join(path, self._train_set_subfolder)\n test_set_path = os.path.join(path, self._test_set_subfolder)\n\n train_set_transforms: List[torch.nn.Module] = []\n if self._train_set_transforms is not None:\n train_set_transforms.extend(self._train_set_transforms)\n train_set_transforms.append(transforms.ToTensor())\n train_set_transforms.append(transforms.Normalize(mean=self._mean, std=self._std))\n\n if self._downloadable:\n train_set_normalized = self._train_set_constructor(root=train_set_path,\n transform=transforms.Compose(train_set_transforms), download=download)\n else:\n train_set_normalized = self._train_set_constructor(root=train_set_path,\n transform=transforms.Compose(train_set_transforms))\n\n train_loader = DataLoader(train_set_normalized, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)\n test_set_normalized = self._test_set_constructor(root=test_set_path, transform=self._test_set_normalization)\n test_loader = DataLoader(test_set_normalized, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers)\n\n return train_loader, test_loader\n\n @property\n def input_size(self) -> Iterable[int]:\n return self._input_size\n\n @property\n def num_classes(self) -> int:\n return self._num_classes\n\n @property\n def test_set_normalization(self) -> torch.nn.Module:\n return self._test_set_normalization\n\n\ndatasets = dict()\n\ndatasets[\"imagenet\"] = Dataset(\n torchvision.datasets.ImageFolder,\n torchvision.datasets.ImageFolder,\n input_size=(3, 224, 224),\n num_classes=1000,\n train_set_subfolder=\"train\",\n test_set_subfolder=\"val\",\n train_set_transforms=[transforms.RandomResizedCrop(224),\n transforms.RandomHorizontalFlip()],\n test_set_transforms=[transforms.Resize(256), transforms.CenterCrop(224)],\n mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225],\n downloadable=False)\n\ndatasets[\"imagenet-hymenoptera\"] = Dataset(\n torchvision.datasets.ImageFolder,\n torchvision.datasets.ImageFolder,\n input_size=(3, 224, 224),\n num_classes=2,\n train_set_subfolder=\"train\",\n test_set_subfolder=\"val\",\n train_set_transforms=[transforms.RandomResizedCrop(224),\n transforms.RandomHorizontalFlip()],\n test_set_transforms=[transforms.Resize(256), transforms.CenterCrop(224)],\n mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225],\n downloadable=False)\n\n\ndatasets[\"mnist\"] = Dataset(functools.partial(torchvision.datasets.MNIST, train=True),\n functools.partial(torchvision.datasets.MNIST, train=False),\n input_size=(1, 28, 28),\n num_classes=10,\n mean=[0.1307],\n std=[0.3081],\n downloadable=True)\n\n\ndatasets[\"fashion_mnist\"] = Dataset(functools.partial(torchvision.datasets.FashionMNIST, train=True),\n functools.partial(torchvision.datasets.FashionMNIST, train=False),\n input_size=(1, 28, 28),\n num_classes=10,\n mean=[0.286],\n std=[0.353],\n downloadable=True)\n\n\ndatasets[\"cifar10\"] = Dataset(functools.partial(torchvision.datasets.CIFAR10, train=True),\n functools.partial(torchvision.datasets.CIFAR10, train=False),\n input_size=(3, 32, 32),\n num_classes=10,\n mean=[0.4914, 0.4822, 0.4465],\n std=[0.247, 0.2435, 0.2616],\n downloadable=True)\n\n\ndatasets[\"cifar100\"] = Dataset(functools.partial(torchvision.datasets.CIFAR100, train=True),\n functools.partial(torchvision.datasets.CIFAR100, train=False),\n input_size=(3, 32, 32),\n num_classes=100,\n mean=[0.5071, 0.4865, 0.4409],\n std=[0.2673, 0.2564, 0.2762],\n downloadable=True)\n\n"
] |
[
[
"torch.utils.data.DataLoader"
]
] |
praveeenbadimala/flow_unsupervised
|
[
"07385fd45e9213c06acacfd891e116f07993575e"
] |
[
"models/actor_critic_combined.py"
] |
[
"import torch\nimport torch.nn as nn\nfrom torch.nn.init import kaiming_normal\nimport torch.nn as nns\n\n# source ref: https://github.com/ClementPinard/FlowNetPytorch\n\ndef conv(batchNorm, in_planes, out_planes, kernel_size=3, stride=1):\n if batchNorm:\n return nn.Sequential(\n nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size-1)//2, bias=False),\n nn.BatchNorm2d(out_planes),\n nn.LeakyReLU(0.1,inplace=True)\n )\n else:\n return nn.Sequential(\n nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=(kernel_size-1)//2, bias=True),\n nn.LeakyReLU(0.1,inplace=True)\n )\n\n\ndef predict_flow(in_planes):\n return nn.Conv2d(in_planes,2,kernel_size=3,stride=1,padding=1,bias=False)\n\n\ndef deconv(in_planes, out_planes):\n return nn.Sequential(\n nn.ConvTranspose2d(in_planes, out_planes, kernel_size=4, stride=2, padding=1, bias=False),\n nn.LeakyReLU(0.1,inplace=True)\n )\n\n\ndef crop_like(input, target):\n if input.size()[2:] == target.size()[2:]:\n return input\n else:\n return input[:, :, :target.size(2), :target.size(3)]\n\n\nclass Actor_Critic_Combined(nn.Module):\n expansion = 1\n\n def __init__(self,actor_network,batchNorm=True):\n super(Actor_Critic_Combined,self).__init__()\n\n self.actor_network = actor_network\n\n self.batchNorm = batchNorm\n self.conv1 = conv(self.batchNorm, 8, 64, kernel_size=7, stride=2)\n self.conv2 = conv(self.batchNorm, 64, 128, kernel_size=5, stride=2)\n self.conv3 = conv(self.batchNorm, 136, 256, kernel_size=5, stride=2)\n self.conv3_1 = conv(self.batchNorm, 256, 256)\n self.conv4 = conv(self.batchNorm, 264, 512, stride=2)\n self.conv4_1 = conv(self.batchNorm, 512, 512)\n self.conv5 = conv(self.batchNorm, 520, 512, stride=2)\n self.conv5_1 = conv(self.batchNorm, 512, 512)\n self.conv6 = conv(self.batchNorm, 520, 1024, stride=2)\n self.conv6_1 = conv(self.batchNorm,1024, 1024)\n\n self.deconv5 = deconv(1024,512)\n self.deconv4 = deconv(1026,256)\n self.deconv3 = deconv(770,128)\n self.deconv2 = deconv(386,64)\n\n self.predict_flow6 = predict_flow(1024)\n self.predict_flow5 = predict_flow(1026)\n self.predict_flow4 = predict_flow(770)\n self.predict_flow3 = predict_flow(386)\n self.predict_flow2 = predict_flow(194)\n\n self.upsampled_flow6_to_5 = nn.ConvTranspose2d(2, 2, 4, 2, 1, bias=False)\n self.upsampled_flow5_to_4 = nn.ConvTranspose2d(2, 2, 4, 2, 1, bias=False)\n self.upsampled_flow4_to_3 = nn.ConvTranspose2d(2, 2, 4, 2, 1, bias=False)\n self.upsampled_flow3_to_2 = nn.ConvTranspose2d(2, 2, 4, 2, 1, bias=False)\n\n for m in self.modules():\n if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):\n kaiming_normal(m.weight.data)\n if m.bias is not None:\n m.bias.data.zero_()\n elif isinstance(m, nn.BatchNorm2d):\n m.weight.data.fill_(1)\n m.bias.data.zero_()\n\n def forward(self, x):\n actor_flow2,actor_flow3,actor_flow4,actor_flow5,actor_flow6 = self.actor_network(x)\n b, _, height_vec, width_vec = x.size()\n action_scaled = nns.functional.upsample(actor_flow2, size=(height_vec, width_vec), mode='bilinear')\n\n critic_input = torch.cat([x.cuda(), action_scaled], 1)\n\n out_conv2 = self.conv2(self.conv1(critic_input))\n b, c, conv_h,conv_w = out_conv2.size()\n img_red = nns.functional.adaptive_avg_pool2d(x, (conv_h , conv_w))\n out_conv3 = self.conv3_1(self.conv3(torch.cat([actor_flow2,out_conv2,img_red],1)))\n b, c, conv_h, conv_w = out_conv3.size()\n img_red = nns.functional.adaptive_avg_pool2d(x, (conv_h, conv_w))\n out_conv4 = self.conv4_1(self.conv4(torch.cat([actor_flow3,out_conv3,img_red],1)))\n b, c, conv_h, conv_w = out_conv4.size()\n img_red = nns.functional.adaptive_avg_pool2d(x, (conv_h, conv_w))\n out_conv5 = self.conv5_1(self.conv5(torch.cat([actor_flow4,out_conv4,img_red],1)))\n b, c, conv_h, conv_w = out_conv5.size()\n img_red = nns.functional.adaptive_avg_pool2d(x, (conv_h, conv_w))\n out_conv6 = self.conv6_1(self.conv6(torch.cat([actor_flow5,out_conv5,img_red],1)))\n\n flow6 = self.predict_flow6(out_conv6)\n flow6_up = crop_like(self.upsampled_flow6_to_5(flow6), out_conv5)\n out_deconv5 = crop_like(self.deconv5(out_conv6), out_conv5)\n\n concat5 = torch.cat((out_conv5,out_deconv5,flow6_up),1)\n flow5 = self.predict_flow5(concat5)\n flow5_up = crop_like(self.upsampled_flow5_to_4(flow5), out_conv4)\n out_deconv4 = crop_like(self.deconv4(concat5), out_conv4)\n\n concat4 = torch.cat((out_conv4,out_deconv4,flow5_up),1)\n flow4 = self.predict_flow4(concat4)\n flow4_up = crop_like(self.upsampled_flow4_to_3(flow4), out_conv3)\n out_deconv3 = crop_like(self.deconv3(concat4), out_conv3)\n\n concat3 = torch.cat((out_conv3,out_deconv3,flow4_up),1)\n flow3 = self.predict_flow3(concat3)\n flow3_up = crop_like(self.upsampled_flow3_to_2(flow3), out_conv2)\n out_deconv2 = crop_like(self.deconv2(concat3), out_conv2)\n\n concat2 = torch.cat((out_conv2,out_deconv2,flow3_up),1)\n flow2 = self.predict_flow2(concat2)\n\n # predict energy at each flow layer\n expected_energy_flow2 = flow2.sum(3).sum(2).sum(1)\n expected_energy_flow3 = flow3.sum(3).sum(2).sum(1)\n expected_energy_flow4 = flow4.sum(3).sum(2).sum(1)\n expected_energy_flow5 = flow5.sum(3).sum(2).sum(1)\n expected_energy_flow6 = flow6.sum(3).sum(2).sum(1)\n\n ret_val = {}\n ret_val['energy']=[expected_energy_flow2,expected_energy_flow3,expected_energy_flow4,expected_energy_flow5,expected_energy_flow6]\n ret_val['flow']=[actor_flow2,actor_flow3,actor_flow4,actor_flow5,actor_flow6]\n return ret_val\n\n def weight_parameters(self):\n return [param for name, param in self.named_parameters() if 'weight' in name]\n\n def bias_parameters(self):\n return [param for name, param in self.named_parameters() if 'bias' in name]\n\n def bias_parameters_critic(self):\n return [param for name, param in self.named_parameters() if 'bias' in name and 'actor_network' not in name]\n\n def weight_parameters_critic(self):\n return [param for name, param in self.named_parameters() if 'weight' in name and 'actor_network' not in name]\n\n\ndef Actor_Critic_combined_Load(actor_net,path=None):\n \"\"\"FlowNetS model architecture from the\n \"Learning Optical Flow with Convolutional Networks\" paper (https://arxiv.org/abs/1504.06852)\n\n Args:\n path : where to load pretrained network of actor critic single network. will create a new one if not set\n \"\"\"\n model = Actor_Critic_Combined(actor_net,batchNorm=False)\n if path is not None:\n data = torch.load(path)\n if 'state_dict' in data.keys():\n model.load_state_dict(data['state_dict'])\n else:\n model.load_state_dict(data)\n return model"
] |
[
[
"torch.nn.functional.upsample",
"torch.nn.init.kaiming_normal",
"torch.nn.ConvTranspose2d",
"torch.cat",
"torch.load",
"torch.nn.Conv2d",
"torch.nn.functional.adaptive_avg_pool2d",
"torch.nn.LeakyReLU",
"torch.nn.BatchNorm2d"
]
] |
AdiVarma27/pyAB
|
[
"4cb3f693ce63ae48b42d3b8353057a00e5dceb6b"
] |
[
"pyab/experiments/experiments.py"
] |
[
"\"\"\"Main file comprising Frequentist & Bayesian A/B Testing methods.\"\"\"\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport scipy.stats as st\nimport statsmodels.stats.api as sms\nfrom statsmodels.stats.power import tt_ind_solve_power\nfrom pyab.utils import check_valid_input, check_valid_parameter, check_t_test\n\nclass ABTestFrequentist:\n \"\"\"\n Frequentist A/B Testing aka Two sample proportion test.\n\n Parameters\n ----------\n alpha : float, default = 0.05\n Significane level or Type 1 error rate.\n\n alt_hypothesis : str, default = 'one_tailed'\n One or two tailed hypothesis test.\n\n * 'one_tailed':\n one tailed hypothesis test\n * 'two_tailed':\n two tailed hypothesis test\n \"\"\"\n\n def __init__(self, alpha=0.05, alt_hypothesis='one_tailed'):\n\n self.alpha = alpha\n self.alt_hypothesis = alt_hypothesis\n self.stat = None\n self.stat_null_crit_upper = None\n self.stat_null_crit_lower = None\n\n all_alt_hypothesis = ['one_tailed', 'two_tailed']\n\n check_valid_parameter(alpha)\n\n if alt_hypothesis not in all_alt_hypothesis:\n raise ValueError(\n \"ABTestFrequentist class supports hypothesis in %s, got %s\"\n % (all_alt_hypothesis, alt_hypothesis)\n )\n\n def conduct_experiment(self, success_null, trials_null, success_alt, trials_alt):\n \"\"\"\n Conduct experiment & generate power curve with provided parameters.\n\n Parameters\n ----------\n success_null : int\n number of successful clicks or successful events (Version-A).\n\n trials_null : int\n number of impressions or events (Version-A).\n\n success_alt : int\n number of successful clicks or successful events (Version-B).\n\n trials_alt : int\n number of impressions or events (Version-B).\n\n Returns\n -------\n stat : float\n z or t statistic.\n\n pvalue : float\n probability of obtaining results atleast as extreme as the results\n actually observed during the test.\n \"\"\"\n\n check_valid_input(success_null, trials_null)\n check_valid_input(success_alt, trials_alt)\n\n self.success_null = success_null\n self.trials_null = trials_null\n self.prop_null = success_null / trials_null\n self.success_alt = success_alt\n self.trials_alt = trials_alt\n self.prop_alt = success_alt / trials_alt\n\n self.stat = self.calculate_stat(self.prop_alt)\n self.is_t_test = True if check_t_test(\n trials_null, trials_alt) else False\n\n if self.alt_hypothesis == 'one_tailed':\n if self.is_t_test:\n if self.right_tailed_flag:\n self.pvalue = st.t.cdf(-self.stat,\n df=trials_null + trials_alt - 2)\n else:\n self.pvalue = st.t.cdf(\n self.stat, df=trials_null + trials_alt - 2)\n\n self.stat_null_crit_lower = st.t.ppf(\n self.alpha, df=trials_null + trials_alt - 2)\n\n self.stat_null_crit_upper = st.t.ppf(\n 1 - self.alpha, df=trials_null + trials_alt - 2)\n\n else:\n if self.right_tailed_flag:\n self.pvalue = st.norm.cdf(-self.stat)\n else:\n self.pvalue = st.norm.cdf(self.stat)\n\n self.stat_null_crit_lower = st.norm.ppf(self.alpha)\n self.stat_null_crit_upper = st.norm.ppf(1 - self.alpha)\n\n self.conf_int_null_crit = (self.prop_null + self.stat_null_crit_lower * \\\n np.sqrt(self.prop_null * (1 - self.prop_null)\n * (1 / trials_null)),\n self.prop_null + self.stat_null_crit_upper * np.sqrt(self.prop_null * \\\n (1 - self.prop_null)\n * (1 / trials_null))\n )\n\n self.beta = 1 - self.calculate_power(self.stat)\n\n if self.right_tailed_flag:\n self.power_curve = {\n temp_moving_prop: self.calculate_power(\n self.calculate_stat(temp_moving_prop)\n )\n for temp_moving_prop in \\\n np.arange(self.prop_null, 1.005, 0.005)\n }\n\n else:\n self.power_curve = {\n temp_moving_prop: self.calculate_power(\n self.calculate_stat(temp_moving_prop)\n )\n for temp_moving_prop in \\\n np.arange(0, self.prop_null + 0.005, 0.005)\n }\n else:\n if self.is_t_test:\n if self.right_tailed_flag:\n self.pvalue = st.t.cdf(-self.stat,\n df=trials_null + trials_alt - 2) * 2\n else:\n self.pvalue = st.t.cdf(\n self.stat, df=trials_null + trials_alt - 2) * 2\n\n self.stat_null_crit_lower = st.t.ppf(self.alpha / 2)\n self.stat_null_crit_upper = st.t.ppf(1 - self.alpha / 2)\n\n else:\n if self.right_tailed_flag:\n self.pvalue = st.norm.cdf(-self.stat) * 2\n else:\n self.pvalue = st.norm.cdf(self.stat) * 2\n\n self.stat_null_crit_lower = st.norm.ppf(self.alpha / 2)\n self.stat_null_crit_upper = st.norm.ppf(1 - self.alpha / 2)\n\n self.conf_int_null_crit = (self.prop_null + self.stat_null_crit_lower *\n np.sqrt(self.prop_null *\n (1 -\n self.prop_null) *\n (1 /\n trials_null)), self.prop_null +\n self.stat_null_crit_upper *\n np.sqrt(self.prop_null *\n (1 -\n self.prop_null) *\n (1 /\n trials_null)), )\n\n self.beta = 1 - self.calculate_power(self.stat)\n\n if self.right_tailed_flag:\n self.power_curve = {\n temp_moving_prop: self.calculate_power(\n self.calculate_stat(temp_moving_prop)\n )\n for temp_moving_prop in np.arange(0, 1.005, 0.005)\n }\n\n else:\n self.power_curve = {\n temp_moving_prop: self.calculate_power(\n self.calculate_stat(temp_moving_prop)\n )\n for temp_moving_prop in np.arange(0, 1.005, 0.005)\n }\n\n self.print_freq_results()\n\n return self.stat, self.pvalue\n\n def calculate_stat(self, prop_alt):\n \"\"\"\n Calculate test statistic with current experiment parameters.\n\n Parameters\n ----------\n prop_alt : float\n alternate hypothesis proportion.\n\n Returns\n -------\n stat : float\n z or t statistic.\n \"\"\"\n\n diff_prop = prop_alt - self.prop_null\n\n self.right_tailed_flag = True if diff_prop >= 0 else False\n\n moving_success_alt = prop_alt * self.trials_alt\n\n prop_pooled = (self.success_null + moving_success_alt) / (self.trials_null + self.trials_alt)\n\n variance = ((prop_pooled) * (1 - prop_pooled) * ((1 / self.trials_null) + (1 / self.trials_alt)))\n\n stat = diff_prop / np.sqrt(variance)\n\n return stat\n\n def calculate_power(self, stat):\n \"\"\"\n Calculate power (1-beta) at given test statistics.\n\n Parameters\n ----------\n stat : float\n z or t test statistic.\n\n Returns\n -------\n 1 - beta : float\n power at given test statistic.\n \"\"\"\n\n if self.is_t_test:\n dist_alt = st.t(loc=stat, df=self.trials_null + self.trials_alt - 2)\n else:\n dist_alt = st.norm(loc=stat)\n\n if self.right_tailed_flag:\n beta = dist_alt.cdf(self.stat_null_crit_upper)\n else:\n beta = 1 - dist_alt.cdf(self.stat_null_crit_lower)\n\n return 1 - beta\n\n def get_sample_size(self, beta=0.1):\n \"\"\"\n Calculate required sample size per group to obtain provided beta.\n\n Parameters\n ----------\n beta : float\n Type 2 error rate.\n\n Returns\n -------\n n : int\n sample size per group.\n \"\"\"\n\n es = sms.proportion_effectsize(self.prop_null, self.prop_alt)\n\n if self.alt_hypothesis == 'two_tailed':\n n = tt_ind_solve_power(\n effect_size=es,\n alpha=self.alpha,\n power=1 - beta,\n alternative='two-sided',\n )\n else:\n n = tt_ind_solve_power(\n effect_size=es,\n alpha=self.alpha,\n power=1 - beta,\n alternative='smaller')\n\n return int(np.round(n, 0))\n\n def plot_power_curve(self, figsize=(9, 6)):\n \"\"\"\n Plot power curve for provided experiment parameters.\n\n Parameters\n ----------\n figsize : tuple, default = (9,6)\n matplotlib plot size.\n \"\"\"\n\n power_curve_ind, power_curve_values = (\n np.array(list(self.power_curve.keys())),\n np.array(list(self.power_curve.values())),\n )\n\n power_curve_diff = np.abs(np.diff(power_curve_values))\n\n power_curve_cutoff = 1.0e-5\n\n plot_power_curve_ind = np.where(\n power_curve_diff > power_curve_cutoff)[0]\n\n plot_power_curve_values = power_curve_values[plot_power_curve_ind]\n\n plot_power_curve_proportion = power_curve_ind[plot_power_curve_ind]\n\n sns.set_style(\"whitegrid\")\n plt.figure(figsize=figsize)\n plt.title(\"Power Curve\")\n sns.lineplot(\n plot_power_curve_proportion,\n plot_power_curve_values,\n color='blue')\n plt.scatter(\n self.prop_alt,\n 1 -\n self.beta,\n color='#0b559f',\n label='Power at alternate proportion %s' %\n (str(\n np.round(\n 1 -\n self.beta,\n 3))))\n plt.legend()\n plt.xlabel(\"Comparison Proportion\")\n plt.ylabel(\"Power\")\n plt.show()\n\n def print_freq_results(self):\n \"\"\"\n Print Frequentist Experiment Results\n \"\"\"\n is_significant = False\n\n if self.pvalue < self.alpha:\n is_significant = True\n\n print(\"pyAB Summary\\n============\\n\")\n print(\"Test Parameters\\n_______________\\n\")\n print(\"Variant A: Success Rate %s, Sample Size %s\" %\n (self.prop_null, self.trials_null))\n print(\n \"Variant B: Success Rate %s, Sample Size %s\" %\n (self.prop_alt, self.trials_alt))\n print(\n \"Type-I Error: %s, %s test\\n\" %\n (self.alpha, self.alt_hypothesis))\n print(\"Test Results\\n____________\\n\")\n print(\"Test Stat: %s\" % (np.round(self.stat, 3)))\n print(\"p-value: %s\" % (np.round(self.pvalue, 3)))\n print(\"Type-II Error: %s\" % (np.round(self.beta, 3)))\n print(\"Power: %s\\n\" % (np.round(1 - self.beta, 3)))\n\n if is_significant:\n print(\n \"There is a statistically significant difference in proportions of two variants.\\n\")\n else:\n print(\n \"There is no statistically significant difference in proportions of two variants.\\n\")\n\n self.plot_power_curve()\n\n\nclass ABTestBayesian:\n \"\"\"\n Bayesian A/B Testing.\n\n Parameters\n ----------\n success_prior : int\n Number of successful samples from prior.\n\n trials_prior : int\n Number of trials from prior.\n \"\"\"\n\n def __init__(self, success_prior, trials_prior):\n\n self.success_prior = success_prior\n self.trials_prior = trials_prior\n self.faliure_prior = self.trials_prior - self.success_prior\n\n check_valid_input(success_prior, trials_prior)\n\n def conduct_experiment(self, success_null, trials_null, success_alt, trials_alt,\n uplift_method='uplift_percent', num_simulations=1000):\n \"\"\"\n Conduct experiment & generate uplift distributions.\n\n Parameters\n ----------\n success_null : int\n Number of successful samples for variant-a.\n\n trials_null : int\n Number of trials for variant-a.\n\n success_alt : int\n Number of successful samples for variant-b.\n\n trials_alt : int\n Number of trials for variant-b.\n\n num_simulations : int\n Number of mcmc simulations.\n\n uplift_method : str, default = 'uplift_percent'\n Uplift evaluation metric.\n\n * 'uplift_percent':\n percent uplift gain from variant-a to variant-b\n * 'uplift_ratio':\n uplift ratio of variant-b & variant-a\n * 'uplift_difference':\n uplift difference between variant-b & variant-a\n \"\"\"\n\n all_uplift_methods = [\n 'uplift_percent',\n 'uplift_ratio',\n 'uplift_difference']\n\n if uplift_method not in all_uplift_methods:\n raise ValueError(\n \"ABTestBayesian class supports uplift methods in %s, got %s\"\n % (all_uplift_methods, uplift_method)\n )\n\n self.num_simulations = num_simulations\n self.uplift_method = uplift_method\n\n check_valid_input(success_null, trials_null)\n check_valid_input(success_alt, trials_alt)\n\n self.success_null = success_null\n self.trials_null = trials_null\n\n self.success_alt = success_alt\n self.trials_alt = trials_alt\n\n faliure_null = self.trials_null - self.success_null\n faliure_alt = self.trials_alt - self.success_alt\n\n self.success_posterior_null = self.success_prior + self.success_null\n self.faliure_posterior_null = self.faliure_prior + faliure_null\n\n self.success_posterior_alt = self.success_prior + self.success_alt\n self.faliure_posterior_alt = self.faliure_prior + faliure_alt\n\n beta_x = np.arange(0, 1.005, 0.005)\n\n beta_prior_pdf = st.beta.pdf(\n beta_x, self.success_prior, self.faliure_prior)\n\n beta_null_pdf = st.beta.pdf(\n beta_x,\n self.success_posterior_null,\n self.faliure_posterior_null)\n\n beta_alt_pdf = st.beta.pdf(\n beta_x,\n self.success_posterior_alt,\n self.faliure_posterior_alt)\n\n self.uplift_dist, self.uplift_area = self.calculate_uplift_area()\n\n self.print_bayesian_results()\n\n def calculate_uplift_area(self):\n \"\"\"\n Calculate Uplift pdf & area beyond threshold.\n\n Returns\n -------\n uplift_distribution : ndarray\n uplift distribution based on chosen uplift method.\n\n uplift_area : float\n percentage area above threshold.\n \"\"\"\n\n beta_mcmc_null = st.beta.rvs(self.success_posterior_null, self.faliure_posterior_null,\n size=self.num_simulations)\n\n beta_mcmc_alt = st.beta.rvs(self.success_posterior_alt, self.faliure_posterior_alt,\n size=self.num_simulations)\n\n if self.uplift_method == 'uplift_percent':\n uplift_dist = (beta_mcmc_alt - beta_mcmc_null) / beta_mcmc_null\n uplift_area = len(uplift_dist[uplift_dist >= 0]) / len(np.abs(uplift_dist))\n\n elif self.uplift_method == 'uplift_ratio':\n uplift_dist = beta_mcmc_alt / beta_mcmc_null\n uplift_area = len(uplift_dist[uplift_dist >= 1]) / len(np.abs(uplift_dist))\n\n elif self.uplift_method == 'uplift_difference':\n uplift_dist = beta_mcmc_alt - beta_mcmc_null\n uplift_area = len(uplift_dist[uplift_dist >= 0]) / len(np.abs(uplift_dist))\n\n return uplift_dist, uplift_area\n\n def plot_uplift_distributions(self, figsize=(18, 6)):\n \"\"\"\n Plot uplift pdf & cdf for provided experiment parameters.\n\n Parameters\n ----------\n figsize : tuple, default = (18, 6)\n matplotlib plot size.\n \"\"\"\n\n sns.set_style(\"whitegrid\")\n\n plt.figure(figsize=figsize)\n plt.subplot(1, 2, 1)\n plt.title(\"Uplift Distribution Plot\")\n ax = sns.kdeplot(self.uplift_dist, shade=True, color='black')\n kde_x, kde_y = ax.lines[0].get_data()\n\n if self.uplift_method == 'uplift_ratio':\n cutoff_point = 1\n cutoff_line = plt.axvline(x=cutoff_point, linestyle='--', color='black')\n else:\n cutoff_point = 0\n cutoff_line = plt.axvline(x=cutoff_point, linestyle='--', color='black')\n\n ax.fill_between(kde_x, kde_y, where=(kde_x <= cutoff_point), interpolate=True,\n color='orange', alpha=0.6)\n ax.fill_between(kde_x, kde_y, where=(kde_x > cutoff_point), interpolate=True,\n color='lightgreen', alpha=0.6)\n\n plt.xlabel(\"Uplift\")\n plt.ylabel(\"Density\")\n plt.subplot(1, 2, 2)\n plt.title(\"Uplift Cumulative Distribution Plot\")\n sns.kdeplot(self.uplift_dist, cumulative=True, color='blue', shade=True)\n plt.xlabel(\"Cumulative Uplift\")\n plt.ylabel(\"Density\")\n plt.show()\n\n def print_bayesian_results(self):\n \"\"\"\n Print Bayesian Experiment Results\n \"\"\"\n\n print(\"pyAB Summary\\n============\\n\")\n print(\"Test Parameters\\n_______________\\n\")\n print(\"Variant A: Successful Trials %s, Sample Size %s\" %\n (self.success_null, self.trials_null))\n print(\"Variant B: Successful Trials %s, Sample Size %s\" %\n (self.success_alt, self.trials_alt))\n print(\"Prior: Successful Trials %s, Sample Size %s\\n\" %\n (self.success_prior, self.trials_prior))\n print(\"Test Results\\n____________\\n\")\n print(\"Evaluation Metric: %s\" % (self.uplift_method))\n print(\"Number of mcmc simulations: %s\\n\" % (self.num_simulations))\n\n if self.uplift_method == 'uplift_percent':\n print(\"%s %% simulations show Uplift Gain Percent above 0.\\n\" %\n (np.round(self.uplift_area * 100, 2)))\n elif self.uplift_method == 'uplift_ratio':\n print(\"%s %% simulations show Uplift Ratio above 1.\\n\" %\n (np.round(self.uplift_area * 100, 2)))\n elif self.uplift_method == 'uplift_difference':\n print(\"%s %% simulations show Uplift Difference above 0.\\n\" %\n (np.round(self.uplift_area * 100, 2)))\n\n self.plot_uplift_distributions()\n"
] |
[
[
"matplotlib.pyplot.legend",
"scipy.stats.norm.ppf",
"numpy.sqrt",
"scipy.stats.norm.cdf",
"numpy.round",
"numpy.where",
"numpy.arange",
"matplotlib.pyplot.subplot",
"numpy.diff",
"scipy.stats.t",
"scipy.stats.t.cdf",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.axvline",
"numpy.abs",
"scipy.stats.beta.rvs",
"scipy.stats.beta.pdf",
"scipy.stats.t.ppf",
"scipy.stats.norm",
"matplotlib.pyplot.xlabel"
]
] |
dukduque/PortfolioManager
|
[
"bc30a3ec9062abb5e7abd99d197b6cc043ab9786"
] |
[
"source/database_handler.py"
] |
[
"\"\"\"\nCreated on Thu May 23 22:32:31 2019\n\n@author: dduque\n\nThis module implements function to manage the prices database and\naccess the information. As of 2019/06/03, the package to access price\ndata is yfinance.\n\"\"\"\n'''\nSetup paths\n'''\n\nimport shutil\nimport yfinance as yf\nimport requests\nimport pickle\nimport datetime\nimport datetime as dt\nimport itertools\nimport bs4 as bs\nimport multiprocessing as mp\nimport numpy as np\nimport pandas as pd\nimport sys\nimport os\nimport time\nfrom pathlib import Path\npath_to_file = os.path.dirname(os.path.realpath(__file__))\nparent_path = os.path.abspath(os.path.join(path_to_file, os.pardir))\nsys.path.insert(0, parent_path)\npath_to_data = os.path.abspath(os.path.join(parent_path, 'data'))\nfrom source import util\n\nEMPTY_METADATA = {\n 'name': '',\n 'sector': '',\n 'subsector': '',\n 'market_cap': '',\n}\n\n\ndef set_data_path(new_path_to_data):\n path_is_new = False\n new_path = Path(new_path_to_data)\n if (not new_path.is_dir()):\n try:\n path_is_new = True\n os.mkdir(str(new_path))\n except Exception as e:\n raise f'{new_path} is no a valid path. {str(e)}'\n \n global path_to_data\n path_to_data = new_path.absolute()\n return path_is_new\n\n\nclass DataManager:\n \"\"\"\n An instance of this class access and maintains the data.\n \"\"\"\n def __init__(self, db_file='close.pkl', metadata_file='metadata.pkl'):\n self.db = load_database(db_file)\n self.metadata = get_tickers_metadata(metadata_file)\n self.db_file = db_file\n self.metadata_file = metadata_file\n \n def get_prices(self, assets=None):\n '''\n assets (str or list): an asset or list of assets.\n '''\n if assets is None or len(assets) == 0:\n return self.db\n \n if type(assets) == str:\n assets = [assets]\n \n for asset in assets:\n if asset not in self.db.columns:\n self.db = update_database_single_stock(self.db, asset,\n self.db_file,\n self.metadata_file)\n return self.db[assets]\n \n def get_metadata(self, asset):\n assert type(asset) == str\n if asset in self.metadata:\n return self.metadata[asset]\n try:\n asset_ticket = yf.Ticker(asset)\n info = asset_ticket.info\n self.metadata[asset] = EMPTY_METADATA.copy()\n self.metadata[asset]['name'] = info['shortName']\n self.metadata[asset]['quoteType'] = info['quoteType']\n if info['quoteType'] == \"ETF\":\n self.metadata[asset]['sector'] = 'ETF'\n self.metadata[asset]['industry'] = 'ETF'\n elif info['quoteType'] == \"EQUITY\":\n self.metadata[asset]['sector'] = info['sector']\n self.metadata[asset]['industry'] = info['industry']\n except Exception:\n self.metadata[asset] = EMPTY_METADATA\n self.metadata[asset]['name'] = asset\n save_metadata(self.metadata, self.metadata_file)\n return self.metadata[asset]\n \n def get_returns(self, start_date, end_date, stocks=[], outlier_return=10):\n '''\n Computes returns from specific dates and list of securities.\n '''\n if len(stocks) == 0 and hasattr(self, '_returns'):\n return self._returns\n \n for s in stocks:\n if s not in self.db.columns:\n try:\n self.get_prices(s)\n self.get_metadata(s)\n except Exception:\n print(f'Fail while obtaining data from security {s}')\n db = self.db[self.db.index >= start_date]\n db = db[db.index <= end_date]\n db = db.dropna(axis=0, how='all')\n db = db.dropna(axis=1)\n db_r = db.apply(quotien_diff, axis=0) # compute returns\n db_r = db_r[db_r < outlier_return].dropna(axis=0) # Filter outliers\n \n self._returns = db_r\n return db_r\n \n def repair_data(self, stock_symbol, start_date):\n if stock_symbol not in self.db.columns:\n return\n stock = yf.Ticker(stock_symbol)\n trials = 3\n for repairing_date in reversed(self.db.index):\n if repairing_date < start_date:\n break\n if np.isnan(self.db.loc[repairing_date, stock_symbol]):\n time.sleep(np.random.uniform(0, 0.1))\n update = stock.history(start=repairing_date,\n end=repairing_date +\n dt.timedelta(days=1)).Close\n if repairing_date in update.index and update.loc[\n repairing_date] != np.nan:\n self.db.loc[repairing_date,\n stock_symbol] = update.loc[repairing_date]\n else:\n print('Not repaired', stock_symbol, repairing_date)\n trials -= 1\n if trials == 0:\n print('Still nan')\n break\n \n save_database(self.db, self.db_file)\n \n @property\n def securities(self):\n return list(self.db.columns)\n\n\ndef save_sp500_tickers():\n '''\n https://pythonprogramming.net/sp500-company-list-python-programming-for-finance/\n '''\n resp = requests.get(\n 'http://en.wikipedia.org/wiki/List_of_S%26P_500_companies')\n soup = bs.BeautifulSoup(resp.text, 'lxml')\n table = soup.find('table', {'class': 'wikitable sortable'})\n tickers = {}\n for row in table.findAll('tr')[1:]:\n ticker = row.findAll('td')[0].text.replace('\\n', '')\n ticker_info = {}\n ticker_info['name'] = row.findAll('td')[1].text.replace('\\n', '')\n ticker_info['sector'] = row.findAll('td')[3].text.replace('\\n', '')\n ticker_info['subsector'] = row.findAll('td')[4].text.replace('\\n', '')\n tickers[ticker] = ticker_info\n for ticker in tickers:\n _, mkt_cap = get_market_cap(ticker)\n tickers[ticker]['market_cap'] = mkt_cap\n path_to_file = os.path.join(path_to_data, \"sp500tickers.pickle\")\n with open(path_to_file, \"wb\") as f:\n pickle.dump(tickers, f)\n\n\ndef get_market_cap(ticker_str):\n '''\n Retrieves the market cap of the ticker given as input. If the ticker information is not available, returns zero.\n '''\n ticker = yf.Ticker(ticker_str)\n print(f'Getting {ticker_str} market cap...')\n try:\n time.sleep(np.random.uniform(0, 500) / 1000)\n return (ticker_str, ticker.info['marketCap'])\n except Exception as e:\n print(e)\n return (ticker_str, 0.0)\n\n\ndef get_sp500_tickers():\n path_to_file = Path(os.path.join(path_to_data, \"sp500.pkl\"))\n if not path_to_file.exists:\n save_sp500_tickers()\n return pickle.load(path_to_file.open('rb'))\n\n\ndef get_tickers_metadata(meta_data_file):\n path_to_file = Path(os.path.join(path_to_data, meta_data_file))\n if not path_to_file.exists:\n return {}\n return pickle.load(path_to_file.open('rb'))\n\n\ndef save_rusell1000_tickers():\n '''\n https://pythonprogramming.net/sp500-company-list-python-programming-for-finance/\n '''\n resp = requests.get('https://en.wikipedia.org/wiki/Russell_1000_Index')\n soup = bs.BeautifulSoup(resp.text, 'lxml')\n tables = soup.find_all('table')\n table = tables[2]\n tickers = []\n for row in table.findAll('tr')[1:]:\n ticker = row.findAll('td')[1].text\n tickers.append(ticker.replace('\\n', ''))\n path_to_file = os.path.join(path_to_data, \"rusell1000tickers.pickle\")\n with open(path_to_file, \"wb\") as f:\n pickle.dump(tickers, f)\n \n return tickers\n\n\ndef load_database(DB_file_name):\n '''\n Loads a pandas database stored as a pickle file\n Args:\n DB_file_name (str): name of the file\n '''\n path_to_database = os.path.join(path_to_data, DB_file_name)\n exists = os.path.isfile(path_to_database)\n if not exists:\n raise 'File %s does not exist' % (DB_file_name)\n try:\n return pd.read_pickle(path_to_database)\n except Exception as e:\n print(e)\n return None\n\n\ndef save_database(BD, DB_file_name):\n '''\n Saves a database of in a pickle file. If a such file\n already exists, a copy of the old file is created.\n Args:\n DB (DataFrame): a pandas data frame\n DB_file_name (str): name of the file\n '''\n path_to_database = os.path.join(path_to_data, DB_file_name)\n exists = os.path.isfile(path_to_database)\n if exists:\n copy_name = 'copy_%s' % (DB_file_name)\n copy_path = os.path.join(path_to_data, copy_name)\n shutil.copyfile(path_to_database, copy_path)\n \n try:\n BD.to_pickle(path_to_database)\n return True\n except Exception as e:\n print(e)\n return False\n\n\ndef save_metadata(metadata, metadata_file):\n path_to_database = os.path.join(path_to_data, metadata_file)\n print(path_to_database)\n exists = os.path.isfile(path_to_database)\n if exists:\n copy_name = 'copy_%s' % (metadata_file)\n copy_path = os.path.join(path_to_data, copy_name)\n shutil.copyfile(path_to_database, copy_path)\n with open(path_to_database, 'wb') as handle:\n pickle.dump(metadata, handle, pickle.HIGHEST_PROTOCOL)\n\n\ndef create_database(stock_symbol, start=None, end=None):\n '''\n Creates a dataframe with one stock.\n Args:\n stock_symbol (str): stock symbol to query\n start (str or datetime): start date of the query\n end (str or datetime): end time of the query (if str, this is a\n exclusive interval)\n Return:\n db (DataFrame): a dataframe with the requested symbol\n status (bool): true if the query was successful\n '''\n try:\n time.sleep(np.random.uniform(0, 0.1))\n db = yf.download(stock_symbol, start=start, end=end, threads=False)\n if len(db.index) == 0:\n # No data found\n return stock_symbol, None, False\n \n db = db.Close\n db = db.loc[~db.index.duplicated(keep='last')]\n if start is not None:\n db = db[db.index >= start]\n db.rename(stock_symbol, inplace=True)\n return stock_symbol, db, True\n except Exception as e:\n print(f'Failed to get: {stock_symbol} , {start}, {end}')\n \n return stock_symbol, None, False\n\n\ndef create_database_mp(input_date):\n return create_database(*input_date)\n\n\ndef add_stock(db, stock_symbol, start=None, end=None):\n '''\n Adds a stock to an existing dataframe.\n Args:\n db (DataFrame): current dataframe\n '''\n _, ndb, status = create_database(stock_symbol, start, end)\n if status:\n join_type = 'inner' if len(db.index) > 0 else 'outer'\n return pd.concat((db, ndb), axis=1, join=join_type), True\n else:\n return db, False\n\n\ndef quotien_diff(x):\n '''\n Computes a division diff operation. Used to compute\n return out of stock prices.\n Args:\n x (DataSeries): pandas data series\n '''\n y = np.array(x)\n return pd.Series(y[1:] / y[:-1], index=x[1:].index)\n\n\ndef get_returns(data_file,\n start_date='2000',\n end_date=dt.datetime.today(),\n stocks=[],\n outlier_return=10):\n '''\n Computes the returns for stocks in the data file from\n a given year. All prices should be available to consider\n a stock.\n Args:\n data_file (str): database file\n start_date (datetime): initial date\n Return:\n db (DataFrame): dataframe with the stock prices\n db_r (DataFrame): dataframe with the returns\n '''\n assert data_file is None, 'Deprecated function'\n assert start_date >= datetime.datetime(1970, 1,\n 1), 'Year should be from 1970'\n db = load_database(data_file)\n if len(stocks) > 0:\n db = db[db.columns.intersection(stocks)]\n db = db[db.index >= start_date]\n db = db[db.index <= end_date]\n db = db.dropna(axis=0, how='all')\n db = db.dropna(axis=1)\n db_r = db.apply(quotien_diff, axis=0) # compute returns\n db_r = db_r[db_r < outlier_return].dropna(axis=1) # Filter outliers\n db = db.filter(db_r.columns, axis=1)\n db = db.filter(db_r.index, axis=0)\n \n return db, db_r\n\n\ndef update_database(db, n_proc, days_back):\n '''\n Updates a database from the last prices.\n If n_proc > 1, runs a mutiprocess version of\n the function to speedup the colection of data.\n '''\n ts = db.index[\n -days_back] # get last date in DB #TODO: what if last date was NaN\n ndb = pd.DataFrame()\n failed_stocks = []\n print('Updating %i stock with %i processors' % (len(db.columns), n_proc))\n if n_proc > 1:\n data_pool = mp.Pool(n_proc)\n stock_list = db.columns.to_list()\n n = 100\n chunks = [\n stock_list[i * n:(i + 1) * n]\n for i in range((len(stock_list) + n - 1) // n)\n ]\n for chunk in chunks:\n stock_tasks = itertools.product(chunk, [ts])\n mp_out = data_pool.map(create_database_mp, stock_tasks)\n for s, db_s, status_s in mp_out:\n if status_s:\n ndb = pd.concat((ndb, db_s), axis=1, join='outer')\n else:\n failed_stocks.append(s)\n \n data_pool.close()\n else:\n for c in db.columns:\n try:\n ndb, status = add_stock(ndb, c, start=ts)\n if not status: # No updated was performed\n failed_stocks.append(c)\n except Exception as e:\n print(e)\n print(failed_stocks)\n # Create new rows with NaN values\n for new_date in ndb.index:\n print(f'Crete row for {new_date}')\n if new_date not in db.index:\n db.loc[new_date] = [np.nan] * len(db.columns)\n # Update NaN values\n db.update(ndb, overwrite=False)\n return db\n\n\ndef update_database_single_stock(db,\n ticker_symbol,\n db_output_file='close.pkl',\n info_output_file='assets_listing.pkl'):\n \n db, status = add_stock(db, ticker_symbol, db.index[0], dt.datetime.today())\n if status:\n save_database(db, db_output_file)\n else:\n print(f\"Database was not updated with ticker {ticker_symbol}\")\n return db\n\n\ndef download_all_data(DB_file_name,\n tickers=[],\n sp500=False,\n rusell1000=False,\n include_bonds=False,\n n_proc=4):\n stocks = set()\n stocks.update(tickers)\n if sp500:\n sp500_stocks = save_sp500_tickers()\n stocks.update(sp500_stocks.keys())\n if rusell1000:\n rusell1000_stocks = save_rusell1000_tickers()\n stocks.update(rusell1000_stocks)\n if include_bonds:\n # TODO: find a larger list of bonds and/or bonds ETFs\n stocks.update([\"GOVT\", \"BLV\"])\n \n stocks = list(stocks)\n ini_data = dt.datetime(year=2000, month=1, day=1)\n today = dt.datetime.today()\n data = yf.download(stocks, start=ini_data, end=today, threads=n_proc)\n close_data = data.Close\n save_database(close_data, DB_file_name)\n return close_data\n\n\ndef run_update_process(db_file_in='close.pkl',\n db_file_out='close.pkl',\n n_proc=4,\n days_back=1):\n db = load_database(db_file_in)\n db = update_database(db, n_proc, days_back)\n save_database(db, db_file_out)\n\n\nif __name__ == '__main__':\n args = util.dh_parse_arguments()\n print(args)\n if args.a == 'u':\n today_ts = datetime.datetime.today()\n str_today = str(today_ts)\n out_file = 'close.pkl' # % (str_today.split(' ')[0])\n run_update_process(args.db_file, out_file, args.n_proc, args.days_back)\n elif args.a == 'd':\n download_all_data(args.db_file, sp500=True, n_proc=args.n_proc)\n elif args.a == 'sp500':\n save_sp500_tickers()\n"
] |
[
[
"pandas.concat",
"pandas.read_pickle",
"pandas.Series",
"numpy.isnan",
"pandas.DataFrame",
"numpy.random.uniform",
"numpy.array"
]
] |
Uditsingh7/Fake-news-predictor
|
[
"e1528b49673edf3b0908630177cbf5dea74fa3ba"
] |
[
"FeatureSelection.py"
] |
[
"\nimport DataPrep\nimport pandas as pd\nimport numpy as np\nfrom sklearn.feature_extraction.text import CountVectorizer\nfrom sklearn.feature_extraction.text import TfidfTransformer\nfrom sklearn.feature_extraction.text import TfidfVectorizer\nfrom sklearn.pipeline import Pipeline\nimport nltk\nimport nltk.corpus \nfrom nltk.tokenize import word_tokenize\nfrom gensim.models.word2vec import Word2Vec\n\n\n#we will start with simple bag of words technique \n#creating feature vector - document term matrix\ncountV = CountVectorizer()\ntrain_count = countV.fit_transform(DataPrep.train_news['Statement'].values)\n\nprint(countV)\nprint(train_count)\n\n#print training doc term matrix\n#we have matrix of size of (10240, 12196) by calling below\ndef get_countVectorizer_stats():\n \n #vocab size\n train_count.shape\n\n #check vocabulary using below command\n print(countV.vocabulary_)\n\n #get feature names\n print(countV.get_feature_names()[:25])\n\n\n#create tf-df frequency features\n#tf-idf \ntfidfV = TfidfTransformer()\ntrain_tfidf = tfidfV.fit_transform(train_count)\n\ndef get_tfidf_stats():\n train_tfidf.shape\n #get train data feature names \n print(train_tfidf.A[:10])\n\n\n#bag of words - with n-grams\n#countV_ngram = CountVectorizer(ngram_range=(1,3),stop_words='english')\n#tfidf_ngram = TfidfTransformer(use_idf=True,smooth_idf=True)\n\ntfidf_ngram = TfidfVectorizer(stop_words='english',ngram_range=(1,4),use_idf=True,smooth_idf=True)\n\n\n#POS Tagging\ntagged_sentences = nltk.corpus.treebank.tagged_sents()\n\ncutoff = int(.75 * len(tagged_sentences))\ntraining_sentences = DataPrep.train_news['Statement']\n \nprint(training_sentences)\n\n#training POS tagger based on words\ndef features(sentence, index):\n \"\"\" sentence: [w1, w2, ...], index: the index of the word \"\"\"\n return {\n 'word': sentence[index],\n 'is_first': index == 0,\n 'is_last': index == len(sentence) - 1,\n 'is_capitalized': sentence[index][0].upper() == sentence[index][0],\n 'is_all_caps': sentence[index].upper() == sentence[index],\n 'is_all_lower': sentence[index].lower() == sentence[index],\n 'prefix-1': sentence[index][0],\n 'prefix-2': sentence[index][:2],\n 'prefix-3': sentence[index][:3],\n 'suffix-1': sentence[index][-1],\n 'suffix-2': sentence[index][-2:],\n 'suffix-3': sentence[index][-3:],\n 'prev_word': '' if index == 0 else sentence[index - 1],\n 'next_word': '' if index == len(sentence) - 1 else sentence[index + 1],\n 'has_hyphen': '-' in sentence[index],\n 'is_numeric': sentence[index].isdigit(),\n 'capitals_inside': sentence[index][1:].lower() != sentence[index][1:]\n }\n \n \n#helper function to strip tags from tagged corpus\t\ndef untag(tagged_sentence):\n return [w for w, t in tagged_sentence]\n\n\n\n#Using Word2Vec \nwith open(\"glove.6B.50d.txt\", \"rb\") as lines:\n w2v = {line.split()[0]: np.array(map(float, line.split()[1:]))\n for line in lines}\n\n\n\n#model = gensim.models.Word2Vec(X, size=100) # x be tokenized text\n#w2v = dict(zip(model.wv.index2word, model.wv.syn0))\n\n\nclass MeanEmbeddingVectorizer(object):\n def __init__(self, word2vec):\n self.word2vec = word2vec\n # if a text is empty we should return a vector of zeros\n # with the same dimensionality as all the other vectors\n self.dim = len(word2vec.itervalues().next())\n\n def fit(self, X, y):\n return self\n\n def transform(self, X):\n return np.array([\n np.mean([self.word2vec[w] for w in words if w in self.word2vec]\n or [np.zeros(self.dim)], axis=0)\n for words in X\n ])\n\n\n\"\"\"\nclass TfidfEmbeddingVectorizer(object):\n def __init__(self, word2vec):\n self.word2vec = word2vec\n self.word2weight = None\n self.dim = len(word2vec.itervalues().next())\n\n def fit(self, X, y):\n tfidf = TfidfVectorizer(analyzer=lambda x: x)\n tfidf.fit(X)\n # if a word was never seen - it must be at least as infrequent\n # as any of the known words - so the default idf is the max of \n # known idf's\n max_idf = max(tfidf.idf_)\n self.word2weight = defaultdict(\n lambda: max_idf,\n [(w, tfidf.idf_[i]) for w, i in tfidf.vocabulary_.items()])\n\n return self\n\n def transform(self, X):\n return np.array([\n np.mean([self.word2vec[w] * self.word2weight[w]\n for w in words if w in self.word2vec] or\n [np.zeros(self.dim)], axis=0)\n for words in X\n ])\n\n\"\"\"\n"
] |
[
[
"sklearn.feature_extraction.text.CountVectorizer",
"sklearn.feature_extraction.text.TfidfTransformer",
"numpy.zeros",
"sklearn.feature_extraction.text.TfidfVectorizer"
]
] |
ubco-mds-2020-labs/dashboard-project-data551_group10
|
[
"ff7932cba58e63e1cd55eafb462e614c0670ab04"
] |
[
"src/app.py"
] |
[
"import dash\nimport dash_core_components as dcc\nimport dash_html_components as html\nimport dash_bootstrap_components as dbc\nfrom dash.dependencies import Input, Output\nimport numpy as np\nimport pandas as pd\nimport altair as alt\nfrom vega_datasets import data\nimport plotly.express as px \n\n\n#####\n##### Data \n#####\nalt.data_transformers.disable_max_rows()\ndf = pd.read_csv(\"data/processed/bank.csv\", sep = ',')\ndf_g = pd.read_csv(\"data/processed/bank_group.csv\", sep = ',')\ndf_c = pd.read_csv(\"data/processed/bank_categorical.csv\", sep = ',')\ndf_n = pd.read_csv(\"data/processed/bank_numeric.csv\", sep = ',')\n\n\n\n\n\n#####\n##### Sidebar Setting\n#####\nSIDEBAR_STYLE = {\n \"position\": \"fixed\",\n \"top\": 0,\n \"left\": 0,\n \"bottom\": 0,\n \"width\": \"20rem\",\n \"padding\": \"2rem 1rem\",\n \"background-color\": \"#f8f9fa\",\n}\n\n\nCONTENT_STYLE = {\n \"margin-left\": \"21rem\",\n \"margin-right\": \"2rem\",\n \"padding\": \"2rem 1rem\",\n}\n\n\n\n\n\n#####\n##### Sidebar Content\n#####\nsidebar = html.Div(\n [\n html.H1(\"Portuguese Bank Term Deposit Subscription Analysis\", className=\"display-4\",style={\"fontSize\": \"40px\", \"color\": \"#02075D\"}),\n html.Hr(),\n dbc.Nav(\n [\n dbc.NavLink(\"Data Exploration\", href=\"/\", active=\"exact\"),\n dbc.NavLink(\"Subsciption Analysis\", href=\"/page-1\", active=\"exact\"),\n\n ],\n vertical=True,\n pills=True,\n ),\n\t\thtml.Hr(),\n html.P(\"Design by Mona Jia, Zhiyan Ma \", className=\"lead\")\n \n\n ],\n style=SIDEBAR_STYLE,\n)\n\n\n\n\n\n\n#####\n##### Dashboard\n#####\n\napp = dash.Dash(external_stylesheets=[dbc.themes.BOOTSTRAP])\n\nserver = app.server\n\ncontent = html.Div(id=\"page-content\", style=CONTENT_STYLE)\n\napp.layout = html.Div([dcc.Location(id=\"url\"), sidebar, content])\n\n\n\n\n\n#####\n##### Web Pages\n#####\[email protected](\n\tOutput(\"page-content\", \"children\"), \n\t[Input(\"url\", \"pathname\")])\n\t\ndef render_page_content(pathname):\n\n\t###\n\t### Web Page 1 - Data Exploration\n\t###\n if pathname == \"/\":\n return dbc.Container([\n html.Br(),\n \thtml.Br(),\n \thtml.H2('Term Deposit Subscription Analysis Dashboard', style={'margin-left':'10px'}),\n \thtml.Br(),\n \t\n \tdbc.Tabs([\n \t\t\n \t\t###\n\t\t\t \t### Tab 1 - Distribution Bar \n\t\t\t \t###\n \tdbc.Tab([\n \n \t\t\t\tdbc.Row([\n \n \t\t\t\t# Bar Menu\n \t\t\t\tdbc.Col([\n \thtml.Br(),\n \thtml.Br(),\n \t\t\t\t \thtml.Label([\n \t\t\t\t\t html.P('PLEASE SELECT AN ATTRIBUTE', style={'margin-left':'25px'}),\n \t\t\t\t\t dcc.Dropdown(\n \t\t\t\t \t\t id = 'xcol-widget', \n \t\t\t \t \t\tvalue = 'Age Group', \n \t\t\t \t\toptions = [{'label': col, 'value': col} for col in df_g.columns], \n \t\t\t \t\tstyle={'width': '300px', 'fontsize': 5, 'marginTop':10, 'margin-left':'10px'}, clearable=False)]),\n \t\t\t \n \t\t \thtml.Br(), \t\n \t\t \thtml.Br(),\n \t\t\t\t \thtml.P('* Ordered by count of records descending ', style={'margin-left':'10px'}),\n\t\t\t\t\t\t\thtml.P('* Hover over the plot to see ', style={'margin-left':'10px'}),\n\t\t\t\t\t\t\thtml.P(' count of each subgroup ', style={'margin-left':'22px'}),\n\t\t\t\t\t\t\thtml.P('* Click on the bar to highlight groups', style={'margin-left':'10px'}),\n\t\t\t\t\t\t\thtml.P(\"* Press 'shift' and click on bars \", style={'margin-left':'10px'}),\n\t\t\t\t\t\t\thtml.P(' to select more than one group', style={'margin-left':'22px'}),\n \t\t\t\t \thtml.Br()\n \t\n \t\n \t\t], style={'marginTop':20}), # /Bar Menu\n \t\n \t\n \n \n \t\t\t\t# Bar Plot\n \t\t\t\t\tdbc.Col([\n \t\t\t html.Br(),\n \t\thtml.Br(),\n \t\thtml.Iframe(id = 'distribution', style = {'border-width': '0', 'width':'700px', 'height': '550px', 'position': 'absolute', 'right': '20px'})\n \n\t\t\t\t\t\t]) # /Bar Plot\n \n \t\t\t\t], style = {'width': '1150px', 'height': '550px'}), # /Row\n \n \t], label='Data Distribution (Count)'), # /Tab1 \n \n \n\n ###\n \t### Tab 2 - Donut\n \t###\n \tdbc.Tab([\n \n \t\tdbc.Row([\n \n \t\t# Donut Menu\n \t\t\tdbc.Col([\n \t\t\n \thtml.Br(),\n \thtml.Br(),\n \t\t\t\t\t\thtml.Label([\n \t\t\t\t\t\t html.P('PLEASE SELECT AN ATTRIBUTE', style={'margin-left':'25px'}),\n \t\t\t\t\t\t dcc.Dropdown(\n \t\t\t \t\t\tid = 'values', \n \t\t\t \t\t\tvalue = 'Type of Job', \n \t\t\t \t\t\toptions = [{'label': col, 'value': col} for col in df_g.columns], \n \t\t\t \t\t\tstyle={'width': '300px', 'fontsize': 5, 'marginTop':10, 'margin-left':'10px'}, clearable=False)]),\n \t\t\t\n \t\t\t\n \t\t \thtml.Br(), \t\n \t\t \thtml.Br(),\n \t\t\t\t \thtml.P('* Hover over the plot to see the subgroup name ', style={'margin-left':'10px'}),\n \t\t\t\t \thtml.P(' and count of records', style={'margin-left':'22px'}),\n\t\t\t\t\t\t\thtml.P('* Remove / Add a subgroup on the chart by ', style={'margin-left':'10px'}),\n\t\t\t\t\t\t\thtml.P(' clicking it on the legend', style={'margin-left':'22px'}),\n\t\t\t\t\t\t\thtml.P('* Double click on a subgroup name first and', style={'margin-left':'10px'}),\n \t\t\t\t \thtml.P(' then click other subgroups you wish to compare', style={'margin-left':'22px'}),\n \t\t\t\t \thtml.Br()\t\n \t\t\t\n \t\t\t\n \t\t], style={'marginTop':20}), # /Donut Menu\n \n \n \n \t\t# Donut Plot\n \t\tdbc.Col([\n \t\t\thtml.Br(),\n\n \t\t\tdcc.Graph(id=\"pie-chart\", style = {'width': '500px', 'height': '500px','position': 'absolute', 'right': '150px'})\n \t\t\t\n \t\t]), # /Donut Plot\n \n \t\t\t\n \t\t], style = {'width': '1150px', 'height': '550px'}) # /Row\n \n \t\t], label='Data Distribution (Ratio)'), # /Tab2 \n \n \n \n\n \n ###\n \t### Tab 3 - Line \n \t###\n \tdbc.Tab([\n \n \t\tdbc.Row([\n \n \t\t\t# Line Menu\n \t\t\t\t\tdbc.Col([\n \n \t\t\t\t\t# Numerical Dropdown Menu \n \t\t\t\t\tdbc.Row([\n\n \t\t\t\t\thtml.Label([\n \t\t \t\t html.Br(),\n \t\t\t\t\t html.P('SELECT AN ATTRIBUTE FOR X AXIS',style={'margin-left':'35px'}),\n \t\t\t\t\t dcc.Dropdown(\n \t\t\t \t\t\t\tid = 'numeric-widget', \n \t\t\t \t\t\t\tvalue = 'Age', \n \t\t\t\t\t\toptions = [{'label': col, 'value': col} for col in df_n.columns], \n \t\t\t\t\t\tstyle={'width': '300px', 'fontsize': 5, 'marginTop':10,'left':'35px'})])], style={'marginTop':20}),\n\n\n \t\t\t\t\t# Categorical Dropdown Menu \n \t\t\t\t\tdbc.Row([\n \t\t\t\t \t\t html.Br(),\n \t\t\t\t \t\t\t html.Label([\n \t\t\t\t\t html.P('SELECT AN ATTRIBUTE FOR Y AXIS',style={'margin-left':'35px'}),\n \t\t\t\t\t dcc.Dropdown(\n \t\t\t\t\t \t\tid = 'categorical-widget', \n \t\t\t\t\t \t\tvalue = 'Education Level', \n \t\t\t\t\t \t\toptions = [{'label': col, 'value': col} for col in df_c.columns], \n \t\t\t\t\t \t\tstyle={'width': '300px', 'fontsize': 5, 'marginTop':10,'left':'35px'})])], style={'marginTop':20}),\n \n \n \t\n \t\t \thtml.Br(),\n \t\t\t\t \thtml.P('* Click and drag on the plot ', style={'margin-left':'15px'}),\n\t\t\t\t\t\t\thtml.P(' to highligh area', style={'margin-left':'27px'}),\n\t\t\t\t\t\t\thtml.P('* Click on the legend to highlight groups', style={'margin-left':'15px'}),\n\t\t\t\t\t\t\thtml.P(\"* Press 'shift' and click on legends \", style={'margin-left':'10px'}),\n\t\t\t\t\t\t\thtml.P(' to select more than one group', style={'margin-left':'27px'}),\n \t\t\t\t \thtml.Br()\n \n \t\t\t\t\t\t], style={'marginTop':20}), # /# Line Menus\n \n \t\n \t\n\t\t\t\t\t\t# Line Plot\n \t\t\t\t\tdbc.Col([ \n \t\thtml.Br(),\n \t\thtml.Br(),\n \t\thtml.Iframe(id = 'nc', style = {'border-width': '0', 'width': '700px', 'height': '550px','position': 'absolute', 'right': '20px'}),\n \t\n\t\t\t\t\t\t]) # /Line Plot\n \n \n \t\t], style = {'width': '1150px', 'height': '550px'}) # /Row\n \n \n \t], label='Correlation Distribution (density)'), # /Tab3\n \n \n\n ###\n \t### Plot 4\n \t###\n \tdbc.Tab([\n \n \t\t\t\tdbc.Row([\n \t\t\t\n \t\t\t\t\t# Box Menu\n \t\t\t\t\tdbc.Col([\n \t\t\t\t\n \t\t\t\t\t\t# Numerical Dropdown Menu \n \t\t\t\t\tdbc.Row([\n\n \t\t\t\t\thtml.Label([\n \t\t \t\t html.Br(),\n \t\t\t\t\t\t\t html.Br(),\n \t\t\t\t\t html.P('SELECT AN ATTRIBUTE FOR X AXIS',style={'margin-left':'35px'}),\n \t\t\t\t\t dcc.Dropdown(\n \t\t\t\t \t\t\tid = 'numeric', \n \t\t\t\t\t\t\tvalue = 'Age', \n \t\t\t\t\t\toptions = [{'label': col, 'value': col} for col in df_n.columns], \n \t\t\t\t\t\tstyle={'width': '300px', 'fontsize': 5, 'marginTop':10, 'left':'35px'})])], style={'marginTop':20}),\n\n\n \t\t\t\t\t# Categorical Dropdown Menu \n \t\t\t\t\tdbc.Row([\n \t\t\t\t \t\t html.Br(),\n \t\t\t\t \t\t\t html.Label([\n \t\t\t\t\t html.P('SELECT AN ATTRIBUTE FOR Y AXIS',style={'margin-left':'35px'}),\n \t\t\t\t\t dcc.Dropdown(\n \t\t\t\t\t \t\tid = 'categorical', \n \t\t\t\t\t \t\tvalue = 'Type of Job', \n \t\t\t\t\t \t\toptions = [{'label': col, 'value': col} for col in df_c.columns], \n \t\t\t\t\t \t\tstyle={'width': '300px', 'fontsize': 5, 'marginTop':10, 'left':'35px'})])], style={'marginTop':20}),\n \t\t\t\t\n\n \t\t \thtml.Br(), \t\n \t\t\t\t \thtml.P('* Hover over the plot to see statistical ', style={'margin-left':'15px'}),\n \t\t\t\t \thtml.P(' summary for each subgroup', style={'margin-left':'27px'}),\n\n \t\t\t\t \thtml.Br()\t\n \t\t\t\t\n \t\t\t\t\n \t\t\t\t\t], style={'marginTop':20}), # /Box Menu\n \t\t\t\t\n \t\t\t\t\n \t\t\t\t\n \t\t\t\t\t# Box Plot\n \t\t\t\t\tdbc.Col([\n \t\t\t\t\t\thtml.Br(),\n \t\thtml.Br(),\n \t\thtml.Iframe(id = 'box', style = {'border-width': '0', 'width': '700px', 'height': '550px','position': 'absolute', 'right': '20px'}),\n \t\t\t\t\n \t\t\t\t\n \t\t\t\t\t]) # /Box Plot\n \n \t], style = {'width': '1150px', 'height': '550px'}) # /Row \n \n \t], label='Correlation Distribution (details)'), # /Tab4 \t\n \t\n \t\n \t\n \t], style={'marginTop':30}) # /Tab1-4\n \t\n ]) # /Page-1\n\n\n\n\t###\n\t### Web Page 2 - Subscription Analysis\n\t###\n elif pathname == \"/page-1\":\n return dbc.Container([\n html.Br(),\n \thtml.Br(),\n \thtml.H2('Term Deposit Subscription Analysis Dashboard'),\n \thtml.Br(),\n \t\n \tdbc.Tabs([\n \t\n \t\t###\n \t\t### Tab 5\n \t\t### \n \tdbc.Tab([\n \n \t\t\t\tdbc.Row([\n \n #Left dropdown menu\n dbc.Col([\n \n # Categorical Dropdown Menu \n \t\t\t\t\tdbc.Row([\n \t\t\t\t \t\t html.Br(),\n \t\t\t\t \t\t\t html.Label([\n \t\t\t\t\t html.P('SELECT AN ATTRIBUTE FOR X AXIS',style={'margin-left':'35px'}),\n \t\t\t\t\t dcc.Dropdown(\n \t\t\t\t\t \t\tid = 'categorical_prediction', \n \t\t\t\t\t \t\tvalue = 'Type of Job', \n \t\t\t\t\t \t\toptions = [{'label': col, 'value': col} for col in df_c.columns], \n \t\t\t\t\t \t\tstyle={'width': '300px', 'fontsize': 5, 'marginTop':10, 'left':'35px'})])], style={'marginTop':20}),\n #Prediction radio item menu\n dbc.Row([\n \t\t\t\t \t\t html.Br(),\n \t\t\t\t \t\t\t html.Label([\n \t\t\t\t\t html.P('SELECT AN ATTRIBUTE FOR Y AXIS',style={'margin-left':'35px'}),\n \t\t\t\t\t dcc.RadioItems(\n id='prediction',\n options=[\n {'label': 'Yes', 'value': 'yes'},\n {'label': 'No', 'value': 'no'}],\n value='yes',\n inputStyle={\"margin-left\": \"80px\"},\n style={'width': '300px', 'fontsize': 5, 'marginTop':10,\"margin-left\": \"-45px\"})\n \n ])], style={'marginTop':20}),\n html.Br(),\n \t\t\t\t \thtml.P('* Use X axis to select categorical variables ', style={'margin-left':'15px'}),\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\thtml.P('* Use Y axis to select subsription', style={'margin-left':'15px'}),\n html.P('or non-subscription', style={'margin-left':'27px'}),\n\t\t\t\t\t\t\thtml.P('* Compare between each categories ', style={'margin-left':'15px'}),\n\t\t\t\t\t\t\t\n \t\t\t\t \thtml.Br()\n \n ],style={'marginTop':30}),\n \n \n \n #Plot 5 Bar plot\n dbc.Col([\n html.Br(),\n \t\thtml.Br(),\n \t\thtml.Iframe(id = 'barplot', style = {'border-width': '0', 'width': '750px', 'height': '1000px','position': 'absolute', 'right': '20px'})\n ])\n \t\t\t\n\n\n\n \n \t\n \t], style = {'width': '1150px', 'height': '550px'}) # /Row \n\n \n \t\t], label='Categorical Variable VS. Subscription (Count)'), # /Tab5 \n \n \n \n \n \n \n \t\t###\n \t\t### Tab 6\n \t\t### \n \tdbc.Tab([\n \n \t\t\t\tdbc.Row([\n \n #Dropdown Menu\n dbc.Col([\n # Numerical Dropdown Menu \n \t\t\t\t\tdbc.Row([\n\n \t\t\t\t\thtml.Label([\n \t\t \t\t html.Br(),\n \t\t\t\t\t\t\t html.Br(),\n \t\t\t\t\t html.P('SELECT AN ATTRIBUTE FOR X AXIS',style={'margin-left':'35px'}),\n \t\t\t\t\t dcc.Dropdown(\n \t\t\t\t \t\t\tid = 'numeric_prediction', \n \t\t\t\t\t\t\tvalue = 'Age', \n \t\t\t\t\t\toptions = [{'label': col, 'value': col} for col in df_n.columns], \n \t\t\t\t\t\tstyle={'width': '300px', 'fontsize': 5, 'marginTop':10, 'left':'35px'})])], ),\n dbc.Row([\n \t\t\t\t \t\t html.Br(),\n \t\t\t\t \t\t\t html.Label([\n \t\t\t\t\t html.P('SELECT AN ATTRIBUTE FOR Y AXIS',style={'margin-left':'35px'}),\n \t\t\t\t\t dcc.RadioItems(\n id='prediction_2',\n options=[\n {'label': 'Yes', 'value': 'yes'},\n {'label': 'No', 'value': 'no'}],\n value='yes',\n inputStyle={\"margin-left\": \"80px\"},\n style={'width': '300px', 'fontsize': 5, 'marginTop':10,\"margin-left\": \"-45px\"}),\n html.Br(),\n \t\t\t\t \thtml.P('* Use X axis to select numerical variables ', style={'margin-left':'25px'}),\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\thtml.P('* Use Y axis to select subsription', style={'margin-left':'25px'}),\n html.P('or non-subscription', style={'margin-left':'37px'}),\n\t\t\t\t\t\t\thtml.P('* Check the trend of the graph', style={'margin-left':'25px'}),\n\t\t\t\t\t\t\t\n \t\t\t\t \thtml.Br()\n \n \n ])], style={'marginTop':20}),\n \n ]),\n \n #Plot 5 Distribution Plot\n dbc.Col([\n html.Br(),\n \t\thtml.Br(),\n \t\thtml.Iframe(id = 'distributionplot', style = {'border-width': '0', 'width': '750px', 'height': '1000px','position': 'absolute', 'right': '20px'})\n ])\n \n \t\t\t\n\n\n\n \n \t\n \t], style = {'width': '1150px', 'height': '550px'}) # /Row \n\n \n \t], label='Numerical Variable VS. Subscription (Distribution)'), # /Tab6 \n \n \t\n \t], style={'marginTop':30}) # /Tab5-6\n \t\n ]) # /Page-2\n\n\n\n\n\n\t###\n\t### Page Error Handling\n ###\n return dbc.Jumbotron(\n [\n html.H1(\"404: Not found\", className=\"text-danger\"),\n html.Hr(),\n html.P(f\"The pathname {pathname} was not recognised...\"),\n ]\n )\n\n\n\n\n\n#####\n##### Plot 1 - Bar\n#####\[email protected](\n Output('distribution', 'srcDoc'),\n Input('xcol-widget', 'value'))\ndef bank_data(xcol):\n click = alt.selection_multi()\n distribution = alt.Chart(df_g).mark_bar().encode(\n y = alt.Y(xcol+':N', sort='-x'), \n x = 'count()', \n color = alt.Color(xcol, legend=None, scale=alt.Scale(scheme='blueorange')), \n tooltip = 'count()',\n opacity = alt.condition(click, alt.value(0.9), alt.value(0.2))).add_selection(click).properties(width = 400, height = 400).configure_axis(\n labelFontSize=20,\n titleFontSize=25)\n return distribution.to_html()\n \n \n\n \n \n#####\n##### Plot 2 - Donut\n#####\[email protected](\n Output(\"pie-chart\", \"figure\"), \n Input(\"values\", \"value\"))\n\ndef generate_chart(valu):\n data1 = df_g.groupby(valu)[valu].count().reset_index(name='counts')\n fig = px.pie(data1, values='counts', names=valu, color_discrete_sequence=px.colors.sequential.RdBu)\n fig.update_traces(hole=.6, hoverinfo=\"label+percent+name\")\n fig.update_layout(margin=dict(t=0, b=0, l=0, r=0))\n return fig\n\n\n\n\n\n#####\n##### Plot 3 - Line\n#####\[email protected](\n Output('nc', 'srcDoc'),\n Input('numeric-widget', 'value'),\n Input('categorical-widget', 'value'))\n\ndef nc_plot(numeric, categorical):\n brush = alt.selection_interval()\n click = alt.selection_multi(fields=[categorical], bind='legend')\n\n chart = alt.Chart(df).mark_line().encode(\n alt.X(numeric + ':Q', bin=alt.Bin(maxbins=30)),\n y = 'count()',\n color = alt.Color(categorical + \":N\", scale=alt.Scale(scheme='blueorange')),\n opacity = alt.condition(click, alt.value(0.9), alt.value(0.2))\n ).add_selection(brush).add_selection(click).properties(width = 400, height = 400).configure_axis(\n labelFontSize=20,\n titleFontSize=25)\n \n return chart.to_html()\n\n\n\n\n\n#####\n##### Plot 4 - Box\n#####\[email protected](\n Output('box', 'srcDoc'),\n Input('numeric', 'value'),\n Input('categorical', 'value'))\n\ndef nc_plot(numeric, categorical):\n\tchart = alt.Chart(df).mark_boxplot().encode(\n \tx=categorical,\n \ty=numeric,\n \tcolor = alt.Color(categorical, scale=alt.Scale(scheme='blueorange'))\n \t).properties(width = 400, height = 400).configure_axis(\n labelFontSize=20,\n titleFontSize=25)\n\n\treturn chart.to_html()\n\t\n\t\n\t\n\t\n\t\n#####\n##### Plot 5 - Bar\n#####\n\[email protected](\n Output('barplot','srcDoc'),\n Input('categorical_prediction','value'),\n Input('prediction','value'))\n\ndef bar_plot(xcol,ycol):\n alt.data_transformers.disable_max_rows()\n click = alt.selection_multi()\n chart = alt.Chart(df[(df[\"Predicted Subscription (current)\"] == ycol)]).mark_bar().encode(\n alt.X(xcol,title = xcol), \n y= \"count(Type of Job)\",\n color = alt.Color(xcol, legend=None)\n ).properties(width=alt.Step(50)).configure_axis(\n labelFontSize=20,\n titleFontSize=25)\n return chart.to_html()\n\n\n\n\n\n\n\n\n#####\n##### Plot 6 - Distribution\n#####\n\[email protected](\n Output('distributionplot','srcDoc'),\n Input('numeric_prediction','value'),\n Input('prediction_2','value'))\n\ndef distribution_plot(xcol,ycol):\n alt.data_transformers.disable_max_rows()\n chart = alt.Chart(df[(df[\"Predicted Subscription (current)\"] == ycol)]).mark_bar().encode(\n alt.X(xcol,title = xcol), \n y= \"count()\"\n ).configure_axis(\n labelFontSize=20,\n titleFontSize=25)\n return chart.to_html()\n\n\n\n\n\n\nif __name__ == \"__main__\":\n app.run_server()\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n"
] |
[
[
"pandas.read_csv"
]
] |
ScienceKot/kydavra
|
[
"e17f3855b94045953d0df6d13b9d9e0dffa9a8a3"
] |
[
"kydavra/GeneticAlgorithmSelector.py"
] |
[
"'''\r\nCreated with love by Sigmoid\r\n\r\n@Author - Păpăluță Vasile - [email protected]\r\n'''\r\n# Importing all needed libraries\r\nimport random\r\nfrom sklearn.metrics import accuracy_score\r\nfrom sklearn.model_selection import train_test_split\r\nclass GeneticAlgorithmSelector:\r\n def __init__(self, nb_children : int = 4, nb_generation : int = 200, scoring_metric = accuracy_score, max : bool = True) -> None:\r\n '''\r\n Setting up the model\r\n :param nb_children: integer, default = 4\r\n The number of children created at every generation\r\n :param nb_generation: integer, default = 200\r\n The number of generations created to find the best feature combination\r\n :param scoring_metric: function, default = sklearn.metrics.accuracy_score\r\n The sklearn like scoring metric\r\n :param max: boolean, default = True\r\n Used to define whatever we need the biggest of the smallest values computed by self.scoring_metric\r\n '''\r\n self.nb_children = nb_children\r\n self.nb_generation = nb_generation\r\n self.scoring_metric = scoring_metric\r\n self.max = max\r\n def inverse(self, value : int) -> int :\r\n '''\r\n This function inverses the value coming to function\r\n :param value: integer, o or 1\r\n The value that should be inverted\r\n :return: integer\r\n Return the inverse of :param value (if value = 0 ==> 1, else 0)\r\n '''\r\n if value == 0:\r\n return 1\r\n else:\r\n return 0\r\n def cross_over(self, population : list) -> list:\r\n '''\r\n This function apply the crossing-over process on 2 arrys-like lists\r\n :param population: 2-d array like list\r\n The population with 2 array that will be uses to create new individuals in the population\r\n :return: 2-d array like list\r\n Return the population with parents and their children after corssing-over\r\n '''\r\n # Creating an empty list for the new generation\r\n new_generation = []\r\n\r\n # Adding nb_children children to the new generatin\r\n for i in range(self.nb_children//2):\r\n first = random.randrange(0, len(self.X_columns)-1)\r\n second = random.randrange(0, len(self.X_columns)-1)\r\n if first > second:\r\n first, second = second, first\r\n new_generation.append(population[0][0:first] + population[1][first: second] + population[0][second:])\r\n new_generation.append(population[1][0:first] + population[0][first: second] + population[1][second:])\r\n\r\n # Adding the new generation to the population\r\n for gene in new_generation:\r\n population.append(gene)\r\n return population\r\n def mutate(self, gene : list) -> list:\r\n '''\r\n This function generates a random mutation on a gene\r\n :param gene: 1-d array like list\r\n The list with zeros and ones that will be mutated\r\n :return: 1-drray like list\r\n The gene list after mutation\r\n '''\r\n # Choosing a random place to generate a mutation\r\n mutation_locus = random.randrange(0, len(self.X_columns)-1)\r\n\r\n # Generating a mutation\r\n gene[mutation_locus] = self.inverse(gene[mutation_locus])\r\n return gene\r\n def gene_to_cols(self, gene : list) -> list:\r\n '''\r\n This function convert the zeros and ones list to columns list\r\n :param gene: 1-d array like list\r\n The list with zeros and ones that must be transformed in a columns sequence\r\n :return: 1-d array like list\r\n The lust with columns that will go to the model\r\n '''\r\n cols = []\r\n for i in range(len(gene)):\r\n if gene[i] == 1:\r\n cols.append(self.X_columns[i])\r\n return cols\r\n def select(self, algo, dataframe : 'pd.DataFrame', y_column : str, test_size=0.2):\r\n '''\r\n This function selects the best columns\r\n :param algo: sklearn algorithm class\r\n An sklearn algorithm class\r\n :param dataframe: pandas DataFrame\r\n Data Frame on which the algorithm is applied\r\n :param y_column: string\r\n The column name of the value that we what to predict\r\n :param test_size: float, default = 0.2\r\n The percent of data set that will be used to find the trained algorithm accuracy\r\n :return: list\r\n The list of columns selected by algorithm\r\n '''\r\n # Getting the list with names of columns without the target one\r\n self.X_columns = [col for col in dataframe.columns if col != y_column]\r\n\r\n # Generating the empty population and a temporal one\r\n population = []\r\n temp = []\r\n for i in range(len(self.X_columns)):\r\n temp.append(random.choice([0, 1]))\r\n population.append(temp)\r\n temp = [self.inverse(x) for x in population[-1]]\r\n population.append(temp)\r\n\r\n # Creating new generations and testing in searching for individual with the best metric\r\n for gen in range(self.nb_generation):\r\n # Creating an empty list with the metrics\r\n acc = []\r\n\r\n # Generating the first cross-over\r\n population = self.cross_over(population)\r\n\r\n # Generating some mutations\r\n for i in range(2, len(population)):\r\n population[i] = self.mutate(population[i])\r\n\r\n # Measuring the accuracy of every individual in the population\r\n for gene in population:\r\n if set(gene) == set([0]):\r\n continue\r\n X = dataframe[self.gene_to_cols(gene)].values\r\n y = dataframe[y_column].values\r\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=test_size, random_state=0)\r\n algo.fit(X_train, y_train)\r\n y_pred = algo.predict(X_test)\r\n acc.append(self.scoring_metric(y_test, y_pred))\r\n\r\n # Selecting the 2 best members of the population based on whatever the metric's property\r\n if self.max:\r\n res = sorted(range(len(acc)), key=lambda sub: acc[sub])[-2:]\r\n else:\r\n res = sorted(range(len(acc)), key=lambda sub: acc[sub])[:2]\r\n\r\n # Creating a new population with the 2 best members\r\n population = [population[res[0]], population[res[1]]]\r\n return self.gene_to_cols(population[0])"
] |
[
[
"sklearn.model_selection.train_test_split"
]
] |
js05212/CollaborativeDeepLearning-TensorFlow
|
[
"f0891a7ce017f0560dca61bb7093d267f6212211"
] |
[
"train_cdl.py"
] |
[
"from lib.cdl import *\nimport numpy as np\nimport tensorflow as tf\nimport scipy.io\nfrom lib.utils import *\n\nnp.random.seed(0)\ntf.set_random_seed(0)\ninit_logging(\"cdl.log\")\n\ndef load_cdl_data():\n data = {}\n data_dir = \"data/citeulike-a/\"\n variables = scipy.io.loadmat(data_dir + \"mult_nor.mat\")\n data[\"content\"] = variables['X']\n\n data[\"train_users\"] = load_rating(data_dir + \"cf-train-1-users.dat\")\n data[\"train_items\"] = load_rating(data_dir + \"cf-train-1-items.dat\")\n data[\"test_users\"] = load_rating(data_dir + \"cf-test-1-users.dat\")\n data[\"test_items\"] = load_rating(data_dir + \"cf-test-1-items.dat\")\n\n return data\n\ndef load_rating(path):\n arr = []\n for line in open(path):\n a = line.strip().split()\n if a[0]==0:\n l = []\n else:\n l = [int(x) for x in a[1:]]\n arr.append(l)\n return arr\n\nparams = Params()\nparams.lambda_u = 1\nparams.lambda_v = 10\nparams.lambda_r = 10000 #1\nparams.a = 1\nparams.b = 0.01\nparams.M = 300\nparams.n_epochs = 100 #100\nparams.max_iter = 100 #100/1\n\ndata = load_cdl_data()\nnum_factors = 50\nmodel = CDL(num_users=5551, num_items=16980, num_factors=num_factors, params=params, \n input_dim=8000, dims=[50], n_z=num_factors, activations=['sigmoid'], \n #loss_type='cross-entropy', lr=0.001, random_seed=0, print_step=10, noise='sp', verbose=False)\n loss_type='cross-entropy', lr=0.001, random_seed=0, print_step=10, noise='mask-0.3', dropout=0.8, verbose=False)\nmodel.load_model(weight_path=\"model/pretrain_cdl\")\nmodel.run(data[\"train_users\"], data[\"train_items\"], data[\"test_users\"], data[\"test_items\"],\n data[\"content\"], params)\nmodel.save_model(weight_path=\"model/cdl\", pmf_path=\"model/pmf_cdl\")\n"
] |
[
[
"tensorflow.set_random_seed",
"numpy.random.seed"
]
] |
PandasCute/DeepCTR
|
[
"bd5dc215e1c21bf12e6b5297d10f293c45e16c77"
] |
[
"deepctr/models/autoint.py"
] |
[
"# -*- coding:utf-8 -*-\n\"\"\"\n\nAuthor:\n Weichen Shen,[email protected]\n\nReference:\n [1] Song W, Shi C, Xiao Z, et al. AutoInt: Automatic Feature Interaction Learning via Self-Attentive Neural Networks[J]. arXiv preprint arXiv:1810.11921, 2018.(https://arxiv.org/abs/1810.11921)\n\n\"\"\"\n\nimport tensorflow as tf\nfrom ..input_embedding import get_inputs_embedding\nfrom ..layers import PredictionLayer, MLP, InteractingLayer\nfrom ..utils import concat_fun\n\n\ndef AutoInt(feature_dim_dict, embedding_size=8, att_layer_num=3, att_embedding_size=8, att_head_num=2, att_res=True, hidden_size=(256, 256), activation='relu',\n l2_reg_deep=0, l2_reg_embedding=1e-5, use_bn=False, keep_prob=1.0, init_std=0.0001, seed=1024,\n final_activation='sigmoid',):\n \"\"\"Instantiates the AutoInt Network architecture.\n\n :param feature_dim_dict: dict,to indicate sparse field and dense field like {'sparse':{'field_1':4,'field_2':3,'field_3':2},'dense':['field_4','field_5']}\n :param embedding_size: positive integer,sparse feature embedding_size\n :param att_layer_num: int.The InteractingLayer number to be used.\n :param att_embedding_size: int.The embedding size in multi-head self-attention network.\n :param att_head_num: int.The head number in multi-head self-attention network.\n :param att_res: bool.Whether or not use standard residual connections before output.\n :param hidden_size: list,list of positive integer or empty list, the layer number and units in each layer of deep net\n :param activation: Activation function to use in deep net\n :param l2_reg_deep: float. L2 regularizer strength applied to deep net\n :param l2_reg_embedding: float. L2 regularizer strength applied to embedding vector\n :param use_bn: bool. Whether use BatchNormalization before activation or not.in deep net\n :param keep_prob: float in (0,1]. keep_prob used in deep net\n :param init_std: float,to use as the initialize std of embedding vector\n :param seed: integer ,to use as random seed.\n :param final_activation: output activation,usually ``'sigmoid'`` or ``'linear'``\n :return: A Keras model instance.\n \"\"\"\n\n if len(hidden_size) <= 0 and att_layer_num <= 0:\n raise ValueError(\"Either hidden_layer or att_layer_num must > 0\")\n if not isinstance(feature_dim_dict, dict) or \"sparse\" not in feature_dim_dict or \"dense\" not in feature_dim_dict:\n raise ValueError(\n \"feature_dim must be a dict like {'sparse':{'field_1':4,'field_2':3,'field_3':2},'dense':['field_5',]}\")\n\n deep_emb_list, _, inputs_list = get_inputs_embedding(\n feature_dim_dict, embedding_size, l2_reg_embedding, 0, init_std, seed, False)\n\n att_input = concat_fun(deep_emb_list, axis=1)\n\n for _ in range(att_layer_num):\n att_input = InteractingLayer(\n att_embedding_size, att_head_num, att_res)(att_input)\n att_output = tf.keras.layers.Flatten()(att_input)\n\n deep_input = tf.keras.layers.Flatten()(concat_fun(deep_emb_list))\n\n if len(hidden_size) > 0 and att_layer_num > 0: # Deep & Interacting Layer\n deep_out = MLP(hidden_size, activation, l2_reg_deep, keep_prob,\n use_bn, seed)(deep_input)\n stack_out = tf.keras.layers.Concatenate()([att_output, deep_out])\n final_logit = tf.keras.layers.Dense(\n 1, use_bias=False, activation=None)(stack_out)\n elif len(hidden_size) > 0: # Only Deep\n deep_out = MLP(hidden_size, activation, l2_reg_deep, keep_prob,\n use_bn, seed)(deep_input)\n final_logit = tf.keras.layers.Dense(\n 1, use_bias=False, activation=None)(deep_out)\n elif att_layer_num > 0: # Only Interacting Layer\n final_logit = tf.keras.layers.Dense(\n 1, use_bias=False, activation=None)(att_output)\n else: # Error\n raise NotImplementedError\n\n output = PredictionLayer(final_activation)(final_logit)\n\n model = tf.keras.models.Model(inputs=inputs_list, outputs=output)\n\n return model\n"
] |
[
[
"tensorflow.keras.layers.Concatenate",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.layers.Flatten",
"tensorflow.keras.models.Model"
]
] |
djcunningham0/multielo
|
[
"de91e3caa9906db56ae4f30cf0b3dccefa00af5c"
] |
[
"tests/test_score_functions.py"
] |
[
"import pytest\nimport numpy as np\nfrom multielo.score_functions import linear_score_function, create_exponential_score_function\nfrom multielo import MultiElo\n\nfrom typing import List\n\n\ndef test_2_player_score_function():\n # should always return [1, 0]\n linear_scores = linear_score_function(2)\n assert np.allclose(linear_scores, np.array([1, 0])), \\\n f\"linear score function does not return [1, 0] for 2-player matchup: {linear_scores}\"\n\n for base in np.random.uniform(1, 3, 10).tolist():\n func = create_exponential_score_function(base)\n exp_scores = func(2)\n assert np.allclose(exp_scores, np.array([1, 0])), \\\n f\"exponential score function does not return [1, 0] for 2-player matchup for base={base}: {exp_scores}\"\n\n\ndef test_linear_score_function():\n for n in range(3, 11):\n scores = linear_score_function(n)\n score_diffs = np.diff(scores)\n assert np.allclose(scores.sum(), 1), f\"linear score function does not sum to 1 for n={n}: {scores}\"\n assert np.allclose(scores.min(), 0), \\\n f\"linear score function does not have minimum score of 0 for n={n}: {scores}\"\n assert np.all(score_diffs < 0), \\\n f\"linear score function is not monotonically decreasing for n={n}: {scores}\"\n\n\ndef test_exponential_score_function():\n for base in np.random.uniform(1, 3, 10).tolist():\n for n in range(3, 11):\n func = create_exponential_score_function(base)\n scores = func(n)\n score_diffs = np.diff(scores)\n assert np.allclose(scores.sum(), 1), \\\n f\"exponential score function does not sum to 1 for base={base}, n={n}\"\n assert np.allclose(scores.min(), 0), \\\n f\"exponential score function does not have minimum score of 0 for n={n}, base={base}: {scores}\"\n assert np.all(score_diffs < 0), \\\n f\"exponential score function is not monotonically decreasing for base={base}, n={n}: {scores}\"\n # differences should also be monotonically increasing (less negative) for exponential score function\n assert np.all(np.diff(score_diffs) > 0), \\\n f\"exponential score function diffs are not monotonically increasing for base={base}, n={n}: {scores}\"\n\n\[email protected](\n \"result_order, actual_scores, base\",\n [\n ([1, 1], [0.5, 0.5], 1),\n ([1, 1], [0.5, 0.5], 2),\n ([1, 1, 1], [1/3, 1/3, 1/3], 1),\n ([1, 2, 2], [2/3, 1/6, 1/6], 1),\n ([1, 1, 2], [0.5, 0.5, 0], 1),\n ([1, 1, 1], [1/3, 1/3, 1/3], 2),\n ([1, 2, 2], [0.75, 0.125, 0.125], 2),\n ([1, 1, 2], [0.5, 0.5, 0], 2),\n ]\n)\ndef test_tie_actual_scores(\n result_order: List[int],\n actual_scores: List[float],\n base: float,\n):\n elo = MultiElo(score_function_base=base)\n n = len(result_order)\n scores = elo.get_actual_scores(n=n, result_order=result_order)\n assert np.allclose(scores, actual_scores)\n"
] |
[
[
"numpy.allclose",
"numpy.all",
"numpy.diff",
"numpy.random.uniform",
"numpy.array"
]
] |
trialanderror123/APSPT
|
[
"1eae0075efd066443037d69d165199eb07e3ad9e"
] |
[
"src/data/dataloader.py"
] |
[
"import torch\nfrom src.features.build_features import build_features\nfrom src.utils import load_train_data, load_prediction_data\nfrom src.config import *\nfrom torch.utils.data import TensorDataset, DataLoader, RandomSampler, SequentialSampler\nfrom transformers import *\nfrom sklearn.model_selection import train_test_split\n\n\n\ndef dataloader_train():\n data = load_train_data()\n data = build_features(data)\n\n tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True) # tokenizer\n encodings = tokenizer.batch_encode_plus(list(data.content.values),max_length=MAX_LENGTH,pad_to_max_length=True) # tokenizer's encoding method\n print('tokenizer outputs: ', encodings.keys())\n\n input_ids = encodings['input_ids'] # tokenized and encoded sentences\n token_type_ids = encodings['token_type_ids'] # token type ids\n attention_masks = encodings['attention_mask'] # attention masks\n\n # Identifying indices of 'one_hot_labels' entries that only occur once - this will allow us to stratify split our training data later\n label_counts = data.one_hot_labels.astype(str).value_counts()\n one_freq = label_counts[label_counts==1].keys()\n one_freq_idxs = sorted(list(data[data.one_hot_labels.astype(str).isin(one_freq)].index), reverse=True)\n print('data label indices with only one instance: ', one_freq_idxs)\n\n # Gathering single instance inputs to force into the training set after stratified split\n one_freq_input_ids = [input_ids.pop(i) for i in one_freq_idxs]\n one_freq_token_types = [token_type_ids.pop(i) for i in one_freq_idxs]\n one_freq_attention_masks = [attention_masks.pop(i) for i in one_freq_idxs]\n one_freq_labels = [LABELS.pop(i) for i in one_freq_idxs]\n print(\"input_ids: {}, list(data.one_hot_labels.values): {}, token_type_ids: {},attention_masks: {}\".format(len(input_ids), len(list(data.one_hot_labels.values)), len(token_type_ids),len(attention_masks)))\n\n train_inputs, validation_inputs, train_labels, validation_labels, train_token_types, validation_token_types, train_masks, validation_masks = train_test_split(input_ids, list(data.one_hot_labels.values), token_type_ids,attention_masks,\n random_state=2020, test_size=TEST_SIZE, stratify = list(data.one_hot_labels.values))\n\n # Add one frequency data to train data\n train_inputs.extend(one_freq_input_ids)\n train_labels.extend(one_freq_labels)\n train_masks.extend(one_freq_attention_masks)\n train_token_types.extend(one_freq_token_types)\n\n # Convert all of our data into torch tensors, the required datatype for our model\n train_inputs = torch.tensor(train_inputs)\n train_labels = torch.tensor(train_labels)\n train_masks = torch.tensor(train_masks)\n train_token_types = torch.tensor(train_token_types)\n\n validation_inputs = torch.tensor(validation_inputs)\n validation_labels = torch.tensor(validation_labels)\n validation_masks = torch.tensor(validation_masks)\n validation_token_types = torch.tensor(validation_token_types)\n\n train_data = TensorDataset(train_inputs, train_masks, train_labels, train_token_types)\n\n train_sampler = RandomSampler(train_data)\n train_dataloader = DataLoader(train_data, sampler=train_sampler, batch_size=BATCH_SIZE)\n\n validation_data = TensorDataset(validation_inputs, validation_masks, validation_labels, validation_token_types)\n validation_sampler = SequentialSampler(validation_data)\n validation_dataloader = DataLoader(validation_data, sampler=validation_sampler, batch_size=BATCH_SIZE)\n\n return train_dataloader, validation_dataloader\n\ndef dataloader_prediction():\n data = load_prediction_data()\n data = data[data['content'].notna()]\n tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True) # tokenizer\n encodings = tokenizer.batch_encode_plus(list(data.content.values),max_length=MAX_LENGTH,pad_to_max_length=True) # tokenizer's encoding method\n input_ids = torch.tensor(encodings['input_ids'], dtype=torch.int32) # tokenized and encoded sentences\n attention_masks = torch.tensor(encodings['attention_mask'], dtype=torch.int32) # attention masks\n return input_ids, attention_masks\n "
] |
[
[
"torch.utils.data.TensorDataset",
"torch.utils.data.SequentialSampler",
"torch.utils.data.DataLoader",
"torch.utils.data.RandomSampler",
"torch.tensor"
]
] |
kosehy/TensorNetwork
|
[
"6478f03bc69e76487b04e69c11f29bbde7ded2e6"
] |
[
"tensornetwork/backends/jax/jax_backend_test.py"
] |
[
"# pytype: skip-file\n\"\"\"Tests for graphmode_tensornetwork.\"\"\"\nimport tensorflow as tf\nimport numpy as np\nimport jax\nimport pytest\nfrom tensornetwork.backends.jax import jax_backend\n\nnp_randn_dtypes = [np.float32, np.float16, np.float64]\nnp_dtypes = np_randn_dtypes + [np.complex64, np.complex128]\n\n\ndef test_tensordot():\n backend = jax_backend.JaxBackend()\n a = backend.convert_to_tensor(2 * np.ones((2, 3, 4)))\n b = backend.convert_to_tensor(np.ones((2, 3, 4)))\n actual = backend.tensordot(a, b, ((1, 2), (1, 2)))\n expected = np.array([[24.0, 24.0], [24.0, 24.0]])\n np.testing.assert_allclose(expected, actual)\n\n\ndef test_reshape():\n backend = jax_backend.JaxBackend()\n a = backend.convert_to_tensor(np.ones((2, 3, 4)))\n actual = backend.shape_tuple(backend.reshape(a, np.array((6, 4, 1))))\n assert actual == (6, 4, 1)\n\n\ndef test_transpose():\n backend = jax_backend.JaxBackend()\n a = backend.convert_to_tensor(\n np.array([[[1., 2.], [3., 4.]], [[5., 6.], [7., 8.]]]))\n actual = backend.transpose(a, [2, 0, 1])\n expected = np.array([[[1.0, 3.0], [5.0, 7.0]], [[2.0, 4.0], [6.0, 8.0]]])\n np.testing.assert_allclose(expected, actual)\n\n\ndef test_concat():\n backend = jax_backend.JaxBackend()\n a = backend.convert_to_tensor(2 * np.ones((1, 3, 1)))\n b = backend.convert_to_tensor(np.ones((1, 2, 1)))\n expected = backend.concat((a, b), axis=1)\n actual = np.array([[[2.0], [2.0], [2.0], [1.0], [1.0]]])\n np.testing.assert_allclose(expected, actual)\n\n\ndef test_shape():\n backend = jax_backend.JaxBackend()\n a = backend.convert_to_tensor(np.ones([2, 3, 4]))\n assert isinstance(backend.shape(a), tuple)\n actual = backend.shape(a)\n expected = np.array([2, 3, 4])\n np.testing.assert_allclose(expected, actual)\n\n\ndef test_shape_tuple():\n backend = jax_backend.JaxBackend()\n a = backend.convert_to_tensor(np.ones([2, 3, 4]))\n actual = backend.shape_tuple(a)\n assert actual == (2, 3, 4)\n\n\ndef test_prod():\n backend = jax_backend.JaxBackend()\n a = backend.convert_to_tensor(2 * np.ones([1, 2, 3, 4]))\n actual = np.array(backend.prod(a))\n assert actual == 2**24\n\n\ndef test_sqrt():\n backend = jax_backend.JaxBackend()\n a = backend.convert_to_tensor(np.array([4., 9.]))\n actual = backend.sqrt(a)\n expected = np.array([2, 3])\n np.testing.assert_allclose(expected, actual)\n\n\ndef test_diag():\n backend = jax_backend.JaxBackend()\n a = backend.convert_to_tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]))\n with pytest.raises(TypeError):\n assert backend.diag(a)\n b = backend.convert_to_tensor(np.array([1.0, 2, 3]))\n actual = backend.diag(b)\n expected = np.array([[1.0, 0.0, 0.0], [0.0, 2.0, 0.0], [0.0, 0.0, 3.0]])\n np.testing.assert_allclose(expected, actual)\n\n\ndef test_convert_to_tensor():\n backend = jax_backend.JaxBackend()\n array = np.ones((2, 3, 4))\n actual = backend.convert_to_tensor(array)\n expected = jax.jit(lambda x: x)(array)\n assert isinstance(actual, type(expected))\n np.testing.assert_allclose(expected, actual)\n\n\ndef test_trace():\n backend = jax_backend.JaxBackend()\n a = backend.convert_to_tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]))\n actual = backend.trace(a)\n np.testing.assert_allclose(actual, 6)\n\n\ndef test_outer_product():\n backend = jax_backend.JaxBackend()\n a = backend.convert_to_tensor(2 * np.ones((2, 1)))\n b = backend.convert_to_tensor(np.ones((1, 2, 2)))\n actual = backend.outer_product(a, b)\n expected = np.array([[[[[2.0, 2.0], [2.0, 2.0]]]], [[[[2.0, 2.0], [2.0,\n 2.0]]]]])\n np.testing.assert_allclose(expected, actual)\n\n\ndef test_einsum():\n backend = jax_backend.JaxBackend()\n a = backend.convert_to_tensor(2 * np.ones((2, 1)))\n b = backend.convert_to_tensor(np.ones((1, 2, 2)))\n actual = backend.einsum('ij,jil->l', a, b)\n expected = np.array([4.0, 4.0])\n np.testing.assert_allclose(expected, actual)\n\n\ndef test_convert_bad_test():\n backend = jax_backend.JaxBackend()\n with pytest.raises(TypeError):\n backend.convert_to_tensor(tf.ones((2, 2)))\n\n\ndef test_norm():\n backend = jax_backend.JaxBackend()\n a = backend.convert_to_tensor(np.ones((2, 2)))\n assert backend.norm(a) == 2\n\n\[email protected](\"dtype\", np_dtypes)\ndef test_eye(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.eye(N=4, M=5, dtype=dtype)\n np.testing.assert_allclose(np.eye(N=4, M=5, dtype=dtype), a)\n\n\[email protected](\"dtype\", np_dtypes)\ndef test_ones(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.ones((4, 4), dtype=dtype)\n np.testing.assert_allclose(np.ones((4, 4), dtype=dtype), a)\n\n\[email protected](\"dtype\", np_dtypes)\ndef test_zeros(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.zeros((4, 4), dtype=dtype)\n np.testing.assert_allclose(np.zeros((4, 4), dtype=dtype), a)\n\n\[email protected](\"dtype\", np_randn_dtypes)\ndef test_randn(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.randn((4, 4), dtype=dtype)\n assert a.shape == (4, 4)\n\n\[email protected](\"dtype\", np_randn_dtypes)\ndef test_random_uniform(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.random_uniform((4, 4), dtype=dtype)\n assert a.shape == (4, 4)\n\n\[email protected](\"dtype\", [np.complex64, np.complex128])\ndef test_randn_non_zero_imag(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.randn((4, 4), dtype=dtype)\n assert np.linalg.norm(np.imag(a)) != 0.0\n\n\[email protected](\"dtype\", [np.complex64, np.complex128])\ndef test_random_uniform_non_zero_imag(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.random_uniform((4, 4), dtype=dtype)\n assert np.linalg.norm(np.imag(a)) != 0.0\n\n\[email protected](\"dtype\", np_dtypes)\ndef test_eye_dtype(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.eye(N=4, M=4, dtype=dtype)\n assert a.dtype == dtype\n\n\[email protected](\"dtype\", np_dtypes)\ndef test_ones_dtype(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.ones((4, 4), dtype=dtype)\n assert a.dtype == dtype\n\n\[email protected](\"dtype\", np_dtypes)\ndef test_zeros_dtype(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.zeros((4, 4), dtype=dtype)\n assert a.dtype == dtype\n\n\[email protected](\"dtype\", np_randn_dtypes)\ndef test_randn_dtype(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.randn((4, 4), dtype=dtype)\n assert a.dtype == dtype\n\n\[email protected](\"dtype\", np_randn_dtypes)\ndef test_random_uniform_dtype(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.random_uniform((4, 4), dtype=dtype)\n assert a.dtype == dtype\n\n\[email protected](\"dtype\", np_randn_dtypes)\ndef test_randn_seed(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.randn((4, 4), seed=10, dtype=dtype)\n b = backend.randn((4, 4), seed=10, dtype=dtype)\n np.testing.assert_allclose(a, b)\n\n\[email protected](\"dtype\", np_randn_dtypes)\ndef test_random_uniform_seed(dtype):\n backend = jax_backend.JaxBackend()\n a = backend.random_uniform((4, 4), seed=10, dtype=dtype)\n b = backend.random_uniform((4, 4), seed=10, dtype=dtype)\n np.testing.assert_allclose(a, b)\n\n\[email protected](\"dtype\", np_randn_dtypes)\ndef test_random_uniform_boundaries(dtype):\n lb = 1.2\n ub = 4.8\n backend = jax_backend.JaxBackend()\n a = backend.random_uniform((4, 4), seed=10, dtype=dtype)\n b = backend.random_uniform((4, 4), (lb, ub), seed=10, dtype=dtype)\n assert((a >= 0).all() and (a <= 1).all() and\n (b >= lb).all() and (b <= ub).all())\n\n\ndef test_random_uniform_behavior():\n seed = 10\n key = jax.random.PRNGKey(seed)\n backend = jax_backend.JaxBackend()\n a = backend.random_uniform((4, 4), seed=seed)\n b = jax.random.uniform(key, (4, 4))\n np.testing.assert_allclose(a, b)\n\n\ndef test_conj():\n backend = jax_backend.JaxBackend()\n real = np.random.rand(2, 2, 2)\n imag = np.random.rand(2, 2, 2)\n a = backend.convert_to_tensor(real + 1j * imag)\n actual = backend.conj(a)\n expected = real - 1j * imag\n np.testing.assert_allclose(expected, actual)\n\n\[email protected](\"dtype\", np_randn_dtypes)\ndef index_update(dtype):\n backend = jax_backend.JaxBackend()\n tensor = backend.randn((4, 2, 3), dtype=dtype, seed=10)\n out = backend.index_update(tensor, tensor > 0.1, 0.0)\n tensor = np.array(tensor)\n tensor[tensor > 0.1] = 0.0\n np.testing.assert_allclose(tensor, out)\n"
] |
[
[
"numpy.imag",
"numpy.eye",
"tensorflow.ones",
"numpy.ones",
"numpy.random.rand",
"numpy.testing.assert_allclose",
"numpy.array",
"numpy.zeros"
]
] |
joenghl/AMC_MPE
|
[
"2b629e52e2ad8dec546868b6b74035c895368b3f"
] |
[
"multiagent/scenarios/evader_v0.py"
] |
[
"import numpy as np\r\nfrom multiagent.core import World, Agent, Landmark\r\nfrom multiagent.scenario import BaseScenario\r\n\r\nclass Scenario(BaseScenario):\r\n \"\"\"\r\n chaser and evader\r\n \"\"\"\r\n def make_world(self):\r\n world = World()\r\n # set any world properties\r\n world.dim_c = 2\r\n num_agents = 5\r\n num_evaders = 1\r\n world.num_agents = num_agents\r\n # add agents (evaders)\r\n world.agents = [Agent() for i in range(num_agents)]\r\n for i, agent in enumerate(world.agents):\r\n agent.name = 'agent %d' % i\r\n agent.collide = True\r\n agent.silent = True\r\n agent.evader = True if i < num_evaders else False # 逃跑者\r\n agent.size = 0.02\r\n agent.max_speed = 1.0\r\n\r\n \r\n # make initial conditions\r\n self.reset_world(world)\r\n return world\r\n\r\n def reset_world(self, world):\r\n # random properties for agents\r\n for i, agent in enumerate(world.agents):\r\n if agent.evader is True:\r\n agent.color = np.array([0.7, 0.1, 0.1])\r\n else:\r\n agent.color = np.array([0.1, 0.1, 0.7])\r\n # set random initial states\r\n for agent in world.agents:\r\n agent.state.p_pos = np.random.uniform(-1, +1, world.dim_p)\r\n agent.state.p_vel = np.zeros(world.dim_p)\r\n agent.state.c = np.zeros(world.dim_c)\r\n\r\n\r\n def is_collision(self, agent1, agent2):\r\n delta_pos = agent1.state.p_pos - agent2.state.p_pos\r\n dist = np.sqrt(np.sum(np.square(delta_pos)))\r\n dist_min = agent1.size + agent2.size\r\n return True if dist < dist_min else False\r\n\r\n def good_agents(self, world):\r\n return [agent for agent in world.agents if agent.evader is not True]\r\n\r\n def evaders(self, world):\r\n return [agent for agent in world.agents if agent.evader is True]\r\n\r\n def reward(self, agent, world):\r\n return self.evader_reward(agent, world) if agent.evader else self.agent_reward(agent, world)\r\n\r\n def agent_reward(self, agent, world):\r\n \"\"\"\r\n agent 奖励分两部分，共享的和私有的\r\n 共享奖励为逃跑者的速度×-1\r\n 私有奖励为是否进入逃跑者范围\r\n 碰撞奖励 -1\r\n \"\"\"\r\n good_agents = self.good_agents(world)\r\n evaders = self.evaders(world)\r\n rew = 0\r\n share_reward = 0\r\n private_rew = 0\r\n view = 0.12\r\n e_vel = []\r\n\r\n if agent.collide:\r\n for a in world.agents:\r\n if a == agent: continue\r\n if self.is_collision(a, agent):\r\n rew -= 1\r\n\r\n for e in evaders:\r\n e_vel.append(e.state.p_vel)\r\n delta_pos = agent.state.p_pos - e.state.p_pos\r\n dist = np.sqrt(np.sum(np.square(delta_pos)))\r\n if dist < view:\r\n private_rew += 1.0\r\n for i in e_vel:\r\n absv = np.sqrt(np.sum(np.square(i)))\r\n share_reward -= absv * 1.0\r\n rew = share_reward + private_rew\r\n return rew\r\n\r\n def evader_reward(self, agent, world):\r\n \"\"\"\r\n 奖励为距离最近的 agent 的距离\r\n 出界 -100\r\n 被所有 agent 看到时，奖励为速度 × -1\r\n \"\"\"\r\n good_agents = self.good_agents(world)\r\n evaders = self.evaders(world)\r\n rew = 0\r\n dists = [np.sqrt(np.sum(np.square(a.state.p_pos - agent.state.p_pos))) for a in good_agents]\r\n rew += min(dists)\r\n if abs(agent.state.p_pos[0]) > 1 or abs(agent.state.p_pos[1]) > 1:\r\n rew -= 100.0\r\n view = 0.12\r\n safe_num = 3\r\n view_num = 0\r\n for a in good_agents:\r\n delta_pos = a.state.p_pos - agent.state.p_pos\r\n dist = np.sqrt(np.sum(np.square(delta_pos)))\r\n if dist < view:\r\n view_num += 1\r\n if view_num == len(good_agents):\r\n absv = np.sqrt(np.sum(np.square(agent.state.p_vel)))\r\n rew -= 1.0 * absv\r\n return rew\r\n\r\n def observation(self, agent, world):\r\n good_agents = self.good_agents(world)\r\n evaders = self.evaders(world)\r\n\r\n evader_pos = []\r\n for evader in evaders:\r\n evader_pos.append(evader.state.p_pos - agent.state.p_pos)\r\n\r\n comm = []\r\n other_pos = []\r\n for other in good_agents:\r\n if other is agent:continue\r\n comm.append(other.state.c)\r\n other_pos.append(other.state.p_pos - agent.state.p_pos)\r\n return np.concatenate([agent.state.p_vel] + [agent.state.p_pos] + evader_pos + other_pos)\r\n"
] |
[
[
"numpy.square",
"numpy.concatenate",
"numpy.random.uniform",
"numpy.array",
"numpy.zeros"
]
] |
josephsalmon/celer
|
[
"2bd090dd450afb269054eb718bb49dc1f697bd99"
] |
[
"celer/tests/test_mtl.py"
] |
[
"import pytest\nimport itertools\nimport numpy as np\nfrom numpy.linalg import norm\n\nfrom sklearn.utils.estimator_checks import check_estimator\nfrom sklearn.linear_model import MultiTaskLassoCV as sklearn_MultiTaskLassoCV\nfrom sklearn.linear_model import MultiTaskLasso as sklearn_MultiTaskLasso\nfrom sklearn.linear_model import lasso_path\n\nfrom celer import (Lasso, GroupLasso, MultiTaskLasso,\n MultiTaskLassoCV)\nfrom celer.homotopy import celer_path, mtl_path, _grp_converter\nfrom celer.group_fast import dnorm_grp\nfrom celer.utils.testing import build_dataset\n\n\[email protected](\"sparse_X, fit_intercept, normalize\",\n itertools.product([0, 1], [0, 1], [0, 1]))\ndef test_GroupLasso_Lasso_equivalence(sparse_X, fit_intercept, normalize):\n \"\"\"Check that GroupLasso with groups of size 1 gives Lasso.\"\"\"\n n_features = 1000\n X, y = build_dataset(\n n_samples=100, n_features=n_features, sparse_X=sparse_X)\n alpha_max = norm(X.T @ y, ord=np.inf) / len(y)\n alpha = alpha_max / 10\n clf = Lasso(alpha, tol=1e-12, fit_intercept=fit_intercept,\n normalize=normalize, verbose=0)\n clf.fit(X, y)\n # take groups of size 1:\n clf1 = GroupLasso(alpha=alpha, groups=1, tol=1e-12,\n fit_intercept=fit_intercept, normalize=normalize,\n verbose=0)\n clf1.fit(X, y)\n\n np.testing.assert_allclose(clf1.coef_, clf.coef_, atol=1e-6)\n np.testing.assert_allclose(clf1.intercept_, clf.intercept_, rtol=1e-4)\n\n\ndef test_GroupLasso_MultitaskLasso_equivalence():\n \"GroupLasso and MultitaskLasso equivalence.\"\"\"\n n_samples, n_features = 30, 50\n X_, Y_ = build_dataset(n_samples, n_features, n_targets=3)\n y = Y_.reshape(-1, order='F')\n X = np.zeros([3 * n_samples, 3 * n_features], order='F')\n\n # block filling new design\n for i in range(3):\n X[i * n_samples:(i + 1) * n_samples, i *\n n_features:(i + 1) * n_features] = X_\n\n grp_indices = np.arange(\n 3 * n_features).reshape(3, -1).reshape(-1, order='F').astype(np.int32)\n grp_ptr = 3 * np.arange(n_features + 1).astype(np.int32)\n\n alpha_max = np.max(norm(X_.T @ Y_, axis=1)) / len(Y_)\n\n X_data = np.empty([1], dtype=X.dtype)\n X_indices = np.empty([1], dtype=np.int32)\n X_indptr = np.empty([1], dtype=np.int32)\n other = dnorm_grp(\n False, y, grp_ptr, grp_indices, X, X_data,\n X_indices, X_indptr, X_data, len(grp_ptr) - 1,\n np.zeros(1, dtype=np.int32), False)\n np.testing.assert_allclose(alpha_max, other / len(Y_))\n\n alpha = alpha_max / 10\n clf = MultiTaskLasso(alpha, fit_intercept=False, tol=1e-8, verbose=2)\n clf.fit(X_, Y_)\n\n groups = [grp.tolist() for grp in grp_indices.reshape(50, 3)]\n clf1 = GroupLasso(alpha=alpha / 3, groups=groups,\n fit_intercept=False, tol=1e-8, verbose=2)\n clf1.fit(X, y)\n\n np.testing.assert_allclose(clf1.coef_, clf.coef_.reshape(-1), atol=1e-4)\n\n\ndef test_convert_groups():\n n_features = 6\n grp_ptr, grp_indices = _grp_converter(3, n_features)\n np.testing.assert_equal(grp_ptr, [0, 3, 6])\n np.testing.assert_equal(grp_indices, [0, 1, 2, 3, 4, 5])\n\n grp_ptr, grp_indices = _grp_converter([1, 3, 2], 6)\n np.testing.assert_equal(grp_ptr, [0, 1, 4, 6])\n np.testing.assert_equal(grp_indices, [0, 1, 2, 3, 4, 5])\n\n groups = [[0, 2, 5], [1, 3], [4]]\n grp_ptr, grp_indices = _grp_converter(groups, 6)\n np.testing.assert_equal(grp_ptr, [0, 3, 5, 6])\n np.testing.assert_equal(grp_indices, [0, 2, 5, 1, 3, 4])\n\n\ndef test_mtl_path():\n X, Y = build_dataset(n_targets=3)\n tol = 1e-10\n params = dict(eps=0.01, tol=tol, n_alphas=10)\n alphas, coefs, gaps = mtl_path(X, Y, **params)\n np.testing.assert_array_less(gaps, tol)\n\n sk_alphas, sk_coefs, sk_gaps = lasso_path(X, Y, **params, max_iter=10000)\n np.testing.assert_array_less(sk_gaps, tol * np.linalg.norm(Y, 'fro')**2)\n np.testing.assert_array_almost_equal(coefs, sk_coefs, decimal=5)\n np.testing.assert_allclose(alphas, sk_alphas)\n\n\ndef test_MultiTaskLassoCV():\n \"\"\"Test that our MultitaskLassoCV behaves like sklearn's.\"\"\"\n X, y = build_dataset(n_samples=30, n_features=50, n_targets=3)\n\n params = dict(eps=1e-2, n_alphas=10, tol=1e-10, cv=2, n_jobs=1,\n fit_intercept=False, verbose=2)\n\n clf = MultiTaskLassoCV(**params)\n clf.fit(X, y)\n\n clf2 = sklearn_MultiTaskLassoCV(**params)\n clf2.max_iter = 10000 # increase max_iter bc of low tol\n clf2.fit(X, y)\n\n np.testing.assert_allclose(clf.mse_path_, clf2.mse_path_,\n atol=1e-4, rtol=1e-04)\n np.testing.assert_allclose(clf.alpha_, clf2.alpha_,\n atol=1e-4, rtol=1e-04)\n np.testing.assert_allclose(clf.coef_, clf2.coef_,\n atol=1e-4, rtol=1e-04)\n\n # check_estimator tests float32 so using tol < 1e-7 causes precision\n # issues\n clf.tol = 1e-5\n check_estimator(clf)\n\n\[email protected](\"fit_intercept\", [True, False])\ndef test_MultiTaskLasso(fit_intercept):\n \"\"\"Test that our MultiTaskLasso behaves as sklearn's.\"\"\"\n X, Y = build_dataset(n_samples=20, n_features=30, n_targets=10)\n alpha_max = np.max(norm(X.T.dot(Y), axis=1)) / X.shape[0]\n\n alpha = alpha_max / 2.\n params = dict(alpha=alpha, fit_intercept=fit_intercept, tol=1e-10,\n normalize=True)\n clf = MultiTaskLasso(**params)\n clf.verbose = 2\n clf.fit(X, Y)\n\n clf2 = sklearn_MultiTaskLasso(**params)\n clf2.fit(X, Y)\n np.testing.assert_allclose(clf.coef_, clf2.coef_, rtol=1e-5)\n if fit_intercept:\n np.testing.assert_allclose(clf.intercept_, clf2.intercept_)\n\n clf.tol = 1e-7\n check_estimator(clf)\n\n\[email protected](\"sparse_X\", [True, False])\ndef test_group_lasso_path(sparse_X):\n n_features = 50\n X, y = build_dataset(\n n_samples=11, n_features=n_features, sparse_X=sparse_X)\n\n alphas, coefs, gaps = celer_path(\n X, y, \"grouplasso\", groups=5, eps=1e-2, n_alphas=10, tol=1e-8)\n tol = 1e-8\n np.testing.assert_array_less(gaps, tol)\n\n\[email protected](\"sparse_X\", [True, False])\ndef test_GroupLasso(sparse_X):\n n_features = 50\n X, y = build_dataset(\n n_samples=11, n_features=n_features, sparse_X=sparse_X)\n\n tol = 1e-8\n clf = GroupLasso(alpha=0.8, groups=10, tol=tol)\n clf.fit(X, y)\n np.testing.assert_array_less(clf.dual_gap_, tol)\n\n clf.tol = 1e-6\n clf.groups = 1 # unsatisfying but sklearn will fit of 5 features\n check_estimator(clf)\n\n\nif __name__ == \"__main__\":\n pass\n # from celer.datasets import load_climate\n # X, y = load_climate()\n\n # center, normalize = True, True\n\n # from celer.homotopy import _alpha_max_grp\n # alpha_max = _alpha_max_grp(X, y, 7, center, normalize)\n\n # clf = GroupLasso(alpha=alpha_max / 100, groups=7,\n # verbose=2, fit_intercept=center, normalize=normalize)\n # clf.alpha = alpha_max / 100\n # clf.fit(X, y)\n"
] |
[
[
"numpy.testing.assert_equal",
"sklearn.linear_model.MultiTaskLasso",
"numpy.arange",
"sklearn.linear_model.MultiTaskLassoCV",
"numpy.linalg.norm",
"numpy.testing.assert_array_less",
"sklearn.linear_model.lasso_path",
"sklearn.utils.estimator_checks.check_estimator",
"numpy.testing.assert_allclose",
"numpy.zeros",
"numpy.empty",
"numpy.testing.assert_array_almost_equal"
]
] |
Podshot/Amulet-Core
|
[
"678a722daa5e4487d193a7e947ccceacac325fd2"
] |
[
"amulet/world_interface/formats/anvil/anvil_format.py"
] |
[
"from __future__ import annotations\n\nimport os\nimport struct\nimport zlib\nimport gzip\nfrom typing import Tuple, Any, Dict, Union, Generator\nimport numpy\nimport time\nimport re\n\nimport amulet_nbt as nbt\n\nfrom amulet.world_interface.formats import Format\nfrom amulet.utils import world_utils\nfrom amulet.utils.format_utils import check_all_exist, check_one_exists, load_leveldat\nfrom amulet.api.errors import ChunkDoesNotExist, LevelDoesNotExist\n\n\nclass AnvilRegion:\n region_regex = re.compile(r\"r\\.(?P<rx>-?\\d+)\\.(?P<rz>-?\\d+)\\.mca\")\n\n @staticmethod\n def get_coords(file_path: str) -> Tuple[Union[int, None], Union[int, None]]:\n file_path = os.path.basename(file_path)\n match = AnvilRegion.region_regex.fullmatch(file_path)\n if match is None:\n return None, None\n return int(match.group(\"rx\")), int(match.group(\"rz\"))\n\n def __init__(self, file_path: str, create=False):\n \"\"\"\n A class wrapper for a region file\n :param file_path: The file path of the region file\n :param create: bool - if true will create the region from scratch. If false will try loading from disk\n \"\"\"\n self._file_path = file_path\n self.rx, self.rz = self.get_coords(file_path)\n\n # [dirty, mod_time, data_length, data] feel free to extend if you want to implement modifying in place and defragging\n self._chunks: Dict[Tuple[int, int], Tuple[bool, int, int, bytes]] = {}\n self._dirty = False # is a chunk in region dirty\n\n if create:\n # create the region from scratch.\n self._loaded = True\n else:\n # mark the region to be loaded when needed\n self._loaded = False\n # shallow load the data\n with open(self._file_path, \"rb\") as fp:\n offsets = numpy.fromfile(fp, dtype=\">u4\", count=1024)\n for x in range(32):\n for z in range(32):\n offset = offsets[x + 32 * z]\n if offset != 0:\n self._chunks[(x, z)] = None\n\n def all_chunk_coords(self) -> Generator[Tuple[int, int]]:\n for cx, cz in self._chunks.keys():\n yield cx + self.rx * 32, cz + self.rz * 32\n\n def _load(self):\n with open(self._file_path, \"rb\") as fp:\n # check that the file is a multiple of 4096 bytes and extend if not\n # TODO: perhaps rewrite this in a way that is more readable\n file_size = os.path.getsize(self._file_path)\n if file_size & 0xFFF:\n file_size = (file_size | 0xFFF) + 1\n fp.truncate(file_size)\n\n # if the length of the region file is 0 extend it to 8KiB TODO (perhaps have some error)\n if not file_size:\n file_size = world_utils.SECTOR_BYTES * 2\n fp.truncate(file_size)\n\n # read the file and populate the internal database\n # self._file_size = file_size\n\n fp.seek(0)\n\n # offsets = fp.read(world_utils.SECTOR_BYTES)\n # mod_times = fp.read(world_utils.SECTOR_BYTES)\n\n # self._free_sectors = free_sectors = numpy.full(\n # file_size // world_utils.SECTOR_BYTES, True, bool\n # )\n # self._free_sectors[0:2] = False, False\n\n offsets = numpy.fromfile(fp, dtype=\">u4\", count=1024)\n mod_times = numpy.fromfile(fp, dtype=\">u4\", count=1024)\n\n # for offset in offsets:\n # sector = offset >> 8\n # count = offset & 0xFF\n #\n # for i in range(sector, sector + count):\n # if i >= len(free_sectors):\n # return False\n #\n # free_sectors[i] = False\n\n for x in range(32):\n for z in range(32):\n offset = offsets[x + 32 * z]\n if offset == 0:\n continue\n sector = offset >> 8\n # count = offset & 0xFF # the number of sectors used\n fp.seek(world_utils.SECTOR_BYTES * sector)\n # read int value and then read that amount of data\n buffer_size = struct.unpack(\">I\", fp.read(4))[0]\n self._chunks[(x, z)] = (\n False,\n mod_times[x + 32 * z],\n buffer_size,\n fp.read(buffer_size),\n )\n\n self._loaded = True\n\n def save(self):\n if self._dirty:\n if not self._loaded:\n self._load()\n offsets = numpy.zeros(1024, dtype=\">u4\")\n mod_times = numpy.zeros(1024, dtype=\">u4\")\n offset = 2\n data = []\n for (\n (cx, cz),\n (dirty, mod_time, buffer_size, buffer),\n ) in self._chunks.items():\n index = cx + (cz << 5)\n sector_count = ((buffer_size + 4 | 0xFFF) + 1) >> 12\n offsets[index] = (offset << 8) + sector_count\n mod_times[index] = mod_time\n data.append(\n struct.pack(\">I\", buffer_size)\n + buffer\n + b\"\\x00\" * ((sector_count << 12) - buffer_size - 4)\n )\n offset += sector_count\n with open(self._file_path, \"wb\") as fp:\n fp.write(\n struct.pack(\">1024I\", *offsets)\n ) # there is probably a prettier way of doing this\n fp.write(\n struct.pack(\">1024I\", *mod_times)\n ) # but I could not work it out with Numpy\n fp.write(b\"\".join(data))\n\n def get_chunk_data(self, cx: int, cz: int) -> nbt.NBTFile:\n if not self._loaded:\n self._load()\n if (cx, cz) in self._chunks:\n return self._decompress(self._chunks[(cx, cz)][3])\n else:\n raise ChunkDoesNotExist\n\n def put_chunk_data(self, cx: int, cz: int, data: nbt.NBTFile):\n \"\"\"compress the data and put it in the class database\"\"\"\n if not self._loaded:\n self._load()\n self._dirty = True\n buffer_size, bytes_data = self._compress(data)\n self._chunks[(cx, cz)] = (True, int(time.time()), buffer_size, bytes_data)\n\n def delete_chunk_data(self, cx: int, cz: int):\n if not self._loaded:\n self._load()\n if (cx, cz) in self._chunks:\n del self._chunks[(cx, cz)]\n self._dirty = True\n\n @staticmethod\n def _compress(data: nbt.NBTFile) -> Tuple[int, bytes]:\n \"\"\"Convert an NBTFile into a compressed bytes object\"\"\"\n data = data.save_to(compressed=False)\n data = b\"\\x02\" + zlib.compress(data)\n return len(data), data\n\n @staticmethod\n def _decompress(data: bytes) -> nbt.NBTFile:\n \"\"\"Convert a bytes object into an NBTFile\"\"\"\n if data[0] == world_utils.VERSION_GZIP:\n return nbt.load(buffer=gzip.decompress(data[1:]), compressed=False)\n elif data[0] == world_utils.VERSION_DEFLATE:\n return nbt.load(buffer=zlib.decompress(data[1:]), compressed=False)\n raise Exception(f\"Invalid compression type {data[0]}\")\n\n\nclass AnvilLevelManager:\n level_regex = re.compile(r\"DIM(?P<level>-?\\d+)\")\n\n def __init__(self, directory: str):\n self._directory = directory\n self._regions: Dict[Tuple[int, int], AnvilRegion] = {}\n\n # shallow load all of the existing region classes\n region_dir = os.path.join(self._directory, \"region\")\n if os.path.isdir(region_dir):\n for region_file_name in os.listdir(region_dir):\n rx, rz = AnvilRegion.get_coords(region_file_name)\n if rx is None:\n continue\n self._regions[(rx, rz)] = AnvilRegion(\n os.path.join(self._directory, \"region\", region_file_name)\n )\n\n def all_chunk_coords(self) -> Generator[Tuple[int, int]]:\n for region in self._regions.values():\n for chunk in region.all_chunk_coords():\n yield chunk\n\n def save(self):\n # use put_chunk_data to actually upload modified chunks\n # run this to push those changes to disk\n\n for region in self._regions.values():\n region.save()\n # TODO: perhaps delete the region from loaded regions so that memory usage doesn't explode\n\n def close(self):\n raise NotImplementedError\n # any final closing requirements (I don't think there are any for anvil)\n\n def get_chunk_data(self, cx: int, cz: int) -> nbt.NBTFile:\n \"\"\"Get an NBTFile of a chunk from the database.\n Will raise ChunkDoesNotExist if the region or chunk does not exist\n \"\"\"\n # get the region key\n return self._get_region(cx, cz).get_chunk_data(cx & 0x1F, cz & 0x1F)\n\n def _get_region(self, cx: int, cz: int, create=False) -> AnvilRegion:\n key = rx, rz = world_utils.chunk_coords_to_region_coords(cx, cz)\n if key in self._regions:\n return self._regions[key]\n\n if create:\n file_path = os.path.join(self._directory, \"region\", f\"r.{rx}.{rz}.mca\")\n self._regions[key] = AnvilRegion(file_path, True)\n else:\n raise ChunkDoesNotExist\n\n return self._regions[key]\n\n def put_chunk_data(self, cx: int, cz: int, data: nbt.NBTFile):\n \"\"\"pass data to the region file class\"\"\"\n # get the region key\n self._get_region(cx, cz, create=True).put_chunk_data(cx & 0x1F, cz & 0x1F, data)\n\n def delete_chunk(self, cx: int, cz: int):\n try:\n self._get_region(cx, cz).delete_chunk_data(cx & 0x1F, cz & 0x1F)\n except ChunkDoesNotExist:\n pass\n\n\nclass AnvilFormat(Format):\n def __init__(self, directory: str):\n super().__init__(directory)\n self.root_tag = nbt.load(filename=os.path.join(self._directory, \"level.dat\"))\n if os.path.isfile(os.path.join(self._directory, \"icon.png\")):\n self._world_image_path = os.path.join(self._directory, \"icon.png\")\n self._levels = None\n\n @property\n def world_name(self):\n return self.root_tag[\"Data\"][\"LevelName\"].value\n\n @world_name.setter\n def world_name(self, value: str):\n self.root_tag[\"Data\"][\"LevelName\"] = nbt.TAG_String(value)\n\n def _load_world(self):\n if self._levels is None:\n self._levels: Dict[int, AnvilLevelManager] = {\n 0: AnvilLevelManager(self._directory)\n }\n for dir_name in os.listdir(self._directory):\n level_path = os.path.join(self._directory, dir_name)\n if os.path.isdir(level_path) and dir_name.startswith(\"DIM\"):\n match = AnvilLevelManager.level_regex.fullmatch(dir_name)\n if match is None:\n continue\n level = int(match.group(\"level\"))\n self._levels[level] = AnvilLevelManager(level_path)\n\n def _get_level(self, level: int):\n self._load_world()\n if level in self._levels:\n return self._levels[level]\n else:\n raise LevelDoesNotExist\n\n def all_chunk_coords(self, dimension: int = 0) -> Generator[Tuple[int, int]]:\n for chunk in self._get_level(dimension).all_chunk_coords():\n yield chunk\n\n def save(self):\n self._load_world()\n for level in self._levels.values():\n level.save()\n # TODO: save other world data\n\n def close(self):\n pass # TODO: release lock file\n\n def _max_world_version(self) -> Tuple[str, int]:\n return \"anvil\", self.root_tag[\"Data\"][\"DataVersion\"].value\n\n def delete_chunk(self, cx: int, cz: int, dimension: int = 0):\n self._get_level(dimension).delete_chunk(cx, cz)\n\n def _put_raw_chunk_data(self, cx: int, cz: int, data: Any, dimension: int = 0):\n \"\"\"\n Actually stores the data from the interface to disk.\n \"\"\"\n self._get_level(dimension).put_chunk_data(cx, cz, data)\n\n def _get_raw_chunk_data(self, cx: int, cz: int, dimension: int = 0) -> Any:\n \"\"\"\n Return the interface key and data to interface with given chunk coordinates.\n\n :param cx: The x coordinate of the chunk.\n :param cz: The z coordinate of the chunk.\n :return: The interface key for the get_interface method and the data to interface with.\n \"\"\"\n return self._get_level(dimension).get_chunk_data(cx, cz)\n\n def _get_interface_key(self, raw_chunk_data) -> Tuple[str, int]:\n return \"anvil\", raw_chunk_data[\"DataVersion\"].value\n\n @staticmethod\n def is_valid(directory) -> bool:\n print(directory)\n if not check_all_exist(directory, \"region\", \"level.dat\"):\n return False\n\n if not check_one_exists(directory, \"playerdata\", \"players\"):\n return False\n\n level_dat_root = load_leveldat(directory)\n\n if \"FML\" in level_dat_root:\n return False\n\n return True\n\n\nFORMAT_CLASS = AnvilFormat\n\nif __name__ == \"__main__\":\n import sys\n\n world_path = sys.argv[1]\n world = AnvilLevelManager(world_path)\n chunk = world.get_chunk_data(0, 0)\n print(chunk)\n world.put_chunk_data(0, 0, chunk)\n world.save()\n"
] |
[
[
"numpy.fromfile",
"numpy.zeros"
]
] |
hackathonismb/Membrane-Protein-Domains-Motifs-Annotations
|
[
"0adf8a34af1691986e6e8d14aeb2fd629b6ee276"
] |
[
"Consensus_domain_extraction/OPM_parser.py"
] |
[
"#!/usr/bin/env python\n# coding: utf-8\n\n# In[ ]:\n\n\nimport urllib.parse\nimport urllib.request\nimport json\nimport pandas\n\nurl = 'https://www.uniprot.org/uploadlists/'\nGPCR_file = \"uniprot-human-allGPCRs.txt\"\nlymphycyte_file = \"uniprot-t-lymphocyte-activation-antigens.txt\"\n\n\nfor line in GPCR_file:\n url1=\"http://www.uniprot.org/uniprot/\" \n \n\ndef read_uniprotfile(chk):\n with open(chk, \"r\") as f:\n uniprot_list1=f.read().splitlines()\n \n str1 = ' '.join(uniprot_list1)\n \n return str1\n\n\nparams = {\n'from': 'ACC+ID',\n'to': 'PDB_ID',\n'format': 'tab',\n'query': read_uniprotfile(GPCR_file) #Change to lymphycyte_file\n}\n\n\ndata = urllib.parse.urlencode(params)\ndata = data.encode('utf-8')\nreq = urllib.request.Request(url,data)\n\n \nwith urllib.request.urlopen(req) as f:\n response = f.read()\nlist1 = response.decode('utf-8')\nwith open('filename.txt', 'w') as outputfile:\n outputfile.write(str(list1))\n outputfile.close()\n\n \nimport pandas as pd\nwith open('filename.txt','r') as f:\n reader = pandas.read_csv(f, delimiter=\"\\t\") \n reader.columns = ['Uniprot_ID', 'PDB_ID']\n reader['PDB_ID'] = reader['PDB_ID'].str.lower()\n\n\n \n # print(reader)\n \n\ndef request_data_OPM(url):\n req = urllib.request.Request(url)\n with urllib.request.urlopen(req) as f:\n response = f.read()\n return response.decode('utf-8')\n\ndf = pandas.read_csv('opm_database.csv')\nimport re\n\nr = re.compile(r\"(\\d+)\\(\\s*(\\d+)-\\s*(\\d+)\\)\")\n\ndf[\"segment\"] = df[\"segment\"].apply(lambda x: r.findall(x))\ndf = df.explode(\"segment\")\ndf[[\"Domain_type\", \"start_resid_OPM\", \"end_resid_OPM\"]] = df.pop(\"segment\").apply(pd.Series)\ndf = df.sort_values(by=\"Domain_type\")\ndf[\"Domain_type\"] = \"TMD\" + df[\"Domain_type\"].astype(str)\n\n\nOPM_list = pd.merge(reader,df,on='PDB_ID')\nOPM_list.drop_duplicates(inplace=True)\n\nconsensus_json = OPM_list.to_json(orient=\"records\") # df to json\njson_obj = json.loads(consensus_json) # formatting nicely\nconsensus_json_formatted_str = json.dumps(json_obj, indent=2)\nprint(consensus_json_formatted_str)\n\n"
] |
[
[
"pandas.merge",
"pandas.read_csv"
]
] |
Spartan-Velanjeri/Virtual-Assistant-Project
|
[
"f2fa52680900c33db5de0807f0bbc498fa9400ee"
] |
[
"extract_embeddings.py"
] |
[
"# USAGE\n# python extract_embeddings.py --dataset Dataset --embeddings output/embeddings.pickle \\\n#\t--detector face_detection_model --embedding-model openface_nn4.small2.v1.t7\n\n# import the necessary packages\nfrom imutils import paths\nimport numpy as np\nimport argparse\nimport imutils\nimport pickle\nimport cv2\nimport os\n\n# construct the argument parser and parse the arguments\nap = argparse.ArgumentParser()\nap.add_argument(\"-i\", \"--dataset\", required=True,\n\thelp=\"path to input directory of faces + images\")\nap.add_argument(\"-e\", \"--embeddings\", required=True,\n\thelp=\"path to output serialized db of facial embeddings\")\nap.add_argument(\"-d\", \"--detector\", required=True,\n\thelp=\"path to OpenCV's deep learning face detector\")\nap.add_argument(\"-m\", \"--embedding-model\", required=True,\n\thelp=\"path to OpenCV's deep learning face embedding model\")\nap.add_argument(\"-c\", \"--confidence\", type=float, default=0.5,\n\thelp=\"minimum probability to filter weak detections\")\nargs = vars(ap.parse_args())\n\n# load our serialized face detector from disk\nprint(\"[INFO] loading face detector...\")\nprotoPath = os.path.sep.join([args[\"detector\"], \"deploy.prototxt\"])\nmodelPath = os.path.sep.join([args[\"detector\"],\n\t\"res10_300x300_ssd_iter_140000.caffemodel\"])\ndetector = cv2.dnn.readNetFromCaffe(protoPath, modelPath)\n\n# load our serialized face embedding model from disk\nprint(\"[INFO] loading face recognizer...\")\nembedder = cv2.dnn.readNetFromTorch(args[\"embedding_model\"])\n\n# grab the paths to the input images in our dataset\nprint(\"[INFO] quantifying faces...\")\nimagePaths = list(paths.list_images(args[\"dataset\"]))\n\n# initialize our lists of extracted facial embeddings and\n# corresponding people names\nknownEmbeddings = []\nknownNames = []\n\n# initialize the total number of faces processed\ntotal = 0\n\n# loop over the image paths\nfor (i, imagePath) in enumerate(imagePaths):\n\t# extract the person name from the image path\n\tprint(\"[INFO] processing image {}/{}\".format(i + 1,\n\t\tlen(imagePaths)))\n\tname = imagePath.split(os.path.sep)[-2]\n\n\t# load the image, resize it to have a width of 600 pixels (while\n\t# maintaining the aspect ratio), and then grab the image\n\t# dimensions\n\timage = cv2.imread(imagePath)\n\timage = imutils.resize(image, width=600)\n\t(h, w) = image.shape[:2]\n\n\t# construct a blob from the image\n\timageBlob = cv2.dnn.blobFromImage(\n\t\tcv2.resize(image, (300, 300)), 1.0, (300, 300),\n\t\t(104.0, 177.0, 123.0), swapRB=False, crop=False)\n\n\t# apply OpenCV's deep learning-based face detector to localize\n\t# faces in the input image\n\tdetector.setInput(imageBlob)\n\tdetections = detector.forward()\n\n\t# ensure at least one face was found\n\tif len(detections) > 0:\n\t\t# we're making the assumption that each image has only ONE\n\t\t# face, so find the bounding box with the largest probability\n\t\ti = np.argmax(detections[0, 0, :, 2])\n\t\tconfidence = detections[0, 0, i, 2]\n\n\t\t# ensure that the detection with the largest probability also\n\t\t# means our minimum probability test (thus helping filter out\n\t\t# weak detections)\n\t\tif confidence > args[\"confidence\"]:\n\t\t\t# compute the (x, y)-coordinates of the bounding box for\n\t\t\t# the face\n\t\t\tbox = detections[0, 0, i, 3:7] * np.array([w, h, w, h])\n\t\t\t(startX, startY, endX, endY) = box.astype(\"int\")\n\n\t\t\t# extract the face ROI and grab the ROI dimensions\n\t\t\tface = image[startY:endY, startX:endX]\n\t\t\t(fH, fW) = face.shape[:2]\n\n\t\t\t# ensure the face width and height are sufficiently large\n\t\t\tif fW < 20 or fH < 20:\n\t\t\t\tcontinue\n\n\t\t\t# construct a blob for the face ROI, then pass the blob\n\t\t\t# through our face embedding model to obtain the 128-d\n\t\t\t# quantification of the face\n\t\t\tfaceBlob = cv2.dnn.blobFromImage(face, 1.0 / 255,\n\t\t\t\t(96, 96), (0, 0, 0), swapRB=True, crop=False)\n\t\t\tembedder.setInput(faceBlob)\n\t\t\tvec = embedder.forward()\n\n\t\t\t# add the name of the person + corresponding face\n\t\t\t# embedding to their respective lists\n\t\t\tknownNames.append(name)\n\t\t\tknownEmbeddings.append(vec.flatten())\n\t\t\ttotal += 1\n\n# dump the facial embeddings + names to disk\nprint(\"[INFO] serializing {} encodings...\".format(total))\ndata = {\"embeddings\": knownEmbeddings, \"names\": knownNames}\nf = open(args[\"embeddings\"], \"wb\")\nf.write(pickle.dumps(data))\nf.close()\n"
] |
[
[
"numpy.array",
"numpy.argmax"
]
] |
cainmagi/MDNC
|
[
"ce5e88b4c4880e8ecdbd82ee1da48335bad20b53"
] |
[
"mdnc/utils/__main__.py"
] |
[
"#!python\n# -*- coding: UTF-8 -*-\n'''\n################################################################\n# Utilities - Compatibility tests\n# @ Modern Deep Network Toolkits for pyTorch\n# Yuchen Jin @ [email protected]\n# Requirements: (Pay attention to version)\n# python 3.5+\n# numpy 1.13+\n# matplotlib 3.1.1+\n# Run the following command to perform the test:\n# ```bash\n# python -m mdnc.utils\n# ```\n################################################################\n'''\n\nimport time\nimport argparse\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport tqdm\n\nfrom mdnc import __version__\nimport mdnc.utils as engine\n\n\nclass TestDraw:\n '''Test functions for draw sub-module.\n '''\n def test_all(self):\n self.test_plot_hist()\n self.test_plot_bar()\n self.test_scatter()\n self.test_training_records()\n self.test_error_bar()\n self.test_distribution()\n\n @engine.draw.setFigure(style='ggplot', font_size=14)\n def test_plot_hist(self):\n def func_gen():\n getbins = np.linspace(0, 25, 80)\n x1 = np.random.normal(loc=7.0, scale=1.0, size=100)\n yield x1, {'bins': getbins, 'label': '$x_1$'}\n x2 = np.random.normal(loc=12.0, scale=3.0, size=1000)\n yield x2, {'bins': getbins, 'label': '$x_2$'}\n engine.draw.plot_hist(func_gen(), xlabel='x', normalized=True, cumulative=False)\n engine.draw.plt.show()\n\n @engine.draw.setFigure(style='dark_background', font_size=14)\n def test_plot_bar(self):\n def func_gen():\n size = 5\n x1 = np.abs(np.random.normal(loc=6.0, scale=3.0, size=size))\n yield x1, {'label': '$x_1$'}\n x2 = np.abs(np.random.normal(loc=9.0, scale=6.0, size=size))\n yield x2, {'label': '$x_2$'}\n x3 = np.abs(np.random.normal(loc=12.0, scale=6.0, size=size))\n yield x3, {'label': '$x_3$'}\n engine.draw.plot_bar(func_gen(), num=3, ylabel='y', y_log=False,\n x_tick_labels=['Jan.', 'Feb.', 'Mar.', 'Apr.', 'May'])\n engine.draw.plt.show()\n\n @engine.draw.setFigure(style='seaborn-darkgrid', font_size=16)\n def test_scatter(self):\n def func_gen():\n size = 100\n for i in range(3):\n center = -4.0 + 4.0 * np.random.rand(2)\n scale = 0.5 + 2.0 * np.random.rand(2)\n x1 = np.random.normal(loc=center[0], scale=scale[0], size=size)\n x2 = np.random.normal(loc=center[1], scale=scale[1], size=size)\n yield np.power(10, x1), np.power(10, x2), {'label': r'$x_{' + str(i + 1) + r'}$'}\n engine.draw.plot_scatter(func_gen(), x_log=True, y_log=True,\n xlabel='Metric 1', ylabel='Metric 2')\n engine.draw.plt.show()\n\n @engine.draw.setFigure(style='Solarize_Light2', font_size=14)\n def test_training_records(self):\n def func_gen_batch():\n size = 100\n x = np.arange(start=0, stop=size)\n for i in range(3):\n begin = 1 + 99.0 * np.random.rand()\n end = 2 + 10 * np.random.rand()\n v = begin * np.exp((np.square((x - size) / size) - 1.0) * end)\n yield x, v, {'label': r'$x_{' + str(i + 1) + r'}$'}\n\n def func_gen_epoch():\n size = 10\n x = np.arange(start=0, stop=size)\n for i in range(3):\n begin = 1 + 99.0 * np.random.rand()\n end = 2 + 10 * np.random.rand()\n v = begin * np.exp((np.square((x - size) / size) - 1.0) * end)\n val_v = begin * np.exp((np.square((x - size) / size) - 1.0) * (end - 1))\n data = np.stack([x, v, x, val_v], axis=0)\n yield data, {'label': r'$x_{' + str(i + 1) + r'}$'}\n\n engine.draw.plot_training_records(func_gen_batch(), y_log=True, x_mark_num=10,\n xlabel='Step', ylabel=r'Batch $\\mathcal{L}$')\n engine.draw.plt.show()\n engine.draw.plot_training_records(func_gen_epoch(), y_log=True, x_mark_num=10,\n xlabel='Step', ylabel=r'Epoch $\\mathcal{L}$')\n engine.draw.plt.show()\n\n @engine.draw.setFigure(style='bmh', font_size=16)\n def test_error_bar(self):\n def func_gen():\n size = 100\n x = np.arange(start=0, stop=size)\n for i in range(3):\n begin = 1 + 99.0 * np.random.rand()\n end = 2 + 10 * np.random.rand()\n exp_v = np.square((x - size) / size) - 1.0\n exp_vnoise = np.random.normal(0.0, np.expand_dims((size - x) / (10 * size), axis=-1), (size, 50))\n v = begin * np.exp((np.expand_dims(exp_v, axis=-1) + exp_vnoise) * end)\n yield x, v, {'label': r'$x_{' + str(i + 1) + r'}$'}\n engine.draw.plot_error_curves(func_gen(), y_log=True,\n y_error_method='minmax',\n xlabel='Step', ylabel=r'$\\mathcal{L}$')\n engine.draw.plt.show()\n engine.draw.plot_error_curves(func_gen(), y_log=True,\n y_error_method='minmax', plot_method='fill',\n xlabel='Step', ylabel=r'$\\mathcal{L}$')\n engine.draw.plt.show()\n\n @engine.draw.setFigure(style='classic', font_size=16)\n def test_distribution(self):\n def func_gen():\n size = 100\n x = np.arange(start=0, stop=size)\n for i in range(1):\n begin = 1 + 99.0 * np.random.rand()\n end = 2 + 10 * np.random.rand()\n exp_v = np.square((x - size) / size) - 1.0\n exp_vnoise = np.random.normal(0.0, np.expand_dims((size - x) / (10 * size), axis=-1), (size, 50))\n v = begin * np.exp((np.expand_dims(exp_v, axis=-1) + exp_vnoise) * end)\n yield x, v, {'label': r'$x_{' + str(i + 1) + r'}$'}\n engine.draw.plot_distribution_curves(func_gen(), method='mean', level=5, outlier=0.05,\n xlabel='Step', ylabel=r'$\\mathcal{L}$', y_log=True)\n engine.draw.plt.show()\n\n def test_draw_context(self):\n with engine.draw.setFigure(style='classic', font_size=16, font_name='arial'):\n t = np.linspace(-10, 10, 100)\n plt.plot(t, 1 / (1 + np.exp(-t)))\n plt.title('In the context, font: arial.')\n plt.show()\n\n\nclass TestTools:\n '''Test functions for tools sub-module.\n '''\n def __init__(self, seed=None):\n self.random_rng = np.random.default_rng(seed=seed)\n\n def test_recorder(self):\n # Test epoch metrics.\n records = self.random_rng.normal(loc=0.0, scale=1.0, size=100)\n val2 = 1.0\n recorder = engine.tools.EpochMetrics(zip(('val1', 'val2'), ([0.0], [val2])))\n for r in records:\n recorder['val1'] = r\n print('utils.tools: EpochMetrics[\"val1\"]={0}, np.mean(records)={1}.'.format(recorder['val1'], np.mean(records)))\n print('utils.tools: EpochMetrics[\"val2\"]={0}, np.max(records)={1}.'.format(recorder['val2'], val2))\n\n def test_ctxwrapper(self):\n num_iters = 100\n with engine.tools.ContextWrapper(tqdm.tqdm(total=num_iters)) as tq:\n for i in range(num_iters):\n tq.update(1)\n time.sleep(0.001)\n\n\n# Argparser\ndef str2bool(v):\n if v.lower() in ('yes', 'true', 't', 'y', '1'):\n return True\n elif v.lower() in ('no', 'false', 'f', 'n', '0'):\n return False\n else:\n raise argparse.ArgumentTypeError('Unsupported value encountered.')\n\n\ndef parse_args(parser, return_args=True):\n parser.add_argument(\n '-udw', '--test_utl_draw', type=str2bool, nargs='?', const=True, default=False, metavar='bool',\n help='''Test the utils.draw module.'''\n )\n parser.add_argument(\n '-uto', '--test_utl_tools', type=str2bool, nargs='?', const=True, default=False, metavar='bool',\n help='''Test the utils.tools module.'''\n )\n if return_args:\n return parser.parse_args()\n else:\n return\n\n\n# Test functions\ndef test_utl_draw():\n print('Compatibility test: mdnc.utils.draw.')\n tester = TestDraw()\n tester.test_all()\n tester.test_draw_context()\n\n\ndef test_utl_tools():\n print('Compatibility test: mdnc.utils.tools.')\n tester = TestTools()\n tester.test_recorder()\n tester.test_ctxwrapper()\n\n\nregistered_tests = {\n 'test_utl_draw': test_utl_draw,\n 'test_utl_tools': test_utl_tools\n}\n\n\nif __name__ == '__main__':\n __spec__ = None # Handle the error caused by pdb module.\n\n print('Compatibility test: mdnc.utils. MDNC version: ', __version__)\n\n # Set parser and parse args.\n aparser = argparse.ArgumentParser(\n description='Compatibility test: mdnc.utils.',\n formatter_class=argparse.ArgumentDefaultsHelpFormatter\n )\n args = vars(parse_args(aparser))\n\n if not any(args.values()):\n aparser.print_help()\n else:\n for k, req_run in args.items():\n if req_run:\n registered_tests[k]()\n"
] |
[
[
"numpy.square",
"numpy.expand_dims",
"matplotlib.pyplot.title",
"numpy.linspace",
"numpy.power",
"numpy.arange",
"numpy.stack",
"numpy.random.normal",
"numpy.mean",
"numpy.random.rand",
"numpy.exp",
"matplotlib.pyplot.show",
"numpy.random.default_rng"
]
] |
xgarrido/pspy
|
[
"8c1c13828ca982a1747ddeed2ee9c35b09fd9f0b"
] |
[
"tutorials/tuto_analytic_cov_spin0and2.py"
] |
[
"\"\"\"\nThese are tests of analytic estimation of a gaussian covariance matrix for spin0 and 2 field\nIt is done in CAR pixellisation.\nWe also provide an option for monte-carlo verification of the covariance matrix\n\"\"\"\nimport matplotlib\n\nmatplotlib.use(\"Agg\")\nimport os\nimport time\n\nimport healpy as hp\nimport numpy as np\nimport pylab as plt\nfrom pspy import pspy_utils, so_cov, so_map, so_mcm, so_spectra, so_window, sph_tools\n\n# We start by specifying the CAR survey parameters, it will go from ra0 to ra1 and from dec0 to dec1 (all in degrees)\n# It will have a resolution of 1 arcminute\nra0, ra1, dec0, dec1 = -10, 10, -8, 8\nres = 2.5\n# ncomp=3 mean that we are going to use spin0 and 2 field\nncomp = 3\n# specify the order of the spectra, this will be the order used in pspy\n# note that if you are doing cross correlation between galaxy and kappa for example, you should follow a similar structure\nspectra = [\"TT\", \"TE\", \"TB\", \"ET\", \"BT\", \"EE\", \"EB\", \"BE\", \"BB\"]\n# clfile are the camb lensed power spectra\nclfile = \"./data/bode_almost_wmap5_lmax_1e4_lensedCls_startAt2.dat\"\n# n_splits stands for the number of splits we want to simulate\nn_splits = 2\n# The type of power spectra we want to compute\ntype = \"Dl\"\n# a binningfile with format, lmin,lmax,lmean\nbinning_file = \"./data/BIN_ACTPOL_50_4_SC_low_ell_startAt2\"\n# the maximum multipole to consider\nlmax = 2000\n# the number of iteration in map2alm\nniter = 0\n# the noise on the spin0 component\nrms_uKarcmin_T = 1\n# the apodisation lengh for the survey mask (in degree)\napo_radius_degree_survey = 1\n# the number of holes in the point source mask\nsource_mask_nholes = 10\n# the radius of the holes (in arcminutes)\nsource_mask_radius = 10\n# the apodisation lengh for the point source mask (in degree)\napo_radius_degree_mask = 0.3\n# for the CAR survey we will use an apodisation type designed for rectangle maps\napo_type = \"Rectangle\"\n# should the cov mat take into account the specificity of polar\nplanck = False\n# parameter for the monte-carlo simulation\ndo_MonteCarlo = True\nread_MonteCarlo = False\nn_sims = 150\n\ntest_dir = \"result_cov_spin0and2\"\npspy_utils.create_directory(test_dir)\nif read_MonteCarlo:\n mc_dir = \"mc_spin0and2\"\n\ntemplate = so_map.car_template(ncomp, ra0, ra1, dec0, dec1, res)\n# the binary template for the window functionpixels\n# for CAR we set pixels inside the survey at 1 and at the border to be zero\nbinary = so_map.car_template(1, ra0, ra1, dec0, dec1, res)\nbinary.data[:] = 0\nbinary.data[1:-1, 1:-1] = 1\n\n# we then apodize the survey mask\nwindow = so_window.create_apodization(\n binary, apo_type=apo_type, apo_radius_degree=apo_radius_degree_survey\n)\n# we create a point source mask\nmask = so_map.simulate_source_mask(\n binary, n_holes=source_mask_nholes, hole_radius_arcmin=source_mask_radius\n)\n# ... and we apodize it\nmask = so_window.create_apodization(mask, apo_type=\"C1\", apo_radius_degree=apo_radius_degree_mask)\n# the window is given by the product of the survey window and the mask window\nwindow.data *= mask.data\n\nwindow.plot(file_name=\"%s/window\" % (test_dir))\n\n# for spin0 and 2 the window need to be a tuple made of two objects\n# the window used for spin0 and the one used for spin 2\nwindow_tuple = (window, window)\n\n\n# the window is going to couple mode together, we compute a mode coupling matrix in order to undo this effect\nmbb_inv, Bbl = so_mcm.mcm_and_bbl_spin0and2(\n window_tuple, binning_file, lmax=lmax, type=\"Dl\", niter=niter\n)\n\nl_th, ps_theory = pspy_utils.ps_lensed_theory_to_dict(clfile, type, lmax=lmax)\nnl_th = pspy_utils.get_nlth_dict(rms_uKarcmin_T, type, lmax, spectra=spectra)\n\nsurvey_id = [\"a\", \"b\", \"c\", \"d\"]\nsurvey_name = [\"split_0\", \"split_1\", \"split_0\", \"split_1\"]\n\nname_list = []\nid_list = []\nfor field in [\"T\", \"E\"]:\n for s, id in zip(survey_name, survey_id):\n name_list += [\"%s%s\" % (field, s)]\n id_list += [\"%s%s\" % (field, id)]\n\n\nClth_dict = {}\nfor name1, id1 in zip(name_list, id_list):\n for name2, id2 in zip(name_list, id_list):\n spec = id1[0] + id2[0]\n Clth_dict[id1 + id2] = ps_theory[spec] + nl_th[spec] * so_cov.delta2(name1, name2)\n\n\ncoupling_dict = so_cov.cov_coupling_spin0and2_simple(window, lmax, niter=niter, planck=planck)\nanalytic_cov = so_cov.cov_spin0and2(Clth_dict, coupling_dict, binning_file, lmax, mbb_inv, mbb_inv)\n\nnp.save(\"%s/analytic_cov.npy\" % test_dir, analytic_cov)\n\nif (do_MonteCarlo == True) or (read_MonteCarlo == True):\n Db_list = {}\n cov = {}\n nameList = []\n specList = []\n for i in range(n_splits):\n nameList += [\"split_%d\" % i]\n for c1, name1 in enumerate(nameList):\n for c2, name2 in enumerate(nameList):\n if c1 > c2:\n continue\n spec_name = \"%sx%s\" % (name1, name2)\n specList += [spec_name]\n Db_list[spec_name] = []\n\n for iii in range(n_sims):\n if do_MonteCarlo:\n t = time.time()\n cmb = template.synfast(clfile)\n splitlist = []\n for i in range(n_splits):\n split = cmb.copy()\n noise = so_map.white_noise(split, rms_uKarcmin_T=rms_uKarcmin_T)\n split.data += noise.data\n splitlist += [split]\n\n almList = []\n for s in splitlist:\n almList += [sph_tools.get_alms(s, window_tuple, niter, lmax)]\n\n for name1, alm1, c1 in zip(nameList, almList, np.arange(n_splits)):\n for name2, alm2, c2 in zip(nameList, almList, np.arange(n_splits)):\n if c1 > c2:\n continue\n ls, ps = so_spectra.get_spectra(alm1, alm2, spectra=spectra)\n spec_name = \"%sx%s\" % (name1, name2)\n lb, Db = so_spectra.bin_spectra(\n ls, ps, binning_file, lmax, type=type, mbb_inv=mbb_inv, spectra=spectra\n )\n vec = []\n for spec in [\"TT\", \"TE\", \"ET\", \"EE\"]:\n vec = np.append(vec, Db[spec])\n Db_list[spec_name] += [vec]\n\n print(\"sim number %04d took %s second to compute\" % (iii, time.time() - t))\n\n elif read_MonteCarlo:\n print(\"reading sim %04d spectra\" % iii)\n for name1, c1 in zip(nameList, np.arange(n_splits)):\n for name2, c2 in zip(nameList, np.arange(n_splits)):\n if c1 > c2:\n continue\n spec_name = \"%sx%s\" % (name1, name2)\n lb, Db = so_spectra.read_ps(\n \"%s/sim_spectra_%s_%04d.dat\" % (mc_dir, spec_name, iii), spectra=spectra\n )\n vec = []\n for spec in [\"TT\", \"TE\", \"ET\", \"EE\"]:\n vec = np.append(vec, Db[spec])\n Db_list[spec_name] += [vec]\n\n n_bins = len(lb)\n\n for spec1 in specList:\n for spec2 in specList:\n cov[spec1, spec2] = 0\n for iii in range(n_sims):\n cov[spec1, spec2] += np.outer(Db_list[spec1][iii], Db_list[spec2][iii])\n cov[spec1, spec2] = cov[spec1, spec2] / n_sims - np.outer(\n np.mean(Db_list[spec1], axis=0), np.mean(Db_list[spec2], axis=0)\n )\n\n cov = cov[\n \"%sx%s\" % (survey_name[0], survey_name[1]), \"%sx%s\" % (survey_name[2], survey_name[3])\n ]\n\n np.save(\"%s/montecarlo_cov.npy\" % test_dir, cov)\n\n corr = so_cov.cov2corr(cov)\n analytic_corr = so_cov.cov2corr(analytic_cov)\n\n plt.figure(figsize=(15, 8))\n plt.subplot(1, 2, 1)\n plt.title(\"Monte-Carlo correlation matrix\", fontsize=22)\n plt.imshow(corr, vmin=-0.5, vmax=0.5, origin=\"lower\")\n plt.colorbar()\n plt.subplot(1, 2, 2)\n plt.title(\"Analytic correlation matrix\", fontsize=22)\n plt.imshow(analytic_corr, vmin=-0.5, vmax=0.5, origin=\"lower\")\n plt.colorbar()\n plt.savefig(\"%s/correlation_matrix.png\" % (test_dir), bbox_inches=\"tight\")\n plt.clf()\n plt.close()\n\n plt.figure(figsize=(15, 15))\n count = 1\n for bl in [\"TTTT\", \"TETE\", \"ETET\", \"EEEE\", \"TTTE\", \"TTET\", \"TTEE\", \"TEET\", \"TEEE\", \"ETEE\"]:\n\n plt.subplot(2, 5, count)\n cov_select = so_cov.selectblock(cov, [\"TT\", \"TE\", \"ET\", \"EE\"], n_bins, block=bl)\n analytic_cov_select = so_cov.selectblock(\n analytic_cov, [\"TT\", \"TE\", \"ET\", \"EE\"], n_bins, block=bl\n )\n var = cov_select.diagonal()\n analytic_var = analytic_cov_select.diagonal()\n\n plt.plot(lb[1:], analytic_var[1:] / var[1:])\n if count == 1 or count == 6:\n plt.ylabel(r\"$\\sigma^{2, \\rm analytic}_{\\ell}/ \\sigma^{2, \\rm MC}_{\\ell}$\", fontsize=22)\n if count > 5:\n plt.xlabel(r\"$\\ell$\", fontsize=22)\n plt.legend()\n count += 1\n\n plt.savefig(\"%s/ratio_variance.png\" % (test_dir), bbox_inches=\"tight\")\n plt.clf()\n plt.close()\n\n plt.figure(figsize=(15, 15))\n count = 1\n for bl in [\"TTTT\", \"TETE\", \"ETET\", \"EEEE\", \"TTTE\", \"TTET\", \"TTEE\", \"TEET\", \"TEEE\", \"ETEE\"]:\n\n plt.subplot(2, 5, count)\n cov_select = so_cov.selectblock(cov, [\"TT\", \"TE\", \"ET\", \"EE\"], n_bins, block=bl)\n analytic_cov_select = so_cov.selectblock(\n analytic_cov, [\"TT\", \"TE\", \"ET\", \"EE\"], n_bins, block=bl\n )\n var = cov_select.diagonal()\n analytic_var = analytic_cov_select.diagonal()\n # plt.semilogy()\n if count == 1:\n plt.semilogy()\n plt.plot(lb[1:], var[1:], \"o\", label=\"MC %sx%s\" % (bl[:2], bl[2:4]))\n plt.plot(lb[1:], analytic_var[1:], label=\"Analytic %sx%s\" % (bl[:2], bl[2:4]))\n if count == 1 or count == 6:\n plt.ylabel(r\"$\\sigma^{2}_{\\ell}$\", fontsize=22)\n if count > 5:\n plt.xlabel(r\"$\\ell$\", fontsize=22)\n plt.legend()\n count += 1\n\n plt.savefig(\"%s/cov_element_comparison.png\" % (test_dir), bbox_inches=\"tight\")\n plt.clf()\n plt.close()\n"
] |
[
[
"matplotlib.use",
"numpy.arange",
"numpy.save",
"numpy.append",
"numpy.mean",
"numpy.outer"
]
] |
angshine/KP2D
|
[
"6673d3b93575585c98f451589cd52e7498803fa0"
] |
[
"kp2d/networks/keypoint_resnet.py"
] |
[
"# Copyright 2020 Toyota Research Institute. All rights reserved.\n\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.utils.model_zoo as model_zoo\nimport torchvision.models as models\nfrom kp2d.utils.image import image_grid\n\n\ndef upsample(x):\n return F.interpolate(x, scale_factor=2, mode=\"nearest\")\n\nclass conv_bn_elu(nn.Module):\n def __init__(self, in_channels, out_channels):\n super(conv_bn_elu, self).__init__()\n\n self.conv = nn.Sequential( \n nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False), \n nn.BatchNorm2d(out_channels), \n nn.LeakyReLU(inplace=True))\n\n def forward(self, x):\n return self.conv(x)\n\nclass KeypointEncoder(nn.Module):\n def __init__(self, pretrained, with_drop):\n super(KeypointEncoder, self).__init__()\n\n self.rn = models.resnet18(pretrained)\n self.dropout = nn.Dropout2d(0.2)\n self.use_dropout = with_drop\n\n def forward(self, input_image):\n self.features = []\n \n x = self.rn.relu(self.rn.bn1(self.rn.conv1(input_image)))\n l1 = self.rn.layer1(self.rn.maxpool(x)) if not self.use_dropout else self.dropout(self.rn.layer1(self.rn.maxpool(x)))\n l2 = self.rn.layer2(l1) if not self.use_dropout else self.dropout(self.rn.layer2(l1))\n l3 = self.rn.layer3(l2) if not self.use_dropout else self.dropout(self.rn.layer3(l2))\n l4 = self.rn.layer4(l3) if not self.use_dropout else self.dropout(self.rn.layer4(l3))\n\n return [x, l1, l2, l3, l4]\n\n\n\nclass KeypointDecoder(nn.Module):\n def __init__(self):\n super(KeypointDecoder, self).__init__()\n\n self.detect_scales = [3]\n self.feat_scales = [1]\n self.depth_scales = [0]\n\n self.num_ch_enc = np.array([64, 64, 128, 256, 512])\n self.num_ch_dec = np.array([32, 64, 128, 256, 256])\n\n self.sigmoid = nn.Sigmoid()\n self.tanh = nn.Tanh()\n self.pad = nn.ReflectionPad2d(1)\n\n # Layer4\n self.upconv4_0 = conv_bn_elu(self.num_ch_enc[4], self.num_ch_dec[4])\n self.upconv4_1 = conv_bn_elu(self.num_ch_dec[4] + self.num_ch_enc[3], self.num_ch_dec[4])\n\n # Layer3\n self.upconv3_0 = conv_bn_elu(self.num_ch_dec[4], self.num_ch_dec[3])\n self.upconv3_1 = conv_bn_elu(self.num_ch_dec[3] + self.num_ch_enc[2], self.num_ch_dec[3])\n\n # Layer2\n self.upconv2_0 = conv_bn_elu(self.num_ch_dec[3], self.num_ch_dec[2])\n self.upconv2_1 = conv_bn_elu(self.num_ch_dec[2] + self.num_ch_enc[1], self.num_ch_dec[2])\n\n # Layer1\n self.upconv1_0 = conv_bn_elu(self.num_ch_dec[2], self.num_ch_dec[1])\n self.upconv1_1 = conv_bn_elu(self.num_ch_dec[1] + self.num_ch_enc[0], self.num_ch_dec[1])\n\n # Score\n self.scoreconv = nn.Sequential(\n nn.Conv2d(self.num_ch_dec[3], self.num_ch_dec[3], kernel_size=3, stride=1, padding=1, bias=False), \n nn.BatchNorm2d(self.num_ch_dec[3]), \n nn.LeakyReLU(inplace=True),\n nn.ReflectionPad2d(1),\n nn.Conv2d(self.num_ch_dec[3], 1, 3))\n # Detector\n self.locconv = nn.Sequential(\n nn.Conv2d(self.num_ch_dec[3], self.num_ch_dec[3], kernel_size=3, stride=1, padding=1, bias=False), \n nn.BatchNorm2d(self.num_ch_dec[3]), \n nn.LeakyReLU(inplace=True), \n nn.ReflectionPad2d(1),\n nn.Conv2d(self.num_ch_dec[3], 2, 3))\n # Descriptor\n self.featconv = nn.Sequential(\n nn.Conv2d(self.num_ch_dec[1], self.num_ch_dec[1], kernel_size=3, stride=1, padding=1, bias=False), \n nn.BatchNorm2d(self.num_ch_dec[1]), \n nn.LeakyReLU(inplace=True),\n nn.ReflectionPad2d(1),\n nn.Conv2d(self.num_ch_dec[1], self.num_ch_dec[1], 3))\n\n def init_weights(self):\n for m in self.modules():\n if isinstance(m, torch.nn.Conv2d):\n torch.nn.init.xavier_uniform_(m.weight)\n if m.bias is not None:\n m.bias.data.zero_()\n\n if isinstance(m, nn.BatchNorm2d):\n nn.init.constant_(m.weight, 1)\n nn.init.constant_(m.bias, 0)\n\n\n def forward(self, input_features):\n self.outputs = {}\n\n # decoder\n x = input_features[4]\n # Layer4\n x = self.upconv4_0(x)\n x = [upsample(x)]\n x += [input_features[3]]\n x = torch.cat(x, 1)\n x = self.upconv4_1(x)\n # Layer3\n x = self.upconv3_0(x)\n x = [upsample(x)]\n x += [input_features[2]]\n x = torch.cat(x, 1)\n x = self.upconv3_1(x)\n # Detector and score\n self.outputs[(\"location\")] = self.tanh(self.locconv(x))\n self.outputs[(\"score\")] = self.sigmoid(self.scoreconv(x))\n # Layer2\n x = self.upconv2_0(x)\n x = [upsample(x)]\n x += [input_features[1]]\n x = torch.cat(x, 1)\n x = self.upconv2_1(x)\n # Layer1\n x = self.upconv1_0(x)\n x = [upsample(x)]\n x += [input_features[0]]\n x = torch.cat(x, 1)\n x = self.upconv1_1(x)\n # Descriptor features\n self.outputs[(\"feature\")] = self.featconv(x)\n\n return self.outputs\n\nclass KeypointResnet(nn.Module):\n def __init__(self, with_drop=True):\n super().__init__()\n print('Instantiating keypoint resnet')\n\n pretrained = True\n self.encoderK = KeypointEncoder(pretrained=pretrained, with_drop=True)\n self.decoderK = KeypointDecoder()\n\n self.cross_ratio = 2.0\n self.cell = 8\n \n def forward(self, x):\n\n B, _, H, W = x.shape\n\n x = self.encoderK(x)\n xK = self.decoderK(x)\n\n score = xK[('score')]\n center_shift = xK[('location')]\n feat = xK[('feature')]\n\n _, _, Hc, Wc = score.shape\n \n ############ Remove border for score ##############\n border_mask = torch.ones(B,Hc,Wc)\n border_mask[:,0] = 0\n border_mask[:,Hc-1] = 0\n border_mask[:,:,0] = 0 \n border_mask[:,:,Wc-1] = 0\n border_mask = border_mask.unsqueeze(1)\n score = score * border_mask.to(score.device)\n\n ############ Remap coordinate ##############\n step = (self.cell-1) / 2.\n center_base = image_grid(B, Hc, Wc,\n dtype=center_shift.dtype,\n device=center_shift.device,\n ones=False, normalized=False).mul(self.cell) + step\n\n coord_un = center_base.add(center_shift.mul(self.cross_ratio * step))\n coord = coord_un.clone()\n coord[:,0] = torch.clamp(coord_un[:,0], min=0, max=W-1)\n coord[:,1] = torch.clamp(coord_un[:,1], min=0, max=H-1)\n\n ############ Sampling feature ##############\n if self.training is False:\n coord_norm = coord[:,:2].clone()\n coord_norm[:,0] = (coord_norm[:,0] / (float(W-1)/2.)) - 1.\n coord_norm[:,1] = (coord_norm[:,1] / (float(H-1)/2.)) - 1.\n coord_norm = coord_norm.permute(0, 2, 3, 1)\n\n feat = torch.nn.functional.grid_sample(feat, coord_norm, align_corners=False)\n\n dn = torch.norm(feat, p=2, dim=1) # Compute the norm.\n feat = feat.div(torch.unsqueeze(dn, 1)) # Divide by norm to normalize.\n\n return score, coord, feat\n"
] |
[
[
"torch.nn.ReflectionPad2d",
"torch.nn.Dropout2d",
"torch.ones",
"torch.norm",
"torch.cat",
"torch.nn.init.constant_",
"torch.nn.Conv2d",
"torch.unsqueeze",
"torch.nn.Tanh",
"torch.nn.Sigmoid",
"torch.nn.init.xavier_uniform_",
"torch.nn.functional.grid_sample",
"torch.nn.LeakyReLU",
"torch.nn.functional.interpolate",
"torch.nn.BatchNorm2d",
"torch.clamp",
"numpy.array"
]
] |
thomassutter/MoPoE
|
[
"477a441ecb6c735a0b8af4d643fe3ac04c58171f",
"477a441ecb6c735a0b8af4d643fe3ac04c58171f"
] |
[
"modalities/MNIST.py",
"celeba/networks/ConvNetworkImgClfCelebA.py"
] |
[
"\nimport torch\n\nfrom modalities.Modality import Modality\n\nfrom utils import utils\nfrom utils.save_samples import write_samples_img_to_file\n\n\nclass MNIST(Modality):\n def __init__(self, name, enc, dec, class_dim, style_dim, lhood_name):\n super().__init__(name, enc, dec, class_dim, style_dim, lhood_name);\n self.data_size = torch.Size((1, 28, 28));\n self.gen_quality_eval = True;\n self.file_suffix = '.png';\n\n\n def save_data(self, d, fn, args):\n img_per_row = args['img_per_row'];\n write_samples_img_to_file(d, fn, img_per_row);\n\n\n\n def plot_data(self, d):\n p = d.repeat(1, 3, 1, 1);\n return p;\n",
"import torch\nimport torch.nn as nn\n\nfrom celeba.networks.FeatureExtractorImg import FeatureExtractorImg\n\n\nclass ClfImg(nn.Module):\n def __init__(self, flags):\n super(ClfImg, self).__init__();\n self.feature_extractor = FeatureExtractorImg(flags, a=2.0, b=0.3);\n self.dropout = nn.Dropout(p=0.5, inplace=False);\n self.linear = nn.Linear(in_features=flags.num_layers_img*flags.DIM_img, out_features=40, bias=True);\n self.sigmoid = nn.Sigmoid();\n\n def forward(self, x_img):\n h = self.feature_extractor(x_img);\n h = self.dropout(h);\n h = h.view(h.size(0), -1);\n h = self.linear(h);\n out = self.sigmoid(h)\n return out;\n\n def get_activations(self, x_img):\n h = self.feature_extractor(x_img);\n return h;\n"
] |
[
[
"torch.Size"
],
[
"torch.nn.Linear",
"torch.nn.Dropout",
"torch.nn.Sigmoid"
]
] |
Racemuis/epoch-based-covariance-estimates
|
[
"9ae2faba05c043031bfdb69c6937492d18c7db1e"
] |
[
"figures/figure_2_2.py"
] |
[
"# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Sun May 2 18:16:28 2021\r\n\r\nFigure 2.2: An aggregated ERP response with a soa of 226.\r\nCode partially taken from SpotPilotData (adapted).\r\n\"\"\"\r\n\r\nimport mne\r\nimport numpy as np\r\nimport matplotlib.pyplot as plt\r\nimport yaml\r\nimport glob\r\n\r\nimport os\r\nos.chdir('..')\r\n\r\nfrom methods.datasets.spot_pilot import SpotPilotData\r\n\r\nmne.set_log_level(False)\r\n\r\ndef preprocessed_to_epoch(preprocessed_data, decimate=10, baseline_ival=(-.2, 0)):\r\n raw_stim_ids = {\"Stimulus/S 1\": 1, \"Stimulus/S 21\": 2} \r\n class_ids = {\"Target\": 2, \"Non-target\": 1}\r\n reject = dict()\r\n events = mne.events_from_annotations(preprocessed_data, event_id=raw_stim_ids)[0]\r\n epo_data = mne.Epochs(preprocessed_data, events, event_id=class_ids,\r\n baseline=baseline_ival, decim=decimate,\r\n reject=reject, proj=False, preload=True)\r\n return epo_data\r\n\r\n\r\ndef _data_path(subject, path):\r\n path_folder = path + f'/subject{subject}'\r\n \r\n # get the path to all files\r\n pattern = r'/*Run_2*.vhdr'\r\n subject_paths = glob.glob(\r\n path_folder + pattern)\r\n return sorted(subject_paths)\r\n\r\ndef average_single_subject_data(subject, path, load_single_trials, plot_channels):\r\n \"\"\"return data for a single subject\"\"\"\r\n getter = SpotPilotData(load_single_trials=True, reject_non_iid=True)\r\n file_path_list = _data_path(subject, path)\r\n evo_t = np.zeros(( len(plot_channels), 71))\r\n evo_nt = np.zeros((len(plot_channels),71))\r\n soa_t = 0\r\n times = []\r\n for p_i, file_path in enumerate(file_path_list):\r\n file_exp_info = SpotPilotData._filename_trial_info_extraction(file_path)\r\n soa = file_exp_info['soa']\r\n # SOA selected by hand, need to verify whether it's in there\r\n if soa != 226:\r\n continue\r\n soa_t += 1\r\n data = getter._get_single_run_data(file_path)\r\n \r\n data.filter(0.5, 16, method='iir')\r\n epo_data = preprocessed_to_epoch(data, baseline_ival=(-0.2, 0))\r\n \r\n # Compute target and non-target ERP at channels\r\n evo_t += epo_data['Target'].average(picks=plot_channels).data\r\n evo_nt += epo_data['Non-target'].average(picks=plot_channels).data\r\n times = epo_data['Non-target'].average(picks=plot_channels).times\r\n target = epo_data['Target'].get_data().shape[0]\r\n non_target = epo_data['Non-target'].get_data().shape[0]\r\n print('Averaged over {} target responses and {} non-target responses. '.format(soa_t * target, soa_t * non_target))\r\n return evo_t/soa_t, evo_nt/soa_t, times\r\n \r\n \r\n# Extract configurations \r\nlocal_cfg_file = r'local_config.yaml'\r\nanalysis_cfg_file = r'analysis_config.yaml'\r\nwith open(local_cfg_file, 'r') as conf_f:\r\n local_cfg = yaml.load(conf_f, Loader=yaml.FullLoader) \r\nwith open(analysis_cfg_file, 'r') as conf_f:\r\n ana_cfg = yaml.load(conf_f, Loader=yaml.FullLoader)\r\n\r\n\r\nprepro_cfg = ana_cfg['default']['data_preprocessing']\r\ndata_path = local_cfg['data_root']\r\n\r\n# Plotting\r\nplot_channels = ['Cz', 'Fz']\r\nchannel_styles = ['-', '--']\r\n\r\nevo_t, evo_nt, times = average_single_subject_data(1, r'C:\\Users\\CC114402\\Documents\\Chiara\\Artificial Intelligence\\Leerjaar 3\\Semester 2\\Bachelor Thesis\\Data & MOABB\\Data', True, plot_channels)\r\n\r\n\r\nmicro = 10**6\r\n# Plot target and non-target ERP for channel\r\nfor ch_i, ch in enumerate(plot_channels):\r\n plt.plot(times, evo_t[ch_i, :]*micro,\r\n linestyle=channel_styles[ch_i], color=\"tab:orange\", label=f'{ch} Target')\r\n plt.plot(times, evo_nt[ch_i, :]*micro,\r\n linestyle=channel_styles[ch_i], color=\"tab:blue\", label=f'{ch} Non-target')\r\n\r\n# Define axes\r\nplt.rcParams[\"figure.figsize\"] = (9,6)\r\nplt.rcParams[\"figure.dpi\"] = 400\r\nplt.xlabel('Time (s)')\r\nplt.ylabel('Amplitude (µV)')\r\nplt.grid()\r\nplt.title(\"The average ERP measured at channels Cz and Fz\")\r\nplt.legend()\r\nplt.show()"
] |
[
[
"matplotlib.pyplot.legend",
"matplotlib.pyplot.title",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel"
]
] |
remram44/d3m-primitives
|
[
"bc7e609447cc827cd43a84fce348f85f4cd2fcd2"
] |
[
"featSelect/Feature_Selector_model.py"
] |
[
"# Algorithms\r\nfrom rpi_d3m_primitives.featSelect.tian_STMB_new import tian_STMB_new\r\nfrom rpi_d3m_primitives.featSelect.STMB_G_test import STMB_G_test\r\nfrom rpi_d3m_primitives.featSelect.sSTMB import sSTMBplus\r\nfrom rpi_d3m_primitives.featSelect.Large_Scale_STMB import Large_Scale_STMB\r\nfrom rpi_d3m_primitives.featSelect.JointMutualInformation import jmi\r\nfrom rpi_d3m_primitives.featSelect.tian_IPCMB import tian_IPCMB\r\nfrom rpi_d3m_primitives.featSelect.Large_Scale_IPCMB import Large_Scale_IPCMB\r\nfrom rpi_d3m_primitives.featSelect.Keyi_STMB_Adaptive_soft import Keyi_STMB_Adaptive_soft\r\nfrom sklearn.neighbors import KNeighborsRegressor, KNeighborsClassifier\r\nfrom sklearn.ensemble import AdaBoostClassifier\r\n# Classes\r\nfrom rpi_d3m_primitives.featSelect.Predictor import Classifier,Regressor\r\n# Packages\r\nimport numpy as np\r\n\r\nclass FeatureSelector:\r\n\tdef __init__(self,train_set,discrete_train_set,problem_type,test_set=None,predictor_base=None):\r\n\t\tself.train_set = train_set\r\n\t\tself.test_set = test_set\r\n\t\tself.discrete_train_set = discrete_train_set\r\n\t\tself.FEATURE_COUNT_THRESHOLD = 150\r\n\t\tself.problem_type = problem_type.lower()\r\n\t\tself.predictor_base = predictor_base\r\n\t\tself.set_predictor(predictor_base)\r\n\t\tif (self.problem_type not in [\"regression\",\"classification\"]):\r\n\t\t\traise ValueError(\"'problem_type' must be either 'regression' or 'classification'\")\r\n\r\n\tdef set_predictor(self,predictor_base):\r\n\t\tif (self.problem_type == \"classification\"):\r\n\t\t\tif (self.predictor_base == None):\r\n#\t\t\t\tself.predictor_base = AdaBoostClassifier(n_estimators=30)\r\n\t\t\t\tself.predictor_base = KNeighborsClassifier(n_neighbors=5)\r\n\t\t\tself.predictor = Classifier(self.predictor_base,self.test_set,self.train_set)\r\n\t\telif (self.problem_type == \"regression\"):\r\n\t\t\tif (self.predictor_base == None):\r\n\t\t\t\tself.predictor_base = KNeighborsRegressor(n_neighbors=3)\r\n\t\t\tself.predictor = Regressor(self.predictor_base,self.test_set,self.train_set)\r\n\r\nclass MBFeatureSelector(FeatureSelector):\r\n\tdef large_scale_selector(self,train_data,train_labels,thres):\r\n\t\tpass\r\n\r\n\tdef small_scale_selector(self,train_data,train_labels,thres):\r\n\t\tpass\r\n\r\n\tdef select_features(self,thres=None):\r\n\t\t# establish threshold for indepence\r\n\t\tif (thres==None):\r\n\t\t\tselected_features = self.find_optimal_threshold()[1]\r\n\t\t\treturn selected_features\r\n\t\ttrain_data = self.discrete_train_set.data\r\n\t\ttrain_labels = self.discrete_train_set.labels\r\n\t\tselected_features = None\r\n\t\tif self.discrete_train_set.num_features > self.FEATURE_COUNT_THRESHOLD:\r\n\t\t\tselected_features = self.large_scale_selector(train_data,train_labels,thres)\r\n\t\telse:\r\n\t\t\tselected_features = self.small_scale_selector(train_data,train_labels,thres)\r\n\t\treturn selected_features\r\n\r\n\r\n\t\"\"\"---------------THRESHOLD FINDING---------------\"\"\"\r\n\tdef find_optimal_threshold(self,max_loop=8):\r\n\t\treturn self.get_threshold(max_loop)\r\n\r\n\tdef get_threshold(self,max_loop):\r\n\t\tpass\r\n\r\n\tdef bisect(self,min_thres,max_thres,optimal_thres,optimal_feats,feats_to_accuracy,optimal_score):\r\n\t\t# Loop\r\n\t\tloop_count = 0\r\n\t\tmax_loop = 3\r\n\t\tsearch_area = max_thres-min_thres\r\n\t\tleft_thres = search_area/4+min_thres\r\n\t\tright_thres = 3*search_area/4+min_thres\r\n\t\twhile (loop_count < max_loop):\r\n\t\t\tloop_count += 1\r\n\t\t\t# Choose\r\n#\t\t\tprint('\\nleft thres')\r\n#\t\t\tprint(left_thres)\r\n#\t\t\tprint('\\nright thres')\r\n#\t\t\tprint(right_thres)\r\n\t\t\tleft_feats = self.select_features(left_thres)\r\n\t\t\tright_feats = self.select_features(right_thres)\r\n\t\t\tchosen_feats,chosen_score = \\\r\n\t\t\t\tself.predictor.choose(left_feats,right_feats,optimal_feats,feats_to_accuracy)\r\n#\t\t\tprint('\\nchosen score')\r\n#\t\t\tprint(chosen_score)\r\n#\t\t\tprint('\\noptimal score')\r\n#\t\t\tprint(optimal_score)\r\n\t\t\tright_chosen = (np.array_equal(right_feats,chosen_feats))\r\n\t\t\tif chosen_score > optimal_score:\r\n#\t\t\tif (not (np.array_equal(chosen_feats, optimal_feats))):\r\n\t\t\t\toptimal_score = chosen_score\r\n\t\t\t\toptimal_feats = chosen_feats\r\n\t\t\t\tif (right_chosen):\r\n\t\t\t\t\toptimal_thres = right_thres\r\n\t\t\t\telse:\r\n\t\t\t\t\toptimal_thres = left_thres\r\n\t\t\telif (chosen_score == optimal_score and len(chosen_feats) < len(optimal_feats)):\r\n\t\t\t\toptimal_score = chosen_score\r\n\t\t\t\toptimal_feats = chosen_feats\r\n\t\t\t\tif (right_chosen):\r\n\t\t\t\t\toptimal_thres = right_thres\r\n\t\t\t\telse:\r\n\t\t\t\t\toptimal_thres = left_thres\r\n\t\t\t\t# Divide\r\n\t\t\t\t#delta = (right_thres - left_thres) / 2\r\n\t\t\tdelta = search_area/(2**(2+loop_count))\r\n\t\t\tif (right_chosen):\r\n\t\t\t\tleft_thres = right_thres - delta\r\n\t\t\t\tright_thres = min(delta + right_thres, max_thres)\r\n\t\t\telse:\r\n\t\t\t\tright_thres = left_thres + delta\r\n\t\t\t\tleft_thres = max(left_thres - delta, min_thres)\r\n#\t\t\telif (list(left_feats) == [] and list(right_feats) == []): #search ares is too large\r\n#\t\t\t\tloop_count -= 1\r\n#\t\t\t\tsearch_area = search_area/2\r\n#\t\t\t\tleft_thres = search_area/4 + min_thres\r\n#\t\t\t\tright_thres = 3*search_area/4 + min_thres\r\n#\t\t\telse:\r\n#\t\t\t\t# The increase in accuracy is insufficient to continue\r\n#\t\t\t\tbreak\r\n\t\t\t# Divide\r\n\t\t\t#delta = (right_thres-left_thres)/2\r\n\t\t\t#if (right_chosen):\r\n\t\t\t#\tleft_thres += delta\r\n\t\t\t#\tright_thres = min(delta+right_thres,3)\r\n\t\t\t#else:\r\n\t\t\t#\tleft_thres = max(left_thres-delta,0)\r\n\t\t\t#\tright_thres -= delta\r\n\t\treturn optimal_thres,optimal_feats,optimal_score\r\n\r\n\tdef get_threshold_bisection(self,max_loop):\r\n\t\t\"\"\"\tUse bisection to find the optimal indepence threshold (used for STMB,IPCMB)\r\n\t\t\"\"\"\r\n\t\t\"'-score' is a stand in for MSE when dealing with regression, and accuracy for classification\"\r\n\t\tfull_test_set = self.test_set\r\n\t\tnum_samples = self.test_set.data.shape[0]\r\n\t\t# Constants\r\n\t\tMAX_THRESHOLD = 1\r\n\t\tMIN_THRESHOLD = 0\r\n\t\tInterv_THRESHOLD = 0.05\r\n\t\tnum_Interv = (MAX_THRESHOLD-MIN_THRESHOLD)/Interv_THRESHOLD\r\n\t\t# Caches\r\n\t\tfeats_to_accuracy = dict()\r\n\t\t# Initial optimal score will be computed with all features\r\n\t\toptimal_thres = 0\r\n\t\toptimal_feats = np.arange(0,self.train_set.data.shape[1])\r\n\t\toptimal_score = self.predictor.score(optimal_feats,feats_to_accuracy)\r\n\t\tfor i in range(3):\r\n\t\t\tfold_start = int(i*num_samples/3)\r\n\t\t\tfold_end = int((i+1)*num_samples/3)\r\n\t\t\tself.predictor.test_set = full_test_set.resample(fold_start,fold_end)\r\n\t\t\tfor min_thres in np.linspace(MIN_THRESHOLD,MAX_THRESHOLD,num_Interv+1):\r\n\t\t\t\toptimal_thres, optimal_feats, optimal_score = self.bisect(min_thres, min_thres+Interv_THRESHOLD, optimal_thres,optimal_feats,feats_to_accuracy,optimal_score)\r\n\t\toptimal_feats = self.select_features(optimal_thres)\r\n\t\tself.predictor.test_set = full_test_set\r\n\t\treturn optimal_thres,optimal_feats\r\n\r\nclass IPCMB(MBFeatureSelector):\r\n\t\"Class that contains the algorithm for feature selection with IPCMB\"\r\n\tdef large_scale_selector(self,train_data,train_labels,thres):\r\n\t\treturn Large_Scale_IPCMB(train_data,train_labels,thres)\r\n\r\n\tdef small_scale_selector(self,train_data,train_labels,thres):\r\n\t\treturn tian_IPCMB(train_data,train_labels,thres)[0]\r\n\r\n\tdef get_threshold(self,max_loop):\r\n\t\treturn self.get_threshold_bisection(max_loop)\r\n\r\nclass STMB(MBFeatureSelector):\r\n\t\"Class that drives the algorithm for feature selection with STMB\"\r\n\tdef large_scale_selector(self,train_data,train_labels,thres):\r\n\t\treturn Large_Scale_STMB(train_data,train_labels,thres)\r\n\r\n\tdef small_scale_selector(self,train_data,train_labels,thres):\r\n\t\tselected_features = tian_STMB_new(train_data,train_labels,thres)[0]\r\n\t\treturn selected_features\r\n\r\n\tdef get_threshold(self,max_loop):\r\n\t\treturn self.get_threshold_bisection(max_loop)\r\n\r\nclass STMB_Gtest(MBFeatureSelector):\r\n\t\"Class that drives the algorithm for feature selection with STMB\"\r\n\tdef select_features(self):\r\n\t\ttrain_data = self.train_set.data\r\n\t\ttrain_labels = self.train_set.labels\r\n\t\tselected_features = STMB_G_test(train_data, train_labels)[0]\r\n\t\treturn selected_features\r\n\r\n\r\nclass ASTMB(MBFeatureSelector):\r\n\t\"Class that drives the algorithm for feature selection with aSTMB\"\r\n\tdef large_scale_selector(self,train_data,train_labels,thres):\r\n\t\treturn self.small_scale_selector(train_data,train_labels,thres)\r\n\r\n\tdef small_scale_selector(self,train_data,train_labels,thres):\r\n\t\tselected_features = Keyi_STMB_Adaptive_soft(train_data,train_labels,thres)[0]\r\n\t\treturn selected_features\r\n\r\n\tdef get_threshold(self,max_loop):\r\n\t\treturn self.get_threshold_bisection(max_loop)\r\n\r\nclass S2TMB(FeatureSelector):\r\n\t\"Class that contains the algorithm for feature selection with sSTMB\"\r\n\tdef select_features(self):\r\n\t\ttrain_data = self.train_set.data\r\n\t\ttrain_labels = self.train_set.labels\r\n\t\ttest_data = self.test_set.data\r\n\t\ttest_labels = self.test_set.labels\r\n\t\tDtrain_data = self.discrete_train_set.data\r\n\t\tDtrain_labels = self.discrete_train_set.labels\r\n\t\treturn sSTMBplus(train_data,train_labels,test_data,test_labels,Dtrain_data,Dtrain_labels,self.problem_type)\r\n\r\nclass JMI(FeatureSelector):\r\n\t\"Class that contains the algorithm for feature selection with JMI\"\r\n\tdef select_features(self,num_feats=None):\r\n\t\tif (num_feats==None):\r\n\t\t\treturn self.get_optimal_num_feats()[1]\r\n\t\ttrain_data = self.train_set.data\r\n\t\ttrain_labels = self.train_set.labels\r\n\t\treturn jmi(train_data,train_labels,num_feats)\r\n\r\n\tdef get_optimal_num_feats(self):\r\n\t\t\"Use exhaustive search to find the optimal number of features in the reduced set (used for JMI)\"\r\n\t\t# Initial optimal score will be computed with all features\r\n\t\tfeats_to_accuracy = dict()\r\n\t\tnum_feats = self.train_set.data.shape[1]\r\n\t\tif (num_feats>20):\r\n\t\t\tnum_feats = 20\r\n\t\toptimal_num_feats = num_feats\r\n\t\tall_feats = self.select_features(num_feats=optimal_num_feats)\r\n\t\toptimal_feats = all_feats\r\n\t\toptimal_score = self.predictor.score(optimal_feats,feats_to_accuracy)\r\n\t\tfor thres in range(1,num_feats):\r\n\t\t\tcandidate_feats = all_feats[:thres]\r\n\t\t\tcandidate_score = self.predictor.score(candidate_feats,feats_to_accuracy)\r\n\t\t\tif (self.predictor.left_performs_better(candidate_score,candidate_feats,optimal_score,optimal_feats)):\r\n\t\t\t\toptimal_feats = candidate_feats\r\n\t\t\t\toptimal_score = candidate_score\r\n\t\treturn optimal_feats.size,optimal_feats\r\n\r\nclass JMIplusSTMB(FeatureSelector):\r\n\t\"Class that contains the algorithm for feature selection using JMI and STMB\"\r\n\tdef select_features(self):\r\n\t\ttrain_set = self.train_set\r\n\t\ttest_set = self.test_set\r\n\t\tjmi_model = JMI(train_set,self.discrete_train_set,self.problem_type,test_set=test_set)\r\n\t\tjmi_feats = jmi_model.select_features()\r\n\t\ttrain_set = self.train_set.subset(jmi_feats)\r\n\t\ttest_set = self.test_set.subset(jmi_feats)\r\n\t\tdiscrete_train_set = self.discrete_train_set.subset(jmi_feats)\r\n\t\tstmb_model = STMB(train_set,discrete_train_set,self.problem_type,test_set=test_set)\r\n\t\tstmb_thres = stmb_model.find_optimal_threshold(max_loop=3)[0]\r\n\t\tstmb_feats = stmb_model.select_features(thres=stmb_thres)\r\n\t\treturn jmi_feats[stmb_feats]\r\n\r\nclass JMIplusASTMB(FeatureSelector):\r\n\t\"Class that contains the algorithm for feature selection using JMI and STMB\"\r\n\tdef select_features(self):\r\n\t\ttrain_set = self.train_set\r\n\t\ttest_set = self.test_set\r\n\t\tjmi_model = JMI(train_set,self.discrete_train_set,self.problem_type,test_set=test_set)\r\n\t\tjmi_feats = jmi_model.select_features()\r\n\t\ttrain_set = self.train_set.subset(jmi_feats)\r\n\t\ttest_set = self.test_set.subset(jmi_feats)\r\n\t\tdiscrete_train_set = self.discrete_train_set.subset(jmi_feats)\r\n\t\tastmb_model = ASTMB(train_set,discrete_train_set,self.problem_type,test_set=test_set)\r\n\t\tastmb_thres = astmb_model.find_optimal_threshold(max_loop=3)[0]\r\n\t\tastmb_feats = astmb_model.select_features(thres=astmb_thres)\r\n\t\treturn jmi_feats[astmb_feats]\r\n\r\nclass JMIplusS2TMB(FeatureSelector):\r\n\t\"Class that contains the algorithm for feature selection using JMI and S2TMB\"\r\n\tdef select_features(self):\r\n\t\ttrain_set = self.train_set\r\n\t\ttest_set = self.test_set\r\n\t\tjmi_model = JMI(train_set,self.discrete_train_set,self.problem_type,test_set=test_set)\r\n\t\tjmi_feats = jmi_model.select_features()\r\n\t\ttrain_set = self.train_set.subset(jmi_feats)\r\n\t\ttest_set = self.test_set.subset(jmi_feats)\r\n\t\tdiscrete_train_set = self.discrete_train_set.subset(jmi_feats)\r\n\t\ts2tmb_model = S2TMB(train_set,discrete_train_set,self.problem_type,test_set=test_set)\r\n\t\ts2tmb_feats = s2tmb_model.select_features()\r\n\t\treturn jmi_feats[s2tmb_feats]"
] |
[
[
"numpy.array_equal",
"numpy.linspace",
"numpy.arange",
"sklearn.neighbors.KNeighborsClassifier",
"sklearn.neighbors.KNeighborsRegressor"
]
] |
adt9595/FootballLeagueSim
|
[
"75cea60ca3f29d32f68894ace82e3f8db3bf7338"
] |
[
"LeagueSimulator/leaguesim.py"
] |
[
"# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Thu Dec 12 19:41:59 2019\r\nLeague Simulator\r\n - Loads team data from text files\r\n - Simulates matches minute-by-minute \r\n - A goal may be scored each minute, with probability based on previous finishes and recent form\r\n - Leagues can be run through multiple of these matches\r\n@author: Alex\r\n\"\"\"\r\n\r\n#import pygame\r\nimport math\r\nimport matplotlib.pyplot as plt\r\nfrom league import League\r\nfrom team import Team\r\nfrom match import Match\r\n\r\n\r\n#pygame.init()\r\n#pygame.font.init()\r\n#gameFont = pygame.font.SysFont('Arial', 22)\r\n#titleFont = pygame.font.Font('freesansbold.ttf',72)\r\n#endFont = pygame.font.Font('freesansbold.ttf',60)\r\n#clock = pygame.time.Clock()\r\n#screen_size = 480\r\n#grey = (184,184,184)\r\n#black = (0,0,0)\r\n#background = (255,255,174)\r\n#tagColour = (255, 238, 71)\r\n\r\n\r\n### Helper functions ################################\r\n\r\ndef weightedSum(x,factor):\r\n total = 0\r\n for i in range(1,len(x)):\r\n total += x[i-1] * (factor/i)\r\n return total\r\n \r\ndef mean(x):\r\n avg = 0\r\n for i in range(len(x)):\r\n avg = avg + x[i]\r\n avg = avg / len(x)\r\n return avg\r\n\r\ndef stddev(x):\r\n ans = 0\r\n avg = mean(x)\r\n for i in range(len(x)):\r\n ans = ans + (x[i] - avg)*(x[i] - avg)\r\n ans = ans / (len(x) - 1)\r\n return math.sqrt(ans)\r\n\r\ndef listProduct(x,y):\r\n return sum(i[0]*i[1] for i in zip(x,y))\r\n\r\ndef plotFigure(data,stepsize,epochs):\r\n steps = [stepsize*i for i in range(epochs)]\r\n plt.plot(steps,data)\r\n plt.plot((0,stepsize*epochs),(87.074,87.074))\r\n plt.axis([0, stepsize*epochs, min(data), max(data)])\r\n plt.show()\r\n \r\n#####################################################\r\n\r\n#class Game:\r\n# def __init__(self):\r\n# screen = pygame.display.set_mode((screen_size, screen_size))\r\n# running = True\r\n# while(running):\r\n# self.draw(screen)\r\n# for event in pygame.event.get():\r\n# if event.type == pygame.QUIT:\r\n# running = False\r\n# pygame.display.quit()\r\n# pygame.quit()\r\n# sys.exit(0)\r\n# \r\n# def draw(self,screen):\r\n# screen.fill(background)\r\n# title = titleFont.render('FOOTY',False,black)\r\n# screen.blit(title,(screen_size/2 - 150,screen_size/2 - 50))\r\n# pygame.display.update()\r\n \r\n\r\nteams = []\r\naverages = []\r\nstepsize = 0.2\r\nepochs = 15\r\n\r\n# Populate league \r\nfor i in range(20):\r\n teams.append(Team('teamdata/team{0}.txt'.format(i)))\r\n \r\n\r\n# Run multiple leagues with varying team rating parameters\r\n#for i in range(epochs):\r\n# prem = League('Premier League',teams,numIterations=20,teamDeltaFactor=stepsize*i,verbose=False)\r\n## prem = League('Premier League',teams,teamDeltaFactor=0.0 + (stepsize * i),numIterations=1)\r\n# averages.append(prem.avg)\r\n#plotFigure(averages,stepsize,epochs)\r\nprem = League('Premier League',teams,teamDeltaFactor=3.0,verbose=True)\r\n#Match(teams[10],teams[19],verbose=True)\r\n\r\n\r\n\"\"\"\r\nStats for premier league 92/93 -> 18/19:\r\n Champion points avg: 87.074\r\n Champion points dev: 6.063\r\n\"\"\"\r\n"
] |
[
[
"matplotlib.pyplot.plot",
"matplotlib.pyplot.show"
]
] |
computational-medicine/BMED360-2021
|
[
"2c6052b9affedf1fee23c89d23941bf08eb2614c",
"2c6052b9affedf1fee23c89d23941bf08eb2614c"
] |
[
"Prog4comp-SL-HPL-Extra/src/Taylor_exp.py",
"Prog4comp-SL-HPL-Extra/src/file_handling_numpy.py"
] |
[
"from math import factorial\r\nfrom numpy import exp, linspace\r\nimport matplotlib.pyplot as plt\r\n\r\ndef f(x):\r\n \"\"\"f(x) and its all its derivatives of higher order\"\"\"\r\n return exp(x)\r\n\r\ndef T(x, c, N):\r\n \"\"\"Builds the T.s. approxim. for f(x) = exp(x) with N + 1 terms\"\"\"\r\n sum = 0\r\n for n in range(N+1):\r\n # Note that f(c)=f'(c)=f''(c)..., when f(x) = exp(x)\r\n sum += (f(c)/factorial(n))*(x-c)**n\r\n return sum\r\n\r\na = -3; b = 3; maxNoOfTerms = 4\r\nc = input('Give the parameter c: ')\r\nxPoints = linspace(a, b, 100)\r\n\r\nfor i in range(maxNoOfTerms):\r\n Tapprox = T(xPoints, c, i)\r\n plt.plot(xPoints, f(xPoints), 'r', xPoints, Tapprox, '--')\r\n plt.axis([-4.0, 4.0, -2, 15])\r\n plt.hold('on')\r\nplt.hold('off')\r\nplt.show()\r\n",
"filename = 'tmp.dat'\nimport numpy\ndata = numpy.loadtxt(filename, comments='#')\nx = data[:,0]\ny = data[:,1]\ndata[:,1] = numpy.log(y) # insert transformed y back in array\nfilename = 'tmp_out.dat'\noutfile = open(filename, 'w') # open file for writing\noutfile.write('# x and y coordinates\\n')\nnumpy.savetxt(outfile, data, fmt='%10.5f')\n\n"
] |
[
[
"numpy.linspace",
"matplotlib.pyplot.hold",
"matplotlib.pyplot.axis",
"numpy.exp",
"matplotlib.pyplot.show"
],
[
"numpy.savetxt",
"numpy.log",
"numpy.loadtxt"
]
] |
Apoorba-Bibeka/LPGA-VISSIM-DataProcessing
|
[
"c707dff6c191dc073add594857331382b6e6891e",
"c707dff6c191dc073add594857331382b6e6891e"
] |
[
"After-Validation-TT-Processing.py",
"12th_Street_VISSIM_Process/Network_Eval_12th_St.py"
] |
[
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue Aug 27 08:04:07 2019\n\n@author: abibeka\n# Get Travel time on LPGA and I-95 (After Validation)\n\"\"\"\n\n#0.0 Housekeeping. Clear variable space\nfrom IPython import get_ipython #run magic commands\nipython = get_ipython()\nipython.magic(\"reset -f\")\nipython = get_ipython()\n\n\n\nimport os\nimport pandas as pd\nimport numpy as np\nimport subprocess\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n\n\n\ndef TTSegName(x):\n TTSeg= {1: 'EB',\n 2: 'WB',\n 3: 'EB LPGA (Tomoka Rd to I-95 SB Ramp)',\n 4: 'EB LPGA (I-95 SB Ramp to I-95 NB Ramp)',\n 5: 'EB LPGA (I-95 NB Ramp to Technology Blvd)',\n 6: 'EB LPGA (Technology Blvd to Willamson Blvd)',\n 7: 'EB LPGA (Willamson Blvd to Clyde-Morris Blvd)',\n 8: 'WB LPGA (Clyde-Morris Blvd to Willamson Blvd)',\n 9: 'WB LPGA (Willamson Blvd to Technology Blvd)',\n 10:'WB LPGA (Technology Blvd to I-95 NB Ramp)',\n 11:'WB LPGA (I-95 NB Ramp to I-95 SB Ramp)',\n 12:'WB LPGA (I-95 SB Ramp to Tomoka Rd)',\n 13:'SB I-95',\n 14:'NB I-95',\n 15:'SB I-95 (SR-40 to SB Off-Ramp)',\n 16:'SB I-95 (SB Off-Ramp to SB Loop-Ramp)',\n 17:'SB I-95 (SB Loop-Ramp to SB On-Ramp)',\n 18:'SB I-95 (SB On-Ramp to US-92)',\n 19:'NB I-95 (US-92 to NB Off-Ramp)',\n 20:'NB I-95 (NB Off-Ramp to NB Loop-Ramp)',\n 21:'NB I-95 ( NB Loop-Ramp to NB On-Ramp)',\n 22:'NB I-95 (NB On-Ramp to SR-40)'}\n if x < 23:\n Nm = TTSeg[x]\n else:\n Nm = None\n return Nm\n\n\n\n\ndef PreProcessVissimTT(file, SegIN):\n '''\n file : VISSIM Results file\n SegIN : Specify segments for which results are needed\n Summarize Vissim Travel time results\n '''\n ExistingAMDat=pd.read_csv(file,sep =';',skiprows=17)\n ExistingAMDat.columns\n ExistingAMDat.rename(columns={'TRAVTM(ALL)':'VissimTT','VEHS(ALL)':'Veh','DISTTRAV(ALL)':'Len'},inplace=True)\n mask=ExistingAMDat[\"$VEHICLETRAVELTIMEMEASUREMENTEVALUATION:SIMRUN\"]==\"AVG\"\n ExistingAMDat = ExistingAMDat[mask]\n ExistingAMDat[\"TTSegNm\"]=ExistingAMDat['VEHICLETRAVELTIMEMEASUREMENT'].apply(TTSegName)\n ExistingAMDat.TIMEINT = pd.Categorical(ExistingAMDat.TIMEINT,['900-1800','1800-2700','2700-3600','3600-4500',\n '4500-5400','5400-6300','6300-7200','7200-8100',\n '8100-9000','9000-9900','9900-10800','10800-11700'])\n \n mask = ExistingAMDat.TTSegNm.isin(SegIN)\n ExistingAMDat = ExistingAMDat[mask]\n ExistingAMDat.loc[:,\"VissimSMS\"] = (ExistingAMDat['Len']/ExistingAMDat['VissimTT']/1.47).round(1)\n mask1 = ~ExistingAMDat['VEHICLETRAVELTIMEMEASUREMENT'].isin([13,14])\n TTData = ExistingAMDat[mask1]\n TTData.loc[:,\"VissimSMS\"] = TTData.groupby(['TTSegNm'])['VissimSMS'].transform(lambda v: v.ffill())\n\n return(TTData)\n\n# Get the Weighted Density by Segments\n#Debug:\n#file = NoBuildAMfi\n#SegKeyVal = TTSegLaneDat\n#SegIN = SegIn1\ndef PreProcessVissimDensity(file, SegKeyVal):\n '''\n file : VISSIM Results file\n SegKeyVal : Key value pair for segment # and TT segment name\n Summarize Vissim Density results\n '''\n ExistingAMDat=pd.read_csv(file,sep =';',skiprows=17)\n ExistingAMDat.columns\n ExistingAMDat.rename(columns={'TRAVTM(ALL)':'VissimTT','VEHS(ALL)':'Veh','DISTTRAV(ALL)':'Len'},inplace=True)\n mask=ExistingAMDat[\"$VEHICLETRAVELTIMEMEASUREMENTEVALUATION:SIMRUN\"]==\"AVG\"\n ExistingAMDat = ExistingAMDat[mask]\n ExistingAMDat = SegKeyVal.merge(ExistingAMDat,left_on=['SegNO'],right_on = ['VEHICLETRAVELTIMEMEASUREMENT'],how= 'left')\n ExistingAMDat.TIMEINT = pd.Categorical(ExistingAMDat.TIMEINT,['900-1800','1800-2700','2700-3600','3600-4500',\n '4500-5400','5400-6300','6300-7200','7200-8100',\n '8100-9000','9000-9900','9900-10800','10800-11700'])\n ExistingAMDat.loc[:,\"VissimSMS\"] = (ExistingAMDat['Len']/ExistingAMDat['VissimTT']/1.47).round(1)\n #Get flow rate and density\n ExistingAMDat.loc[:,'FlowRate'] = ExistingAMDat.Veh *4\n ExistingAMDat.loc[:,'FlowRate_PerLane'] = ExistingAMDat.Veh *4/ ExistingAMDat.NumLanes\n ExistingAMDat.loc[:,\"VissimSMS\"] = (ExistingAMDat['Len']/ExistingAMDat['VissimTT']/1.47).round(1)\n ExistingAMDat.loc[:,'Density'] = (ExistingAMDat.FlowRate/ ExistingAMDat.VissimSMS).round(1)\n ExistingAMDat.loc[:,'Density_Len_Lanes'] = ExistingAMDat.Density *ExistingAMDat.Len\n ExistingAMDat.loc[:,'Len_Lanes'] = ExistingAMDat.Len * ExistingAMDat.NumLanes\n ExistingAMDat.columns\n DensityData = ExistingAMDat.groupby(['TIMEINT','SegName']).aggregate({'Len_Lanes':'sum','Density_Len_Lanes':'sum','VissimSMS':'mean','FlowRate_PerLane':'mean'}).reset_index()\n #DensityData = ExistingAMDat.groupby(['TIMEINT','SegName'])['Len_Lanes','Density_Len_Lanes'].sum().reset_index()\n DensityData.loc[:,'WeightedDensity'] = (DensityData.Density_Len_Lanes/ DensityData.Len_Lanes).round(1)\n DensityData.loc[:,\"WeightedDensity\"] = DensityData.groupby(['SegName'])['WeightedDensity'].transform(lambda v: v.ffill())\n DensityData.loc[:,\"VissimSMS\"] = DensityData.groupby(['SegName'])['VissimSMS'].transform(lambda v: v.ffill())\n DensityData = DensityData[['TIMEINT','SegName','WeightedDensity']]\n return(DensityData)\n\n\nI95_Segs = [ 'NB I-95 (US-92 to NB Off-Ramp)',\n 'NB I-95 (NB Off-Ramp to NB Loop-Ramp)',\n 'NB I-95 ( NB Loop-Ramp to NB On-Ramp)',\n 'NB I-95 (NB On-Ramp to SR-40)',\n 'SB I-95 (SR-40 to SB Off-Ramp)',\n 'SB I-95 (SB Off-Ramp to SB Loop-Ramp)',\n 'SB I-95 (SB Loop-Ramp to SB On-Ramp)',\n 'SB I-95 (SB On-Ramp to US-92)'\n ]\n \nLPGASeg=['EB LPGA (Tomoka Rd to I-95 SB Ramp)',\n 'EB LPGA (I-95 SB Ramp to I-95 NB Ramp)',\n 'EB LPGA (I-95 NB Ramp to Technology Blvd)', \n 'EB LPGA (Technology Blvd to Willamson Blvd)',\n 'EB LPGA (Willamson Blvd to Clyde-Morris Blvd)',\n 'WB LPGA (Clyde-Morris Blvd to Willamson Blvd)', \n 'WB LPGA (Willamson Blvd to Technology Blvd)', \n 'WB LPGA (Technology Blvd to I-95 NB Ramp)',\n 'WB LPGA (I-95 NB Ramp to I-95 SB Ramp)',\n 'WB LPGA (I-95 SB Ramp to Tomoka Rd)']\n\n# VISSIM File\n#*********************************************************************************\nPathToFile= r'C:\\Users\\abibeka\\OneDrive - Kittelson & Associates, Inc\\Documents\\LPGA\\VISSIM-Files\\VISSIM - V2'\nExistingPMfi = r'Existing\\20834_Existing_PM--C1C2C3C4C5C6C7C8_Vehicle Travel Time Results.att'\nExistingPMfi = os.path.join(PathToFile,ExistingPMfi)\nExistingAMfi =r'Existing\\20834_Existing_AM--C1C2aC3C4C5C6C7C8C9_Vehicle Travel Time Results.att'\nExistingAMfi = os.path.join(PathToFile,ExistingAMfi)\n\n\n\nNoBuildAMfi = r'No Build\\20834_NoBuild_AM--C1C2C3C4C5C6C7C8C9_Vehicle Travel Time Results.att'\nNoBuildPMfi = r'No Build\\20834_NoBuild_PM---C1C2C3C4C5C6C7C8_Vehicle Travel Time Results.att'\nBuildDCDI_AMfi = r'Build\\DCDI\\20834_Build1_6LnMod_AM---C1C2C3C4C5C6C7C8C9C10_Vehicle Travel Time Results.att'\nBuildDCDI_PMfi = r'Build\\DCDI\\20834_Build1_6LnMod_PM---C1C2C3C4C5C6C7C8C9_Vehicle Travel Time Results.att'\nBuildDCMI_AMfi = r'Build\\DCMI\\20834_DCMI_AM_20180808--C1C2C3C4C5C6C7C8_Vehicle Travel Time Results.att'\nBuildDCMI_PMfi = r'Build\\DCMI\\20834_DCMI_PM_20180808--C1C2C3C4C5C6C7C8_Vehicle Travel Time Results.att'\n\nNoBuildAMfi = os.path.join(PathToFile,NoBuildAMfi)\nNoBuildPMfi = os.path.join(PathToFile,NoBuildPMfi)\nBuildDCDI_AMfi = os.path.join(PathToFile,BuildDCDI_AMfi)\nBuildDCDI_PMfi = os.path.join(PathToFile,BuildDCDI_PMfi)\nBuildDCMI_AMfi = os.path.join(PathToFile,BuildDCMI_AMfi)\nBuildDCMI_PMfi = os.path.join(PathToFile,BuildDCMI_PMfi)\n\n#*******************************************************************************\n#*******************************************************************************\n# Which File are we analysising. Only make changes here and done:\nFileAM = ExistingAMfi\nFileAM = NoBuildAMfi\nFileAM = BuildDCDI_AMfi\nFileAM = BuildDCMI_AMfi\n#File Being Processed\n#*******************************************************************************\nFileAM = BuildDCMI_AMfi\n#*******************************************************************************\n\ndef switch_PMFile(argument):\n switcher = {\n ExistingAMfi: ExistingPMfi,\n NoBuildAMfi: NoBuildPMfi,\n BuildDCDI_AMfi: BuildDCDI_PMfi,\n BuildDCMI_AMfi: BuildDCMI_PMfi\n }\n return switcher.get(argument, \"Invalid Name\")\n\nFilePM = switch_PMFile(FileAM)\n\ndef switch_OutputTag(argument):\n switcher = {\n ExistingAMfi: \"Existing\",\n NoBuildAMfi: \"No-Build\",\n BuildDCDI_AMfi: \"DCDI\",\n BuildDCMI_AMfi: \"DCMI\"\n }\n return switcher.get(argument, \"Invalid Name\")\n \nOutputFolderName = switch_OutputTag(FileAM)\n\nif((FileAM == BuildDCDI_AMfi) | (FileAM == BuildDCMI_AMfi)):\n AreResultsForBuild = True\nelse: AreResultsForBuild = False\n# Get the time keys to convert Vissim intervals to Hours of the day\nPathToVis = r'C:\\Users\\abibeka\\OneDrive - Kittelson & Associates, Inc\\Documents\\LPGA\\VISSIM-Files'\nTimeConvFi = 'TravelTimeKeyValuePairs.xlsx'\nTimeConvFi = pd.ExcelFile(os.path.join(PathToVis,TimeConvFi))\nTimeConvFi.sheet_names\nTimeKeys = TimeConvFi.parse('TimeVissimKey')\n\nif(AreResultsForBuild):\n TTSegLaneDat = TimeConvFi.parse('Build')\n TTSegLaneDat = TTSegLaneDat.dropna()\nelse:\n # Get The Travel time (TT) segment and # of lane data\n TTSegLaneDat = TimeConvFi.parse('Existing')\n TTSegLaneDat = TTSegLaneDat.dropna()\n\n\n#Summarize the Travel time for AM and PM. Concatenate the 2 datasets.\nSegIn1 = I95_Segs+ LPGASeg\nTTAM = PreProcessVissimTT(FileAM,SegIn1)\nTTPM = PreProcessVissimTT(FilePM,SegIn1)\nDenAM = PreProcessVissimDensity(FileAM,TTSegLaneDat)\nDenPM = PreProcessVissimDensity(FilePM,TTSegLaneDat)\nTTAM = TTAM.merge(DenAM,left_on=['TIMEINT','TTSegNm'],right_on=['TIMEINT','SegName'],how='left')\nTTPM = TTPM.merge(DenPM,left_on=['TIMEINT','TTSegNm'],right_on=['TIMEINT','SegName'],how='left')\nTTAM.loc[:,'AnalysisPeriod'] = 'AM'\nTTPM.loc[:,'AnalysisPeriod'] = 'PM'\nVissim_TT = pd.concat([TTAM,TTPM],sort=False)\nVissim_TT.columns\nVissim_TT = Vissim_TT[['AnalysisPeriod','TIMEINT','TTSegNm','VissimSMS','WeightedDensity','Veh','Len']]\n\n#Correction-Oversaturated-Conditions\n# For 10 to 20 mph if the density > 45, just use it else replace with 160\nmask = (Vissim_TT.VissimSMS < 20) & (Vissim_TT.WeightedDensity < 45)\nVissim_TT.loc[mask,\"WeightedDensity\"] = 160 # 33 ft. spacing\n# For < 10 mph replace all values with 160\nmask = (Vissim_TT.VissimSMS < 10) & (Vissim_TT.WeightedDensity < 200)\nVissim_TT.loc[mask,\"WeightedDensity\"] = 160 # 33 ft. spacing\nDebug = Vissim_TT.loc[mask,\"WeightedDensity\"]\n\n# Convert Vissim intervals to Hours of the day\nlkey_ = ['AnalysisPeriod','TIMEINT']\nVissim_TT = Vissim_TT.merge(TimeKeys,left_on = lkey_, right_on =lkey_,how = 'inner')\n\n\n\n#Sort the Travel Segments in Correct Order\nVissim_TT.TTSegNm = pd.Categorical(Vissim_TT.TTSegNm,SegIn1)\nVissim_TT.Time = pd.Categorical(Vissim_TT.Time,TimeKeys.Time)\nVissim_TT.TIMEINT = pd.Categorical(Vissim_TT.TIMEINT,['900-1800','1800-2700','2700-3600','3600-4500',\n '4500-5400','5400-6300','6300-7200','7200-8100',\n '8100-9000','9000-9900','9900-10800','10800-11700'])\n \nVissim_TT.loc[:,'Dir'] = Vissim_TT.TTSegNm.apply(lambda x: x.split(' ')[0])\nVissim_TT.rename(columns={'WeightedDensity':'Density'},inplace=True)\n\nVissim_TT.sort_values(['AnalysisPeriod','TIMEINT','Dir','TTSegNm'],inplace=True)\nVissim_TT.set_index(['TIMEINT','Dir','TTSegNm','AnalysisPeriod'],inplace=True)\nVissim_TT = Vissim_TT.unstack()\nVissim_TT = Vissim_TT.swaplevel(0,1,axis=1)\n\nmux = pd.MultiIndex.from_product([['AM','PM'],['Time','VissimSMS','Density','Veh','Len','FlowRate'],\n ], names=Vissim_TT.columns.names)\nVissim_TT = Vissim_TT.reindex(mux,axis=1)\nidx = pd.IndexSlice\nVissim_I95 = Vissim_TT.loc[idx[:,:,I95_Segs], idx[:,['VissimSMS','Density']]] \nVissim_LPGA =Vissim_TT.loc[idx[:,:,LPGASeg], idx[:,['VissimSMS']]]\n\n\n\nTimePer = ['AM','PM']\nDirection = ['NB','SB','EB','WB']\nPerfMeasure = ['VissimSMS','Density']\nt = 'AM'\nd = 'SB'\nPerfMes ='Density'\n(not((d=='EB' or d=='WB') & (PerfMes=='Density')))\nif not os.path.exists(r'C:\\Users\\abibeka\\OneDrive - Kittelson & Associates, Inc\\Documents\\LPGA\\VISSIM-Files\\Figs\\{}'.format(OutputFolderName)):\n os.makedirs(r'C:\\Users\\abibeka\\OneDrive - Kittelson & Associates, Inc\\Documents\\LPGA\\VISSIM-Files\\Figs\\{}'.format(OutputFolderName))\nos.chdir(r'C:\\Users\\abibeka\\OneDrive - Kittelson & Associates, Inc\\Documents\\LPGA\\VISSIM-Files\\Figs\\{}'.format(OutputFolderName))\nos.getcwd()\nDictFigs = {}\nidx = pd.IndexSlice\n#Color Palettes\n#https://matplotlib.org/users/colormaps.html\nfor t in TimePer:\n for d in Direction:\n for PerfMes in PerfMeasure:\n if(not((d=='EB' or d=='WB') & (PerfMes=='Density'))):\n HeatMapDat = Vissim_TT.loc[idx[:,d,:], idx[t,['Time',PerfMes]]]\n HeatMapDat = HeatMapDat.droplevel(0,axis=1).reset_index()\n HeatMapDat = HeatMapDat.pivot('Time','TTSegNm',PerfMes)\n HeatMapDat = HeatMapDat.astype('int32')\n plt.figure()\n if PerfMes=='Density':\n title_ = \"Density (veh/mile/lane)\"\n colorBar_ = 'viridis_r'\n vmax_ = 160; vmin_ = 0\n g = sns.heatmap(HeatMapDat,cmap = colorBar_, linewidths=.5,vmin=vmin_, vmax=vmax_, annot=True,fmt=\"d\")\n else: \n title_ = \"Space Mean Speed (mph)\"\n colorBar_ = 'viridis'\n if(d=='SB') | (d=='NB'):\n vmax_ = 70; vmin_ = 0\n else:\n vmax_ = 45; vmin_ = 0\n g = sns.heatmap(HeatMapDat,cmap = colorBar_, linewidths=.5, vmin=vmin_, vmax=vmax_, annot=True,fmt=\"d\")\n \n # figure size in inches\n #sns.set(rc={'figure.figsize':(6,10)})\n \n g.set_xticklabels(rotation=30,labels = g.get_xticklabels(),ha='right')\n g.set_title('{}—{}'.format(t,title_))\n g.set_xlabel(\"\")\n g.set_ylabel(\"Time Interval\")\n fig = g.get_figure()\n fig.savefig(\"\".join([t,d,PerfMes,'.jpg']),bbox_inches=\"tight\")\n\n\nif not os.path.exists(r'C:\\Users\\abibeka\\OneDrive - Kittelson & Associates, Inc\\Documents\\LPGA\\VISSIM-Files\\Figs\\{}'.format(OutputFolderName)):\n os.makedirs(r'C:\\Users\\abibeka\\OneDrive - Kittelson & Associates, Inc\\Documents\\LPGA\\VISSIM-Files\\Figs\\{}'.format(OutputFolderName))\nos.chdir(r'C:\\Users\\abibeka\\OneDrive - Kittelson & Associates, Inc\\Documents\\LPGA\\VISSIM-Files\\Figs\\{}'.format(OutputFolderName))\nos.getcwd()\nt = 'AM'\nd = 'SB'\nPerfMes ='VissimSMS'\nfor t in TimePer:\n for d in Direction:\n for PerfMes in PerfMeasure:\n os.chdir(r'C:\\Users\\abibeka\\OneDrive - Kittelson & Associates, Inc\\Documents\\LPGA\\VISSIM-Files\\Figs\\{}'.format(OutputFolderName))\n if not os.path.exists('{}/{}/{}'.format(t,d,PerfMes)):\n os.makedirs('{}/{}/{}'.format(t,d,PerfMes))\n os.chdir('{}/{}/{}'.format(t,d,PerfMes))\n if(not((d=='EB' or d=='WB') & (PerfMes=='Density'))):\n LinePlotDat = Vissim_TT.loc[idx[:,d,:], idx[t,['Time',PerfMes]]]\n LinePlotDat = LinePlotDat.droplevel(0,axis=1).reset_index()\n for Tseg in LinePlotDat.TTSegNm.unique():\n TempDat = LinePlotDat[LinePlotDat.TTSegNm==Tseg]\n sns.set(rc={'figure.figsize':(6,4)})\n sns.set_style(\"ticks\")\n fig,ax1 = plt.subplots()\n sns.lineplot('Time',PerfMes,data = TempDat,ax=ax1)\n if(PerfMes == 'VissimSMS'):\n ax1.set_ylim(0,70)\n ylab = \"Space Mean Speed (mph)\"\n else: \n ax1.set_ylim(0,170)\n ylab = \"Density (veh/mile/lane)\"\n\n ax1.set_title('{}—{}'.format(t,Tseg), y =1.05)\n ax1.set_ylabel(ylab)\n ax1.set_xlabel(\"Time Interval\")\n # Must draw the canvas to position the ticks\n fig.canvas.draw()\n ax1.set_xticklabels(rotation=30,labels = ax1.get_xticklabels(),ha='right')\n fig.savefig(\"_\".join([Tseg,d,PerfMes,'.jpg']),bbox_inches=\"tight\")\n plt.close()\n#Write Results to Output File\nPathToOutFi = r'C:\\Users\\abibeka\\OneDrive - Kittelson & Associates, Inc\\Documents\\LPGA\\VISSIM-Files'\nOutFi = \"AfterValidationRes.xlsx\"\nOutFi = os.path.join(PathToOutFi,OutFi)\nif(OutputFolderName =='Existing'):\n writer=pd.ExcelWriter(OutFi)\nelse:\n writer=pd.ExcelWriter(OutFi, mode ='a')\nVissim_LPGA.to_excel(writer, '{}-LPGA-SMS-Res'.format(OutputFolderName),na_rep='NaN')\nVissim_I95.to_excel(writer,'{}-I95-SMS&Density-Res'.format(OutputFolderName),na_rep='NaN')\nwriter.save()\n\nif(OutputFolderName == 'DCMI'):\n subprocess.Popen([OutFi],shell=True) \n\n",
"# -*- coding: utf-8 -*-\n\"\"\"\nCreated on Tue Sep 10 13:25:02 2019\n\n@author: abibeka\n\"\"\"\n\n\n#0.0 Housekeeping. Clear variable space\nfrom IPython import get_ipython #run magic commands\nipython = get_ipython()\nipython.magic(\"reset -f\")\nipython = get_ipython()\n\nimport os\nimport pandas as pd\n\n#os.chdir(r'C:\\Users\\abibeka\\OneDrive - Kittelson & Associates, Inc\\Documents\\12th-Street-TransitWay\\Results')\nos.chdir(r'H:\\20\\20548 - Arlington County Engineering On-Call\\009 - 12th Street Transitway Extension\\vissim\\Results')\n\ndef CleanNetPerFun(file):\n '''\n \n '''\n Dat = pd.read_csv(file,sep =';',skiprows=1,comment=\"*\")\n Dat.columns\n Dat = Dat[Dat['$VEHICLENETWORKPERFORMANCEMEASUREMENTEVALUATION:SIMRUN']=='AVG']\n Dat.columns =[x.strip() for x in Dat.columns]\n Dat = Dat.rename(columns = {\n 'DELAYAVG(ALL)': 'Average Delay — All (sec)',\n 'DELAYTOT(ALL)': 'Total Delay — All (sec)',\n 'STOPSTOT(ALL)': 'Total Stops — All',\n 'STOPSAVG(ALL)': 'Average Stops — All',\n 'SPEEDAVG(ALL)': 'Average Speed — All',\n 'DELAYLATENT' : 'Latent Delay (sec)',\n 'DEMANDLATENT': 'Latent Demand (veh)'\n })\n Dat = Dat[['TIMEINT','Average Delay — All (sec)', \n 'Total Delay — All (sec)','Total Stops — All','Average Stops — All',\n 'Average Speed — All','Latent Delay (sec)', 'Latent Demand (veh)']] \n Dat.dtypes\n listVar = ['Average Delay — All (sec)', \n 'Total Delay — All (sec)','Average Stops — All',\n 'Average Speed — All','Latent Delay (sec)', 'Latent Demand (veh)']\n Dat.loc[:,listVar] = Dat.loc[:,listVar].applymap(lambda x: format(x,',.1f'))\n Dat.loc[:,'Total Stops — All'] =Dat.loc[:,'Total Stops — All'].apply(lambda x: format(x,','))\n return(Dat)\n\n\n#*********************************************************************************\n# Specify Files\n#*********************************************************************************\n\nx1 = pd.ExcelFile(r'ResultsNameMap.xlsx')\n\nNetPerfFile_AM = r'./RawVissimOutput/20548_2019_am-existing_V5_Vehicle Network Performance Evaluation Results.att'\nfile = NetPerfFile_AM\nNetPerfFile_PM = NetPerfFile_AM\n\n\n\nDataDict = {\n 'ExistAM': NetPerfFile_AM,\n 'ExistPM': NetPerfFile_PM,\n }\n\n\nOutFi = r'NetworkPerfEvalRes.xlsx'\n\nwriter=pd.ExcelWriter(OutFi)\nfor name, file, in DataDict.items():\n Dat = CleanNetPerFun(file)\n Dat.to_excel(writer,name,na_rep=' ')\nwriter.save() \n\n \n\n"
] |
[
[
"pandas.concat",
"pandas.read_csv",
"pandas.Categorical",
"matplotlib.pyplot.subplots",
"pandas.MultiIndex.from_product",
"matplotlib.pyplot.close",
"pandas.ExcelWriter",
"matplotlib.pyplot.figure"
],
[
"pandas.read_csv",
"pandas.ExcelFile",
"pandas.ExcelWriter"
]
] |
KyawThuHtun/OpenCV-with-Python
|
[
"2c471060d4f2aa4ec45cda5f544a61923e4ea2ed"
] |
[
"coding-exercises-avairds/week2-image-operation/part2-intermediate/mask.py"
] |
[
"import cv2 as cv\nimport numpy as np\n\nimg = cv.imread(\"nancy1.jpg\", 1)\ncv.imshow(\"org\", img)\n\nmask = np.zeros(img.shape[:2], dtype=\"uint8\") # black image as like org-image dimension\n(cX, cY) = (img.shape[1] // 2, img.shape[0] // 2) # find center\n\n# create mask\ncv.rectangle(mask, (cX - 60, cY - 60), (cX + 60, cY + 60)\n , 255, -1)\ncv.imshow(\"Mask\", mask)\n\n# mask cover the interest region using\n# bitwise_and method\nmasked = cv.bitwise_and(img, img, mask=mask)\ncv.imshow(\"Mask Applied to Image\", masked)\n\ncv.waitKey(0)\ncv.destroyAllWindows()"
] |
[
[
"numpy.zeros"
]
] |
TaylorHere/modin
|
[
"044534315c95aa45aed8e53b665cec19abb055e2"
] |
[
"modin/backends/base/query_compiler.py"
] |
[
"# Licensed to Modin Development Team under one or more contributor license agreements.\n# See the NOTICE file distributed with this work for additional information regarding\n# copyright ownership. The Modin Development Team licenses this file to you under the\n# Apache License, Version 2.0 (the \"License\"); you may not use this file except in\n# compliance 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, software distributed under\n# the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF\n# ANY KIND, either express or implied. See the License for the specific language\n# governing permissions and limitations under the License.\nimport abc\n\nfrom modin.data_management.functions.default_methods import (\n DataFrameDefault,\n SeriesDefault,\n DateTimeDefault,\n StrDefault,\n BinaryDefault,\n ResampleDefault,\n RollingDefault,\n CatDefault,\n GroupByDefault,\n)\nfrom modin.error_message import ErrorMessage\n\nfrom pandas.core.dtypes.common import is_scalar\nimport pandas.core.resample\nimport pandas\nimport numpy as np\nfrom typing import List, Hashable\n\n\ndef _get_axis(axis):\n def axis_getter(self):\n ErrorMessage.default_to_pandas(f\"DataFrame.get_axis({axis})\")\n return self.to_pandas().axes[axis]\n\n return axis_getter\n\n\ndef _set_axis(axis):\n def axis_setter(self, labels):\n new_qc = DataFrameDefault.register(pandas.DataFrame.set_axis)(\n self, axis=axis, labels=labels\n )\n self.__dict__.update(new_qc.__dict__)\n\n return axis_setter\n\n\nclass BaseQueryCompiler(abc.ABC):\n \"\"\"Abstract Class that handles the queries to Modin dataframes.\n\n Note: See the Abstract Methods and Fields section immediately below this\n for a list of requirements for subclassing this object.\n \"\"\"\n\n @abc.abstractmethod\n def default_to_pandas(self, pandas_op, *args, **kwargs):\n \"\"\"\n Default to pandas behavior.\n\n Parameters\n ----------\n pandas_op : callable\n The operation to apply, must be compatible pandas DataFrame call\n args\n The arguments for the `pandas_op`\n kwargs\n The keyword arguments for the `pandas_op`\n\n Returns\n -------\n BaseQueryCompiler\n The result of the `pandas_op`, converted back to BaseQueryCompiler\n \"\"\"\n pass\n\n # Abstract Methods and Fields: Must implement in children classes\n # In some cases, there you may be able to use the same implementation for\n # some of these abstract methods, but for the sake of generality they are\n # treated differently.\n\n lazy_execution = False\n\n # Metadata modification abstract methods\n def add_prefix(self, prefix, axis=1):\n if axis:\n return DataFrameDefault.register(pandas.DataFrame.add_prefix)(\n self, prefix=prefix\n )\n else:\n return SeriesDefault.register(pandas.Series.add_prefix)(self, prefix=prefix)\n\n def add_suffix(self, suffix, axis=1):\n if axis:\n return DataFrameDefault.register(pandas.DataFrame.add_suffix)(\n self, suffix=suffix\n )\n else:\n return SeriesDefault.register(pandas.Series.add_suffix)(self, suffix=suffix)\n\n # END Metadata modification abstract methods\n\n # Abstract copy\n # For copy, we don't want a situation where we modify the metadata of the\n # copies if we end up modifying something here. We copy all of the metadata\n # to prevent that.\n def copy(self):\n return DataFrameDefault.register(pandas.DataFrame.copy)(self)\n\n # END Abstract copy\n\n # Abstract join and append helper functions\n\n def concat(self, axis, other, **kwargs):\n \"\"\"Concatenates two objects together.\n\n Args:\n axis: The axis index object to join (0 for columns, 1 for index).\n other: The other_index to concat with.\n\n Returns:\n Concatenated objects.\n \"\"\"\n concat_join = [\"inner\", \"outer\"]\n\n def concat(df, axis, other, **kwargs):\n kwargs.pop(\"join_axes\", None)\n ignore_index = kwargs.get(\"ignore_index\", False)\n if kwargs.get(\"join\", \"outer\") in concat_join:\n if not isinstance(other, list):\n other = [other]\n other = [df] + other\n result = pandas.concat(other, axis=axis, **kwargs)\n else:\n if isinstance(other, (list, np.ndarray)) and len(other) == 1:\n other = other[0]\n ignore_index = kwargs.pop(\"ignore_index\", None)\n kwargs[\"how\"] = kwargs.pop(\"join\", None)\n result = df.join(other, rsuffix=\"r_\", **kwargs)\n if ignore_index:\n if axis == 0:\n result = result.reset_index(drop=True)\n else:\n result.columns = pandas.RangeIndex(len(result.columns))\n return result\n\n return DataFrameDefault.register(concat)(self, axis=axis, other=other, **kwargs)\n\n # END Abstract join and append helper functions\n\n # Data Management Methods\n @abc.abstractmethod\n def free(self):\n \"\"\"In the future, this will hopefully trigger a cleanup of this object.\"\"\"\n # TODO create a way to clean up this object.\n pass\n\n @abc.abstractmethod\n def finalize(self):\n \"\"\"Finalize constructing the dataframe calling all deferred functions which were used to build it.\"\"\"\n pass\n\n # END Data Management Methods\n\n # To/From Pandas\n @abc.abstractmethod\n def to_pandas(self):\n \"\"\"Converts Modin DataFrame to Pandas DataFrame.\n\n Returns:\n Pandas DataFrame of the QueryCompiler.\n \"\"\"\n pass\n\n @classmethod\n @abc.abstractmethod\n def from_pandas(cls, df, data_cls):\n \"\"\"Improve simple Pandas DataFrame to an advanced and superior Modin DataFrame.\n\n Parameters\n ----------\n df: pandas.DataFrame\n The pandas DataFrame to convert from.\n data_cls :\n Modin DataFrame object to convert to.\n\n Returns\n -------\n BaseQueryCompiler\n QueryCompiler containing data from the Pandas DataFrame.\n \"\"\"\n pass\n\n # END To/From Pandas\n\n # From Arrow\n @classmethod\n @abc.abstractmethod\n def from_arrow(cls, at, data_cls):\n \"\"\"Improve simple Arrow Table to an advanced and superior Modin DataFrame.\n\n Parameters\n ----------\n at : Arrow Table\n The Arrow Table to convert from.\n data_cls :\n Modin DataFrame object to convert to.\n\n Returns\n -------\n BaseQueryCompiler\n QueryCompiler containing data from the Pandas DataFrame.\n \"\"\"\n pass\n\n # END From Arrow\n\n # To NumPy\n\n def to_numpy(self, **kwargs):\n \"\"\"\n Converts Modin DataFrame to NumPy array.\n\n Returns\n -------\n NumPy array of the QueryCompiler.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.to_numpy)(self, **kwargs)\n\n # END To NumPy\n\n # Abstract inter-data operations (e.g. add, sub)\n # These operations require two DataFrames and will change the shape of the\n # data if the index objects don't match. An outer join + op is performed,\n # such that columns/rows that don't have an index on the other DataFrame\n # result in NaN values.\n\n def add(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.add)(self, other=other, **kwargs)\n\n def combine(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.combine)(\n self, other=other, **kwargs\n )\n\n def combine_first(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.combine_first)(\n self, other=other, **kwargs\n )\n\n def eq(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.eq)(self, other=other, **kwargs)\n\n def floordiv(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.floordiv)(\n self, other=other, **kwargs\n )\n\n def ge(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.ge)(self, other=other, **kwargs)\n\n def gt(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.gt)(self, other=other, **kwargs)\n\n def le(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.le)(self, other=other, **kwargs)\n\n def lt(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.lt)(self, other=other, **kwargs)\n\n def mod(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.mod)(self, other=other, **kwargs)\n\n def mul(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.mul)(self, other=other, **kwargs)\n\n def corr(self, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.corr)(self, **kwargs)\n\n def cov(self, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.cov)(self, **kwargs)\n\n def dot(self, other, **kwargs):\n if kwargs.get(\"squeeze_self\", False):\n applyier = pandas.Series.dot\n else:\n applyier = pandas.DataFrame.dot\n return BinaryDefault.register(applyier)(self, other=other, **kwargs)\n\n def ne(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.ne)(self, other=other, **kwargs)\n\n def pow(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.pow)(self, other=other, **kwargs)\n\n def rfloordiv(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.rfloordiv)(\n self, other=other, **kwargs\n )\n\n def rmod(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.rmod)(\n self, other=other, **kwargs\n )\n\n def rpow(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.rpow)(\n self, other=other, **kwargs\n )\n\n def rsub(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.rsub)(\n self, other=other, **kwargs\n )\n\n def rtruediv(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.rtruediv)(\n self, other=other, **kwargs\n )\n\n def sub(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.sub)(self, other=other, **kwargs)\n\n def truediv(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.truediv)(\n self, other=other, **kwargs\n )\n\n def __and__(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.__and__)(\n self, other=other, **kwargs\n )\n\n def __or__(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.__or__)(\n self, other=other, **kwargs\n )\n\n def __rand__(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.__rand__)(\n self, other=other, **kwargs\n )\n\n def __ror__(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.__ror__)(\n self, other=other, **kwargs\n )\n\n def __rxor__(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.__rxor__)(\n self, other=other, **kwargs\n )\n\n def __xor__(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.__xor__)(\n self, other=other, **kwargs\n )\n\n def df_update(self, other, **kwargs):\n return BinaryDefault.register(pandas.DataFrame.update, inplace=True)(\n self, other=other, **kwargs\n )\n\n def series_update(self, other, **kwargs):\n return BinaryDefault.register(pandas.Series.update, inplace=True)(\n self, other=other, squeeze_self=True, squeeze_other=True, **kwargs\n )\n\n def clip(self, lower, upper, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.clip)(\n self, lower=lower, upper=upper, **kwargs\n )\n\n def where(self, cond, other, **kwargs):\n \"\"\"Gets values from this manager where cond is true else from other.\n\n Args:\n cond: Condition on which to evaluate values.\n\n Returns:\n New QueryCompiler with updated data and index.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.where)(\n self, cond=cond, other=other, **kwargs\n )\n\n def merge(self, right, **kwargs):\n \"\"\"\n Merge DataFrame or named Series objects with a database-style join.\n\n Parameters\n ----------\n right : BaseQueryCompiler\n The query compiler of the right DataFrame to merge with.\n\n Returns\n -------\n BaseQueryCompiler\n A new query compiler that contains result of the merge.\n\n Notes\n -----\n See pd.merge or pd.DataFrame.merge for more info on kwargs.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.merge)(\n self, right=right, **kwargs\n )\n\n def join(self, right, **kwargs):\n \"\"\"\n Join columns of another DataFrame.\n\n Parameters\n ----------\n right : BaseQueryCompiler\n The query compiler of the right DataFrame to join with.\n\n Returns\n -------\n BaseQueryCompiler\n A new query compiler that contains result of the join.\n\n Notes\n -----\n See pd.DataFrame.join for more info on kwargs.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.join)(self, right, **kwargs)\n\n # END Abstract inter-data operations\n\n # Abstract Transpose\n def transpose(self, *args, **kwargs):\n \"\"\"Transposes this QueryCompiler.\n\n Returns:\n Transposed new QueryCompiler.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.transpose)(\n self, *args, **kwargs\n )\n\n def columnarize(self):\n \"\"\"\n Transposes this QueryCompiler if it has a single row but multiple columns.\n\n This method should be called for QueryCompilers representing a Series object,\n i.e. self.is_series_like() should be True.\n\n Returns\n -------\n BaseQueryCompiler\n Transposed new QueryCompiler or self.\n \"\"\"\n if len(self.columns) != 1 or (\n len(self.index) == 1 and self.index[0] == \"__reduced__\"\n ):\n return self.transpose()\n return self\n\n def is_series_like(self):\n \"\"\"Return True if QueryCompiler has a single column or row\"\"\"\n return len(self.columns) == 1 or len(self.index) == 1\n\n # END Abstract Transpose\n\n # Abstract reindex/reset_index (may shuffle data)\n def reindex(self, axis, labels, **kwargs):\n \"\"\"Fits a new index for this Manger.\n\n Args:\n axis: The axis index object to target the reindex on.\n labels: New labels to conform 'axis' on to.\n\n Returns:\n New QueryCompiler with updated data and new index.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.reindex)(\n self, axis=axis, labels=labels, **kwargs\n )\n\n def reset_index(self, **kwargs):\n \"\"\"Removes all levels from index and sets a default level_0 index.\n\n Returns:\n New QueryCompiler with updated data and reset index.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.reset_index)(self, **kwargs)\n\n def set_index_from_columns(\n self, keys: List[Hashable], drop: bool = True, append: bool = False\n ):\n \"\"\"Create new row labels from a list of columns.\n\n Parameters\n ----------\n keys : list of hashable\n The list of column names that will become the new index.\n drop : boolean\n Whether or not to drop the columns provided in the `keys` argument.\n append : boolean\n Whether or not to add the columns in `keys` as new levels appended to the\n existing index.\n\n Returns\n -------\n PandasQueryCompiler\n A new QueryCompiler with updated index.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.set_index)(\n self, keys=keys, drop=drop, append=append\n )\n\n # END Abstract reindex/reset_index\n\n # Full Reduce operations\n #\n # These operations result in a reduced dimensionality of data.\n # Currently, this means a Pandas Series will be returned, but in the future\n # we will implement a Distributed Series, and this will be returned\n # instead.\n\n def is_monotonic_increasing(self):\n \"\"\"Return boolean if values in the object are monotonic_increasing.\n\n Returns\n -------\n bool\n \"\"\"\n return SeriesDefault.register(pandas.Series.is_monotonic_increasing)(self)\n\n def is_monotonic_decreasing(self):\n \"\"\"Return boolean if values in the object are monotonic_decreasing.\n\n Returns\n -------\n bool\n \"\"\"\n return SeriesDefault.register(pandas.Series.is_monotonic_decreasing)(self)\n\n def count(self, **kwargs):\n \"\"\"Counts the number of non-NaN objects for each column or row.\n\n Return:\n Pandas series containing counts of non-NaN objects from each column or row.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.count)(self, **kwargs)\n\n def max(self, **kwargs):\n \"\"\"Returns the maximum value for each column or row.\n\n Return:\n Pandas series with the maximum values from each column or row.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.max)(self, **kwargs)\n\n def mean(self, **kwargs):\n \"\"\"Returns the mean for each numerical column or row.\n\n Return:\n Pandas series containing the mean from each numerical column or row.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.mean)(self, **kwargs)\n\n def min(self, **kwargs):\n \"\"\"Returns the minimum from each column or row.\n\n Return:\n Pandas series with the minimum value from each column or row.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.min)(self, **kwargs)\n\n def prod(self, **kwargs):\n \"\"\"Returns the product of each numerical column or row.\n\n Return:\n Pandas series with the product of each numerical column or row.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.prod)(self, **kwargs)\n\n def sum(self, **kwargs):\n \"\"\"Returns the sum of each numerical column or row.\n\n Return:\n Pandas series with the sum of each numerical column or row.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.sum)(self, **kwargs)\n\n def to_datetime(self, *args, **kwargs):\n return SeriesDefault.register(pandas.to_datetime)(self, *args, **kwargs)\n\n # END Abstract full Reduce operations\n\n # Abstract map partitions operations\n # These operations are operations that apply a function to every partition.\n def abs(self):\n return DataFrameDefault.register(pandas.DataFrame.abs)(self)\n\n def applymap(self, func):\n return DataFrameDefault.register(pandas.DataFrame.applymap)(self, func=func)\n\n def conj(self, **kwargs):\n \"\"\"\n Return the complex conjugate, element-wise.\n\n The complex conjugate of a complex number is obtained\n by changing the sign of its imaginary part.\n \"\"\"\n\n def conj(df, *args, **kwargs):\n return pandas.DataFrame(np.conj(df))\n\n return DataFrameDefault.register(conj)(self, **kwargs)\n\n def isin(self, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.isin)(self, **kwargs)\n\n def isna(self):\n return DataFrameDefault.register(pandas.DataFrame.isna)(self)\n\n def negative(self, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.__neg__)(self, **kwargs)\n\n def notna(self):\n return DataFrameDefault.register(pandas.DataFrame.notna)(self)\n\n def round(self, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.round)(self, **kwargs)\n\n def replace(self, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.replace)(self, **kwargs)\n\n def series_view(self, **kwargs):\n return SeriesDefault.register(pandas.Series.view)(self, **kwargs)\n\n def to_numeric(self, *args, **kwargs):\n return SeriesDefault.register(pandas.to_numeric)(self, *args, **kwargs)\n\n def unique(self, **kwargs):\n return SeriesDefault.register(pandas.Series.unique)(self, **kwargs)\n\n def searchsorted(self, **kwargs):\n return SeriesDefault.register(pandas.Series.searchsorted)(self, **kwargs)\n\n # END Abstract map partitions operations\n\n def value_counts(self, **kwargs):\n return SeriesDefault.register(pandas.Series.value_counts)(self, **kwargs)\n\n def stack(self, level, dropna):\n return DataFrameDefault.register(pandas.DataFrame.stack)(\n self, level=level, dropna=dropna\n )\n\n # Abstract map partitions across select indices\n def astype(self, col_dtypes, **kwargs):\n \"\"\"Converts columns dtypes to given dtypes.\n\n Args:\n col_dtypes: Dictionary of {col: dtype,...} where col is the column\n name and dtype is a numpy dtype.\n\n Returns:\n DataFrame with updated dtypes.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.astype)(\n self, dtype=col_dtypes, **kwargs\n )\n\n @property\n def dtypes(self):\n return self.to_pandas().dtypes\n\n # END Abstract map partitions across select indices\n\n # Abstract column/row partitions reduce operations\n #\n # These operations result in a reduced dimensionality of data.\n # Currently, this means a Pandas Series will be returned, but in the future\n # we will implement a Distributed Series, and this will be returned\n # instead.\n def all(self, **kwargs):\n \"\"\"Returns whether all the elements are true, potentially over an axis.\n\n Return:\n Pandas Series containing boolean values or boolean.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.all)(self, **kwargs)\n\n def any(self, **kwargs):\n \"\"\"Returns whether any the elements are true, potentially over an axis.\n\n Return:\n Pandas Series containing boolean values or boolean.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.any)(self, **kwargs)\n\n def first_valid_index(self):\n \"\"\"Returns index of first non-NaN/NULL value.\n\n Return:\n Scalar of index name.\n \"\"\"\n return (\n DataFrameDefault.register(pandas.DataFrame.first_valid_index)(self)\n .to_pandas()\n .squeeze()\n )\n\n def idxmax(self, **kwargs):\n \"\"\"Returns the first occurance of the maximum over requested axis.\n\n Returns:\n Series containing the maximum of each column or axis.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.idxmax)(self, **kwargs)\n\n def idxmin(self, **kwargs):\n \"\"\"Returns the first occurance of the minimum over requested axis.\n\n Returns:\n Series containing the minimum of each column or axis.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.idxmin)(self, **kwargs)\n\n def last_valid_index(self):\n \"\"\"Returns index of last non-NaN/NULL value.\n\n Return:\n Scalar of index name.\n \"\"\"\n return (\n DataFrameDefault.register(pandas.DataFrame.last_valid_index)(self)\n .to_pandas()\n .squeeze()\n )\n\n def median(self, **kwargs):\n \"\"\"Returns median of each column or row.\n\n Returns:\n Series containing the median of each column or row.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.median)(self, **kwargs)\n\n def memory_usage(self, **kwargs):\n \"\"\"Returns the memory usage of each column.\n\n Returns:\n Series containing the memory usage of each column.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.memory_usage)(self, **kwargs)\n\n def nunique(self, **kwargs):\n \"\"\"Returns the number of unique items over each column or row.\n\n Returns:\n Series of ints indexed by column or index names.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.nunique)(self, **kwargs)\n\n def quantile_for_single_value(self, **kwargs):\n \"\"\"Returns quantile of each column or row.\n\n Returns:\n Series containing the quantile of each column or row.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.quantile)(self, **kwargs)\n\n def skew(self, **kwargs):\n \"\"\"Returns skew of each column or row.\n\n Returns:\n Series containing the skew of each column or row.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.skew)(self, **kwargs)\n\n def sem(self, **kwargs):\n \"\"\"\n Returns standard deviation of the mean over requested axis.\n\n Returns\n -------\n BaseQueryCompiler\n QueryCompiler containing the standard deviation of the mean over requested axis.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.sem)(self, **kwargs)\n\n def std(self, **kwargs):\n \"\"\"Returns standard deviation of each column or row.\n\n Returns:\n Series containing the standard deviation of each column or row.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.std)(self, **kwargs)\n\n def var(self, **kwargs):\n \"\"\"Returns variance of each column or row.\n\n Returns:\n Series containing the variance of each column or row.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.var)(self, **kwargs)\n\n # END Abstract column/row partitions reduce operations\n\n # Abstract column/row partitions reduce operations over select indices\n #\n # These operations result in a reduced dimensionality of data.\n # Currently, this means a Pandas Series will be returned, but in the future\n # we will implement a Distributed Series, and this will be returned\n # instead.\n def describe(self, **kwargs):\n \"\"\"Generates descriptive statistics.\n\n Returns:\n DataFrame object containing the descriptive statistics of the DataFrame.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.describe)(self, **kwargs)\n\n # END Abstract column/row partitions reduce operations over select indices\n\n # Map across rows/columns\n # These operations require some global knowledge of the full column/row\n # that is being operated on. This means that we have to put all of that\n # data in the same place.\n def cumsum(self, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.cumsum)(self, **kwargs)\n\n def cummax(self, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.cummax)(self, **kwargs)\n\n def cummin(self, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.cummin)(self, **kwargs)\n\n def cumprod(self, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.cumprod)(self, **kwargs)\n\n def diff(self, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.diff)(self, **kwargs)\n\n def dropna(self, **kwargs):\n \"\"\"Returns a new QueryCompiler with null values dropped along given axis.\n Return:\n New QueryCompiler\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.dropna)(self, **kwargs)\n\n def nlargest(self, n=5, columns=None, keep=\"first\"):\n if columns is None:\n return SeriesDefault.register(pandas.Series.nlargest)(self, n=n, keep=keep)\n else:\n return DataFrameDefault.register(pandas.DataFrame.nlargest)(\n self, n=n, columns=columns, keep=keep\n )\n\n def nsmallest(self, n=5, columns=None, keep=\"first\"):\n if columns is None:\n return SeriesDefault.register(pandas.Series.nsmallest)(self, n=n, keep=keep)\n else:\n return DataFrameDefault.register(pandas.DataFrame.nsmallest)(\n self, n=n, columns=columns, keep=keep\n )\n\n def eval(self, expr, **kwargs):\n \"\"\"Returns a new QueryCompiler with expr evaluated on columns.\n\n Args:\n expr: The string expression to evaluate.\n\n Returns:\n A new QueryCompiler with new columns after applying expr.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.eval)(\n self, expr=expr, **kwargs\n )\n\n def mode(self, **kwargs):\n \"\"\"Returns a new QueryCompiler with modes calculated for each label along given axis.\n\n Returns:\n A new QueryCompiler with modes calculated.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.mode)(self, **kwargs)\n\n def fillna(self, **kwargs):\n \"\"\"Replaces NaN values with the method provided.\n\n Returns:\n A new QueryCompiler with null values filled.\n \"\"\"\n\n squeeze_self = kwargs.pop(\"squeeze_self\", False)\n squeeze_value = kwargs.pop(\"squeeze_value\", False)\n\n def fillna(df, value, **kwargs):\n if squeeze_self:\n df = df.squeeze(axis=1)\n if squeeze_value:\n value = value.squeeze(axis=1)\n return df.fillna(value, **kwargs)\n\n return DataFrameDefault.register(fillna)(self, **kwargs)\n\n def query(self, expr, **kwargs):\n \"\"\"Query columns of the QueryCompiler with a boolean expression.\n\n Args:\n expr: Boolean expression to query the columns with.\n\n Returns:\n QueryCompiler containing the rows where the boolean expression is satisfied.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.query)(\n self, expr=expr, **kwargs\n )\n\n def rank(self, **kwargs):\n \"\"\"Computes numerical rank along axis. Equal values are set to the average.\n\n Returns:\n QueryCompiler containing the ranks of the values along an axis.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.rank)(self, **kwargs)\n\n def sort_index(self, **kwargs):\n \"\"\"Sorts the data with respect to either the columns or the indices.\n\n Returns:\n QueryCompiler containing the data sorted by columns or indices.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.sort_index)(self, **kwargs)\n\n def melt(self, *args, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.melt)(self, *args, **kwargs)\n\n def sort_columns_by_row_values(self, rows, ascending=True, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.sort_values)(\n self, by=rows, axis=1, ascending=ascending, **kwargs\n )\n\n def sort_rows_by_column_values(self, rows, ascending=True, **kwargs):\n return DataFrameDefault.register(pandas.DataFrame.sort_values)(\n self, by=rows, axis=0, ascending=ascending, **kwargs\n )\n\n # END Abstract map across rows/columns\n\n # Map across rows/columns\n # These operations require some global knowledge of the full column/row\n # that is being operated on. This means that we have to put all of that\n # data in the same place.\n def quantile_for_list_of_values(self, **kwargs):\n \"\"\"Returns Manager containing quantiles along an axis for numeric columns.\n\n Returns:\n QueryCompiler containing quantiles of original QueryCompiler along an axis.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.quantile)(self, **kwargs)\n\n # END Abstract map across rows/columns\n\n # Abstract __getitem__ methods\n def getitem_array(self, key):\n \"\"\"\n Get column or row data specified by key.\n Parameters\n ----------\n key : BaseQueryCompiler, numpy.ndarray, pandas.Index or list\n Target numeric indices or labels by which to retrieve data.\n Returns\n -------\n BaseQueryCompiler\n A new Query Compiler.\n \"\"\"\n\n def getitem_array(df, key):\n return df[key]\n\n return DataFrameDefault.register(getitem_array)(self, key)\n\n def getitem_column_array(self, key, numeric=False):\n \"\"\"Get column data for target labels.\n\n Args:\n key: Target labels by which to retrieve data.\n numeric: A boolean representing whether or not the key passed in represents\n the numeric index or the named index.\n\n Returns:\n A new Query Compiler.\n \"\"\"\n\n def get_column(df, key):\n if numeric:\n return df.iloc[:, key]\n else:\n return df[key]\n\n return DataFrameDefault.register(get_column)(self, key=key)\n\n def getitem_row_array(self, key):\n \"\"\"Get row data for target labels.\n\n Args:\n key: Target numeric indices by which to retrieve data.\n\n Returns:\n A new Query Compiler.\n \"\"\"\n\n def get_row(df, key):\n return df.iloc[key]\n\n return DataFrameDefault.register(get_row)(self, key=key)\n\n # END Abstract __getitem__ methods\n\n # Abstract insert\n # This method changes the shape of the resulting data. In Pandas, this\n # operation is always inplace, but this object is immutable, so we just\n # return a new one from here and let the front end handle the inplace\n # update.\n def insert(self, loc, column, value):\n \"\"\"Insert new column data.\n\n Args:\n loc: Insertion index.\n column: Column labels to insert.\n value: Dtype object values to insert.\n\n Returns:\n A new QueryCompiler with new data inserted.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.insert, inplace=True)(\n self, loc=loc, column=column, value=value\n )\n\n # END Abstract insert\n\n # Abstract drop\n def drop(self, index=None, columns=None):\n \"\"\"Remove row data for target index and columns.\n\n Args:\n index: Target index to drop.\n columns: Target columns to drop.\n\n Returns:\n A new QueryCompiler.\n \"\"\"\n if index is None and columns is None:\n return self\n else:\n return DataFrameDefault.register(pandas.DataFrame.drop)(\n self, index=index, columns=columns\n )\n\n # END drop\n\n # UDF (apply and agg) methods\n # There is a wide range of behaviors that are supported, so a lot of the\n # logic can get a bit convoluted.\n def apply(self, func, axis, *args, **kwargs):\n \"\"\"Apply func across given axis.\n\n Args:\n func: The function to apply.\n axis: Target axis to apply the function along.\n\n Returns:\n A new QueryCompiler.\n \"\"\"\n return DataFrameDefault.register(pandas.DataFrame.apply)(\n self, func=func, axis=axis, *args, **kwargs\n )\n\n # END UDF\n\n # Manual Partitioning methods (e.g. merge, groupby)\n # These methods require some sort of manual partitioning due to their\n # nature. They require certain data to exist on the same partition, and\n # after the shuffle, there should be only a local map required.\n\n def groupby_count(\n self,\n by,\n axis,\n groupby_args,\n map_args,\n reduce_args=None,\n numeric_only=True,\n drop=False,\n ):\n \"\"\"Perform a groupby count.\n\n Parameters\n ----------\n by : BaseQueryCompiler\n The query compiler object to groupby.\n axis : 0 or 1\n The axis to groupby. Must be 0 currently.\n groupby_args : dict\n The arguments for the groupby component.\n map_args : dict\n The arguments for the `map_func`.\n reduce_args : dict\n The arguments for `reduce_func`.\n numeric_only : bool\n Whether to drop non-numeric columns.\n drop : bool\n Whether the data in `by` was dropped.\n\n Returns\n -------\n BaseQueryCompiler\n \"\"\"\n return GroupByDefault.register(pandas.core.groupby.DataFrameGroupBy.count)(\n self,\n by=by,\n axis=axis,\n groupby_args=groupby_args,\n map_args=map_args,\n reduce_args=reduce_args,\n numeric_only=numeric_only,\n drop=drop,\n )\n\n def groupby_any(\n self,\n by,\n axis,\n groupby_args,\n map_args,\n reduce_args=None,\n numeric_only=True,\n drop=False,\n ):\n \"\"\"Perform a groupby any.\n\n Parameters\n ----------\n by : BaseQueryCompiler\n The query compiler object to groupby.\n axis : 0 or 1\n The axis to groupby. Must be 0 currently.\n groupby_args : dict\n The arguments for the groupby component.\n map_args : dict\n The arguments for the `map_func`.\n reduce_args : dict\n The arguments for `reduce_func`.\n numeric_only : bool\n Whether to drop non-numeric columns.\n drop : bool\n Whether the data in `by` was dropped.\n\n Returns\n -------\n BaseQueryCompiler\n \"\"\"\n return GroupByDefault.register(pandas.core.groupby.DataFrameGroupBy.any)(\n self,\n by=by,\n axis=axis,\n groupby_args=groupby_args,\n map_args=map_args,\n reduce_args=reduce_args,\n numeric_only=numeric_only,\n drop=drop,\n )\n\n def groupby_min(\n self,\n by,\n axis,\n groupby_args,\n map_args,\n reduce_args=None,\n numeric_only=True,\n drop=False,\n ):\n \"\"\"Perform a groupby min.\n\n Parameters\n ----------\n by : BaseQueryCompiler\n The query compiler object to groupby.\n axis : 0 or 1\n The axis to groupby. Must be 0 currently.\n groupby_args : dict\n The arguments for the groupby component.\n map_args : dict\n The arguments for the `map_func`.\n reduce_args : dict\n The arguments for `reduce_func`.\n numeric_only : bool\n Whether to drop non-numeric columns.\n drop : bool\n Whether the data in `by` was dropped.\n\n Returns\n -------\n BaseQueryCompiler\n \"\"\"\n return GroupByDefault.register(pandas.core.groupby.DataFrameGroupBy.min)(\n self,\n by=by,\n axis=axis,\n groupby_args=groupby_args,\n map_args=map_args,\n reduce_args=reduce_args,\n numeric_only=numeric_only,\n drop=drop,\n )\n\n def groupby_prod(\n self,\n by,\n axis,\n groupby_args,\n map_args,\n reduce_args=None,\n numeric_only=True,\n drop=False,\n ):\n \"\"\"Perform a groupby prod.\n\n Parameters\n ----------\n by : BaseQueryCompiler\n The query compiler object to groupby.\n axis : 0 or 1\n The axis to groupby. Must be 0 currently.\n groupby_args : dict\n The arguments for the groupby component.\n map_args : dict\n The arguments for the `map_func`.\n reduce_args : dict\n The arguments for `reduce_func`.\n numeric_only : bool\n Whether to drop non-numeric columns.\n drop : bool\n Whether the data in `by` was dropped.\n\n Returns\n -------\n BaseQueryCompiler\n \"\"\"\n return GroupByDefault.register(pandas.core.groupby.DataFrameGroupBy.prod)(\n self,\n by=by,\n axis=axis,\n groupby_args=groupby_args,\n map_args=map_args,\n reduce_args=reduce_args,\n numeric_only=numeric_only,\n drop=drop,\n )\n\n def groupby_max(\n self,\n by,\n axis,\n groupby_args,\n map_args,\n reduce_args=None,\n numeric_only=True,\n drop=False,\n ):\n \"\"\"Perform a groupby max.\n\n Parameters\n ----------\n by : BaseQueryCompiler\n The query compiler object to groupby.\n axis : 0 or 1\n The axis to groupby. Must be 0 currently.\n groupby_args : dict\n The arguments for the groupby component.\n map_args : dict\n The arguments for the `map_func`.\n reduce_args : dict\n The arguments for `reduce_func`.\n numeric_only : bool\n Whether to drop non-numeric columns.\n drop : bool\n Whether the data in `by` was dropped.\n\n Returns\n -------\n BaseQueryCompiler\n \"\"\"\n return GroupByDefault.register(pandas.core.groupby.DataFrameGroupBy.max)(\n self,\n by=by,\n axis=axis,\n groupby_args=groupby_args,\n map_args=map_args,\n reduce_args=reduce_args,\n numeric_only=numeric_only,\n drop=drop,\n )\n\n def groupby_all(\n self,\n by,\n axis,\n groupby_args,\n map_args,\n reduce_args=None,\n numeric_only=True,\n drop=False,\n ):\n \"\"\"Perform a groupby all.\n\n Parameters\n ----------\n by : BaseQueryCompiler\n The query compiler object to groupby.\n axis : 0 or 1\n The axis to groupby. Must be 0 currently.\n groupby_args : dict\n The arguments for the groupby component.\n map_args : dict\n The arguments for the `map_func`.\n reduce_args : dict\n The arguments for `reduce_func`.\n numeric_only : bool\n Whether to drop non-numeric columns.\n drop : bool\n Whether the data in `by` was dropped.\n\n Returns\n -------\n BaseQueryCompiler\n \"\"\"\n return GroupByDefault.register(pandas.core.groupby.DataFrameGroupBy.all)(\n self,\n by=by,\n axis=axis,\n groupby_args=groupby_args,\n map_args=map_args,\n reduce_args=reduce_args,\n numeric_only=numeric_only,\n drop=drop,\n )\n\n def groupby_sum(\n self,\n by,\n axis,\n groupby_args,\n map_args,\n reduce_args=None,\n numeric_only=True,\n drop=False,\n ):\n \"\"\"Perform a groupby sum.\n\n Parameters\n ----------\n by : BaseQueryCompiler\n The query compiler object to groupby.\n axis : 0 or 1\n The axis to groupby. Must be 0 currently.\n groupby_args : dict\n The arguments for the groupby component.\n map_args : dict\n The arguments for the `map_func`.\n reduce_args : dict\n The arguments for `reduce_func`.\n numeric_only : bool\n Whether to drop non-numeric columns.\n drop : bool\n Whether the data in `by` was dropped.\n\n Returns\n -------\n BaseQueryCompiler\n \"\"\"\n return GroupByDefault.register(pandas.core.groupby.DataFrameGroupBy.sum)(\n self,\n by=by,\n axis=axis,\n groupby_args=groupby_args,\n map_args=map_args,\n reduce_args=reduce_args,\n numeric_only=numeric_only,\n drop=drop,\n )\n\n def groupby_size(\n self,\n by,\n axis,\n groupby_args,\n map_args,\n reduce_args=None,\n numeric_only=True,\n drop=False,\n ):\n \"\"\"Perform a groupby size.\n\n Parameters\n ----------\n by : BaseQueryCompiler\n The query compiler object to groupby.\n axis : 0 or 1\n The axis to groupby. Must be 0 currently.\n groupby_args : dict\n The arguments for the groupby component.\n map_args : dict\n The arguments for the `map_func`.\n reduce_args : dict\n The arguments for `reduce_func`.\n numeric_only : bool\n Whether to drop non-numeric columns.\n drop : bool\n Whether the data in `by` was dropped.\n\n Returns\n -------\n BaseQueryCompiler\n \"\"\"\n return GroupByDefault.register(pandas.core.groupby.DataFrameGroupBy.size)(\n self,\n by=by,\n axis=axis,\n groupby_args=groupby_args,\n map_args=map_args,\n reduce_args=reduce_args,\n numeric_only=numeric_only,\n drop=drop,\n method=\"size\",\n )\n\n def groupby_agg(\n self,\n by,\n is_multi_by,\n axis,\n agg_func,\n agg_args,\n agg_kwargs,\n groupby_kwargs,\n drop=False,\n ):\n if isinstance(by, type(self)) and len(by.columns) == 1:\n by = by.columns[0] if drop else by.to_pandas().squeeze()\n elif isinstance(by, type(self)):\n by = list(by.columns)\n\n return GroupByDefault.register(pandas.core.groupby.DataFrameGroupBy.aggregate)(\n self,\n by=by,\n is_multi_by=is_multi_by,\n axis=axis,\n agg_func=agg_func,\n groupby_args=groupby_kwargs,\n agg_args=agg_kwargs,\n drop=drop,\n )\n\n # END Manual Partitioning methods\n\n def unstack(self, level, fill_value):\n return DataFrameDefault.register(pandas.DataFrame.unstack)(\n self, level=level, fill_value=fill_value\n )\n\n def pivot(self, index, columns, values):\n return DataFrameDefault.register(pandas.DataFrame.pivot)(\n self, index=index, columns=columns, values=values\n )\n\n def pivot_table(\n self,\n index,\n values,\n columns,\n aggfunc,\n fill_value,\n margins,\n dropna,\n margins_name,\n observed,\n ):\n return DataFrameDefault.register(pandas.DataFrame.pivot_table)(\n self,\n index=index,\n values=values,\n columns=columns,\n aggfunc=aggfunc,\n fill_value=fill_value,\n margins=margins,\n dropna=dropna,\n margins_name=margins_name,\n observed=observed,\n )\n\n def get_dummies(self, columns, **kwargs):\n \"\"\"Convert categorical variables to dummy variables for certain columns.\n\n Args:\n columns: The columns to convert.\n\n Returns:\n A new QueryCompiler.\n \"\"\"\n\n def get_dummies(df, columns, **kwargs):\n return pandas.get_dummies(df, columns=columns, **kwargs)\n\n return DataFrameDefault.register(get_dummies)(self, columns=columns, **kwargs)\n\n def repeat(self, repeats):\n \"\"\"\n Repeat elements of a Series.\n\n Returns a new Series where each element of the current Series\n is repeated consecutively a given number of times.\n\n Parameters\n ----------\n repeats : int or array of ints\n The number of repetitions for each element. This should be a\n non-negative integer. Repeating 0 times will return an empty\n Series.\n\n Returns\n -------\n Series\n Newly created Series with repeated elements.\n \"\"\"\n return SeriesDefault.register(pandas.Series.repeat)(self, repeats=repeats)\n\n # Indexing\n\n index = property(_get_axis(0), _set_axis(0))\n columns = property(_get_axis(1), _set_axis(1))\n\n def get_axis(self, axis):\n \"\"\"\n Return index labels of the specified axis.\n\n Parameters\n ----------\n axis: int,\n Axis to return labels on.\n\n Returns\n -------\n Index\n \"\"\"\n return self.index if axis == 0 else self.columns\n\n def view(self, index=None, columns=None):\n index = [] if index is None else index\n columns = [] if columns is None else columns\n\n def applyier(df):\n return df.iloc[index, columns]\n\n return DataFrameDefault.register(applyier)(self)\n\n def insert_item(self, axis, loc, value, how=\"inner\", replace=False):\n \"\"\"\n Insert new column/row defined by `value` at the specified `loc`\n\n Parameters\n ----------\n axis: int, axis to insert along\n loc: int, position to insert `value`\n value: BaseQueryCompiler, value to insert\n how : str,\n The type of join to join to make.\n replace: bool (default False),\n Whether to insert item at `loc` or to replace item at `loc`.\n\n Returns\n -------\n A new BaseQueryCompiler\n \"\"\"\n assert isinstance(value, type(self))\n\n def mask(idx):\n if len(idx) == len(self.get_axis(axis)):\n return self\n return (\n self.getitem_column_array(idx, numeric=True)\n if axis\n else self.getitem_row_array(idx)\n )\n\n if 0 <= loc < len(self.get_axis(axis)):\n first_mask = mask(list(range(loc)))\n second_mask_loc = loc + 1 if replace else loc\n second_mask = mask(list(range(second_mask_loc, len(self.get_axis(axis)))))\n return first_mask.concat(axis, [value, second_mask], join=how, sort=False)\n else:\n return self.concat(axis, [value], join=how, sort=False)\n\n def setitem(self, axis, key, value):\n def setitem(df, axis, key, value):\n if is_scalar(key) and isinstance(value, pandas.DataFrame):\n value = value.squeeze()\n if not axis:\n df[key] = value\n else:\n df.loc[key] = value\n return df\n\n return DataFrameDefault.register(setitem)(self, axis=axis, key=key, value=value)\n\n def write_items(self, row_numeric_index, col_numeric_index, broadcasted_items):\n def write_items(df, broadcasted_items):\n if isinstance(df.iloc[row_numeric_index, col_numeric_index], pandas.Series):\n broadcasted_items = broadcasted_items.squeeze()\n df.iloc[\n list(row_numeric_index), list(col_numeric_index)\n ] = broadcasted_items\n return df\n\n return DataFrameDefault.register(write_items)(\n self, broadcasted_items=broadcasted_items\n )\n\n # END Abstract methods for QueryCompiler\n\n @property\n def __constructor__(self):\n \"\"\"By default, constructor method will invoke an init.\"\"\"\n return type(self)\n\n # __delitem__\n # This will change the shape of the resulting data.\n def delitem(self, key):\n return self.drop(columns=[key])\n\n # END __delitem__\n\n def has_multiindex(self, axis=0):\n \"\"\"\n Check if specified axis is indexed by MultiIndex.\n\n Parameters\n ----------\n axis : 0 or 1, default 0\n The axis to check (0 - index, 1 - columns).\n\n Returns\n -------\n bool\n True if index at specified axis is MultiIndex and False otherwise.\n \"\"\"\n if axis == 0:\n return isinstance(self.index, pandas.MultiIndex)\n assert axis == 1\n return isinstance(self.columns, pandas.MultiIndex)\n\n def get_index_name(self, axis=0):\n \"\"\"\n Get index name of specified axis.\n\n Parameters\n ----------\n axis: int (default 0),\n Axis to return index name on.\n\n Returns\n -------\n hashable\n Index name, None for MultiIndex.\n \"\"\"\n return self.get_axis(axis).name\n\n def set_index_name(self, name, axis=0):\n \"\"\"\n Set index name for the specified axis.\n\n Parameters\n ----------\n name: hashable,\n New index name.\n axis: int (default 0),\n Axis to set name along.\n \"\"\"\n self.get_axis(axis).name = name\n\n def get_index_names(self, axis=0):\n \"\"\"\n Get index names of specified axis.\n\n Parameters\n ----------\n axis: int (default 0),\n Axis to return index names on.\n\n Returns\n -------\n list\n Index names.\n \"\"\"\n return self.get_axis(axis).names\n\n def set_index_names(self, names, axis=0):\n \"\"\"\n Set index names for the specified axis.\n\n Parameters\n ----------\n names: list,\n New index names.\n axis: int (default 0),\n Axis to set names along.\n \"\"\"\n self.get_axis(axis).names = names\n\n # DateTime methods\n\n dt_ceil = DateTimeDefault.register(pandas.Series.dt.ceil)\n dt_components = DateTimeDefault.register(pandas.Series.dt.components)\n dt_date = DateTimeDefault.register(pandas.Series.dt.date)\n dt_day = DateTimeDefault.register(pandas.Series.dt.day)\n dt_day_name = DateTimeDefault.register(pandas.Series.dt.day_name)\n dt_dayofweek = DateTimeDefault.register(pandas.Series.dt.dayofweek)\n dt_dayofyear = DateTimeDefault.register(pandas.Series.dt.dayofyear)\n dt_days = DateTimeDefault.register(pandas.Series.dt.days)\n dt_days_in_month = DateTimeDefault.register(pandas.Series.dt.days_in_month)\n dt_daysinmonth = DateTimeDefault.register(pandas.Series.dt.daysinmonth)\n dt_end_time = DateTimeDefault.register(pandas.Series.dt.end_time)\n dt_floor = DateTimeDefault.register(pandas.Series.dt.floor)\n dt_freq = DateTimeDefault.register(pandas.Series.dt.freq)\n dt_hour = DateTimeDefault.register(pandas.Series.dt.hour)\n dt_is_leap_year = DateTimeDefault.register(pandas.Series.dt.is_leap_year)\n dt_is_month_end = DateTimeDefault.register(pandas.Series.dt.is_month_end)\n dt_is_month_start = DateTimeDefault.register(pandas.Series.dt.is_month_start)\n dt_is_quarter_end = DateTimeDefault.register(pandas.Series.dt.is_quarter_end)\n dt_is_quarter_start = DateTimeDefault.register(pandas.Series.dt.is_quarter_start)\n dt_is_year_end = DateTimeDefault.register(pandas.Series.dt.is_year_end)\n dt_is_year_start = DateTimeDefault.register(pandas.Series.dt.is_year_start)\n dt_microsecond = DateTimeDefault.register(pandas.Series.dt.microsecond)\n dt_microseconds = DateTimeDefault.register(pandas.Series.dt.microseconds)\n dt_minute = DateTimeDefault.register(pandas.Series.dt.minute)\n dt_month = DateTimeDefault.register(pandas.Series.dt.month)\n dt_month_name = DateTimeDefault.register(pandas.Series.dt.month_name)\n dt_nanosecond = DateTimeDefault.register(pandas.Series.dt.nanosecond)\n dt_nanoseconds = DateTimeDefault.register(pandas.Series.dt.nanoseconds)\n dt_normalize = DateTimeDefault.register(pandas.Series.dt.normalize)\n dt_quarter = DateTimeDefault.register(pandas.Series.dt.quarter)\n dt_qyear = DateTimeDefault.register(pandas.Series.dt.qyear)\n dt_round = DateTimeDefault.register(pandas.Series.dt.round)\n dt_second = DateTimeDefault.register(pandas.Series.dt.second)\n dt_seconds = DateTimeDefault.register(pandas.Series.dt.seconds)\n dt_start_time = DateTimeDefault.register(pandas.Series.dt.start_time)\n dt_strftime = DateTimeDefault.register(pandas.Series.dt.strftime)\n dt_time = DateTimeDefault.register(pandas.Series.dt.time)\n dt_timetz = DateTimeDefault.register(pandas.Series.dt.timetz)\n dt_to_period = DateTimeDefault.register(pandas.Series.dt.to_period)\n dt_to_pydatetime = DateTimeDefault.register(pandas.Series.dt.to_pydatetime)\n dt_to_pytimedelta = DateTimeDefault.register(pandas.Series.dt.to_pytimedelta)\n dt_to_timestamp = DateTimeDefault.register(pandas.Series.dt.to_timestamp)\n dt_total_seconds = DateTimeDefault.register(pandas.Series.dt.total_seconds)\n dt_tz = DateTimeDefault.register(pandas.Series.dt.tz)\n dt_tz_convert = DateTimeDefault.register(pandas.Series.dt.tz_convert)\n dt_tz_localize = DateTimeDefault.register(pandas.Series.dt.tz_localize)\n dt_week = DateTimeDefault.register(pandas.Series.dt.week)\n dt_weekday = DateTimeDefault.register(pandas.Series.dt.weekday)\n dt_weekofyear = DateTimeDefault.register(pandas.Series.dt.weekofyear)\n dt_year = DateTimeDefault.register(pandas.Series.dt.year)\n\n # End of DateTime methods\n\n # Resample methods\n\n resample_agg_df = ResampleDefault.register(pandas.core.resample.Resampler.aggregate)\n resample_agg_ser = ResampleDefault.register(\n pandas.core.resample.Resampler.aggregate, squeeze_self=True\n )\n resample_app_df = ResampleDefault.register(pandas.core.resample.Resampler.apply)\n resample_app_ser = ResampleDefault.register(\n pandas.core.resample.Resampler.apply, squeeze_self=True\n )\n resample_asfreq = ResampleDefault.register(pandas.core.resample.Resampler.asfreq)\n resample_backfill = ResampleDefault.register(\n pandas.core.resample.Resampler.backfill\n )\n resample_bfill = ResampleDefault.register(pandas.core.resample.Resampler.bfill)\n resample_count = ResampleDefault.register(pandas.core.resample.Resampler.count)\n resample_ffill = ResampleDefault.register(pandas.core.resample.Resampler.ffill)\n resample_fillna = ResampleDefault.register(pandas.core.resample.Resampler.fillna)\n resample_first = ResampleDefault.register(pandas.core.resample.Resampler.first)\n resample_get_group = ResampleDefault.register(\n pandas.core.resample.Resampler.get_group\n )\n resample_interpolate = ResampleDefault.register(\n pandas.core.resample.Resampler.interpolate\n )\n resample_last = ResampleDefault.register(pandas.core.resample.Resampler.last)\n resample_max = ResampleDefault.register(pandas.core.resample.Resampler.max)\n resample_mean = ResampleDefault.register(pandas.core.resample.Resampler.mean)\n resample_median = ResampleDefault.register(pandas.core.resample.Resampler.median)\n resample_min = ResampleDefault.register(pandas.core.resample.Resampler.min)\n resample_nearest = ResampleDefault.register(pandas.core.resample.Resampler.nearest)\n resample_nunique = ResampleDefault.register(pandas.core.resample.Resampler.nunique)\n resample_ohlc_df = ResampleDefault.register(pandas.core.resample.Resampler.ohlc)\n resample_ohlc_ser = ResampleDefault.register(\n pandas.core.resample.Resampler.ohlc, squeeze_self=True\n )\n resample_pad = ResampleDefault.register(pandas.core.resample.Resampler.pad)\n resample_pipe = ResampleDefault.register(pandas.core.resample.Resampler.pipe)\n resample_prod = ResampleDefault.register(pandas.core.resample.Resampler.prod)\n resample_quantile = ResampleDefault.register(\n pandas.core.resample.Resampler.quantile\n )\n resample_sem = ResampleDefault.register(pandas.core.resample.Resampler.sem)\n resample_size = ResampleDefault.register(pandas.core.resample.Resampler.size)\n resample_std = ResampleDefault.register(pandas.core.resample.Resampler.std)\n resample_sum = ResampleDefault.register(pandas.core.resample.Resampler.sum)\n resample_transform = ResampleDefault.register(\n pandas.core.resample.Resampler.transform\n )\n resample_var = ResampleDefault.register(pandas.core.resample.Resampler.var)\n\n # End of Resample methods\n\n # Str methods\n\n str_capitalize = StrDefault.register(pandas.Series.str.capitalize)\n str_center = StrDefault.register(pandas.Series.str.center)\n str_contains = StrDefault.register(pandas.Series.str.contains)\n str_count = StrDefault.register(pandas.Series.str.count)\n str_endswith = StrDefault.register(pandas.Series.str.endswith)\n str_find = StrDefault.register(pandas.Series.str.find)\n str_findall = StrDefault.register(pandas.Series.str.findall)\n str_get = StrDefault.register(pandas.Series.str.get)\n str_index = StrDefault.register(pandas.Series.str.index)\n str_isalnum = StrDefault.register(pandas.Series.str.isalnum)\n str_isalpha = StrDefault.register(pandas.Series.str.isalpha)\n str_isdecimal = StrDefault.register(pandas.Series.str.isdecimal)\n str_isdigit = StrDefault.register(pandas.Series.str.isdigit)\n str_islower = StrDefault.register(pandas.Series.str.islower)\n str_isnumeric = StrDefault.register(pandas.Series.str.isnumeric)\n str_isspace = StrDefault.register(pandas.Series.str.isspace)\n str_istitle = StrDefault.register(pandas.Series.str.istitle)\n str_isupper = StrDefault.register(pandas.Series.str.isupper)\n str_join = StrDefault.register(pandas.Series.str.join)\n str_len = StrDefault.register(pandas.Series.str.len)\n str_ljust = StrDefault.register(pandas.Series.str.ljust)\n str_lower = StrDefault.register(pandas.Series.str.lower)\n str_lstrip = StrDefault.register(pandas.Series.str.lstrip)\n str_match = StrDefault.register(pandas.Series.str.match)\n str_normalize = StrDefault.register(pandas.Series.str.normalize)\n str_pad = StrDefault.register(pandas.Series.str.pad)\n str_partition = StrDefault.register(pandas.Series.str.partition)\n str_repeat = StrDefault.register(pandas.Series.str.repeat)\n str_replace = StrDefault.register(pandas.Series.str.replace)\n str_rfind = StrDefault.register(pandas.Series.str.rfind)\n str_rindex = StrDefault.register(pandas.Series.str.rindex)\n str_rjust = StrDefault.register(pandas.Series.str.rjust)\n str_rpartition = StrDefault.register(pandas.Series.str.rpartition)\n str_rsplit = StrDefault.register(pandas.Series.str.rsplit)\n str_rstrip = StrDefault.register(pandas.Series.str.rstrip)\n str_slice = StrDefault.register(pandas.Series.str.slice)\n str_slice_replace = StrDefault.register(pandas.Series.str.slice_replace)\n str_split = StrDefault.register(pandas.Series.str.split)\n str_startswith = StrDefault.register(pandas.Series.str.startswith)\n str_strip = StrDefault.register(pandas.Series.str.strip)\n str_swapcase = StrDefault.register(pandas.Series.str.swapcase)\n str_title = StrDefault.register(pandas.Series.str.title)\n str_translate = StrDefault.register(pandas.Series.str.translate)\n str_upper = StrDefault.register(pandas.Series.str.upper)\n str_wrap = StrDefault.register(pandas.Series.str.wrap)\n str_zfill = StrDefault.register(pandas.Series.str.zfill)\n\n # End of Str methods\n\n # Rolling methods\n\n rolling_aggregate = RollingDefault.register(\n pandas.core.window.rolling.Rolling.aggregate\n )\n rolling_apply = RollingDefault.register(pandas.core.window.rolling.Rolling.apply)\n rolling_corr = RollingDefault.register(pandas.core.window.rolling.Rolling.corr)\n rolling_count = RollingDefault.register(pandas.core.window.rolling.Rolling.count)\n rolling_cov = RollingDefault.register(pandas.core.window.rolling.Rolling.cov)\n rolling_kurt = RollingDefault.register(pandas.core.window.rolling.Rolling.kurt)\n rolling_max = RollingDefault.register(pandas.core.window.rolling.Rolling.max)\n rolling_mean = RollingDefault.register(pandas.core.window.rolling.Rolling.mean)\n rolling_median = RollingDefault.register(pandas.core.window.rolling.Rolling.median)\n rolling_min = RollingDefault.register(pandas.core.window.rolling.Rolling.min)\n rolling_quantile = RollingDefault.register(\n pandas.core.window.rolling.Rolling.quantile\n )\n rolling_skew = RollingDefault.register(pandas.core.window.rolling.Rolling.skew)\n rolling_std = RollingDefault.register(pandas.core.window.rolling.Rolling.std)\n rolling_sum = RollingDefault.register(pandas.core.window.rolling.Rolling.sum)\n rolling_var = RollingDefault.register(pandas.core.window.rolling.Rolling.var)\n\n # End of Rolling methods\n\n # Window methods\n\n window_mean = RollingDefault.register(pandas.core.window.Window.mean)\n window_std = RollingDefault.register(pandas.core.window.Window.std)\n window_sum = RollingDefault.register(pandas.core.window.Window.sum)\n window_var = RollingDefault.register(pandas.core.window.Window.var)\n\n # End of Window methods\n\n # Categories methods\n\n cat_codes = CatDefault.register(pandas.Series.cat.codes)\n\n # End of Categories methods\n\n # DataFrame methods\n\n invert = DataFrameDefault.register(pandas.DataFrame.__invert__)\n mad = DataFrameDefault.register(pandas.DataFrame.mad)\n kurt = DataFrameDefault.register(pandas.DataFrame.kurt)\n sum_min_count = sum\n prod_min_count = prod\n compare = DataFrameDefault.register(pandas.DataFrame.compare)\n\n # End of DataFrame methods\n"
] |
[
[
"pandas.concat",
"numpy.conj",
"pandas.core.dtypes.common.is_scalar",
"pandas.get_dummies"
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.