repo_name
stringlengths 8
130
| hexsha
sequence | file_path
sequence | code
sequence | apis
sequence |
|---|---|---|---|---|
IBM/urcanet | [
"ce3f41eba23c24506ea2cf9e77cd3898a4eafbaf"
] | [
"orca/modules/bert.py"
] | [
"import torch\nimport torch.nn as nn\n\nfrom pytorch_pretrained_bert.modeling import BertEncoder, BertPooler, BertLayerNorm, BertPreTrainedModel\n\nclass BertEmbeddingsModified(nn.Module):\n \"\"\"Construct the embeddings from word, position and token_type embeddings.\n \"\"\"\n def __init__(self, config):\n super(BertEmbeddingsModified, self).__init__()\n self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=0)\n self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)\n self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)\n self.history_embeddings = nn.Embedding(4, config.hidden_size, padding_idx=0)\n self.turn_embeddings = nn.Embedding(8, config.hidden_size, padding_idx=0)\n\n # self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load\n # any TensorFlow checkpoint file\n self.LayerNorm = BertLayerNorm(config.hidden_size, eps=1e-12)\n self.dropout = nn.Dropout(config.hidden_dropout_prob)\n\n def forward(self, input_ids, token_type_ids=None, history_encoding=None, turn_encoding=None, scenario_encoding=None):\n seq_length = input_ids.size(1)\n position_ids = torch.arange(seq_length, dtype=torch.long, device=input_ids.device)\n position_ids = position_ids.unsqueeze(0).expand_as(input_ids)\n if token_type_ids is None:\n token_type_ids = torch.zeros_like(input_ids)\n if history_encoding is None:\n history_encoding = torch.zeros_like(input_ids)\n if turn_encoding is None:\n turn_encoding = torch.zeros_like(input_ids)\n if scenario_encoding is None:\n scenario_encoding = torch.zeros_like(input_ids)\n\n words_embeddings = self.word_embeddings(input_ids)\n position_embeddings = self.position_embeddings(position_ids)\n token_type_embeddings = self.token_type_embeddings(token_type_ids)\n history_embeddings = self.history_embeddings(history_encoding)\n scenario_embeddings = self.history_embeddings(scenario_encoding)\n turn_embeddings = self.turn_embeddings(turn_encoding)\n\n embeddings = words_embeddings + position_embeddings + token_type_embeddings + history_embeddings + turn_embeddings + scenario_embeddings\n embeddings = self.LayerNorm(embeddings)\n embeddings = self.dropout(embeddings)\n return embeddings\n\nclass BertModelModified(BertPreTrainedModel):\n def __init__(self, config):\n super(BertModelModified, self).__init__(config)\n self.embeddings = BertEmbeddingsModified(config)\n self.encoder = BertEncoder(config)\n self.pooler = BertPooler(config)\n self.apply(self.init_bert_weights) \n self.embeddings.history_embeddings.weight[0].data.zero_() # self.embeddings.history_embeddings.padding_idx\n self.embeddings.turn_embeddings.weight[0].data.zero_() # self.embeddings.turn_embeddings.padding_idx\n\n def forward(self, input_ids, token_type_ids=None, history_encoding=None, turn_encoding=None, scenario_encoding=None, attention_mask=None, output_all_encoded_layers=True):\n if attention_mask is None:\n attention_mask = torch.ones_like(input_ids)\n if token_type_ids is None:\n token_type_ids = torch.zeros_like(input_ids)\n if history_encoding is None:\n history_encoding = torch.zeros_like(input_ids)\n if turn_encoding is None:\n turn_encoding = torch.zeros_like(input_ids)\n if scenario_encoding is None:\n scenario_encoding = torch.zeros_like(input_ids)\n \n extended_attention_mask = attention_mask.unsqueeze(1).unsqueeze(2)\n\n extended_attention_mask = extended_attention_mask.to(dtype=next(self.parameters()).dtype) # fp16 compatibility\n extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0\n\n embedding_output = self.embeddings(input_ids, token_type_ids, history_encoding, turn_encoding, scenario_encoding)\n encoded_layers = self.encoder(embedding_output,\n extended_attention_mask,\n output_all_encoded_layers=output_all_encoded_layers)\n sequence_output = encoded_layers[-1]\n pooled_output = self.pooler(sequence_output)\n if not output_all_encoded_layers:\n encoded_layers = encoded_layers[-1]\n return encoded_layers, pooled_output"
] | [
[
"torch.ones_like",
"torch.zeros_like",
"torch.nn.Embedding",
"torch.arange",
"torch.nn.Dropout"
]
] |
One-sixth/check_cuda_numerical_stability | [
"0229632f81e8558436132eb0a9d8e8c2b332cb81"
] | [
"_check_cuda_numerical_stability.py"
] | [
"'''\n用于检测cuda运算错误\n'''\n\nimport torch\nimport torch.nn as nn\nfrom torch.backends import cudnn\nimport argparse\nimport time\nimport math\n\n\ndef ConvBnAct(in_ch, out_ch, ker_sz, stride, pad, act=nn.Identity(), group=1, dilation=1):\n return nn.Sequential(nn.Conv2d(in_ch, out_ch, ker_sz, stride, pad, groups=group, bias=False, dilation=dilation),\n nn.BatchNorm2d(out_ch, eps=1e-8, momentum=0.9),\n act)\n\n\ndef DeConvBnAct(in_ch, out_ch, ker_sz, stride, pad, act=nn.Identity(), group=1, dilation=1):\n return nn.Sequential(nn.ConvTranspose2d(in_ch, out_ch, ker_sz, stride, pad, groups=group, bias=False, dilation=dilation),\n nn.BatchNorm2d(out_ch, eps=1e-8, momentum=0.9),\n act)\n\n\nclass RevSequential(nn.ModuleList):\n '''\n 功能大部分与ModuleList重叠\n '''\n def __init__(self, modules=None):\n super().__init__(modules)\n\n def append(self, module):\n assert hasattr(module, 'invert') and callable(module.invert)\n super().append(module)\n\n def extend(self, modules):\n for m in modules:\n self.append(m)\n\n def forward(self, x1, x2):\n y1, y2 = x1, x2\n for m in self:\n y1, y2 = m(y1, y2)\n return y1, y2\n\n def invert(self, y1, y2):\n x1, x2 = y1, y2\n for m in list(self)[::-1]:\n x1, x2 = m.invert(x1, x2)\n return x1, x2\n\n\nclass RevGroupBlock(RevSequential):\n '''\n 当前只支持输入通道等于输出通道，并且不允许下采样\n '''\n def __init__(self, in_ch, out_ch, stride, act, block_type, blocks, **kwargs):\n assert in_ch == out_ch\n assert stride == 1\n mods = []\n for _ in range(blocks):\n mods.append(block_type(in_ch=in_ch, out_ch=out_ch, stride=1, act=act, **kwargs))\n # self.extend(mods)\n super().__init__(mods)\n\n\nclass RevBlockC(nn.Module):\n def __init__(self, in_ch, out_ch, stride, act, **kwargs):\n super().__init__()\n inter_ch = in_ch // 2\n self.conv1 = ConvBnAct(in_ch, inter_ch, ker_sz=3, stride=1, pad=1, act=act)\n self.conv2 = ConvBnAct(inter_ch, inter_ch, ker_sz=5, stride=1, pad=2, act=act, group=inter_ch)\n self.conv3 = ConvBnAct(in_ch, in_ch, ker_sz=1, stride=1, pad=0, act=nn.Identity())\n\n def func(self, x):\n y1 = self.conv1(x)\n y2 = self.conv2(y1)\n y = torch.cat([y1, y2], dim=1)\n y = self.conv3(y)\n return y\n\n def forward(self, x1, x2):\n y = x1 + self.func(x2)\n return x2, y\n\n def invert(self, y1, y2):\n x2, y = y1, y2\n x1 = y - self.func(x2)\n return x1, x2\n\n\nif __name__ == '__main__':\n cudnn.benchmark = False\n cudnn.deterministic = True\n torch.set_grad_enabled(False)\n # Close tf32 features. Fix low numerical accuracy on rtx30xx gpu.\n try:\n torch.backends.cuda.matmul.allow_tf32 = False\n torch.backends.cudnn.allow_tf32 = False\n except AttributeError as e:\n print('Info. This pytorch version is not support with tf32.')\n\n parse = argparse.ArgumentParser(description='Used to detect CUDA numerical stability problems.')\n parse.add_argument('-i', type=int, help='card id. Which cuda card do you want to test. default: 0', default=0)\n parse.add_argument('-t', type=int, help='minute. Test duration. When the setting is less than or equal to 0, it will not stop automatically. defaule: 30', default=30)\n parse.add_argument('-bs', type=int, help='Test batch size when testing. defaule: 20', default=20)\n parse = parse.parse_args()\n\n duration = parse.t * 60\n if duration <= 0:\n duration = math.inf\n\n card_id = parse.i\n if card_id == -1:\n # 使用cpu测试理论上是永远不会报错的\n device = torch.device('cpu')\n else:\n device = torch.device(f'cuda:{card_id}')\n\n batch_size = parse.bs\n assert batch_size > 0\n\n start_time = time.time()\n test_count = 0\n\n act = nn.ELU()\n rvb = RevGroupBlock(128, 128, 1, act, RevBlockC, 32).to(device)\n rvb.eval()\n\n is_no_error = True\n\n print('CUDA numerical stability test begin.')\n while is_no_error:\n cur_time = time.time()\n if cur_time - start_time > duration:\n break\n test_count += 1\n\n if test_count % 50 == 0:\n # 每50次迭代后，刷新一次网络权重\n rvb = RevGroupBlock(128, 128, 1, act, RevBlockC, 32).to(device)\n rvb.eval()\n\n a1 = torch.randn(batch_size, 128, 128, 128, device=device)\n b1, b2 = rvb(a1, a1)\n o_a1, o_a2 = rvb.invert(b1, b2)\n max_diff_1 = torch.abs(o_a1 - o_a2).max()\n max_diff_2 = torch.abs(a1 - o_a1).max()\n\n line = f'elapsed/total: {int(cur_time-start_time)}/{duration} card_id: {card_id} count: {test_count} max_diff_1: {max_diff_1:.8f} max_diff_2: {max_diff_2:.8f}'\n print(line)\n if max_diff_1 > 1e-3 or max_diff_2 > 1e-3:\n print(f'A large numerical error was found!')\n is_no_error = False\n\n if is_no_error:\n print(f'Test passed. Card ID: {card_id}')\n else:\n print(f'Test failed. Card ID: {card_id}')\n"
] | [
[
"torch.nn.BatchNorm2d",
"torch.set_grad_enabled",
"torch.randn",
"torch.device",
"torch.nn.Conv2d",
"torch.abs",
"torch.nn.Identity",
"torch.nn.ELU",
"torch.cat",
"torch.nn.ConvTranspose2d"
]
] |
mrzhuzhe/mmdetection | [
"c04ca2c2a65500bc248a5d2ab6ace5b15f00064d"
] | [
"mmdet/models/losses/ae_loss.py"
] | [
"# Copyright (c) OpenMMLab. All rights reserved.\r\nimport mmcv\r\nimport torch\r\nimport torch.nn as nn\r\nimport torch.nn.functional as F\r\n\r\nfrom ..builder import LOSSES\r\n\r\n\r\[email protected](derivate=True, coderize=True)\r\ndef ae_loss_per_image(tl_preds, br_preds, match):\r\n \"\"\"Associative Embedding Loss in one image.\r\n\r\n Associative Embedding Loss including two parts: pull loss and push loss.\r\n Pull loss makes embedding vectors from same object closer to each other.\r\n Push loss distinguish embedding vector from different objects, and makes\r\n the gap between them is large enough.\r\n\r\n During computing, usually there are 3 cases:\r\n - no object in image: both pull loss and push loss will be 0.\r\n - one object in image: push loss will be 0 and pull loss is computed\r\n by the two corner of the only object.\r\n - more than one objects in image: pull loss is computed by corner pairs\r\n from each object, push loss is computed by each object with all\r\n other objects. We use confusion matrix with 0 in diagonal to\r\n compute the push loss.\r\n\r\n Args:\r\n tl_preds (tensor): Embedding feature map of left-top corner.\r\n br_preds (tensor): Embedding feature map of bottim-right corner.\r\n match (list): Downsampled coordinates pair of each ground truth box.\r\n \"\"\"\r\n\r\n tl_list, br_list, me_list = [], [], []\r\n if len(match) == 0: # no object in image\r\n pull_loss = tl_preds.sum() * 0.\r\n push_loss = tl_preds.sum() * 0.\r\n else:\r\n for m in match:\r\n [tl_y, tl_x], [br_y, br_x] = m\r\n tl_e = tl_preds[:, tl_y, tl_x].view(-1, 1)\r\n br_e = br_preds[:, br_y, br_x].view(-1, 1)\r\n tl_list.append(tl_e)\r\n br_list.append(br_e)\r\n me_list.append((tl_e + br_e) / 2.0)\r\n\r\n tl_list = torch.cat(tl_list)\r\n br_list = torch.cat(br_list)\r\n me_list = torch.cat(me_list)\r\n\r\n assert tl_list.size() == br_list.size()\r\n\r\n # N is object number in image, M is dimension of embedding vector\r\n N, M = tl_list.size()\r\n\r\n pull_loss = (tl_list - me_list).pow(2) + (br_list - me_list).pow(2)\r\n pull_loss = pull_loss.sum() / N\r\n\r\n margin = 1 # exp setting of CornerNet, details in section 3.3 of paper\r\n\r\n # confusion matrix of push loss\r\n conf_mat = me_list.expand((N, N, M)).permute(1, 0, 2) - me_list\r\n conf_weight = 1 - torch.eye(N).type_as(me_list)\r\n conf_mat = conf_weight * (margin - conf_mat.sum(-1).abs())\r\n\r\n if N > 1: # more than one object in current image\r\n push_loss = F.relu(conf_mat).sum() / (N * (N - 1))\r\n else:\r\n push_loss = tl_preds.sum() * 0.\r\n\r\n return pull_loss, push_loss\r\n\r\n\r\[email protected]_module()\r\nclass AssociativeEmbeddingLoss(nn.Module):\r\n \"\"\"Associative Embedding Loss.\r\n\r\n More details can be found in\r\n `Associative Embedding <https://arxiv.org/abs/1611.05424>`_ and\r\n `CornerNet <https://arxiv.org/abs/1808.01244>`_ .\r\n Code is modified from `kp_utils.py <https://github.com/princeton-vl/CornerNet/blob/master/models/py_utils/kp_utils.py#L180>`_ # noqa: E501\r\n\r\n Args:\r\n pull_weight (float): Loss weight for corners from same object.\r\n push_weight (float): Loss weight for corners from different object.\r\n \"\"\"\r\n\r\n def __init__(self, pull_weight=0.25, push_weight=0.25):\r\n super(AssociativeEmbeddingLoss, self).__init__()\r\n self.pull_weight = pull_weight\r\n self.push_weight = push_weight\r\n\r\n def forward(self, pred, target, match):\r\n \"\"\"Forward function.\"\"\"\r\n batch = pred.size(0)\r\n pull_all, push_all = 0.0, 0.0\r\n for i in range(batch):\r\n pull, push = ae_loss_per_image(pred[i], target[i], match[i])\r\n\r\n pull_all += self.pull_weight * pull\r\n push_all += self.push_weight * push\r\n\r\n return pull_all, push_all\r\n"
] | [
[
"torch.eye",
"torch.cat",
"torch.nn.functional.relu"
]
] |
PhilippRue/ase-notebook | [
"46205d7e1b0e5a48a3ca61d84d4ee877eea19e62"
] | [
"ase_notebook/atoms_convert.py"
] | [
"\"\"\"Module for serializing ``ase.Atoms``.\"\"\"\n# TODO very recent versions of ase.Atoms have `todict` and `fromdict` methods, ands\n# see: https://gitlab.com/ase/ase/atoms.py and\n# https://gitlab.com/ase/ase/blob/master/ase/io/jsonio.py\nimport datetime\nimport json\n\nimport ase\nfrom ase.constraints import dict2constraint\nimport numpy as np\n\n\nclass ASEEncoder(json.JSONEncoder):\n \"\"\"JSON Encoder for ase.Atoms serialization.\"\"\"\n\n def default(self, obj):\n \"\"\"Parse object.\"\"\"\n if hasattr(obj, \"todict\"):\n d = obj.todict()\n\n if not isinstance(d, dict):\n raise RuntimeError(\n f\"todict() of {obj} returned object of type {type(d)} \"\n \"but should have returned dict\"\n )\n if hasattr(obj, \"ase_objtype\"):\n d[\"__ase_objtype__\"] = obj.ase_objtype\n\n return d\n if isinstance(obj, np.ndarray):\n flatobj = obj.ravel()\n if np.iscomplexobj(obj):\n flatobj.dtype = obj.real.dtype\n return {\"__ndarray__\": (obj.shape, str(obj.dtype), flatobj.tolist())}\n if isinstance(obj, np.integer):\n return int(obj)\n if isinstance(obj, np.bool_):\n return bool(obj)\n if isinstance(obj, datetime.datetime):\n return {\"__datetime__\": obj.isoformat()}\n if isinstance(obj, complex):\n return {\"__complex__\": (obj.real, obj.imag)}\n\n return json.JSONEncoder.default(self, obj)\n\n\ndef create_ndarray(shape, dtype, data):\n \"\"\"Create ndarray from shape, dtype and flattened data.\"\"\"\n array = np.empty(shape, dtype=dtype)\n flatbuf = array.ravel()\n if np.iscomplexobj(array):\n flatbuf.dtype = array.real.dtype\n flatbuf[:] = data\n return array\n\n\ndef try_int(obj):\n \"\"\"Try conversion of object to int.\"\"\"\n try:\n return int(obj)\n except ValueError:\n return obj\n\n\ndef numpyfy(obj):\n \"\"\"Convert an object to numpy array(s) recursively.\"\"\"\n if isinstance(obj, dict):\n if \"__complex_ndarray__\" in obj:\n r, i = (np.array(x) for x in obj[\"__complex_ndarray__\"])\n return r + i * 1j\n return {try_int(key): numpyfy(value) for key, value in obj.items()}\n if isinstance(obj, list) and len(obj) > 0:\n try:\n a = np.array(obj)\n except ValueError:\n pass\n else:\n if a.dtype in [bool, int, float] or str(a.dtype).startswith(\"<U\"):\n return a\n obj = [numpyfy(value) for value in obj]\n return obj\n\n\ndef ase_decoder_hook(dct):\n \"\"\"JSON decoder hook for ase.Atoms de-serialization.\"\"\"\n if \"__datetime__\" in dct:\n return datetime.datetime.strptime(dct[\"__datetime__\"], \"%Y-%m-%dT%H:%M:%S.%f\")\n if \"__complex__\" in dct:\n return complex(*dct[\"__complex__\"])\n\n if \"__ndarray__\" in dct:\n return create_ndarray(*dct[\"__ndarray__\"])\n\n # No longer used (only here for backwards compatibility):\n if \"__complex_ndarray__\" in dct:\n r, i = (np.array(x) for x in dct[\"__complex_ndarray__\"])\n return r + i * 1j\n\n if \"__ase_objtype__\" in dct:\n objtype = dct.pop(\"__ase_objtype__\")\n dct = numpyfy(dct)\n\n if objtype == \"cell\":\n from ase.cell import Cell\n\n pbc = dct.pop(\"pbc\", None)\n obj = Cell(**dct)\n if pbc is not None:\n obj._pbc = pbc\n else:\n raise RuntimeError(\n \"Do not know how to decode object type {} \"\n \"into an actual object\".format(objtype)\n )\n\n assert obj.ase_objtype == objtype\n return obj\n\n return dct\n\n\ndef serialize_atoms(atoms: ase.Atoms, description: str = \"\") -> str:\n \"\"\"Serialize an ase.Atoms instance to a dictionary.\"\"\"\n dct = {\n \"description\": description,\n \"cell\": atoms.cell,\n \"arrays\": atoms.arrays,\n \"info\": atoms.info,\n \"constraints\": atoms.constraints,\n \"celldisp\": atoms.get_celldisp(),\n \"calculator\": atoms.calc,\n }\n return ASEEncoder().encode(dct)\n\n\ndef deserialize_atoms(json_string: str) -> ase.Atoms:\n \"\"\"Deserialize a JSON string to an ase.Atoms instance.\"\"\"\n data = json.JSONDecoder(object_hook=ase_decoder_hook).decode(json_string)\n atoms = ase.Atoms()\n atoms.cell = data[\"cell\"]\n atoms.arrays = numpyfy(data[\"arrays\"])\n atoms.info = data[\"info\"]\n atoms.constraints = [dict2constraint(d) for d in data[\"constraints\"]]\n atoms.set_celldisp(data[\"celldisp\"])\n # TODO ase.calculators.calculator.Calculator has a todict method,\n # but not clear how to convert it back\n\n return atoms\n\n\ndef convert_to_atoms(obj):\n \"\"\"Attempt to convert an object to an ase.Atoms object.\"\"\"\n if isinstance(obj, ase.Atoms):\n return obj\n\n if isinstance(obj, str):\n return deserialize_atoms(obj)\n\n if isinstance(obj, dict):\n return deserialize_atoms(json.loads(obj))\n\n if hasattr(obj, \"lattice\") and hasattr(obj, \"sites\"):\n # we assume the obj is a pymatgen Structure\n\n # from pymatgen.io.ase adaptor\n if not obj.is_ordered:\n raise ValueError(\"ASE Atoms only supports ordered Pymatgen structures\")\n symbols = [str(site.specie.symbol) for site in obj]\n positions = [site.coords for site in obj]\n cell = obj.lattice.matrix\n # TODO test if slab, then use pbc = [True, True, False]\n atoms = ase.Atoms(symbols=symbols, positions=positions, pbc=True, cell=cell)\n\n # additionally, propagate site properties\n for key, array in obj.site_properties.items():\n if key not in atoms.arrays:\n atoms.set_array(key, np.array(array))\n # TODO propagate partial occupancies, and other properties\n\n return atoms\n\n raise TypeError(f\"Cannot convert object of type {obj.__class__.__name__}\")\n"
] | [
[
"numpy.array",
"numpy.iscomplexobj",
"numpy.empty"
]
] |
ChengShusss/spt | [
"f68e6b317ae64237aec5d0a058064804a28996d1"
] | [
"src/_test/testSimply.py"
] | [
"#!/usr/local/bin/python3\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib as mpl\n\n# Setup, and create the data to plot\ny = np.random.rand(100000)\ny[50000:] *= 2\ny[np.geomspace(10, 50000, 400).astype(int)] = -1\nmpl.rcParams['path.simplify'] = True\n\nmpl.rcParams['path.simplify_threshold'] = 0.0\nplt.plot(y)\nplt.show()\n\nmpl.rcParams['path.simplify_threshold'] = 1.0\nplt.plot(y)\nplt.show()"
] | [
[
"matplotlib.pyplot.plot",
"matplotlib.pyplot.show",
"numpy.random.rand",
"numpy.geomspace"
]
] |
upc-arco/PCA-DIRIE-Pruning | [
"697ce664786e9791c7cf8911e642b3e6e70d7b98"
] | [
"transformer/ffn_layer.py"
] | [
"# Copyright 2021 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\"\"\"Implementation of fully connected network.\"\"\"\n\nimport tensorflow as tf\nfrom pruning import custom_layers\n\nclass FeedForwardNetwork(tf.keras.layers.Layer):\n \"\"\"Fully connected feedforward network.\"\"\"\n\n def __init__(self, hidden_size, filter_size, relu_dropout):\n \"\"\"Initialize FeedForwardNetwork.\n\n Args:\n hidden_size: int, output dim of hidden layer.\n filter_size: int, filter size for the inner (first) dense layer.\n relu_dropout: float, dropout rate for training.\n \"\"\"\n super(FeedForwardNetwork, self).__init__()\n self.hidden_size = hidden_size\n self.filter_size = filter_size\n self.relu_dropout = relu_dropout\n\n def build(self, input_shape):\n self.filter_dense_layer = custom_layers.MyDenseLayer(\n self.filter_size,\n use_bias=True,\n activation=tf.nn.relu,\n name=\"filter_layer\")\n self.output_dense_layer = custom_layers.MyDenseLayer(\n self.hidden_size, use_bias=True, use_mask=True, name=\"output_layer\")\n super(FeedForwardNetwork, self).build(input_shape)\n\n def get_config(self):\n return {\n \"hidden_size\": self.hidden_size,\n \"filter_size\": self.filter_size,\n \"relu_dropout\": self.relu_dropout,\n }\n\n def call(self, x, training):\n \"\"\"Return outputs of the feedforward network.\n\n Args:\n x: tensor with shape [batch_size, length, hidden_size]\n training: boolean, whether in training mode or not.\n\n Returns:\n Output of the feedforward network.\n tensor with shape [batch_size, length, hidden_size]\n \"\"\"\n # Retrieve dynamically known shapes\n output = self.filter_dense_layer(x)\n if training:\n output = tf.nn.dropout(output, rate=self.relu_dropout)\n output = self.output_dense_layer(output)\n\n return output\n"
] | [
[
"tensorflow.nn.dropout"
]
] |
batucimenn/eyeTrackingUsingOpenCV | [
"4f6c3249cb52f04208405a9ac48ccf41d0d38364"
] | [
"eyeTrackingUsingOpenCV.py"
] | [
"import cv2\r\nimport numpy as np\r\nimport dlib\r\nimport time\r\nimport matplotlib.pyplot as plt\r\nfrom math import hypot,ceil\r\n\r\n#cap = cv2.VideoCapture(\"projectvideo.mp4\")\r\ncap = cv2.VideoCapture(0)\r\nliste=[]\r\ndetector = dlib.get_frontal_face_detector()\r\npredictor = dlib.shape_predictor(\"shape_predictor_68_face_landmarks.dat\")\r\n\r\ndef midpoint(p1 ,p2):\r\n return int((p1.x + p2.x)/2), int((p1.y + p2.y)/2)\r\n\r\nfont = cv2.FONT_HERSHEY_PLAIN\r\n\r\ndef get_blinking_ratio(eye_points, facial_landmarks):\r\n left_point = (facial_landmarks.part(eye_points[0]).x, facial_landmarks.part(eye_points[0]).y)\r\n right_point = (facial_landmarks.part(eye_points[3]).x, facial_landmarks.part(eye_points[3]).y)\r\n center_top = midpoint(facial_landmarks.part(eye_points[1]), facial_landmarks.part(eye_points[2]))\r\n center_bottom = midpoint(facial_landmarks.part(eye_points[5]), facial_landmarks.part(eye_points[4]))\r\n #hor_line = cv2.line(frame, left_point, right_point, (0, 255, 0), 2)\r\n #ver_line = cv2.line(frame, center_top, center_bottom, (0, 255, 0), 2)\r\n hor_line_lenght = hypot((left_point[0] - right_point[0]), (left_point[1] - right_point[1]))\r\n ver_line_lenght = hypot((center_top[0] - center_bottom[0]), (center_top[1] - center_bottom[1]))\r\n ratio = hor_line_lenght / ver_line_lenght\r\n return ratio\r\n\r\ndef get_gaze_ratio(eye_points, facial_landmarks):\r\n left_eye_region = np.array([(facial_landmarks.part(eye_points[0]).x, facial_landmarks.part(eye_points[0]).y),\r\n (facial_landmarks.part(eye_points[1]).x, facial_landmarks.part(eye_points[1]).y),\r\n (facial_landmarks.part(eye_points[2]).x, facial_landmarks.part(eye_points[2]).y),\r\n (facial_landmarks.part(eye_points[3]).x, facial_landmarks.part(eye_points[3]).y),\r\n (facial_landmarks.part(eye_points[4]).x, facial_landmarks.part(eye_points[4]).y),\r\n (facial_landmarks.part(eye_points[5]).x, facial_landmarks.part(eye_points[5]).y)], np.int32)\r\n # cv2.polylines(frame, [left_eye_region], True, (0, 0, 255), 2)\r\n height, width, _ = frame.shape\r\n mask = np.zeros((height, width), np.uint8)\r\n cv2.polylines(mask, [left_eye_region], True, 255, 2)\r\n cv2.fillPoly(mask, [left_eye_region], 255)\r\n eye = cv2.bitwise_and(gray, gray, mask=mask)\r\n min_x = np.min(left_eye_region[:, 0])\r\n max_x = np.max(left_eye_region[:, 0])\r\n min_y = np.min(left_eye_region[:, 1])\r\n max_y = np.max(left_eye_region[:, 1])\r\n gray_eye = eye[min_y: max_y, min_x: max_x ] \r\n _, threshold_eye = cv2.threshold(gray_eye, 70, 255, cv2.THRESH_BINARY)\r\n height, width = threshold_eye.shape\r\n left_side_threshold = threshold_eye[0: height, 0: int(width / 2)]\r\n left_side_white = cv2.countNonZero(left_side_threshold)\r\n right_side_threshold = threshold_eye[0: height, int(width / 2): width]\r\n right_side_white = cv2.countNonZero(right_side_threshold)\r\n if left_side_white == 0:\r\n gaze_ratio = 1\r\n elif right_side_white == 0:\r\n gaze_ratio = 5\r\n else:\r\n gaze_ratio = left_side_white / right_side_white\r\n return gaze_ratio\r\n \r\nstart_time = time.time()\r\nwhile True:\r\n _, frame = cap.read()\r\n new_frame = np.zeros((500, 500, 3), np.uint8)\r\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\r\n faces = detector(gray)\r\n for face in faces:\r\n #x, y = face.left(), face.top()\r\n #x1, y1 = face.right(), face.bottom()\r\n #cv2.rectangle(frame, (x, y), (x1, y1), (0, 255, 0), 2)\r\n landmarks = predictor(gray, face)\r\n # Detect blinking\r\n left_eye_ratio = get_blinking_ratio([36, 37, 38, 39, 40, 41], landmarks)\r\n right_eye_ratio = get_blinking_ratio([42, 43, 44, 45, 46, 47], landmarks)\r\n blinking_ratio = (left_eye_ratio + right_eye_ratio) / 2\r\n #if blinking_ratio > 5.7:\r\n #cv2.putText(frame, \"GOZLER KAPALI\", (50, 150), font, 2, (0, 0, 255),3)\r\n # Gaze detection\r\n gaze_ratio_left_eye = get_gaze_ratio([36, 37, 38, 39, 40, 41], landmarks)\r\n gaze_ratio_right_eye = get_gaze_ratio([42, 43, 44, 45, 46, 47], landmarks)\r\n gaze_ratio = (gaze_ratio_right_eye + gaze_ratio_left_eye) / 2\r\n if blinking_ratio > 5.7:\r\n cv2.putText(frame, \"GOZLER KAPALI\", (50, 150), font, 2, (0, 0, 255),3)\r\n liste.append(0) \r\n elif gaze_ratio <= 1:\r\n cv2.putText(frame, \"SAG\", (50, 100), font, 2, (0, 0, 255), 3)\r\n new_frame[:] = (0, 0, 255)\r\n liste.append(1) \r\n elif 1 < gaze_ratio < 1.5:\r\n cv2.putText(frame, \"ORTA\", (50, 100), font, 2, (0, 0, 255), 3)\r\n liste.append(2) \r\n else:\r\n new_frame[:] = (255, 0, 0)\r\n cv2.putText(frame, \"SOL\", (50, 100), font, 2, (0, 0, 255), 3)\r\n liste.append(1) \r\n #if len(liste)%60==0 and len(liste)>0:\r\n if sum(liste)/len(liste)<=1:\r\n cv2.putText(frame, \"DIKKATSIZ\", (1000,50), font, 2,(0,0,255),3) \r\n elif 1<sum(liste)/len(liste)<=1.5:\r\n cv2.putText(frame, \"ORTA DIKKATLI\", (1000,50), font, 2,(0,0,255),3) \r\n else:\r\n cv2.putText(frame, \"DIKKATLI\", (1000,50), font, 2,(0,0,255),3)\r\n \r\n \r\n \r\n\r\n\r\n\r\n\r\n\r\n\r\n cv2.imshow(\"Frame\", frame)\r\n cv2.imshow(\"New frame\", new_frame)\r\n\r\n #key = cv2.waitKey(1) \r\n #if key == 27:\r\n # break\r\n if cv2.waitKey(1) & 0xFF == ord('q'):\r\n break\r\nstop_time=time.time()\r\ncap.release()\r\ncv2.destroyAllWindows()\r\nprint(stop_time-start_time)\r\n\r\n\r\n\r\nmy_time = stop_time-start_time\r\nmy_frame = ceil(len(liste)/my_time)\r\ntoplam = 0\r\ntoplam_r = 0\r\nsayac = 0\r\nort = []\r\nekstra = len(liste)%my_frame\r\n\r\nfor i in liste:\r\n toplam += i\r\n sayac += 1\r\n if sayac%my_frame == 0:\r\n ort.append(toplam/my_frame)\r\n toplam = 0\r\n\r\nliste.reverse()\r\nprint(liste[1])\r\nif ekstra != 0:\r\n for i in range(ekstra):\r\n toplam_r += liste[i]\r\n \r\n ort.append(toplam_r/ekstra)\r\n\r\nprint(ceil(my_time),ort)\r\n#plot(x, y, color='green', marker='o', linestyle='dashed', linewidth=2, markersize=12)\r\n#plt.plot(range(1,len(ort)+1), ort, color=\"blue\")\r\nplt.scatter(range(1,len(ort)+1), ort, color=\"blue\")\r\nplt.xlabel(\"Zaman [s]\")\r\nplt.ylabel(\"Dikkat Değer Puanı [0-Min 2-Max]]\")\r\nplt.title(\"Zaman - Dikkat Değer Puanı Grafiği\")\r\nplt.grid()\r\nplt.ylim([0, 2])\r\nplt.show()\r\n\r\n\r\n\r\n\r\n\r\n\r\n"
] | [
[
"numpy.zeros",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel",
"numpy.min",
"matplotlib.pyplot.ylim",
"numpy.max",
"matplotlib.pyplot.xlabel"
]
] |
jtegedor/poliastro | [
"48c854a4ad5500116f7c09ca171f77a60e2de04b"
] | [
"src/poliastro/twobody/propagation.py"
] | [
"\"\"\"The following script holds the different high level functions for the\ndifferent propagators available at poliastro:\n\n+-------------+------------+-----------------+-----------------+\n| Propagator | Elliptical | Parabolic | Hyperbolic |\n+-------------+------------+-----------------+-----------------+\n| farnocchia | ✓ | ✓ | ✓ |\n+-------------+------------+-----------------+-----------------+\n| vallado | ✓ | ✓ | ✓ |\n+-------------+------------+-----------------+-----------------+\n| mikkola | ✓ | ✓ | ✓ |\n+-------------+------------+-----------------+-----------------+\n| markley | ✓ | x | x |\n+-------------+------------+-----------------+-----------------+\n| pimienta | ✓ | ✓ | x |\n+-------------+------------+-----------------+-----------------+\n| gooding | ✓ | x | x |\n+-------------+------------+-----------------+-----------------+\n| danby | ✓ | ✓ | ✓ |\n+-------------+------------+-----------------+-----------------+\n| cowell | ✓ | ✓ | ✓ |\n+-------------+------------+-----------------+-----------------+\n\n\"\"\"\nimport numpy as np\nfrom astropy import units as u\nfrom astropy.coordinates import CartesianDifferential, CartesianRepresentation\nfrom scipy.integrate import DOP853, solve_ivp\n\nfrom poliastro.core.propagation import (\n danby as danby_fast,\n farnocchia as farnocchia_fast,\n func_twobody,\n gooding as gooding_fast,\n markley as markley_fast,\n mikkola as mikkola_fast,\n pimienta as pimienta_fast,\n vallado as vallado_fast,\n)\n\n\ndef cowell(k, r, v, tofs, rtol=1e-11, *, events=None, f=func_twobody):\n \"\"\"Propagates orbit using Cowell's formulation.\n\n Parameters\n ----------\n k : ~astropy.units.Quantity\n Standard gravitational parameter of the attractor.\n r : ~astropy.units.Quantity\n Position vector.\n v : ~astropy.units.Quantity\n Velocity vector.\n tofs : ~astropy.units.Quantity\n Array of times to propagate.\n rtol : float, optional\n Maximum relative error permitted, default to 1e-10.\n events : function(t, u(t)), optional\n Passed to `solve_ivp`: Integration stops when this function\n returns <= 0., assuming you set events.terminal=True\n f : function(t0, u, k), optional\n Objective function, default to Keplerian-only forces.\n\n Returns\n -------\n rr : ~astropy.units.Quantity\n Propagated position vectors.\n vv : ~astropy.units.Quantity\n Propagated velocity vectors.\n\n Raises\n ------\n RuntimeError\n If the algorithm didn't converge.\n\n Note\n -----\n This method uses the `solve_ivp` method from `scipy.integrate` using the\n Dormand & Prince integration method of order 8(5,3) (DOP853).\n If multiple tofs are provided, the method propagates to the maximum value\n (unless a terminal event is defined) and calculates the other values via dense output.\n\n \"\"\"\n k = k.to_value(u.km ** 3 / u.s ** 2)\n x, y, z = r.to_value(u.km)\n vx, vy, vz = v.to_value(u.km / u.s)\n tofs = tofs.to_value(u.s)\n\n u0 = np.array([x, y, z, vx, vy, vz])\n\n result = solve_ivp(\n f,\n (0, max(tofs)),\n u0,\n args=(k,),\n rtol=rtol,\n atol=1e-12,\n method=DOP853,\n dense_output=True,\n events=events,\n )\n if not result.success:\n raise RuntimeError(\"Integration failed\")\n\n if events is not None:\n # Collect only the terminal events\n terminal_events = [event for event in events if event.terminal]\n\n # If there are no terminal events, then the last time of integration is the\n # greatest one from the original array of propagation times\n if not terminal_events:\n last_t = max(tofs)\n else:\n # Filter the event which triggered first\n last_t = min([event.last_t for event in terminal_events]).to_value(u.s)\n tofs = [tof for tof in tofs if tof < last_t] + [last_t]\n\n rrs = []\n vvs = []\n for i in range(len(tofs)):\n t = tofs[i]\n y = result.sol(t)\n rrs.append(y[:3])\n vvs.append(y[3:])\n\n return rrs * u.km, vvs * u.km / u.s\n\n\ndef farnocchia(k, r, v, tofs, **kwargs):\n \"\"\"Propagates orbit.\n\n Parameters\n ----------\n k : ~astropy.units.Quantity\n Standard gravitational parameter of the attractor.\n r : ~astropy.units.Quantity\n Position vector.\n v : ~astropy.units.Quantity\n Velocity vector.\n tofs : ~astropy.units.Quantity\n Array of times to propagate.\n\n Returns\n -------\n rr : ~astropy.units.Quantity\n Propagated position vectors.\n vv : ~astropy.units.Quantity\n Propagated velocity vectors.\n\n \"\"\"\n k = k.to_value(u.km ** 3 / u.s ** 2)\n r0 = r.to_value(u.km)\n v0 = v.to_value(u.km / u.s)\n tofs = tofs.to_value(u.s)\n\n results = np.array([farnocchia_fast(k, r0, v0, tof) for tof in tofs])\n return (\n results[:, 0] << u.km,\n results[:, 1] << u.km / u.s,\n )\n\n\ndef vallado(k, r, v, tofs, numiter=350, **kwargs):\n \"\"\"Propagates Keplerian orbit.\n\n Parameters\n ----------\n k : ~astropy.units.Quantity\n Standard gravitational parameter of the attractor.\n r : ~astropy.units.Quantity\n Position vector.\n v : ~astropy.units.Quantity\n Velocity vector.\n tofs : ~astropy.units.Quantity\n Array of times to propagate.\n numiter : int, optional\n Maximum number of iterations, default to 35.\n\n Returns\n -------\n rr : ~astropy.units.Quantity\n Propagated position vectors.\n vv : ~astropy.units.Quantity\n Propagated velocity vectors.\n\n Raises\n ------\n RuntimeError\n If the algorithm didn't converge.\n\n Note\n -----\n This algorithm is based on Vallado implementation, and does basic Newton\n iteration on the Kepler equation written using universal variables. Battin\n claims his algorithm uses the same amount of memory but is between 40 %\n and 85 % faster.\n\n \"\"\"\n k = k.to_value(u.km ** 3 / u.s ** 2)\n r0 = r.to_value(u.km)\n v0 = v.to_value(u.km / u.s)\n tofs = tofs.to_value(u.s)\n\n results = np.array([_kepler(k, r0, v0, tof, numiter=numiter) for tof in tofs])\n return (\n results[:, 0] << u.km,\n results[:, 1] << u.km / u.s,\n )\n\n\ndef _kepler(k, r0, v0, tof, *, numiter):\n # Compute Lagrange coefficients\n f, g, fdot, gdot = vallado_fast(k, r0, v0, tof, numiter)\n\n assert np.abs(f * gdot - fdot * g - 1) < 1e-5 # Fixed tolerance\n\n # Return position and velocity vectors\n r = f * r0 + g * v0\n v = fdot * r0 + gdot * v0\n\n return r, v\n\n\ndef mikkola(k, r, v, tofs, rtol=None):\n \"\"\"Solves Kepler Equation by a cubic approximation. This method is valid\n no mater the orbit's nature.\n\n Parameters\n ----------\n k : ~astropy.units.Quantity\n Standard gravitational parameter of the attractor.\n r : ~astropy.units.Quantity\n Position vector.\n v : ~astropy.units.Quantity\n Velocity vector.\n tofs : ~astropy.units.Quantity\n Array of times to propagate.\n rtol: float\n This method does not require of tolerance since it is non iterative.\n\n Returns\n -------\n rr : ~astropy.units.Quantity\n Propagated position vectors.\n vv : ~astropy.units.Quantity\n\n Note\n ----\n This method was derived by Seppo Mikola in his paper *A Cubic Approximation\n For Kepler's Equation* with DOI: https://doi.org/10.1007/BF01235850\n\n \"\"\"\n\n k = k.to_value(u.m ** 3 / u.s ** 2)\n r0 = r.to_value(u.m)\n v0 = v.to_value(u.m / u.s)\n tofs = tofs.to_value(u.s)\n\n results = np.array([mikkola_fast(k, r0, v0, tof) for tof in tofs])\n return (\n results[:, 0] << u.m,\n results[:, 1] << u.m / u.s,\n )\n\n\ndef markley(k, r, v, tofs, rtol=None):\n \"\"\"Elliptical Kepler Equation solver based on a fifth-order\n refinement of the solution of a cubic equation.\n\n Parameters\n ----------\n k : ~astropy.units.Quantity\n Standard gravitational parameter of the attractor.\n r : ~astropy.units.Quantity\n Position vector.\n v : ~astropy.units.Quantity\n Velocity vector.\n tofs : ~astropy.units.Quantity\n Array of times to propagate.\n rtol: float\n This method does not require of tolerance since it is non iterative.\n\n Returns\n -------\n rr : ~astropy.units.Quantity\n Propagated position vectors.\n vv : ~astropy.units.Quantity\n Propagated velocity vectors.\n\n Note\n ----\n This method was originally presented by Markley in his paper *Kepler Equation Solver*\n with DOI: https://doi.org/10.1007/BF00691917\n\n \"\"\"\n\n k = k.to_value(u.m ** 3 / u.s ** 2)\n r0 = r.to_value(u.m)\n v0 = v.to_value(u.m / u.s)\n tofs = tofs.to_value(u.s)\n\n results = np.array([markley_fast(k, r0, v0, tof) for tof in tofs])\n return (\n results[:, 0] << u.m,\n results[:, 1] << u.m / u.s,\n )\n\n\ndef pimienta(k, r, v, tofs, rtol=None):\n \"\"\"Kepler solver for both elliptic and parabolic orbits based on a 15th\n order polynomial with accuracies around 10e-5 for elliptic case and 10e-13\n in the hyperbolic regime.\n\n Parameters\n ----------\n k : ~astropy.units.Quantity\n Standard gravitational parameter of the attractor.\n r : ~astropy.units.Quantity\n Position vector.\n v : ~astropy.units.Quantity\n Velocity vector.\n tofs : ~astropy.units.Quantity\n Array of times to propagate.\n rtol: float\n This method does not require of tolerance since it is non iterative.\n\n Returns\n -------\n rr : ~astropy.units.Quantity\n Propagated position vectors.\n vv : ~astropy.units.Quantity\n Propagated velocity vectors.\n\n Note\n ----\n This algorithm was developed by Pimienta-Peñalver and John L. Crassidis in\n their paper *Accurate Kepler Equation solver without trascendental function\n evaluations*. Original paper is on Buffalo's UBIR repository: http://hdl.handle.net/10477/50522\n\n \"\"\"\n\n k = k.to_value(u.m ** 3 / u.s ** 2)\n r0 = r.to_value(u.m)\n v0 = v.to_value(u.m / u.s)\n tofs = tofs.to_value(u.s)\n\n results = np.array([pimienta_fast(k, r0, v0, tof) for tof in tofs])\n return (\n results[:, 0] << u.m,\n results[:, 1] << u.m / u.s,\n )\n\n\ndef gooding(k, r, v, tofs, numiter=150, rtol=1e-8):\n \"\"\"Solves the Elliptic Kepler Equation with a cubic convergence and\n accuracy better than 10e-12 rad is normally achieved. It is not valid for\n eccentricities equal or greater than 1.0.\n\n Parameters\n ----------\n k : ~astropy.units.Quantity\n Standard gravitational parameter of the attractor.\n r : ~astropy.units.Quantity\n Position vector.\n v : ~astropy.units.Quantity\n Velocity vector.\n tofs : ~astropy.units.Quantity\n Array of times to propagate.\n rtol: float\n This method does not require of tolerance since it is non iterative.\n\n Returns\n -------\n rr : ~astropy.units.Quantity\n Propagated position vectors.\n vv : ~astropy.units.Quantity\n\n Note\n ----\n This method was developed by Gooding and Odell in their paper *The\n hyperbolic Kepler equation (and the elliptic equation revisited)* with\n DOI: https://doi.org/10.1007/BF01235540\n\n \"\"\"\n\n k = k.to_value(u.m ** 3 / u.s ** 2)\n r0 = r.to_value(u.m)\n v0 = v.to_value(u.m / u.s)\n tofs = tofs.to_value(u.s)\n\n results = np.array(\n [gooding_fast(k, r0, v0, tof, numiter=numiter, rtol=rtol) for tof in tofs]\n )\n return (\n results[:, 0] << u.m,\n results[:, 1] << u.m / u.s,\n )\n\n\ndef danby(k, r, v, tofs, rtol=1e-8):\n \"\"\"Kepler solver for both elliptic and parabolic orbits based on Danby's\n algorithm.\n\n Parameters\n ----------\n k : ~astropy.units.Quantity\n Standard gravitational parameter of the attractor.\n r : ~astropy.units.Quantity\n Position vector.\n v : ~astropy.units.Quantity\n Velocity vector.\n tofs : ~astropy.units.Quantity\n Array of times to propagate.\n rtol: float\n Relative error for accuracy of the method.\n\n Returns\n -------\n rr : ~astropy.units.Quantity\n Propagated position vectors.\n vv : ~astropy.units.Quantity\n Propagated velocity vectors.\n\n Note\n ----\n This algorithm was developed by Danby in his paper *The solution of Kepler\n Equation* with DOI: https://doi.org/10.1007/BF01686811\n\n \"\"\"\n\n k = k.to_value(u.m ** 3 / u.s ** 2)\n r0 = r.to_value(u.m)\n v0 = v.to_value(u.m / u.s)\n tofs = tofs.to_value(u.s)\n\n results = np.array([danby_fast(k, r0, v0, tof) for tof in tofs])\n return (\n results[:, 0] << u.m,\n results[:, 1] << u.m / u.s,\n )\n\n\ndef propagate(orbit, time_of_flight, *, method=farnocchia, rtol=1e-10, **kwargs):\n \"\"\"Propagate an orbit some time and return the result.\n\n Parameters\n ----------\n orbit : ~poliastro.twobody.Orbit\n Orbit object to propagate.\n time_of_flight : ~astropy.time.TimeDelta\n Time of propagation.\n method : callable, optional\n Propagation method, default to farnocchia.\n rtol : float, optional\n Relative tolerance, default to 1e-10.\n\n Returns\n -------\n astropy.coordinates.CartesianRepresentation\n Propagation coordinates.\n \"\"\"\n\n # Check if propagator fulfills orbit requirements\n if orbit.ecc < 1.0 and method not in ELLIPTIC_PROPAGATORS:\n raise ValueError(\n \"Can not use an parabolic/hyperbolic propagator for elliptical/circular orbits.\"\n )\n elif orbit.ecc == 1.0 and method not in PARABOLIC_PROPAGATORS:\n raise ValueError(\n \"Can not use an elliptic/hyperbolic propagator for parabolic orbits.\"\n )\n elif orbit.ecc > 1.0 and method not in HYPERBOLIC_PROPAGATORS:\n raise ValueError(\n \"Can not use an elliptic/parabolic propagator for hyperbolic orbits.\"\n )\n\n rr, vv = method(\n orbit.attractor.k,\n orbit.r,\n orbit.v,\n time_of_flight.reshape(-1).to(u.s),\n rtol=rtol,\n **kwargs\n )\n\n cartesian = CartesianRepresentation(\n rr, differentials=CartesianDifferential(vv, xyz_axis=1), xyz_axis=1\n )\n\n return cartesian\n\n\nELLIPTIC_PROPAGATORS = [\n farnocchia,\n vallado,\n mikkola,\n markley,\n pimienta,\n gooding,\n danby,\n cowell,\n]\nPARABOLIC_PROPAGATORS = [farnocchia, vallado, mikkola, pimienta, gooding, cowell]\nHYPERBOLIC_PROPAGATORS = [\n farnocchia,\n vallado,\n mikkola,\n pimienta,\n gooding,\n danby,\n cowell,\n]\nALL_PROPAGATORS = list(\n set(ELLIPTIC_PROPAGATORS + PARABOLIC_PROPAGATORS + HYPERBOLIC_PROPAGATORS)\n)\n"
] | [
[
"numpy.array",
"numpy.abs"
]
] |
p517332051/face_benchmark | [
"c76c2b2142ecf65b7bace4b007a33fa4e795d2d0"
] | [
"maskrcnn_benchmark/data/datasets/FaceDataset.py"
] | [
"import os\nimport numpy as np\nimport torch\nimport torch.utils.data as data\nimport random\nimport tqdm\nfrom PIL import Image\nclass FaceDataset(data.Dataset):\n def __init__(self, data_dir, ann_file, transforms=None, augmenter=None,im_info=[112,96]):\n assert transforms is not None\n\n self.root = data_dir\n self.file_list = ann_file\n self.augmenter = augmenter\n self.transform = transforms\n self.im_info = im_info\n image_list = []\n label_list = []\n with open(ann_file) as f:\n img_label_list = f.read().splitlines()\n\n self.image_label_list = []\n for info in img_label_list:\n image_path, label_name = info.split(' ')\n self.image_label_list.append([image_path, int(label_name)])\n image_list.append(image_path)\n label_list.append(int(label_name))\n\n self.image_list = image_list\n self.label_list = label_list\n self.class_nums = len(set(self.label_list))\n # self.class_nums = max(self.label_list)\n print(\"dataset size: \", len(self.image_list), '/', self.class_nums)\n\n def __getitem__(self, index):\n img_path = self.image_list[index]\n label = self.label_list[index]\n p = random.random()\n img = Image.open(os.path.join(self.root, img_path)).convert('RGB')\n if self.augmenter is not None and p<=0.2:\n img_array = np.asarray(img)\n img_array = self.augmenter.augment_image(img_array)\n img = Image.fromarray(img_array.astype('uint8')).convert('RGB')\n img = self.transform(img)\n\n return img, label, index\n\n def __len__(self):\n return len(self.image_list)\n\n def get_img_info(self, index):\n return {\"height\": self.im_info[0], \"width\": self.im_info[1]}\n# def FaceDataset():\n# return FR_train_data\n\n\n\nclass TripletFaceDataset(data.Dataset):\n\n def __init__(self, data_dir, ann_file, n_triplets, transforms=None, augmenter=None,im_info=[112,96]):\n\n assert transforms is not None\n self.root = data_dir\n self.file_list = ann_file\n self.augmenter = augmenter\n self.transform = transforms\n self.im_info = im_info\n image_list = []\n label_list = []\n with open(self.file_list) as f:\n img_label_list = f.read().splitlines()\n self.image_label_list = []\n for info in img_label_list:\n image_path, label_name = info.split(' ')\n self.image_label_list.append([image_path, int(label_name)])\n image_list.append(image_path)\n label_list.append(int(label_name))\n\n self.image_list = image_list\n self.label_list = label_list\n self.class_nums = len(set(self.label_list))\n # self.class_nums = max(self.label_list)\n print(\"dataset size: \", len(self.image_list), '/', self.class_nums)\n\n self.n_triplets = n_triplets\n\n print('Generating {} triplets'.format(self.n_triplets))\n self.training_triplets = self.generate_triplets(self.image_list, self.label_list, self.n_triplets,self.class_nums)\n\n @staticmethod\n def generate_triplets(imgs, labels, num_triplets, n_classes):\n def create_indices(imgs, labels):\n inds = dict()\n for idx, img_path in enumerate(imgs):\n label = labels[idx]\n if label not in inds:\n inds[label] = []\n inds[label].append(img_path)\n return inds\n\n triplets = []\n # Indices = array of labels and each label is an array of indices\n indices = create_indices(imgs, labels)\n\n for x in range(num_triplets):\n c1 = np.random.randint(0, n_classes-1)\n c2 = np.random.randint(0, n_classes-1)\n while len(indices[c1]) < 2:\n c1 = np.random.randint(0, n_classes-1)\n\n while c1 == c2:\n c2 = np.random.randint(0, n_classes-1)\n if len(indices[c1]) == 2: # hack to speed up process\n n1, n2 = 0, 1\n else:\n n1 = np.random.randint(0, len(indices[c1]) - 1)\n n2 = np.random.randint(0, len(indices[c1]) - 1)\n while n1 == n2:\n n2 = np.random.randint(0, len(indices[c1]) - 1)\n if len(indices[c2]) ==1:\n n3 = 0\n else:\n n3 = np.random.randint(0, len(indices[c2]) - 1)\n\n triplets.append([indices[c1][n1], indices[c1][n2], indices[c2][n3],c1,c2])\n return triplets\n def loader(self,img_path):\n p = random.random()\n img = Image.open(os.path.join(self.root, img_path)).convert('RGB')\n if self.augmenter is not None and p<=0.2:\n img_array = np.asarray(img)\n img_array = self.augmenter.augment_image(img_array)\n img = Image.fromarray(img_array.astype('uint8')).convert('RGB')\n return img\n def __getitem__(self, index):\n '''\n Args:\n index: Index of the triplet or the matches - not of a single image\n Returns:\n '''\n def transform(img_path):\n \"\"\"Convert image into numpy array and apply transformation\n Doing this so that it is consistent with all other datasets\n to return a PIL Image.\n \"\"\"\n\n img = self.loader(img_path)\n return self.transform(img)\n\n # Get the index of each image in the triplet\n a, p, n,c1,c2 = self.training_triplets[index]\n\n # transform images if required\n img_a, img_p, img_n = transform(a), transform(p), transform(n)\n return img_a, img_p, img_n,c1,c2\n\n def __len__(self):\n return len(self.training_triplets)\n def get_img_info(self, index):\n return {\"height\": self.im_info[0], \"width\": self.im_info[1]}"
] | [
[
"numpy.random.randint",
"numpy.asarray"
]
] |
peternara/DeepHash | [
"c6f4c6733f619718d437bf39ef9fb6854476f20c"
] | [
"DeepHash/model/dtq/util.py"
] | [
"import numpy as np\nimport math\nfrom distance.npversion import distance\n\nclass Dataset(object):\n def __init__(self, dataset, output_dim, code_dim):\n self._dataset = dataset\n self.n_samples = dataset.n_samples\n self._train = dataset.train\n self._output = np.zeros((self.n_samples, output_dim), dtype=np.float32)\n # code_dim = K 수를 의미 = config.subspace * config.subcenter\n self._codes = np.zeros((self.n_samples, code_dim), dtype=np.float32)\n self._triplets = np.array([])\n self._trip_index_in_epoch = 0\n self._index_in_epoch = 0\n self._epochs_complete = 0\n self._perm = np.arange(self.n_samples)\n np.random.shuffle(self._perm)\n return\n\n def update_triplets(self, margin, n_part=10, dist_type='euclidean2', select_strategy='margin'):\n \"\"\"\n :param select_strategy: hard, all, margin\n :param dist_type: distance type, e.g. euclidean2, cosine\n :param margin: triplet margin parameter\n :n_part: number of part to split data\n \"\"\"\n n_samples = self.n_samples\n np.random.shuffle(self._perm)\n embedding = self._output[self._perm[:n_samples]]\n labels = self._dataset.get_labels()[self._perm[:n_samples]]\n n_samples_per_part = int(math.ceil(n_samples / n_part))\n triplets = []\n for i in range(n_part):\n start = n_samples_per_part * i\n end = min(n_samples_per_part * (i+1), n_samples)\n dist = distance(embedding[start:end], pair=True, dist_type=dist_type)\n for idx_anchor in range(0, end - start):\n label_anchor = np.copy(labels[idx_anchor+start, :])\n label_anchor[label_anchor==0] = -1\n all_pos = np.where(np.any(labels[start:end] == label_anchor, axis=1))[0]\n all_neg = np.array(list(set(range(end-start)) - set(all_pos)))\n\n if select_strategy == 'hard':\n idx_pos = all_pos[np.argmax(dist[idx_anchor, all_pos])]\n if idx_pos == idx_anchor:\n continue\n idx_neg = all_neg[np.argmin(dist[idx_anchor, all_neg])]\n triplets.append((idx_anchor + start, idx_pos + start, idx_neg + start))\n continue\n\n for idx_pos in all_pos:\n if idx_pos == idx_anchor:\n continue\n\n if select_strategy == 'all':\n selected_neg = all_neg\n elif select_strategy == 'margin':\n selected_neg = all_neg[np.where(dist[idx_anchor, all_neg] - dist[idx_anchor, idx_pos] < margin)[0]]\n\n if selected_neg.shape[0] > 0:\n idx_neg = np.random.choice(selected_neg)\n triplets.append((idx_anchor + start, idx_pos + start, idx_neg + start))\n self._triplets = np.array(triplets)\n np.random.shuffle(self._triplets)\n\n # assert\n anchor = labels[self._triplets[:, 0]]\n mapper = lambda anchor, other: np.any(anchor * (anchor == other), -1)\n assert(np.all(mapper(anchor, labels[self._triplets[:, 1]])))\n assert(np.all(np.invert(anchor, labels[self._triplets[:, 2]])))\n return\n\n def next_batch_triplet(self, batch_size):\n \"\"\"\n Args:\n batch_size\n Returns:\n data, label, codes\n \"\"\"\n start = self._trip_index_in_epoch\n self._trip_index_in_epoch += batch_size\n if self._trip_index_in_epoch > self.triplets.shape[0]:\n start = 0\n self._trip_index_in_epoch = batch_size\n end = self._trip_index_in_epoch\n\n # stack index of anchors, positive, negetive to one array\n arr = self.triplets[start:end]\n idx = self._perm[np.concatenate([arr[:, 0], arr[:, 1], arr[:, 2]], axis=0)]\n data, label = self._dataset.data(idx)\n\n return data, label, self._codes[idx]\n\n def next_batch(self, batch_size):\n \"\"\"\n Args:\n batch_size\n Returns:\n [batch_size, (n_inputs)]: next batch images, by stacking anchor, positive, negetive\n [batch_size, n_class]: next batch labels\n \"\"\"\n start = self._index_in_epoch\n self._index_in_epoch += batch_size\n if self._index_in_epoch > self.n_samples:\n if self._train:\n self._epochs_complete += 1\n start = 0\n self._index_in_epoch = batch_size\n else:\n # Validation stage only process once\n start = self.n_samples - batch_size\n self._index_in_epoch = self.n_samples\n end = self._index_in_epoch\n\n data, label = self._dataset.data(self._perm[start:end])\n return (data, label, self._codes[self._perm[start: end], :])\n\n def next_batch_output_codes(self, batch_size):\n start = self._index_in_epoch\n self._index_in_epoch += batch_size\n # Another epoch finish\n if self._index_in_epoch > self.n_samples:\n if self._train:\n # Start next epoch\n start = 0\n self._index_in_epoch = batch_size\n else:\n # Validation stage only process once\n start = self.n_samples - batch_size\n self._index_in_epoch = self.n_samples\n end = self._index_in_epoch\n\n return (self._output[self._perm[start: end], :],\n self._codes[self._perm[start: end], :])\n\n def feed_batch_output(self, batch_size, output):\n start = self._index_in_epoch - batch_size\n end = self._index_in_epoch\n self._output[self._perm[start:end], :] = output\n return\n\n def feed_batch_triplet_output(self, batch_size, triplet_output):\n anchor, pos, neg = np.split(triplet_output, 3, axis=0)\n start = self._trip_index_in_epoch - batch_size\n end = self._trip_index_in_epoch\n idx = self._perm[self._triplets[start:end, :]]\n self._output[idx[:, 0]] = anchor\n self._output[idx[:, 1]] = pos\n self._output[idx[:, 2]] = neg\n return\n\n def feed_batch_codes(self, batch_size, codes):\n \"\"\"\n Args:\n batch_size\n [batch_size, n_output]\n \"\"\"\n start = self._index_in_epoch - batch_size\n end = self._index_in_epoch\n self._codes[self._perm[start:end], :] = codes\n return\n\n @property\n def output(self):\n return self._output\n\n @property\n def codes(self):\n return self._codes\n\n @property\n def triplets(self):\n return self._triplets\n\n @property\n def label(self):\n return self._dataset.get_labels()\n\n def finish_epoch(self):\n self._index_in_epoch = 0\n"
] | [
[
"numpy.random.shuffle",
"numpy.zeros",
"numpy.invert",
"numpy.argmin",
"numpy.any",
"numpy.random.choice",
"numpy.copy",
"numpy.argmax",
"numpy.arange",
"numpy.where",
"numpy.array",
"numpy.concatenate",
"numpy.split"
]
] |
fredriko/search_with_machine_learning_course | [
"85670d7adf337fede418fa5665b3c5ee80e42b2b"
] | [
"index_queries.py"
] | [
"import click\nimport pandas as pd\nfrom opensearchpy import OpenSearch\nfrom opensearchpy.helpers import bulk\n\nimport logging\n\nlogger = logging.getLogger(__name__)\nlogger.setLevel(logging.INFO)\nlogging.basicConfig(format='%(levelname)s:%(message)s')\n\n\ndef get_opensearch():\n host = 'localhost'\n port = 9200\n auth = ('admin', 'admin')\n client = OpenSearch(\n hosts=[{'host': host, 'port': port}],\n http_compress=True, # enables gzip compression for request bodies\n http_auth=auth,\n # client_cert = client_cert_path,\n # client_key = client_key_path,\n use_ssl=True,\n verify_certs=False,\n ssl_assert_hostname=False,\n ssl_show_warn=False,\n # ca_certs=ca_certs_path\n )\n return client\n\n\[email protected]()\[email protected]('--source_file', '-s', help='source csv file', required=True)\ndef main(source_file):\n index_name = 'bbuy_queries'\n client = get_opensearch()\n ds = pd.read_csv(source_file)\n # print(ds.columns)\n ds['click_time'] = pd.to_datetime(ds['click_time'])\n ds['query_time'] = pd.to_datetime(ds['query_time'])\n # print(ds.dtypes)\n docs = []\n for idx, row in ds.iterrows():\n doc = {}\n for col in ds.columns:\n doc[col] = row[col]\n docs.append({'_index': index_name, '_source': doc})\n if idx % 300 == 0:\n bulk(client, docs, request_timeout=60)\n logger.info(f'{idx} documents indexed')\n docs = []\n if len(docs) > 0:\n bulk(client, docs, request_timeout=60)\n logger.info(f'Done indexing {ds.shape[0]} records')\n\n\nif __name__ == \"__main__\":\n main()\n"
] | [
[
"pandas.read_csv",
"pandas.to_datetime"
]
] |
blester125/baseline | [
"4ad4147d4a88a42b309c6784a95b0b9f1faa2c60"
] | [
"baseline/tf/seq2seq/training/datasets.py"
] | [
"import tensorflow as tf\nfrom baseline.tf.tfy import TRAIN_FLAG\nfrom eight_mile.utils import listify\nfrom baseline.utils import get_model_file, get_metric_cmp\nfrom baseline.train import create_trainer, register_training_func\nfrom baseline.tf.seq2seq.training.utils import to_tensors, SHUF_BUF_SZ, NUM_PREFETCH\n\n\n@register_training_func('seq2seq', 'dataset')\ndef fit_datasets(model_params, ts, vs, es=None, **kwargs):\n \"\"\"\n Train an encoder-decoder network using TensorFlow with `tf.dataset`. This\n is the default behavior for training.\n\n :param model_params: The model (or parameters to create the model) to train\n :param ts: A training data set\n :param vs: A validation data set\n :param es: A test data set, can be None\n :param kwargs:\n See below\n\n :Keyword Arguments:\n * *do_early_stopping* (``bool``) --\n Stop after evaluation data is no longer improving. Defaults to True\n * *verbose* (`dict`) A dictionary containing `console` boolean and `file` name if on\n * *epochs* (``int``) -- how many epochs. Default to 20\n * *outfile* -- Model output file, defaults to classifier-model.pyth\n * *patience* --\n How many epochs where evaluation is no longer improving before we give up\n * *reporting* --\n Callbacks which may be used on reporting updates\n * *nsteps* (`int`) -- If we should report every n-steps, this should be passed\n * *ema_decay* (`float`) -- If we are doing an exponential moving average, what decay to us4e\n * *clip* (`int`) -- If we are doing gradient clipping, what value to use\n * *optim* (`str`) -- The name of the optimizer we are using\n * *lr* (`float`) -- The learning rate we are using\n * *mom* (`float`) -- If we are using SGD, what value to use for momentum\n * *beta1* (`float`) -- Adam-specific hyper-param, defaults to `0.9`\n * *beta2* (`float`) -- Adam-specific hyper-param, defaults to `0.999`\n * *epsilon* (`float`) -- Adam-specific hyper-param, defaults to `1e-8\n\n :return: None\n \"\"\"\n\n epochs = int(kwargs.get('epochs', 5))\n patience = int(kwargs.get('patience', epochs))\n model_file = get_model_file('seq2seq', 'tf', kwargs.get('basedir'))\n do_early_stopping = bool(kwargs.get('do_early_stopping', True))\n\n best_metric = 0\n if do_early_stopping:\n early_stopping_metric = kwargs.get('early_stopping_metric', 'perplexity')\n early_stopping_cmp, best_metric = get_metric_cmp(early_stopping_metric, kwargs.get('early_stopping_cmp'))\n patience = kwargs.get('patience', epochs)\n print('Doing early stopping on [%s] with patience [%d]' % (early_stopping_metric, patience))\n\n reporting_fns = listify(kwargs.get('reporting', []))\n print('reporting', reporting_fns)\n\n batchsz = kwargs['batchsz']\n ## First, make tf.datasets for ts, vs and es\n # https://github.com/tensorflow/tensorflow/blob/master/tensorflow/contrib/distribute/README.md\n # effective_batch_sz = args.batchsz*args.gpus\n test_batchsz = kwargs.get('test_batchsz', batchsz)\n src_lengths_key = model_params.get('src_lengths_key')\n train_dataset = tf.data.Dataset.from_tensor_slices(to_tensors(ts, src_lengths_key))\n train_dataset = train_dataset.shuffle(buffer_size=SHUF_BUF_SZ)\n train_dataset = train_dataset.batch(batchsz, drop_remainder=False)\n train_dataset = train_dataset.repeat(epochs + 1)\n train_dataset = train_dataset.prefetch(NUM_PREFETCH)\n\n valid_dataset = tf.data.Dataset.from_tensor_slices(to_tensors(vs, src_lengths_key))\n valid_dataset = valid_dataset.batch(batchsz, drop_remainder=False)\n valid_dataset = valid_dataset.repeat(epochs + 1)\n valid_dataset = valid_dataset.prefetch(NUM_PREFETCH)\n\n iter = tf.compat.v1.data.Iterator.from_structure(tf.compat.v1.data.get_output_types(train_dataset),\n tf.compat.v1.data.get_output_shapes(train_dataset))\n\n features, tgt = iter.get_next()\n # Add features to the model params\n model_params.update(features)\n # This is kind of crazy, but seems to work, hardwire a graph op for `mx_tgt_len`\n model_params.update({'tgt': tgt, 'mx_tgt_len': tf.reduce_max(features['tgt_len'])})\n\n # create the initialization operations\n train_init_op = iter.make_initializer(train_dataset)\n valid_init_op = iter.make_initializer(valid_dataset)\n\n TRAIN_FLAG()\n trainer = create_trainer(model_params, **kwargs)\n\n last_improved = 0\n\n for epoch in range(epochs):\n trainer.sess.run(train_init_op)\n trainer.train(ts, reporting_fns)\n trainer.sess.run(valid_init_op)\n test_metrics = trainer.test(vs, reporting_fns, phase='Valid')\n\n if do_early_stopping is False:\n trainer.checkpoint()\n trainer.model.save(model_file)\n\n elif early_stopping_cmp(test_metrics[early_stopping_metric], best_metric):\n last_improved = epoch\n best_metric = test_metrics[early_stopping_metric]\n print('New best %.3f' % best_metric)\n trainer.checkpoint()\n trainer.model.save(model_file)\n\n elif (epoch - last_improved) > patience:\n print('Stopping due to persistent failures to improve')\n break\n\n if do_early_stopping is True:\n print('Best performance on %s: %.3f at epoch %d' % (early_stopping_metric, best_metric, last_improved))\n\n if es is not None:\n print('Reloading best checkpoint')\n trainer.recover_last_checkpoint()\n\n test_dataset = tf.data.Dataset.from_tensor_slices(to_tensors(es, src_lengths_key))\n test_dataset = test_dataset.batch(test_batchsz, drop_remainder=False)\n test_dataset = test_dataset.repeat(epochs + 1)\n test_dataset = test_dataset.prefetch(NUM_PREFETCH)\n test_init_op = iter.make_initializer(test_dataset)\n\n trainer.sess.run(test_init_op)\n trainer.test(es, reporting_fns, phase='Test')\n"
] | [
[
"tensorflow.compat.v1.data.get_output_types",
"tensorflow.reduce_max",
"tensorflow.compat.v1.data.get_output_shapes"
]
] |
preller/morpheus | [
"ba10271c6ace5aff3b35509ab5fbf42bcd6750b6"
] | [
"morpheus/classifier.py"
] | [
"# MIT License\n# Copyright 2018 Ryan Hausen\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in all\n# copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n# THE SOFTWARE.\n# ==============================================================================\n\"\"\"An interface for interacting with Morpheus\"\"\"\nimport os\nimport time\nimport json\nfrom subprocess import Popen\nfrom typing import Iterable, List, Tuple, Callable, Dict, Union\n\nimport imageio\nimport numpy as np\nimport tensorflow.compat.v1 as tf\nfrom astropy.io import fits\nfrom matplotlib.colors import hsv_to_rgb\nfrom scipy import ndimage as ndi\nfrom skimage.feature import peak_local_max\nfrom skimage.filters import sobel\nfrom skimage.measure import regionprops\nfrom skimage.morphology import watershed\nfrom tqdm import tqdm\n\ntf.disable_eager_execution()\n\nimport morpheus.core.helpers as helpers\nimport morpheus.core.model as model\n\n\nclass Classifier:\n \"\"\"The primary interface for the use of Morpheus.\n\n Images can be classified by calling\n :py:meth:`~morpheus.classifier.Classifier.classify` and passing\n numpy arrays or string FITS file locations.\n\n After an image this this class offers some post processing functionality by\n generating segmentation maps using\n :py:meth:`~morpheus.classifier.Classifier.segmap_from_classified`, colorized\n morphological classifications using\n :py:meth:`~morpheus.classifier.Classifier.colorize_classification`, and\n generating catalogs using\n :py:meth:`~morpheus.classifier.Classifier.catalog_from_classified`.\n\n For more examples, see the `documentation <https://morpheus-astro.readthedocs.io/>`_.\n \"\"\"\n\n __graph = None\n __session = None\n __X = tf.placeholder(tf.float32, shape=[None, 40, 40, 4])\n\n @staticmethod\n def classify(\n h: Union[np.ndarray, str] = None,\n j: Union[np.ndarray, str] = None,\n z: Union[np.ndarray, str] = None,\n v: Union[np.ndarray, str] = None,\n out_dir: str = None,\n batch_size: int = 1000,\n out_type: str = \"rank_vote\",\n gpus: List[int] = None,\n cpus: int = None,\n parallel_check_interval: float = 1,\n ) -> dict:\n \"\"\"Generates per-pixel classifications from input images.\n\n Args:\n h (Union[np.ndarray, str]): The H band image or the path to it\n j (Union[np.ndarray, str]): The J band image or the path to it\n v (Union[np.ndarray, str]): The V band image or the path to it\n z (Union[np.ndarray, str]): The Z band image or the path to it\n out_dir (str): If provided, a directory to save the output to\n batch_size (int): The size of the batches to use when classifying the input\n out_type (str): The method by which to aggregate classifications\n for a single pixel. Can be one of \"rank_vote\",\n \"mean_var\", or \"both\"\n gpus (List[int]): The GPU ids to use for parallel classification\n the ids can be found using ``nvidia-smi``\n cpus (int): The number of cpus to use for parallel classification.\n parallel_check_interval (float): If running a parallel job, how often\n to check on the running sub-processes\n in minutes.\n\n Returns:\n Dictionary containing the classification output for the given input\n\n Raises:\n ValueError if both gpus and cpus are given\n ValueError if mixed string and numpy arrays are given for h, j, v, z\n ValueError if h, j, v, or z are None\n \"\"\"\n\n Classifier._variables_not_none([\"h\", \"j\", \"v\", \"z\"], [h, j, v, z])\n are_files = Classifier._valid_input_types_is_str(h, j, v, z)\n workers, is_gpu = Classifier._validate_parallel_params(gpus, cpus)\n\n if are_files:\n hduls, [h, j, v, z] = Classifier._parse_files(h, j, v, z)\n\n if out_dir is None:\n out_dir = \".\"\n else:\n hduls = []\n\n if len(workers) == 1:\n classified = Classifier._classify_arrays(\n h=h,\n j=j,\n v=v,\n z=z,\n out_type=out_type,\n out_dir=out_dir,\n batch_size=batch_size,\n )\n else:\n if out_dir is None:\n out_dir = \".\"\n Classifier._build_parallel_classification_structure(\n [h, j, v, z], workers, batch_size, out_dir, out_type\n )\n Classifier._run_parallel_jobs(\n workers, is_gpu, out_dir, parallel_check_interval\n )\n Classifier._stitch_parallel_classifications(workers, out_dir, out_type)\n\n classification_hduls, classified = Classifier._retrieve_classifications(\n out_dir, out_type\n )\n\n hduls.extend(classification_hduls)\n\n for hdul in hduls:\n hdul.close()\n\n return classified\n\n @staticmethod\n def catalog_from_classified(\n classified: dict,\n flux: np.ndarray,\n segmap: np.ndarray,\n aggregation_scheme: Callable = None,\n out_file: str = None,\n ) -> List[Dict]:\n \"\"\"Creates a catalog of sources and their morphologies.\n\n Args:\n classified (dict): A dictionary containing the output from morpheus.\n flux (np.ndarray): The corresponding flux image in H band\n segmap (np.ndarray): A labeled segmap where every pixel with a\n value > 0 is associated with a source.\n aggregation_scheme (func): Function that takes three arguments `classified`,\n `flux`, and `segmap`, same as this\n function, then returns a numpy array\n containing the morphological classification\n in the following order-spheroid, disk,\n irregular, and point source/compact. If\n None, then the flux weighting scheme\n in\n out_file (str): a location to save the catalog. Can either be .csv\n or .json. Anything else will raise a ValueError.\n\n\n Returns:\n A JSON-compatible list of dictionary objects with the following keys:\n {\n 'id': the id from the segmap\n 'location': a (y,x) location -- the max pixel within the segmap\n 'morphology': a dictionary containing the morphology values.\n }\n \"\"\"\n\n if out_file:\n if out_file.endswith((\".csv\", \".json\")):\n is_csv = out_file.endswith(\".csv\")\n else:\n raise ValueError(\"out_file must end with .csv or .json\")\n\n if aggregation_scheme is None:\n aggregation_scheme = Classifier.aggregation_scheme_flux_weighted\n\n catalog = []\n\n for region in regionprops(segmap, flux):\n _id = region.label\n\n if _id < 1:\n continue\n\n img = region.intensity_image\n seg = region.filled_image\n\n start_y, start_x, end_y, end_x = region.bbox\n dat = {}\n for k in classified:\n dat[k] = classified[k][start_y:end_y, start_x:end_x].copy()\n\n classification = aggregation_scheme(dat, img, seg)\n\n masked_flux = img * seg\n\n # https://stackoverflow.com/a/3584260\n y, x = np.unravel_index(masked_flux.argmax(), masked_flux.shape)\n y, x = int(start_y + y), int(start_x + x)\n\n catalog.append(\n {\"id\": _id, \"location\": [y, x], \"morphology\": classification}\n )\n\n if out_file:\n with open(out_file, \"w\") as f:\n if is_csv:\n f.write(\"source_id,y,x,sph,dsk,irr,ps\\n\")\n\n for c in catalog:\n csv = \"{},{},{},{},{},{},{}\\n\"\n f.write(\n csv.format(\n c[\"id\"],\n c[\"location\"][0],\n c[\"location\"][1],\n c[\"morphology\"][0],\n c[\"morphology\"][1],\n c[\"morphology\"][2],\n c[\"morphology\"][3],\n )\n )\n else:\n json.dump(catalog, f)\n\n return catalog\n\n # TODO: make the output file with the FITS helper if the output dir is used.\n @staticmethod\n def segmap_from_classified(\n classified: dict,\n flux: np.ndarray,\n bkg_src_threshold: float = 0.0,\n out_dir: str = None,\n min_distance: int = 20,\n mask: np.ndarray = None,\n deblend: bool = True,\n ) -> np.ndarray:\n \"\"\"Generate a segmentation map from the classification output.\n\n For more information about the segmentation process, see:\n https://arxiv.org/abs/1906.11248\n\n Args:\n data (dict): A dictionary containing the output from morpheus.\n flux (np.ndarray): The flux to use when making the segmap\n bkg_src_threshold (float): The max value that a background\n classification pixel can take and be\n considered a source. The default is 0.\n Should be between [0,1]\n out_dir (str): A path to save the segmap in.\n min_distance (int): The minimum distance for deblending\n mask (np.ndarry): A boolean mask indicating which pixels\n deblend (bool): If ``True``, perform deblending as described in 2.\n in the algorithm description. If ``False`` return\n segmap without deblending.\n\n Returns:\n A np.ndarray segmentation map\n \"\"\"\n if bkg_src_threshold < 0 or bkg_src_threshold >= 1:\n err_msg = [\n \"Invalid value for `bkg_src_threshold`, use a value in the \",\n \"range [0, 1)\",\n ]\n\n raise ValueError(err_msg)\n\n bkg = classified[\"background\"]\n markers = np.zeros_like(flux, dtype=np.uint8)\n\n print(\"Building Markers...\")\n if mask is None:\n mask = classified[\"n\"] > 0\n\n is_bkg = np.logical_and(bkg == 1, mask)\n is_src = np.logical_and(bkg <= bkg_src_threshold, mask)\n\n markers[is_bkg] = 1\n markers[is_src] = 2\n\n sobel_img = sobel(bkg)\n\n print(\"Watershedding...\")\n segmented = watershed(sobel_img, markers, mask=mask) - 1\n segmented[np.logical_not(mask)] = 0\n\n labeled, _ = ndi.label(segmented)\n\n labeled[np.logical_not(mask)] = -1\n\n if deblend:\n labeled = Classifier._deblend(labeled, flux, min_distance)\n\n if out_dir:\n fits.PrimaryHDU(data=labeled).writeto(os.path.join(out_dir, \"segmap.fits\"))\n\n return labeled\n\n @staticmethod\n def colorize_classified(\n classified: dict, out_dir: str = None, hide_unclassified: bool = True\n ) -> np.ndarray:\n \"\"\"Makes a color image from the classification output.\n\n The colorization scheme is defined in HSV and is as follows:\n\n * Spheroid = Red\n * Disk = Blue\n * Irregular = Green\n * Point Source = Yellow\n\n The hue is set to be the color associated with the highest ranked class\n for a given pixel. The saturation is set to be the difference between the\n highest ranked class and the second highest ranked class for a given\n pixel. For example, if the top two classes have nearly equal values given\n by the classifier, then the saturation will be low and the pixel will\n appear more white. If the top two classes have very different\n values, then the saturation will be high and the pixel's color will be\n vibrant and not white. The value for a pixel is set to be 1-bkg, where\n bkg is value given to the background class. If the background class has\n a high value, then the pixel will appear more black. If the background\n value is low, then the pixel will take on the color given by the hue and\n saturation values.\n\n Args:\n data (dict): A dictionary containing the output from Morpheus.\n out_dir (str): a path to save the image in.\n hide_unclassified (bool): If true, black out the edges of the image\n that are unclassified. If false, show the\n borders as white.\n\n Returns:\n A [width, height, 3] array representing the RGB image.\n \"\"\"\n red = 0.0 # spheroid\n blue = 0.7 # disk\n yellow = 0.18 # point source\n green = 0.3 # irregular\n\n shape = classified[\"n\"].shape\n\n colors = np.array([red, blue, green, yellow])\n morphs = np.dstack(\n [classified[i] for i in helpers.LabelHelper.MORPHOLOGIES[:-1]]\n )\n ordered = np.argsort(-morphs, axis=-1)\n\n hues = np.zeros(shape)\n sats = np.zeros(shape)\n vals = 1 - classified[\"background\"]\n\n # the classifier doesn't return values for this area so black it out\n if hide_unclassified:\n vals[0:5, :] = 0\n vals[-5:, :] = 0\n vals[:, 0:5] = 0\n vals[:, -5:] = 0\n\n for i in tqdm(range(shape[0])):\n for j in range(shape[1]):\n hues[i, j] = colors[ordered[i, j, 0]]\n sats[i, j] = (\n morphs[i, j, ordered[i, j, 0]] - morphs[i, j, ordered[i, j, 1]]\n )\n\n hsv = np.dstack([hues, sats, vals])\n rgb = hsv_to_rgb(hsv)\n\n if out_dir:\n png = (rgb * 255).astype(np.uint8)\n imageio.imwrite(os.path.join(out_dir, \"colorized.png\"), png)\n\n return rgb\n\n @staticmethod\n def _retrieve_classifications(\n out_dir: str, out_type: str\n ) -> Tuple[List[fits.HDUList], dict]:\n\n f_names = []\n for morph in helpers.LabelHelper.MORPHOLOGIES:\n if out_type in [\"mean_var\", \"both\"]:\n f_names.extend(\n [\n os.path.join(out_dir, f\"{morph}_mean.fits\"),\n os.path.join(out_dir, f\"{morph}_var.fits\"),\n ]\n )\n if out_type in [\"rank_vote\", \"both\"]:\n f_names.append(os.path.join(out_dir, f\"{morph}.fits\"))\n\n f_names.append(os.path.join(out_dir, \"n.fits\"))\n\n hduls, arrs = helpers.FitsHelper.get_files(f_names)\n\n classified = {\n os.path.split(n)[1].replace(\".fits\", \"\"): a for n, a in zip(f_names, arrs)\n }\n\n return hduls, classified\n\n @staticmethod\n def _valid_input_types_is_str(\n h: Union[np.ndarray, str] = None,\n j: Union[np.ndarray, str] = None,\n z: Union[np.ndarray, str] = None,\n v: Union[np.ndarray, str] = None,\n ):\n in_types = {type(val) for val in [h, j, z, v]}\n\n if len(in_types) > 1:\n raise ValueError(\n \"Mixed input type usuage. Ensure all are numpy arrays or strings.\"\n )\n\n t = in_types.pop()\n\n if t in [np.ndarray, str]:\n return t == str\n else:\n raise ValueError(\"Input type must either be numpy array or string\")\n\n # NEW API ==================================================================\n\n @staticmethod\n def _classify_arrays(\n h: np.ndarray = None,\n j: np.ndarray = None,\n z: np.ndarray = None,\n v: np.ndarray = None,\n out_dir: str = None,\n batch_size: int = 1000,\n out_type: str = \"rank_vote\",\n ) -> Dict:\n \"\"\"Classify numpy arrays using Morpheus.\n\n Args:\n h (np.ndarray): the H band values for an image\n j (np.ndarray): the J band values for an image\n z (np.ndarray): the Z band values for an image\n v (np.ndarray): the V band values for an image\n out_dir (str): The location where to save the output files\n if None returns the output in memory only.\n batch_size (int): the number of image sections blackto process at a time\n out_type (str): how to process the output from Morpheus. If\n 'mean_var' record output using mean and variance, If\n 'rank_vote' record output as the normalized vote\n count. If 'both' record both outputs.\n\n Returns:\n A dictionary containing the output classifications.\n\n Raises:\n ValueError if out_type is not one of ['mean_var', 'rank_vote', 'both']\n \"\"\"\n Classifier._variables_not_none([\"h\", \"j\", \"z\", \"v\"], [h, j, z, v])\n Classifier._arrays_same_size([h, j, z, v])\n\n if out_type not in [\"mean_var\", \"rank_vote\", \"both\"]:\n raise ValueError(\"Invalid value for `out_type`\")\n\n mean_var = out_type in [\"mean_var\", \"both\"]\n rank_vote = out_type in [\"rank_vote\", \"both\"]\n\n shape = h.shape\n\n hduls = []\n data = {}\n if out_dir:\n if mean_var:\n hs, ds = helpers.FitsHelper.create_mean_var_files(shape, out_dir)\n hduls.extend(hs)\n data.update(ds)\n if rank_vote:\n hs, ds = helpers.FitsHelper.create_rank_vote_files(shape, out_dir)\n hduls.extend(hs)\n data.update(ds)\n\n hs, ds = helpers.FitsHelper.create_n_file(shape, out_dir)\n hduls.extend(hs)\n data.update(ds)\n else:\n if mean_var:\n data.update(helpers.LabelHelper.make_mean_var_arrays(shape))\n if rank_vote:\n data.update(helpers.LabelHelper.make_rank_vote_arrays(shape))\n\n data.update(helpers.LabelHelper.make_n_array(shape))\n\n indicies = helpers.LabelHelper.windowed_index_generator(*shape)\n\n window_y, window_x = helpers.LabelHelper.UPDATE_MASK_N.shape\n batch_estimate = shape[0] - window_y + 1\n batch_estimate *= shape[1] - window_x + 1\n batch_estimate = batch_estimate // batch_size\n pbar = tqdm(total=batch_estimate, desc=\"classifying\", unit=\"batch\")\n\n while True:\n batch = []\n batch_idx = []\n\n for _ in range(batch_size):\n try:\n y, x = next(indicies)\n except StopIteration:\n break\n\n combined = np.array(\n [img[y : y + window_y, x : x + window_x] for img in [h, j, v, z]]\n )\n batch.append(Classifier._standardize_img(combined))\n batch_idx.append((y, x))\n\n if not batch:\n break\n\n batch = np.array(batch)\n\n labels = Classifier._call_morpheus(batch)\n\n helpers.LabelHelper.update_labels(data, labels, batch_idx, out_type)\n\n pbar.update()\n\n if rank_vote:\n helpers.LabelHelper.finalize_rank_vote(data)\n\n for hdul in hduls:\n hdul.close()\n\n return data\n\n @staticmethod\n def _standardize_img(img: np.ndarray) -> np.ndarray:\n \"\"\"Standardizes an input img to mean 0 and unit variance.\n\n Uses the formula described in:\n\n https://www.tensorflow.org/api_docs/python/tf/image/per_image_standardization\n\n Args:\n img (np.ndarray): the input array to standardize\n\n Returns:\n The standardized input\n \"\"\"\n num = img - img.mean()\n denom = max(img.std(), 1 / np.sqrt(np.prod(img.shape)))\n return num / denom\n\n @staticmethod\n def _arrays_same_size(arrays: List[np.ndarray]) -> None:\n \"\"\"Verifies that all arrays are the same shape.\n\n Args:\n arrays (List[np.ndarray]): List of arrays that should have the same\n shape.\n\n Returns:\n None\n\n Raises:\n ValueError if arrays are not the same shape\n \"\"\"\n\n arr_shapes = [a.shape for a in arrays]\n\n arr_comp = arr_shapes[0]\n arr_to_comp = arr_shapes[1:]\n\n if not np.array_equiv(arr_comp, arr_to_comp):\n raise ValueError(f\"All shapes not the same: {arr_shapes}.\")\n\n @staticmethod\n def _variables_not_none(names: List[str], values: List[np.ndarray]) -> None:\n \"\"\"Verifies that all variables are not None.\n\n Args:\n names (List[str]): list of names of variables in the same order as\n `values`\n names (List[np.ndarray]): list of numpy arrays that should not be\n None\n\n Returns:\n None\n\n Raises:\n ValueError if a variable is None\n\n \"\"\"\n\n nones = []\n for name, value in zip(names, values):\n if value is None:\n nones.append(name)\n\n if nones:\n raise ValueError(\"{} should not be None\".format(nones))\n\n @staticmethod\n def _parse_files(\n h: str, j: str, v: str, z: str\n ) -> Tuple[List[fits.HDUList], List[np.ndarray]]:\n \"\"\"Validates that files exist. And returns the corresponding arrays.\n\n Args:\n h (str): the file location of the H band img\n j (str): the file location of the J band img\n v (str): the file location of the V band img\n z (str): the file location of the Z bnad img\n\n Returns:\n A tuple containing the a (List[HDUL], List[np.ndarray])\n\n Raises:\n ValueError if a variable is None\n\n \"\"\"\n Classifier._variables_not_none([\"h\", \"j\", \"z\", \"v\"], [h, j, z, v])\n\n return helpers.FitsHelper.get_files([h, j, v, z])\n\n @staticmethod\n def _call_morpheus(batch: np.ndarray) -> np.ndarray:\n \"\"\"Use morpheus to classify a batch of input values.\n\n Morpheus is called as a singleton using this method.\n\n Args:\n batch (np.ndarray): The input data in the shape\n [batch, channels, width, height]\n\n Returns:\n The classified numpy array with shape [batch, width, height, channels]\n\n \"\"\"\n batch = np.transpose(batch, axes=[0, 2, 3, 1])\n\n if Classifier.__graph is None:\n config = model.Morpheus.inference_hparams()\n inference_dataset = model.Morpheus.mock_dataset()\n\n # build graph\n m = model.Morpheus(config, inference_dataset, \"channels_last\")\n Classifier.__graph = m.inference(Classifier.__X)\n\n # get weights\n saver = tf.train.Saver()\n Classifier.__session = tf.Session()\n w_location = model.Morpheus.get_weights_dir()\n saver.restore(Classifier.__session, tf.train.latest_checkpoint(w_location))\n\n return Classifier.__session.run(\n Classifier.__graph, feed_dict={Classifier.__X: batch}\n )\n\n @staticmethod\n def _get_split_length(shape: List[int], num_workers: int) -> int:\n \"\"\"Calculate the size of the sub images for classification.\n\n Args:\n shape (List[int]): the shape of the array to be split\n num_workers (int): the number of splits to make\n\n Returns:\n The length of each split along axis 0\n\n TODO: Implement splits along other axes\n \"\"\"\n\n return (shape[0] + (num_workers - 1) * 40) // num_workers\n\n @staticmethod\n def _get_split_slice_generator(\n shape: Tuple[int], num_workers: int, slice_length: int\n ) -> Iterable[slice]:\n \"\"\"Creates a generator that yields `slice` objects to split imgs.\n\n Args:\n shape (Tuple[int]): The shape of the array to be split\n num_workers (int): The number of splits to make\n split_length (int): The length each slice should be\n\n Returns\n A generator that yields slice objects\n\n TODO: Implement splits along other axes\n \"\"\"\n\n idx = 0\n for i in range(num_workers):\n start_idx = max(idx - 39, 0)\n\n if i == num_workers - 1:\n end_idx = shape[0]\n else:\n end_idx = start_idx + slice_length - 1\n\n idx = end_idx\n\n yield slice(start_idx, end_idx)\n\n @staticmethod\n def _make_runnable_file(\n path: str, batch_size: int = 1000, out_type: str = \"rank_vote\"\n ) -> None:\n \"\"\"Creates a file at `path` that classfies local FITS files.\n\n Args:\n path (str): The dir to save the file in\n batch_size (int): The batch size for Morpheus to use when classifying\n the input\n out_type (str): how to process the output from Morpheus. If\n 'mean_var' record output using mean and variance, If\n 'rank_vote' record output as the normalized vote\n count. If 'both' record both outputs.\n\n Returns:\n None\n \"\"\"\n\n local = os.path.dirname(os.path.dirname(__file__))\n text = [\n \"import sys\",\n f'sys.path.append(\"{local}\")',\n \"import os\",\n \"import numpy as np\",\n \"from tqdm import tqdm\",\n \"from morpheus.classifier import Classifier\",\n \"def main():\",\n \" data_dir = '.'\",\n \" output_dir = './output'\",\n \" if 'output' not in os.listdir():\",\n \" os.mkdir('./output')\",\n \" files = {\",\n \" 'h':os.path.join(data_dir, 'h.fits'),\",\n \" 'j':os.path.join(data_dir, 'j.fits'),\",\n \" 'v':os.path.join(data_dir, 'v.fits'),\",\n \" 'z':os.path.join(data_dir, 'z.fits')\",\n \" }\",\n \" Classifier.classify(h=files['h'],\",\n \" j=files['j'],\",\n \" v=files['v'],\",\n \" z=files['z'],\",\n f\" batch_size={batch_size},\",\n f' out_type=\"{out_type}\",',\n \" out_dir=output_dir)\",\n \" sys.exit(0)\",\n \"if __name__=='__main__':\",\n \" main()\",\n ]\n\n with open(os.path.join(path, \"main.py\"), \"w\") as f:\n f.write(\"\\n\".join(text))\n\n @staticmethod\n def _build_parallel_classification_structure(\n arrs: List[np.ndarray],\n workers: List[int],\n batch_size: int,\n out_dir: str,\n out_type: str,\n ) -> None:\n \"\"\"Sets up the subdirs and files to run the parallel classification.\n\n Args:\n arrs (List[np.ndarray]): List of arrays to split up in the order HJVZ\n workers (List[int]): A list of worker ID's that can either be CUDA GPU\n ID's or a list dummy numbers for cpu workers\n batch_size (int): The batch size for Morpheus to use when classifying\n the input.\n out_dir (str): the location to place the subdirs in\n\n Returns:\n None\n \"\"\"\n\n shape = arrs[0].shape\n num_workers = len(workers)\n split_slices = Classifier._get_split_slice_generator(\n shape, num_workers, Classifier._get_split_length(shape, num_workers)\n )\n\n for worker, split_slice in tqdm(zip(sorted(workers), split_slices)):\n sub_output_dir = os.path.join(out_dir, str(worker))\n os.mkdir(sub_output_dir)\n\n for name, data in zip([\"h\", \"j\", \"v\", \"z\"], arrs):\n tmp_location = os.path.join(sub_output_dir, \"{}.fits\".format(name))\n fits.PrimaryHDU(data=data[split_slice, :]).writeto(tmp_location)\n\n Classifier._make_runnable_file(sub_output_dir, batch_size, out_type)\n\n @staticmethod\n def _stitch_parallel_classifications(\n workers: List[int], out_dir: str, out_type: str\n ) -> None:\n \"\"\"Stitch the seperate outputs made from the parallel classifications.\n\n Args:\n workers (List[int]): A list of worker ID's that can either be CUDA GPU\n ID's or a list dummy numbers for cpu workers\n out_dir (str): the location that contains the parallel classified\n subdirs\n out_type (str): how to process the output from Morpheus. If\n 'mean_var' record output using mean and variance, If\n 'rank_vote' record output as the normalized vote\n count. If 'both' record both outputs.\n\n Returns:\n None\n \"\"\"\n jobs = []\n if out_type in [\"mean_var\", \"both\"]:\n jobs.append(\"mean_var\")\n if out_type in [\"rank_vote\", \"both\"]:\n jobs.append(\"rank_vote\")\n\n for morph in helpers.LabelHelper.MORPHOLOGIES:\n for job in jobs:\n if job == \"mean_var\":\n to_be_stitched = []\n for worker_id in workers: # each worker was assinged a dir by id\n dir_list = [out_dir, str(worker_id), \"output\"]\n f_mean = os.path.join(*(dir_list + [f\"{morph}_mean.fits\"]))\n f_var = os.path.join(*(dir_list + [f\"{morph}_var.fits\"]))\n f_n = os.path.join(*(dir_list + [\"n.fits\"]))\n\n to_be_stitched.append(\n (\n fits.getdata(f_mean),\n fits.getdata(f_var),\n fits.getdata(f_n),\n )\n )\n\n new_y = sum(t[0].shape[0] for t in to_be_stitched)\n new_y -= 39 * (len(to_be_stitched) - 1)\n\n new_x = to_be_stitched[0][0].shape[1]\n\n combined_mean = np.zeros(shape=[new_y, new_x], dtype=np.float32)\n combined_var = np.zeros(shape=[new_y, new_x], dtype=np.float32)\n combined_n = np.zeros(shape=[new_y, new_x], dtype=np.float32)\n\n start_y = 0\n for new_mean, new_var, new_n in to_be_stitched:\n Classifier._merge_parallel_means_vars(\n combined_mean,\n combined_var,\n combined_n,\n new_mean,\n new_var,\n new_n,\n start_y,\n )\n\n start_y += new_n.shape[0] - 39\n\n to_write = [\n (combined_mean, f\"{morph}_mean.fits\"),\n (combined_var, f\"{morph}_var.fits\"),\n (combined_n, \"n.fits\"),\n ]\n\n for f, n in to_write:\n fits.PrimaryHDU(data=f).writeto(\n os.path.join(out_dir, n), overwrite=True\n )\n\n if job == \"rank_vote\":\n to_be_stitched = []\n for worker_id in workers: # each worker was assinged a dir by id\n dir_list = [out_dir, str(worker_id), \"output\"]\n f_votes = os.path.join(*(dir_list + [f\"{morph}.fits\"]))\n f_n = os.path.join(*(dir_list + [\"n.fits\"]))\n\n to_be_stitched.append(\n (fits.getdata(f_votes), fits.getdata(f_n))\n )\n\n new_y = sum(t[0].shape[0] for t in to_be_stitched)\n new_y -= 39 * (len(to_be_stitched) - 1)\n\n new_x = to_be_stitched[0][0].shape[1]\n\n combined_votes = np.zeros(shape=[new_y, new_x], dtype=np.float32)\n combined_n = np.zeros(shape=[new_y, new_x], dtype=np.float32)\n\n start_y = 0\n for new_votes, new_n in to_be_stitched:\n Classifier._merge_parallel_rank_votes(\n combined_votes, combined_n, new_votes, new_n, start_y\n )\n\n start_y += new_n.shape[0] - 39\n\n to_write = [\n (combined_votes, f\"{morph}.fits\"),\n (combined_n, \"n.fits\"),\n ]\n\n for f, n in to_write:\n fits.PrimaryHDU(data=f).writeto(\n os.path.join(out_dir, n), overwrite=True\n )\n\n @staticmethod\n def _merge_parallel_means_vars(\n total_mean: np.ndarray,\n total_var: np.ndarray,\n total_n: np.ndarray,\n new_mean: np.ndarray,\n new_var: np.ndarray,\n new_n: np.ndarray,\n y_idx: int,\n ) -> None:\n \"\"\"Merge merge means/vars from a new piece to total.\n\n Derived from:\n https://www.emathzone.com/tutorials/basic-statistics/combined-variance.html\n\n Args:\n total (np.ndarray): The array of means to add ``new`` to\n total_n (np.ndarray): The array of counts to add ``new_n`` to\n new (np.ndarray): the new means to add to ``total``\n new_n (np.ndarray): the new counts to add to ``total``\n y_idx (int): index for placement of ``new`` into ``total`` along y axis\n\n Returns:\n None\n \"\"\"\n ys = slice(y_idx, y_idx + new_mean.shape[0])\n\n x1, x2 = total_mean[ys, :].copy(), new_mean.copy()\n s1, s2 = total_var[ys, :].copy(), new_var.copy()\n n1, n2 = total_n[ys, :].copy(), new_n.copy()\n\n denominator = n1 + n2\n\n xc_numerator = n1 * x1 + n2 * x2\n xc = np.where(denominator > 0, xc_numerator / denominator, 0)\n\n sc_numerator = (n1 * (s1 + np.square(x1 - xc))) + (\n n2 * (s2 + np.square(x2 - xc))\n )\n sc = np.where(denominator > 0, sc_numerator / denominator, 0)\n\n total_mean[ys, :] = xc\n total_var[ys, :] = sc\n total_n[ys, :] = denominator\n\n @staticmethod\n def _merge_parallel_rank_votes(\n total_votes: np.ndarray,\n total_n: np.ndarray,\n new_votes: np.ndarray,\n new_n: np.ndarray,\n y_idx: int,\n ) -> None:\n \"\"\"Merge vote counts from a new piece to total\n\n Args:\n total_count (np.ndarray): The array of votes to add ``new`` to\n total_n (np.ndarray): The array of counts to add ``new_n`` to\n new_votes (np.ndarray): The array of votes to add to ``total``\n new_n (np.ndarray): The array of counts to add to ``new``\n y_idx (int): index for placement pf ``new`` into ``total`` along y axis\n\n Returns:\n None\n \"\"\"\n ys = slice(y_idx, y_idx + new_votes.shape[0])\n\n x1, x2 = total_votes[ys, :].copy(), new_votes.copy()\n n1, n2 = total_n[ys, :].copy(), new_n.copy()\n\n numerator = (n1 * x1) + (n2 * x2)\n denominator = n1 + n2\n mean = np.where(denominator > 0, numerator / denominator, 0)\n\n total_votes[ys, :] = mean\n total_n[ys, :] = denominator\n\n # TODO: Add an informative output.\n @staticmethod\n def _run_parallel_jobs(\n workers: List[int], is_gpu: bool, out_dir: str, parallel_check_interval: float\n ) -> None:\n \"\"\"Starts and tracks parallel job runs.\n\n WARNING: This will not finish running until all subprocesses are complete\n\n Args:\n workers (List[int]): A list of worker ID's to assign to a portion of an\n image.\n is_gpu (bool): if True the worker ID's belong to NVIDIA GPUs and will\n be used as an argument in CUDA_VISIBLE_DEVICES. If False,\n then the ID's are assocaited with CPU workers\n out_dir (str): the location with the partitioned data\n parallel_check_interval (float): If gpus are given, then this is the number\n of minutes to wait between polling each\n subprocess for completetion\n\n Returns:\n None\n \"\"\"\n\n processes = {}\n\n for worker in workers:\n if is_gpu:\n cmd_string = f\"CUDA_VISIBLE_DEVICES={worker} python main.py\"\n else:\n cmd_string = f\"CUDA_VISIBLE_DEVICES=-1 python main.py\"\n\n sub_dir = os.path.join(out_dir, str(worker))\n processes[worker] = Popen(cmd_string, shell=True, cwd=sub_dir)\n\n is_running = np.ones([len(workers)], dtype=np.bool)\n while is_running.any():\n for i, g in enumerate(sorted(workers)):\n if is_running[i] and (processes[g].poll() is not None):\n is_running[i] = False\n\n if is_running.any():\n time.sleep(parallel_check_interval * 60)\n else: # we're done we can skip sleep\n break\n\n @staticmethod\n def _validate_parallel_params(\n gpus: List[int] = None, cpus: int = None\n ) -> Tuple[List[int], bool]:\n \"\"\"Validates that the parallelism scheme.\n\n Only one of the arguments should be given.\n\n Args:\n gpus (List[int]): A list of the CUDA gpu ID's to use for a\n parallel classification.\n cpus (int): Number of cpus to use foa a parallel classification\n\n Returns:\n A tuple containing the list of worker ids and a boolean indicating\n wheter or not the ids belong to GPUS\n\n Raises:\n ValueError if both cpus and gpus are not None\n \"\"\"\n\n # invalid params\n if (gpus is not None) and (cpus is not None):\n raise ValueError(\"Please only give a value cpus or gpus, not both.\")\n\n # Simple serial run\n if (gpus is None) and (cpus is None):\n return [0], False\n\n if gpus is not None:\n if len(gpus) == 1:\n err = \"Only one gpus indicated. If you are trying to select \"\n err += \"a single gpu, then use the CUDA_VISIBLE_DEVICES environment \"\n err += \"variable. For more information visit: \"\n err += \"https://devblogs.nvidia.com/cuda-pro-tip-control-gpu-visibility-cuda_visible_devices/\"\n\n raise ValueError(err)\n else:\n return gpus, True\n else:\n if cpus < 2:\n raise ValueError(\n \"If passing cpus please indicate a value greater than 1.\"\n )\n\n return np.arange(cpus), False\n\n @staticmethod\n def _deblend(segmap: np.ndarray, flux: np.ndarray, min_distance: int) -> np.ndarray:\n \"\"\"Deblends a segmentation map according to the description in make_segmap.\n\n Args:\n segmap (np.ndarray): The segmentation map image to deblend\n flux (np.ndarray): The corresponding flux image in H band\n min_distance (int): The radius of the PSF for the instrument used on H band\n\n Returns:\n A np.ndarray representing the deblended segmap\n \"\"\"\n\n max_id = segmap.max()\n\n for region in tqdm(regionprops(segmap, flux), desc=\"Deblending\"):\n\n # greater than 1 indicates that the region is not background\n if region.label > 0:\n flx = region.intensity_image\n seg = region.filled_image\n flux_map = flx * seg\n\n maxes = peak_local_max(\n flux_map, min_distance=min_distance, num_peaks=20\n )\n\n # more than 1 source found, deblend\n if maxes.shape[0] > 1:\n start_y, start_x, end_y, end_x = region.bbox\n markers = np.zeros_like(seg, dtype=np.int)\n\n for y, x in maxes:\n max_id += 1\n markers[y, x] = max_id\n\n deblended = watershed(-flux_map, markers, mask=seg)\n\n local_segmap = segmap[start_y:end_y, start_x:end_x].copy()\n local_segmap = np.where(seg, deblended, local_segmap)\n segmap[start_y:end_y, start_x:end_x] = local_segmap\n\n return segmap\n\n @staticmethod\n def aggregation_scheme_flux_weighted(\n data: dict, flux: np.ndarray, segmap: np.ndarray\n ) -> List[float]:\n \"\"\"Aggregates pixel level morphological classifications to the source level.\n\n Uses a flux-weighted mean of the pixel level morphologies to calculate\n the aggregate source level morphology.\n\n Args:\n data (dict): A dictionary containing the output from morpheus.\n flux (np.ndarray): The corresponding flux image in H band\n segmap (int): The binary map indicating pixels that belong to the\n source\n\n Returns:\n The morphological classification as a list of floats in the\n following order: ['spheroid', 'disk', 'irregular', 'point source']\n \"\"\"\n classifications = np.zeros([4])\n\n morphs = [\"spheroid\", \"disk\", \"irregular\", \"point_source\"]\n\n morphs = [data[m] for m in morphs]\n\n for i, m in enumerate(morphs):\n classifications[i] = np.mean(m[segmap] * flux[segmap])\n\n return (classifications / classifications.sum()).tolist()\n"
] | [
[
"numpy.argsort",
"numpy.dstack",
"tensorflow.compat.v1.disable_eager_execution",
"tensorflow.compat.v1.placeholder",
"tensorflow.compat.v1.train.Saver",
"numpy.transpose",
"numpy.logical_and",
"numpy.logical_not",
"numpy.where",
"numpy.mean",
"tensorflow.compat.v1.Session",
"scipy.ndimage.label",
"numpy.zeros",
"matplotlib.colors.hsv_to_rgb",
"numpy.array_equiv",
"numpy.arange",
"numpy.prod",
"numpy.square",
"numpy.zeros_like",
"tensorflow.compat.v1.train.latest_checkpoint",
"numpy.array"
]
] |
KDD2022-MSCMT/MSCMT | [
"6a3e1e6230aa519a57345f6dbb0731b3ed6fe1ce"
] | [
"object_detector/mrcnn/config.py"
] | [
"\n\nimport math\nimport numpy as np\n\n\n# Base Configuration Class\n# Don't use this class directly. Instead, sub-class it and override\n# the configurations you need to change.\n\nclass Config(object):\n \"\"\"Base configuration class. For custom configurations, create a\n sub-class that inherits from this one and override properties\n that need to be changed.\n \"\"\"\n # Name the configurations. For example, 'COCO', 'Experiment 3', ...etc.\n # Useful if your code needs to do things differently depending on which\n # experiment is running.\n NAME = None # Override in sub-classes\n\n # NUMBER OF GPUs to use. For CPU training, use 1\n GPU_COUNT = 1\n\n # Number of images to train with on each GPU. A 12GB GPU can typically\n # handle 2 images of 1024x1024px.\n # Adjust based on your GPU memory and image sizes. Use the highest\n # number that your GPU can handle for best performance.\n IMAGES_PER_GPU = 2\n\n # Number of training steps per epoch\n # This doesn't need to match the size of the training set. Tensorboard\n # updates are saved at the end of each epoch, so setting this to a\n # smaller number means getting more frequent TensorBoard updates.\n # Validation stats are also calculated at each epoch end and they\n # might take a while, so don't set this too small to avoid spending\n # a lot of time on validation stats.\n STEPS_PER_EPOCH = 1000\n\n # Number of validation steps to run at the end of every training epoch.\n # A bigger number improves accuracy of validation stats, but slows\n # down the training.\n VALIDATION_STEPS = 50\n\n # Backbone network architecture\n # Supported values are: resnet50, resnet101\n BACKBONE = \"resnet101\"\n\n # The strides of each layer of the FPN Pyramid. These values\n # are based on a Resnet101 backbone.\n BACKBONE_STRIDES = [4, 8, 16, 32, 64]\n\n # Number of classification classes (including background)\n NUM_CLASSES = 1 # Override in sub-classes\n\n # Length of square anchor side in pixels\n RPN_ANCHOR_SCALES = (32, 64, 128, 256, 512)\n\n # Ratios of anchors at each cell (width/height)\n # A value of 1 represents a square anchor, and 0.5 is a wide anchor\n RPN_ANCHOR_RATIOS = [0.5, 1, 2]\n\n # Anchor stride\n # If 1 then anchors are created for each cell in the backbone feature map.\n # If 2, then anchors are created for every other cell, and so on.\n RPN_ANCHOR_STRIDE = 1\n\n # Non-max suppression threshold to filter RPN proposals.\n # You can increase this during training to generate more propsals.\n RPN_NMS_THRESHOLD = 0.7\n\n # How many anchors per image to use for RPN training\n RPN_TRAIN_ANCHORS_PER_IMAGE = 256\n\n # ROIs kept after non-maximum supression (training and inference)\n POST_NMS_ROIS_TRAINING = 2000\n POST_NMS_ROIS_INFERENCE = 1000\n\n # If enabled, resizes instance masks to a smaller size to reduce\n # memory load. Recommended when using high-resolution images.\n USE_MINI_MASK = True\n MINI_MASK_SHAPE = (56, 56) # (height, width) of the mini-mask\n\n # Input image resizing\n # Generally, use the \"square\" resizing mode for training and inferencing\n # and it should work well in most cases. In this mode, images are scaled\n # up such that the small side is = IMAGE_MIN_DIM, but ensuring that the\n # scaling doesn't make the long side > IMAGE_MAX_DIM. Then the image is\n # padded with zeros to make it a square so multiple images can be put\n # in one batch.\n # Available resizing modes:\n # none: No resizing or padding. Return the image unchanged.\n # square: Resize and pad with zeros to get a square image\n # of size [max_dim, max_dim].\n # pad64: Pads width and height with zeros to make them multiples of 64.\n # If IMAGE_MIN_DIM or IMAGE_MIN_SCALE are not None, then it scales\n # up before padding. IMAGE_MAX_DIM is ignored in this mode.\n # The multiple of 64 is needed to ensure smooth scaling of feature\n # maps up and down the 6 levels of the FPN pyramid (2**6=64).\n # crop: Picks random crops from the image. First, scales the image based\n # on IMAGE_MIN_DIM and IMAGE_MIN_SCALE, then picks a random crop of\n # size IMAGE_MIN_DIM x IMAGE_MIN_DIM. Can be used in training only.\n # IMAGE_MAX_DIM is not used in this mode.\n IMAGE_RESIZE_MODE = \"square\"\n IMAGE_MIN_DIM = 800\n IMAGE_MAX_DIM = 1024\n # Minimum scaling ratio. Checked after MIN_IMAGE_DIM and can force further\n # up scaling. For example, if set to 2 then images are scaled up to double\n # the width and height, or more, even if MIN_IMAGE_DIM doesn't require it.\n # Howver, in 'square' mode, it can be overruled by IMAGE_MAX_DIM.\n IMAGE_MIN_SCALE = 0\n\n # Image mean (RGB)\n MEAN_PIXEL = np.array([123.7, 116.8, 103.9])\n\n # Number of ROIs per image to feed to classifier/mask heads\n # The Mask RCNN paper uses 512 but often the RPN doesn't generate\n # enough positive proposals to fill this and keep a positive:negative\n # ratio of 1:3. You can increase the number of proposals by adjusting\n # the RPN NMS threshold.\n TRAIN_ROIS_PER_IMAGE = 200\n\n # Percent of positive ROIs used to train classifier/mask heads\n ROI_POSITIVE_RATIO = 0.33\n\n # Pooled ROIs\n POOL_SIZE = 7\n MASK_POOL_SIZE = 14\n\n # Shape of output mask\n # To change this you also need to change the neural network mask branch\n MASK_SHAPE = [28, 28]\n\n # Maximum number of ground truth instances to use in one image\n MAX_GT_INSTANCES = 100\n\n # Bounding box refinement standard deviation for RPN and final detections.\n RPN_BBOX_STD_DEV = np.array([0.1, 0.1, 0.2, 0.2])\n BBOX_STD_DEV = np.array([0.1, 0.1, 0.2, 0.2])\n\n # Max number of final detections\n DETECTION_MAX_INSTANCES = 100\n\n # Minimum probability value to accept a detected instance\n # ROIs below this threshold are skipped\n DETECTION_MIN_CONFIDENCE = 0.7\n\n # Non-maximum suppression threshold for detection\n DETECTION_NMS_THRESHOLD = 0.3\n\n # Learning rate and momentum\n # The Mask RCNN paper uses lr=0.02, but on TensorFlow it causes\n # weights to explode. Likely due to differences in optimzer\n # implementation.\n LEARNING_RATE = 0.001\n LEARNING_MOMENTUM = 0.9\n\n # Weight decay regularization\n WEIGHT_DECAY = 0.0001\n\n # Loss weights for more precise optimization.\n # Can be used for R-CNN training setup.\n LOSS_WEIGHTS = {\n \"rpn_class_loss\": 1.,\n \"rpn_bbox_loss\": 1.,\n \"mrcnn_class_loss\": 1.,\n \"mrcnn_bbox_loss\": 1.,\n \"mrcnn_mask_loss\": 1.\n }\n\n # Use RPN ROIs or externally generated ROIs for training\n # Keep this True for most situations. Set to False if you want to train\n # the head branches on ROI generated by code rather than the ROIs from\n # the RPN. For example, to debug the classifier head without having to\n # train the RPN.\n USE_RPN_ROIS = True\n\n # Train or freeze batch normalization layers\n # None: Train BN layers. This is the normal mode\n # False: Freeze BN layers. Good when using a small batch size\n # True: (don't use). Set layer in training mode even when inferencing\n TRAIN_BN = False # Defaulting to False since batch size is often small\n\n # Gradient norm clipping\n GRADIENT_CLIP_NORM = 5.0\n\n def __init__(self):\n \"\"\"Set values of computed attributes.\"\"\"\n # Effective batch size\n self.BATCH_SIZE = self.IMAGES_PER_GPU * self.GPU_COUNT\n\n # Input image size\n if self.IMAGE_RESIZE_MODE == \"crop\":\n self.IMAGE_SHAPE = np.array([self.IMAGE_MIN_DIM, self.IMAGE_MIN_DIM, 3])\n else:\n self.IMAGE_SHAPE = np.array([self.IMAGE_MAX_DIM, self.IMAGE_MAX_DIM, 3])\n\n # Image meta data length\n # See compose_image_meta() for details\n self.IMAGE_META_SIZE = 1 + 3 + 3 + 4 + 1 + self.NUM_CLASSES\n\n def display(self):\n \"\"\"Display Configuration values.\"\"\"\n print(\"\\nConfigurations:\")\n for a in dir(self):\n if not a.startswith(\"__\") and not callable(getattr(self, a)):\n print(\"{:30} {}\".format(a, getattr(self, a)))\n print(\"\\n\")\n"
] | [
[
"numpy.array"
]
] |
janEbert/pySDC | [
"167d78c4118bc3a5a446ec973fe65fb35db94471"
] | [
"pySDC/playgrounds/Boris/spiraling_particle_ProblemClass.py"
] | [
"\nimport numpy as np\n\nfrom pySDC.core.Problem import ptype\nfrom pySDC.implementations.datatype_classes.particles import particles, fields, acceleration\n\n\nclass planewave_single(ptype):\n \"\"\"\n Example implementing a single particle spiraling in a trap\n \"\"\"\n\n def __init__(self, cparams, dtype_u=particles, dtype_f=fields):\n \"\"\"\n Initialization routine\n\n Args:\n cparams: custom parameters for the example\n dtype_u: particle data type (will be passed parent class)\n dtype_f: fields data type (will be passed parent class)\n \"\"\"\n\n # these parameters will be used later, so assert their existence\n assert 'delta' in cparams # polarization\n assert 'a0' in cparams # normalized amplitude\n assert 'u0' in cparams # initial position and velocity\n\n # add parameters as attributes for further reference\n for k, v in cparams.items():\n setattr(self, k, v)\n\n # set nparts to one (lonely particle, you know)\n self.nparts = 1\n # invoke super init, passing nparts, dtype_u and dtype_f\n super(planewave_single, self).__init__(self.nparts, dtype_u, dtype_f, cparams)\n\n def eval_f(self, part, t):\n \"\"\"\n Routine to compute the electric and magnetic fields\n\n Args:\n t: current time\n part: the current particle\n Returns:\n E and B field for the particle (external only)\n \"\"\"\n\n f = self.dtype_f((3, self.nparts))\n\n R = np.linalg.norm(part.pos.values[:, 0], 2)\n f.elec.values[0, 0] = self.params.a0 / (R ** 3) * part.pos.values[0, 0]\n f.elec.values[1, 0] = self.params.a0 / (R ** 3) * part.pos.values[1, 0]\n f.elec.values[2, 0] = 0\n\n f.magn.values[0, 0] = 0\n f.magn.values[1, 0] = 0\n f.magn.values[2, 0] = R\n\n return f\n\n def u_init(self):\n \"\"\"\n Initialization routine for the single particle\n\n Returns:\n particle type\n \"\"\"\n\n u0 = self.params.u0\n # some abbreviations\n u = self.dtype_u((3, 1))\n\n u.pos.values[0, 0] = u0[0][0]\n u.pos.values[1, 0] = u0[0][1]\n u.pos.values[2, 0] = u0[0][2]\n\n u.vel.values[0, 0] = u0[1][0]\n u.vel.values[1, 0] = u0[1][1]\n u.vel.values[2, 0] = u0[1][2]\n\n u.q[:] = u0[2][0]\n u.m[:] = u0[3][0]\n\n return u\n\n def build_f(self, f, part, t):\n \"\"\"\n Helper function to assemble the correct right-hand side out of B and E field\n\n Args:\n f: wannabe right-hand side, actually the E field\n part: particle data\n t: current time\n Returns:\n correct RHS of type acceleration\n \"\"\"\n\n assert isinstance(part, particles)\n rhs = acceleration((3, self.nparts))\n rhs.values[:, 0] = part.q[:] / part.m[:] * \\\n (f.elec.values[:, 0] + np.cross(part.vel.values[:, 0], f.magn.values[:, 0]))\n\n return rhs\n\n def boris_solver(self, c, dt, old_fields, new_fields, old_parts):\n \"\"\"\n The actual Boris solver for static (!) B fields, extended by the c-term\n\n Args:\n c: the c term gathering the known values from the previous iteration\n dt: the (probably scaled) time step size\n old_fields: the field values at the previous node m\n new_fields: the field values at the current node m+1\n old_parts: the particles at the previous node m\n Returns:\n the velocities at the (m+1)th node\n \"\"\"\n\n N = self.nparts\n vel = particles.velocity((3, 1))\n\n Emean = 1.0 / 2.0 * (old_fields.elec + new_fields.elec)\n\n for n in range(N):\n a = old_parts.q[n] / old_parts.m[n]\n\n c.values[:, n] += dt / 2 * a * \\\n np.cross(old_parts.vel.values[:, n], old_fields.magn.values[:, n] - new_fields.magn.values[:, n])\n\n # pre-velocity, separated by the electric forces (and the c term)\n vm = old_parts.vel.values[:, n] + dt / 2 * a * Emean.values[:, n] + c.values[:, n] / 2\n # rotation\n t = dt / 2 * a * new_fields.magn.values[:, n]\n s = 2 * t / (1 + np.linalg.norm(t, 2) ** 2)\n vp = vm + np.cross(vm + np.cross(vm, t), s)\n # post-velocity\n vel.values[:, n] = vp + dt / 2 * a * Emean.values[:, n] + c.values[:, n] / 2\n\n return vel\n"
] | [
[
"numpy.cross",
"numpy.linalg.norm"
]
] |
sausagecy/Relation-Shape-CNN | [
"a91ac768cd720773359dda9b3e234815f88d88b4"
] | [
"utils/pointnet2_modules.py"
] | [
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nimport utils.pointnet2_utils as pointnet2_utils\nimport utils.pytorch_utils as pt_utils\nfrom typing import List\nimport numpy as np\nimport time\nimport math\n\nclass _PointnetSAModuleBase(nn.Module):\n\n def __init__(self):\n super().__init__()\n self.npoint = None\n self.groupers = None\n self.mlps = None\n\n def forward(self, xyz: torch.Tensor,\n features: torch.Tensor = None) -> (torch.Tensor, torch.Tensor):\n r\"\"\"\n Parameters\n ----------\n xyz : torch.Tensor\n (B, N, 3) tensor of the xyz coordinates of the points\n features : torch.Tensor\n (B, C, N) tensor of the descriptors of the the points\n\n Returns\n -------\n new_xyz : torch.Tensor\n (B, npoint, 3) tensor of the new points' xyz\n new_features : torch.Tensor\n (B, npoint, \\sum_k(mlps[k][-1])) tensor of the new_points descriptors\n \"\"\"\n\n new_features_list = []\n xyz_flipped = xyz.transpose(1, 2).contiguous()\n if self.npoint is not None:\n fps_idx = pointnet2_utils.furthest_point_sample(xyz, self.npoint) # (B, npoint)\n new_xyz = pointnet2_utils.gather_operation(xyz_flipped, fps_idx).transpose(1, 2).contiguous()\n fps_idx = fps_idx.data\n else:\n new_xyz = None\n fps_idx = None\n \n for i in range(len(self.groupers)):\n new_features = self.groupers[i](xyz, new_xyz, features, fps_idx) if self.npoint is not None else self.groupers[i](xyz, new_xyz, features) # (B, C, npoint, nsample)\n new_features = self.mlps[i](\n new_features\n ) # (B, mlp[-1], npoint)\n\n new_features_list.append(new_features)\n \n return new_xyz, torch.cat(new_features_list, dim=1)\n\n\nclass PointnetSAModuleMSG(_PointnetSAModuleBase):\n r\"\"\"Pointnet set abstrction layer with multiscale grouping\n\n Parameters\n ----------\n npoint : int\n Number of points\n radii : list of float32\n list of radii to group with\n nsamples : list of int32\n Number of samples in each ball query\n mlps : list of list of int32\n Spec of the pointnet before the global max_pool for each scale\n bn : bool\n Use batchnorm\n \"\"\"\n\n def __init__(\n self,\n *,\n npoint: int,\n radii: List[float],\n nsamples: List[int],\n mlps: List[List[int]],\n use_xyz: bool = True,\n bias = True,\n init = nn.init.kaiming_normal_,\n first_layer = False,\n relation_prior = 1\n ):\n super().__init__()\n assert len(radii) == len(nsamples) == len(mlps)\n self.npoint = npoint\n self.groupers = nn.ModuleList()\n self.mlps = nn.ModuleList()\n \n # initialize shared mapping functions\n C_in = (mlps[0][0] + 3) if use_xyz else mlps[0][0]\n C_out = mlps[0][1]\n\n \n if relation_prior == 0:\n in_channels = 1\n elif relation_prior == 1 or relation_prior == 2:\n in_channels = 10\n else:\n assert False, \"relation_prior can only be 0, 1, 2.\"\n \n if first_layer:\n mapping_func1 = nn.Conv2d(in_channels = in_channels, out_channels = math.floor(C_out / 2), kernel_size = (1, 1), \n stride = (1, 1), bias = bias)\n mapping_func2 = nn.Conv2d(in_channels = math.floor(C_out / 2), out_channels = 16, kernel_size = (1, 1), \n stride = (1, 1), bias = bias)\n xyz_raising = nn.Conv2d(in_channels = C_in, out_channels = 16, kernel_size = (1, 1), \n stride = (1, 1), bias = bias)\n init(xyz_raising.weight)\n if bias:\n nn.init.constant_(xyz_raising.bias, 0)\n elif npoint is not None:\n mapping_func1 = nn.Conv2d(in_channels = in_channels, out_channels = math.floor(C_out / 4), kernel_size = (1, 1), \n stride = (1, 1), bias = bias)\n mapping_func2 = nn.Conv2d(in_channels = math.floor(C_out / 4), out_channels = C_in, kernel_size = (1, 1), \n stride = (1, 1), bias = bias)\n if npoint is not None:\n init(mapping_func1.weight)\n init(mapping_func2.weight)\n if bias:\n nn.init.constant_(mapping_func1.bias, 0)\n nn.init.constant_(mapping_func2.bias, 0) \n \n # channel raising mapping\n cr_mapping = nn.Conv1d(in_channels = C_in if not first_layer else 16, out_channels = C_out, kernel_size = 1, \n stride = 1, bias = bias)\n init(cr_mapping.weight)\n nn.init.constant_(cr_mapping.bias, 0)\n \n if first_layer:\n mapping = [mapping_func1, mapping_func2, cr_mapping, xyz_raising]\n elif npoint is not None:\n mapping = [mapping_func1, mapping_func2, cr_mapping]\n \n for i in range(len(radii)):\n radius = radii[i]\n nsample = nsamples[i]\n self.groupers.append(\n pointnet2_utils.QueryAndGroup(radius, nsample, use_xyz=use_xyz)\n if npoint is not None else pointnet2_utils.GroupAll(use_xyz)\n )\n mlp_spec = mlps[i]\n if use_xyz:\n mlp_spec[0] += 3\n if npoint is not None:\n self.mlps.append(pt_utils.SharedRSConv(mlp_spec, mapping = mapping, relation_prior = relation_prior, first_layer = first_layer))\n else: # global convolutional pooling\n self.mlps.append(pt_utils.GloAvgConv(C_in = C_in, C_out = C_out))\n\n\nclass PointnetSAModule(PointnetSAModuleMSG):\n r\"\"\"Pointnet set abstrction layer\n\n Parameters\n ----------\n npoint : int\n Number of features\n radius : float\n Radius of ball\n nsample : int\n Number of samples in the ball query\n mlp : list\n Spec of the pointnet before the global max_pool\n bn : bool\n Use batchnorm\n \"\"\"\n\n def __init__(\n self,\n *,\n mlp: List[int],\n npoint: int = None,\n radius: float = None,\n nsample: int = None,\n use_xyz: bool = True,\n ):\n super().__init__(\n mlps=[mlp],\n npoint=npoint,\n radii=[radius],\n nsamples=[nsample],\n use_xyz=use_xyz\n )\n\n\nclass PointnetFPModule(nn.Module):\n r\"\"\"Propigates the features of one set to another\n\n Parameters\n ----------\n mlp : list\n Pointnet module parameters\n bn : bool\n Use batchnorm\n \"\"\"\n\n def __init__(self, *, mlp: List[int], bn: bool = True):\n super().__init__()\n self.mlp = pt_utils.SharedMLP(mlp, bn=bn)\n\n def forward(\n self, unknown: torch.Tensor, known: torch.Tensor,\n unknow_feats: torch.Tensor, known_feats: torch.Tensor\n ) -> torch.Tensor:\n r\"\"\"\n Parameters\n ----------\n unknown : torch.Tensor\n (B, n, 3) tensor of the xyz positions of the unknown features\n known : torch.Tensor\n (B, m, 3) tensor of the xyz positions of the known features\n unknow_feats : torch.Tensor\n (B, C1, n) tensor of the features to be propigated to\n known_feats : torch.Tensor\n (B, C2, m) tensor of features to be propigated\n\n Returns\n -------\n new_features : torch.Tensor\n (B, mlp[-1], n) tensor of the features of the unknown features\n \"\"\"\n\n dist, idx = pointnet2_utils.three_nn(unknown, known)\n dist_recip = 1.0 / (dist + 1e-8)\n norm = torch.sum(dist_recip, dim=2, keepdim=True)\n weight = dist_recip / norm\n\n interpolated_feats = pointnet2_utils.three_interpolate(\n known_feats, idx, weight\n )\n if unknow_feats is not None:\n new_features = torch.cat([interpolated_feats, unknow_feats],\n dim=1) #(B, C2 + C1, n)\n else:\n new_features = interpolated_feats\n \n new_features = new_features.unsqueeze(-1)\n new_features = self.mlp(new_features)\n\n return new_features.squeeze(-1)\n \n\nif __name__ == \"__main__\":\n from torch.autograd import Variable\n torch.manual_seed(1)\n torch.cuda.manual_seed_all(1)\n xyz = Variable(torch.randn(2, 9, 3).cuda(), requires_grad=True)\n xyz_feats = Variable(torch.randn(2, 9, 6).cuda(), requires_grad=True)\n\n test_module = PointnetSAModuleMSG(\n npoint=2, radii=[5.0, 10.0], nsamples=[6, 3], mlps=[[9, 3], [9, 6]]\n )\n test_module.cuda()\n print(test_module(xyz, xyz_feats))\n\n # test_module = PointnetFPModule(mlp=[6, 6])\n # test_module.cuda()\n # from torch.autograd import gradcheck\n # inputs = (xyz, xyz, None, xyz_feats)\n # test = gradcheck(test_module, inputs, eps=1e-6, atol=1e-4)\n # print(test)\n\n for _ in range(1):\n _, new_features = test_module(xyz, xyz_feats)\n new_features.backward(\n torch.cuda.FloatTensor(*new_features.size()).fill_(1)\n )\n print(new_features)\n print(xyz.grad)\n"
] | [
[
"torch.sum",
"torch.cuda.manual_seed_all",
"torch.nn.init.constant_",
"torch.randn",
"torch.manual_seed",
"torch.nn.Conv1d",
"torch.nn.ModuleList",
"torch.nn.Conv2d",
"torch.cat"
]
] |
chuanglaipv/realtime_object_detection_xavier | [
"694c91db953a2e18440fcdcf5f38df90ba063bfc"
] | [
"lib/detection_nms_v1.py"
] | [
"import numpy as np\nfrom tf_utils import visualization_utils_cv2 as vis_util\nfrom lib.session_worker import SessionWorker\nfrom lib.load_graph_nms_v1 import LoadFrozenGraph\nfrom lib.load_label_map import LoadLabelMap\nfrom lib.mpvariable import MPVariable\nfrom lib.mpvisualizeworker import MPVisualizeWorker, visualization\nfrom lib.mpio import start_sender\n\nimport time\nimport cv2\nimport tensorflow as tf\nimport os\n\nimport sys\nPY2 = sys.version_info[0] == 2\nPY3 = sys.version_info[0] == 3\nif PY2:\n import Queue\nelif PY3:\n import queue as Queue\n\n\nclass NMSV1():\n def __init__(self):\n return\n\n def start(self, cfg):\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n GET CONFIG\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n FORCE_GPU_COMPATIBLE = cfg['force_gpu_compatible']\n SAVE_TO_FILE = cfg['save_to_file']\n VISUALIZE = cfg['visualize']\n VIS_WORKER = cfg['vis_worker']\n VIS_TEXT = cfg['vis_text']\n MAX_FRAMES = cfg['max_frames']\n WIDTH = cfg['width']\n HEIGHT = cfg['height']\n FPS_INTERVAL = cfg['fps_interval']\n DET_INTERVAL = cfg['det_interval']\n DET_TH = cfg['det_th']\n SPLIT_MODEL = cfg['split_model']\n LOG_DEVICE = cfg['log_device']\n ALLOW_MEMORY_GROWTH = cfg['allow_memory_growth']\n SPLIT_SHAPE = cfg['split_shape']\n DEBUG_MODE = cfg['debug_mode']\n LABEL_PATH = cfg['label_path']\n NUM_CLASSES = cfg['num_classes']\n SRC_FROM = cfg['src_from']\n CAMERA = 0\n MOVIE = 1\n IMAGE = 2\n if SRC_FROM == 'camera':\n SRC_FROM = CAMERA\n VIDEO_INPUT = cfg['camera_input']\n elif SRC_FROM == 'movie':\n SRC_FROM = MOVIE\n VIDEO_INPUT = cfg['movie_input']\n elif SRC_FROM == 'image':\n SRC_FROM = IMAGE\n VIDEO_INPUT = cfg['image_input']\n \"\"\" \"\"\"\n\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n LOAD FROZEN_GRAPH\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n load_frozen_graph = LoadFrozenGraph(cfg)\n graph = load_frozen_graph.load_graph()\n \"\"\" \"\"\"\n\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n LOAD LABEL MAP\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n llm = LoadLabelMap()\n category_index = llm.load_label_map(cfg)\n \"\"\" \"\"\"\n\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n PREPARE TF CONFIG OPTION\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n # Session Config: allow seperate GPU/CPU adressing and limit memory allocation\n config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=LOG_DEVICE)\n config.gpu_options.allow_growth = ALLOW_MEMORY_GROWTH\n config.gpu_options.force_gpu_compatible = FORCE_GPU_COMPATIBLE\n #config.gpu_options.per_process_gpu_memory_fraction = 0.01 # 80MB memory is enough to run on TX2\n \"\"\" \"\"\"\n\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n PREPARE GRAPH I/O TO VARIABLE\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n # Define Input and Ouput tensors\n image_tensor = graph.get_tensor_by_name('image_tensor:0')\n detection_boxes = graph.get_tensor_by_name('detection_boxes:0')\n detection_scores = graph.get_tensor_by_name('detection_scores:0')\n detection_classes = graph.get_tensor_by_name('detection_classes:0')\n num_detections = graph.get_tensor_by_name('num_detections:0')\n\n if SPLIT_MODEL:\n SPLIT_TARGET_NAME = ['Postprocessor/convert_scores',\n 'Postprocessor/ExpandDims_1',\n ]\n split_out = []\n split_in = []\n for stn in SPLIT_TARGET_NAME:\n split_out += [graph.get_tensor_by_name(stn+':0')]\n split_in += [graph.get_tensor_by_name(stn+'_1:0')]\n \"\"\" \"\"\"\n\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n START WORKER THREAD\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n # gpu_worker uses in split_model and non-split_model\n gpu_tag = 'GPU'\n cpu_tag = 'CPU'\n gpu_worker = SessionWorker(gpu_tag, graph, config)\n if SPLIT_MODEL:\n gpu_opts = split_out\n cpu_worker = SessionWorker(cpu_tag, graph, config)\n cpu_opts = [detection_boxes, detection_scores, detection_classes, num_detections]\n else:\n gpu_opts = [detection_boxes, detection_scores, detection_classes, num_detections]\n \"\"\" \"\"\"\n\n \"\"\"\n START VISUALIZE WORKER\n \"\"\"\n if VISUALIZE and VIS_WORKER:\n q_out = Queue.Queue()\n vis_worker = MPVisualizeWorker(cfg, MPVariable.vis_in_con)\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n START SENDER THREAD\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n start_sender(MPVariable.det_out_con, q_out)\n proc_frame_counter = 0\n vis_proc_time = 0\n\n\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n WAIT UNTIL THE FIRST DUMMY IMAGE DONE\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n print('Loading...')\n sleep_interval = 0.1\n \"\"\"\n PUT DUMMY DATA INTO GPU WORKER\n \"\"\"\n gpu_feeds = {image_tensor: [np.zeros((300, 300, 3))]}\n gpu_extras = {}\n gpu_worker.put_sess_queue(gpu_opts, gpu_feeds, gpu_extras)\n if SPLIT_MODEL:\n \"\"\"\n PUT DUMMY DATA INTO CPU WORKER\n \"\"\"\n cpu_feeds = {split_in[0]: np.zeros((1, SPLIT_SHAPE, NUM_CLASSES)),\n split_in[1]: np.zeros((1, SPLIT_SHAPE, 1, 4))}\n cpu_extras = {}\n cpu_worker.put_sess_queue(cpu_opts, cpu_feeds, cpu_extras)\n \"\"\"\n WAIT UNTIL JIT-COMPILE DONE\n \"\"\"\n while True:\n g = gpu_worker.get_result_queue()\n if g is None:\n time.sleep(sleep_interval)\n else:\n break\n if SPLIT_MODEL:\n while True:\n c = cpu_worker.get_result_queue()\n if c is None:\n time.sleep(sleep_interval)\n else:\n break\n \"\"\" \"\"\"\n\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n START CAMERA\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n if SRC_FROM == CAMERA:\n from lib.webcam import WebcamVideoStream as VideoReader\n elif SRC_FROM == MOVIE:\n from lib.video import VideoReader\n elif SRC_FROM == IMAGE:\n from lib.image import ImageReader as VideoReader\n video_reader = VideoReader()\n\n if SRC_FROM == IMAGE:\n video_reader.start(VIDEO_INPUT, save_to_file=SAVE_TO_FILE)\n else: # CAMERA, MOVIE\n video_reader.start(VIDEO_INPUT, WIDTH, HEIGHT, save_to_file=SAVE_TO_FILE)\n frame_cols, frame_rows = video_reader.getSize()\n \"\"\" STATISTICS FONT \"\"\"\n fontScale = frame_rows/1000.0\n if fontScale < 0.4:\n fontScale = 0.4\n fontThickness = 1 + int(fontScale)\n fontFace = cv2.FONT_HERSHEY_SIMPLEX\n if SRC_FROM == MOVIE:\n dir_path, filename = os.path.split(VIDEO_INPUT)\n filepath_prefix = filename\n elif SRC_FROM == CAMERA:\n filepath_prefix = 'frame'\n \"\"\" \"\"\"\n\n\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n DETECTION LOOP\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n print('Starting Detection')\n sleep_interval = 0.005\n top_in_time = None\n frame_in_processing_counter = 0\n try:\n if not video_reader.running:\n raise IOError((\"Input src error.\"))\n while MPVariable.running.value:\n if top_in_time is None:\n top_in_time = time.time()\n \"\"\"\n SPRIT/NON-SPLIT MODEL CAMERA TO WORKER\n \"\"\"\n if video_reader.running:\n if gpu_worker.is_sess_empty(): # must need for speed\n cap_in_time = time.time()\n if SRC_FROM == IMAGE:\n frame, filepath = video_reader.read()\n if frame is not None:\n frame_in_processing_counter += 1\n else:\n frame = video_reader.read()\n if frame is not None:\n filepath = filepath_prefix+'_'+str(proc_frame_counter)+'.png'\n frame_in_processing_counter += 1\n if frame is not None:\n image_expanded = np.expand_dims(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB), axis=0) # np.expand_dims is faster than []\n #image_expanded = np.expand_dims(frame, axis=0) # BGR image for input. Of couse, bad accuracy in RGB trained model, but speed up.\n cap_out_time = time.time()\n # put new queue\n gpu_feeds = {image_tensor: image_expanded}\n gpu_extras = {'image':frame, 'top_in_time':top_in_time, 'cap_in_time':cap_in_time, 'cap_out_time':cap_out_time, 'filepath': filepath} # always image draw.\n gpu_worker.put_sess_queue(gpu_opts, gpu_feeds, gpu_extras)\n elif frame_in_processing_counter <= 0:\n MPVariable.running.value = False\n break\n\n g = gpu_worker.get_result_queue()\n if SPLIT_MODEL:\n # if g is None: gpu thread has no output queue. ok skip, let's check cpu thread.\n if g is not None:\n # gpu thread has output queue.\n result_slice_out, extras = g['results'], g['extras']\n\n if cpu_worker.is_sess_empty():\n # When cpu thread has no next queue, put new queue.\n # else, drop gpu queue.\n cpu_feeds = {}\n for i in range(len(result_slice_out)):\n cpu_feeds.update({split_in[i]:result_slice_out[i]})\n cpu_extras = extras\n cpu_worker.put_sess_queue(cpu_opts, cpu_feeds, cpu_extras)\n else:\n # else: cpu thread is busy. don't put new queue. let's check cpu result queue.\n frame_in_processing_counter -= 1\n # check cpu thread.\n q = cpu_worker.get_result_queue()\n else:\n \"\"\"\n NON-SPLIT MODEL\n \"\"\"\n q = g\n if q is None:\n \"\"\"\n SPLIT/NON-SPLIT MODEL\n \"\"\"\n # detection is not complete yet. ok nothing to do.\n time.sleep(sleep_interval)\n continue\n\n frame_in_processing_counter -= 1\n boxes, scores, classes, num, extras = q['results'][0], q['results'][1], q['results'][2], q['results'][3], q['extras']\n boxes, scores, classes = np.squeeze(boxes), np.squeeze(scores), np.squeeze(classes)\n det_out_time = time.time()\n\n \"\"\"\n ALWAYS BOX DRAW ON IMAGE\n \"\"\"\n vis_in_time = time.time()\n image = extras['image']\n if SRC_FROM == IMAGE:\n filepath = extras['filepath']\n frame_rows, frame_cols = image.shape[:2]\n \"\"\" STATISTICS FONT \"\"\"\n fontScale = frame_rows/1000.0\n if fontScale < 0.4:\n fontScale = 0.4\n fontThickness = 1 + int(fontScale)\n else:\n filepath = extras['filepath']\n image = visualization(category_index, image, boxes, scores, classes, DEBUG_MODE, VIS_TEXT, FPS_INTERVAL,\n fontFace=fontFace, fontScale=fontScale, fontThickness=fontThickness)\n\n \"\"\"\n VISUALIZATION\n \"\"\"\n if VISUALIZE:\n if (MPVariable.vis_skip_rate.value == 0) or (proc_frame_counter % MPVariable.vis_skip_rate.value < 1):\n if VIS_WORKER:\n q_out.put({'image':image, 'vis_in_time':vis_in_time})\n else:\n \"\"\"\n SHOW\n \"\"\"\n cv2.imshow(\"Object Detection\", image)\n # Press q to quit\n if cv2.waitKey(1) & 0xFF == 113: #ord('q'):\n break\n MPVariable.vis_frame_counter.value += 1\n vis_out_time = time.time()\n \"\"\"\n PROCESSING TIME\n \"\"\"\n vis_proc_time = vis_out_time - vis_in_time\n MPVariable.vis_proc_time.value += vis_proc_time\n else:\n \"\"\"\n NO VISUALIZE\n \"\"\"\n for box, score, _class in zip(boxes, scores, classes):\n if proc_frame_counter % DET_INTERVAL == 0 and score > DET_TH:\n label = category_index[_class]['name']\n print(\"label: {}\\nscore: {}\\nbox: {}\".format(label, score, box))\n\n vis_out_time = time.time()\n \"\"\"\n PROCESSING TIME\n \"\"\"\n vis_proc_time = vis_out_time - vis_in_time\n\n if SAVE_TO_FILE:\n if SRC_FROM == IMAGE:\n video_reader.save(image, filepath)\n else:\n video_reader.save(image)\n\n proc_frame_counter += 1\n if proc_frame_counter > 100000:\n proc_frame_counter = 0\n \"\"\"\n PROCESSING TIME\n \"\"\"\n top_in_time = extras['top_in_time']\n cap_proc_time = extras['cap_out_time'] - extras['cap_in_time']\n gpu_proc_time = extras[gpu_tag+'_out_time'] - extras[gpu_tag+'_in_time']\n if SPLIT_MODEL:\n cpu_proc_time = extras[cpu_tag+'_out_time'] - extras[cpu_tag+'_in_time']\n else:\n cpu_proc_time = 0\n lost_proc_time = det_out_time - top_in_time - cap_proc_time - gpu_proc_time - cpu_proc_time\n total_proc_time = det_out_time - top_in_time\n MPVariable.cap_proc_time.value += cap_proc_time\n MPVariable.gpu_proc_time.value += gpu_proc_time\n MPVariable.cpu_proc_time.value += cpu_proc_time\n MPVariable.lost_proc_time.value += lost_proc_time\n MPVariable.total_proc_time.value += total_proc_time\n\n if DEBUG_MODE:\n if SPLIT_MODEL:\n sys.stdout.write('snapshot FPS:{: ^5.1f} total:{: ^10.5f} cap:{: ^10.5f} gpu:{: ^10.5f} cpu:{: ^10.5f} lost:{: ^10.5f} | vis:{: ^10.5f}\\n'.format(\n MPVariable.fps.value, total_proc_time, cap_proc_time, gpu_proc_time, cpu_proc_time, lost_proc_time, vis_proc_time))\n else:\n sys.stdout.write('snapshot FPS:{: ^5.1f} total:{: ^10.5f} cap:{: ^10.5f} gpu:{: ^10.5f} lost:{: ^10.5f} | vis:{: ^10.5f}\\n'.format(\n MPVariable.fps.value, total_proc_time, cap_proc_time, gpu_proc_time, lost_proc_time, vis_proc_time))\n \"\"\"\n EXIT WITHOUT GUI\n \"\"\"\n if not VISUALIZE and MAX_FRAMES > 0:\n if proc_frame_counter >= MAX_FRAMES:\n MPVariable.running.value = False\n break\n\n \"\"\"\n CHANGE SLEEP INTERVAL\n \"\"\"\n if MPVariable.frame_counter.value == 0 and MPVariable.fps.value > 0:\n sleep_interval = 0.1 / MPVariable.fps.value\n MPVariable.sleep_interval.value = sleep_interval\n MPVariable.frame_counter.value += 1\n top_in_time = None\n \"\"\"\n END while\n \"\"\"\n except KeyboardInterrupt:\n pass\n except:\n import traceback\n traceback.print_exc()\n finally:\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n CLOSE\n \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\" \"\"\"\n if VISUALIZE and VIS_WORKER:\n q_out.put(None)\n MPVariable.running.value = False\n gpu_worker.stop()\n if SPLIT_MODEL:\n cpu_worker.stop()\n video_reader.stop()\n\n if VISUALIZE:\n cv2.destroyAllWindows()\n \"\"\" \"\"\"\n\n return\n\n"
] | [
[
"numpy.squeeze",
"tensorflow.ConfigProto",
"numpy.zeros"
]
] |
ricklupton/py-bem | [
"026b2b82b6f09d57b213cfe17aa849dbdf3c7b71"
] | [
"bem/fast_interpolation.py"
] | [
"\"\"\"\nFrom http://stackoverflow.com/a/13504757\n\"\"\"\n\nfrom scipy.interpolate import interp1d\nfrom scipy.interpolate._fitpack import _bspleval\nimport numpy as np\n\n\nclass fast_interpolation:\n def __init__(self, x, y, axis=-1):\n assert len(x) == y.shape[axis]\n self.x = x\n self.y = y\n self.axis = axis\n self._f = interp1d(x, y, axis=axis, kind='slinear', copy=False)\n\n def __getstate__(self):\n return dict(x=self.x, y=self.y, axis=self.axis)\n\n def __setstate__(self, state):\n self.x = state['x']\n self.y = state['y']\n self.axis = state['axis']\n self._f = interp1d(self.x, self.y, axis=self.axis,\n kind='slinear', copy=False)\n\n def __call__(self, new_x):\n #assert new_x.shape == y.shape\n xj, cvals, k = self._f._spline\n result = np.empty_like(new_x)\n for i, value in enumerate(new_x.flat):\n result.flat[i] = _bspleval(value, self.x, cvals[:, i], k, 0)\n return result\n"
] | [
[
"numpy.empty_like",
"scipy.interpolate.interp1d",
"scipy.interpolate._fitpack._bspleval"
]
] |
noelevans/playground | [
"da529e967a15bcb217fff091ac0ec5c4dc1821ce"
] | [
"kaggle/sf-crime/logistic_regressions.py"
] | [
"from sklearn.linear_model import LogisticRegression\n\n\nclass MultivariateLogisticOvrModel(object):\n\n def model_and_predict(self, X_train, y_train, X_test):\n model = LogisticRegression(dual=True, fit_intercept=True, \n multi_class='ovr')\n model.fit(X_train, y_train)\n return model.predict(X_test)\n\n\nclass MultivariateLogisticMultinomialModel(object):\n\n def model_and_predict(self, X_train, y_train, X_test):\n model = LogisticRegression(dual=False, fit_intercept=False, \n multi_class='multinomial')\n model.fit(X_train, y_train)\n return model.predict(X_test)\n\n"
] | [
[
"sklearn.linear_model.LogisticRegression"
]
] |
Onkar627/cupy | [
"8eef1ad5393c0a92c5065bc05137bf997f37044a"
] | [
"cupyx/scipy/ndimage/_measurements.py"
] | [
"import warnings\n\nimport numpy\n\nimport cupy\nfrom cupy import _core\nfrom cupy import _util\n\n\ndef label(input, structure=None, output=None):\n \"\"\"Labels features in an array.\n\n Args:\n input (cupy.ndarray): The input array.\n structure (array_like or None): A structuring element that defines\n feature connections. ```structure``` must be centersymmetric. If\n None, structure is automatically generated with a squared\n connectivity equal to one.\n output (cupy.ndarray, dtype or None): The array in which to place the\n output.\n Returns:\n label (cupy.ndarray): An integer array where each unique feature in\n ```input``` has a unique label in the array.\n\n num_features (int): Number of features found.\n\n .. warning::\n\n This function may synchronize the device.\n\n .. seealso:: :func:`scipy.ndimage.label`\n \"\"\"\n if not isinstance(input, cupy.ndarray):\n raise TypeError('input must be cupy.ndarray')\n if input.dtype.char in 'FD':\n raise TypeError('Complex type not supported')\n if structure is None:\n structure = _generate_binary_structure(input.ndim, 1)\n elif isinstance(structure, cupy.ndarray):\n structure = cupy.asnumpy(structure)\n structure = numpy.array(structure, dtype=bool)\n if structure.ndim != input.ndim:\n raise RuntimeError('structure and input must have equal rank')\n for i in structure.shape:\n if i != 3:\n raise ValueError('structure dimensions must be equal to 3')\n\n if isinstance(output, cupy.ndarray):\n if output.shape != input.shape:\n raise ValueError(\"output shape not correct\")\n caller_provided_output = True\n else:\n caller_provided_output = False\n if output is None:\n output = cupy.empty(input.shape, numpy.int32)\n else:\n output = cupy.empty(input.shape, output)\n\n if input.size == 0:\n # empty\n maxlabel = 0\n elif input.ndim == 0:\n # 0-dim array\n maxlabel = 0 if input.item() == 0 else 1\n output[...] = maxlabel\n else:\n if output.dtype != numpy.int32:\n y = cupy.empty(input.shape, numpy.int32)\n else:\n y = output\n maxlabel = _label(input, structure, y)\n if output.dtype != numpy.int32:\n output[...] = y[...]\n\n if caller_provided_output:\n return maxlabel\n else:\n return output, maxlabel\n\n\ndef _generate_binary_structure(rank, connectivity):\n if connectivity < 1:\n connectivity = 1\n if rank < 1:\n return numpy.array(True, dtype=bool)\n output = numpy.fabs(numpy.indices([3] * rank) - 1)\n output = numpy.add.reduce(output, 0)\n return output <= connectivity\n\n\ndef _label(x, structure, y):\n elems = numpy.where(structure != 0)\n vecs = [elems[dm] - 1 for dm in range(x.ndim)]\n offset = vecs[0]\n for dm in range(1, x.ndim):\n offset = offset * 3 + vecs[dm]\n indxs = numpy.where(offset < 0)[0]\n dirs = [[vecs[dm][dr] for dm in range(x.ndim)] for dr in indxs]\n dirs = cupy.array(dirs, dtype=numpy.int32)\n ndirs = indxs.shape[0]\n y_shape = cupy.array(y.shape, dtype=numpy.int32)\n count = cupy.zeros(2, dtype=numpy.int32)\n _kernel_init()(x, y)\n _kernel_connect()(y_shape, dirs, ndirs, x.ndim, y, size=y.size)\n _kernel_count()(y, count, size=y.size)\n maxlabel = int(count[0])\n labels = cupy.empty(maxlabel, dtype=numpy.int32)\n _kernel_labels()(y, count, labels, size=y.size)\n _kernel_finalize()(maxlabel, cupy.sort(labels), y, size=y.size)\n return maxlabel\n\n\ndef _kernel_init():\n return _core.ElementwiseKernel(\n 'X x', 'Y y', 'if (x == 0) { y = -1; } else { y = i; }',\n 'cupyx_scipy_ndimage_label_init')\n\n\ndef _kernel_connect():\n return _core.ElementwiseKernel(\n 'raw int32 shape, raw int32 dirs, int32 ndirs, int32 ndim',\n 'raw Y y',\n '''\n if (y[i] < 0) continue;\n for (int dr = 0; dr < ndirs; dr++) {\n int j = i;\n int rest = j;\n int stride = 1;\n int k = 0;\n for (int dm = ndim-1; dm >= 0; dm--) {\n int pos = rest % shape[dm] + dirs[dm + dr * ndim];\n if (pos < 0 || pos >= shape[dm]) {\n k = -1;\n break;\n }\n k += pos * stride;\n rest /= shape[dm];\n stride *= shape[dm];\n }\n if (k < 0) continue;\n if (y[k] < 0) continue;\n while (1) {\n while (j != y[j]) { j = y[j]; }\n while (k != y[k]) { k = y[k]; }\n if (j == k) break;\n if (j < k) {\n int old = atomicCAS( &y[k], k, j );\n if (old == k) break;\n k = old;\n }\n else {\n int old = atomicCAS( &y[j], j, k );\n if (old == j) break;\n j = old;\n }\n }\n }\n ''',\n 'cupyx_scipy_ndimage_label_connect')\n\n\ndef _kernel_count():\n return _core.ElementwiseKernel(\n '', 'raw Y y, raw int32 count',\n '''\n if (y[i] < 0) continue;\n int j = i;\n while (j != y[j]) { j = y[j]; }\n if (j != i) y[i] = j;\n else atomicAdd(&count[0], 1);\n ''',\n 'cupyx_scipy_ndimage_label_count')\n\n\ndef _kernel_labels():\n return _core.ElementwiseKernel(\n '', 'raw Y y, raw int32 count, raw int32 labels',\n '''\n if (y[i] != i) continue;\n int j = atomicAdd(&count[1], 1);\n labels[j] = i;\n ''',\n 'cupyx_scipy_ndimage_label_labels')\n\n\ndef _kernel_finalize():\n return _core.ElementwiseKernel(\n 'int32 maxlabel', 'raw int32 labels, raw Y y',\n '''\n if (y[i] < 0) {\n y[i] = 0;\n continue;\n }\n int yi = y[i];\n int j_min = 0;\n int j_max = maxlabel - 1;\n int j = (j_min + j_max) / 2;\n while (j_min < j_max) {\n if (yi == labels[j]) break;\n if (yi < labels[j]) j_max = j - 1;\n else j_min = j + 1;\n j = (j_min + j_max) / 2;\n }\n y[i] = j + 1;\n ''',\n 'cupyx_scipy_ndimage_label_finalize')\n\n\n_ndimage_variance_kernel = _core.ElementwiseKernel(\n 'T input, R labels, raw X index, uint64 size, raw float64 mean',\n 'raw float64 out',\n \"\"\"\n for (ptrdiff_t j = 0; j < size; j++) {\n if (labels == index[j]) {\n atomicAdd(&out[j], (input - mean[j]) * (input - mean[j]));\n break;\n }\n }\n \"\"\",\n 'cupyx_scipy_ndimage_variance')\n\n\n_ndimage_sum_kernel = _core.ElementwiseKernel(\n 'T input, R labels, raw X index, uint64 size',\n 'raw float64 out',\n \"\"\"\n for (ptrdiff_t j = 0; j < size; j++) {\n if (labels == index[j]) {\n atomicAdd(&out[j], input);\n break;\n }\n }\n \"\"\",\n 'cupyx_scipy_ndimage_sum')\n\n\ndef _ndimage_sum_kernel_2(input, labels, index, sum_val, batch_size=4):\n for i in range(0, index.size, batch_size):\n matched = labels == index[i:i + batch_size].reshape(\n (-1,) + (1,) * input.ndim)\n sum_axes = tuple(range(1, 1 + input.ndim))\n sum_val[i:i + batch_size] = cupy.where(matched, input, 0).sum(\n axis=sum_axes)\n return sum_val\n\n\n_ndimage_mean_kernel = _core.ElementwiseKernel(\n 'T input, R labels, raw X index, uint64 size',\n 'raw float64 out, raw uint64 count',\n \"\"\"\n for (ptrdiff_t j = 0; j < size; j++) {\n if (labels == index[j]) {\n atomicAdd(&out[j], input);\n atomicAdd(&count[j], 1);\n break;\n }\n }\n \"\"\",\n 'cupyx_scipy_ndimage_mean')\n\n\ndef _ndimage_mean_kernel_2(input, labels, index, batch_size=4,\n return_count=False):\n sum_val = cupy.empty_like(index, dtype=cupy.float64)\n count = cupy.empty_like(index, dtype=cupy.uint64)\n for i in range(0, index.size, batch_size):\n matched = labels == index[i:i + batch_size].reshape(\n (-1,) + (1,) * input.ndim)\n mean_axes = tuple(range(1, 1 + input.ndim))\n count[i:i + batch_size] = matched.sum(axis=mean_axes)\n sum_val[i:i + batch_size] = cupy.where(matched, input, 0).sum(\n axis=mean_axes)\n if return_count:\n return sum_val / count, count\n return sum_val / count\n\n\ndef _mean_driver(input, labels, index, return_count=False, use_kern=False):\n if use_kern:\n return _ndimage_mean_kernel_2(input, labels, index,\n return_count=return_count)\n\n out = cupy.zeros_like(index, cupy.float64)\n count = cupy.zeros_like(index, dtype=cupy.uint64)\n sum, count = _ndimage_mean_kernel(input,\n labels, index, index.size, out, count)\n if return_count:\n return sum / count, count\n return sum / count\n\n\ndef variance(input, labels=None, index=None):\n \"\"\"Calculates the variance of the values of an n-D image array, optionally\n at specified sub-regions.\n\n Args:\n input (cupy.ndarray): Nd-image data to process.\n labels (cupy.ndarray or None): Labels defining sub-regions in `input`.\n If not None, must be same shape as `input`.\n index (cupy.ndarray or None): `labels` to include in output. If None\n (default), all values where `labels` is non-zero are used.\n\n Returns:\n cupy.ndarray: Values of variance, for each sub-region if\n `labels` and `index` are specified.\n\n .. seealso:: :func:`scipy.ndimage.variance`\n \"\"\"\n if not isinstance(input, cupy.ndarray):\n raise TypeError('input must be cupy.ndarray')\n\n if input.dtype in (cupy.complex64, cupy.complex128):\n raise TypeError(\"cupyx.scipy.ndimage.variance doesn't support %{}\"\n \"\".format(input.dtype.type))\n\n use_kern = False\n # There are constraints on types because of atomicAdd() in CUDA.\n if input.dtype not in [cupy.int32, cupy.float16, cupy.float32,\n cupy.float64, cupy.uint32, cupy.uint64,\n cupy.ulonglong]:\n warnings.warn(\n 'Using the slower implementation because the provided '\n f'type {input.dtype} is not supported by cupyx.scipy.ndimage.sum. '\n 'Consider using an array of type int32, float16, '\n 'float32, float64, uint32, uint64 as data types '\n 'for the fast implementation', _util.PerformanceWarning)\n use_kern = True\n\n def calc_var_with_intermediate_float(input):\n vals_c = input - input.mean()\n count = vals_c.size\n # Does not use `ndarray.mean()` here to return the same results as\n # SciPy does, especially in case `input`'s dtype is float16.\n return cupy.square(vals_c).sum() / cupy.asanyarray(count).astype(float)\n\n if labels is None:\n return calc_var_with_intermediate_float(input)\n\n if not isinstance(labels, cupy.ndarray):\n raise TypeError('label must be cupy.ndarray')\n\n input, labels = cupy.broadcast_arrays(input, labels)\n\n if index is None:\n return calc_var_with_intermediate_float(input[labels > 0])\n\n if cupy.isscalar(index):\n return calc_var_with_intermediate_float(input[labels == index])\n\n if not isinstance(index, cupy.ndarray):\n if not isinstance(index, int):\n raise TypeError('index must be cupy.ndarray or a scalar int')\n else:\n return (input[labels == index]).var().astype(cupy.float64,\n copy=False)\n\n mean_val, count = _mean_driver(input, labels, index, True, use_kern)\n if use_kern:\n new_axis = (..., *(cupy.newaxis for _ in range(input.ndim)))\n return cupy.where(labels[None, ...] == index[new_axis],\n cupy.square(input - mean_val[new_axis]),\n 0).sum(tuple(range(1, input.ndim + 1))) / count\n out = cupy.zeros_like(index, dtype=cupy.float64)\n return _ndimage_variance_kernel(input, labels, index, index.size, mean_val,\n out) / count\n\n\ndef sum_labels(input, labels=None, index=None):\n \"\"\"Calculates the sum of the values of an n-D image array, optionally\n at specified sub-regions.\n\n Args:\n input (cupy.ndarray): Nd-image data to process.\n labels (cupy.ndarray or None): Labels defining sub-regions in `input`.\n If not None, must be same shape as `input`.\n index (cupy.ndarray or None): `labels` to include in output. If None\n (default), all values where `labels` is non-zero are used.\n\n Returns:\n sum (cupy.ndarray): sum of values, for each sub-region if\n `labels` and `index` are specified.\n\n .. seealso:: :func:`scipy.ndimage.sum_labels`\n \"\"\"\n if not isinstance(input, cupy.ndarray):\n raise TypeError('input must be cupy.ndarray')\n\n if input.dtype in (cupy.complex64, cupy.complex128):\n raise TypeError(\"cupyx.scipy.ndimage.sum does not support %{}\".format(\n input.dtype.type))\n\n use_kern = False\n # There is constraints on types because of atomicAdd() in CUDA.\n if input.dtype not in [cupy.int32, cupy.float16, cupy.float32,\n cupy.float64, cupy.uint32, cupy.uint64,\n cupy.ulonglong]:\n warnings.warn(\n 'Using the slower implmentation as '\n 'cupyx.scipy.ndimage.sum supports int32, float16, '\n 'float32, float64, uint32, uint64 as data types'\n 'for the fast implmentation', _util.PerformanceWarning)\n use_kern = True\n\n if labels is None:\n return input.sum()\n\n if not isinstance(labels, cupy.ndarray):\n raise TypeError('label must be cupy.ndarray')\n\n input, labels = cupy.broadcast_arrays(input, labels)\n\n if index is None:\n return input[labels != 0].sum()\n\n if not isinstance(index, cupy.ndarray):\n if not isinstance(index, int):\n raise TypeError('index must be cupy.ndarray or a scalar int')\n else:\n return (input[labels == index]).sum()\n\n if index.size == 0:\n return cupy.array([], dtype=cupy.int64)\n\n out = cupy.zeros_like(index, dtype=cupy.float64)\n\n # The following parameters for sum where determined using a Tesla P100.\n if (input.size >= 262144 and index.size <= 4) or use_kern:\n return _ndimage_sum_kernel_2(input, labels, index, out)\n return _ndimage_sum_kernel(input, labels, index, index.size, out)\n\n\ndef sum(input, labels=None, index=None):\n \"\"\"Calculates the sum of the values of an n-D image array, optionally\n at specified sub-regions.\n\n Args:\n input (cupy.ndarray): Nd-image data to process.\n labels (cupy.ndarray or None): Labels defining sub-regions in `input`.\n If not None, must be same shape as `input`.\n index (cupy.ndarray or None): `labels` to include in output. If None\n (default), all values where `labels` is non-zero are used.\n\n Returns:\n sum (cupy.ndarray): sum of values, for each sub-region if\n `labels` and `index` are specified.\n\n Notes:\n This is an alias for `cupyx.scipy.ndimage.sum_labels` kept for\n backwards compatibility reasons. For new code please prefer\n `sum_labels`.\n\n .. seealso:: :func:`scipy.ndimage.sum`\n \"\"\"\n return sum_labels(input, labels, index)\n\n\ndef mean(input, labels=None, index=None):\n \"\"\"Calculates the mean of the values of an n-D image array, optionally\n at specified sub-regions.\n\n Args:\n input (cupy.ndarray): Nd-image data to process.\n labels (cupy.ndarray or None): Labels defining sub-regions in `input`.\n If not None, must be same shape as `input`.\n index (cupy.ndarray or None): `labels` to include in output. If None\n (default), all values where `labels` is non-zero are used.\n\n Returns:\n mean (cupy.ndarray): mean of values, for each sub-region if\n `labels` and `index` are specified.\n\n\n .. seealso:: :func:`scipy.ndimage.mean`\n \"\"\"\n if not isinstance(input, cupy.ndarray):\n raise TypeError('input must be cupy.ndarray')\n\n if input.dtype in (cupy.complex64, cupy.complex128):\n raise TypeError(\"cupyx.scipy.ndimage.mean does not support %{}\".format(\n input.dtype.type))\n\n use_kern = False\n # There is constraints on types because of atomicAdd() in CUDA.\n if input.dtype not in [cupy.int32, cupy.float16, cupy.float32,\n cupy.float64, cupy.uint32, cupy.uint64,\n cupy.ulonglong]:\n warnings.warn(\n 'Using the slower implmentation as '\n 'cupyx.scipy.ndimage.mean supports int32, float16, '\n 'float32, float64, uint32, uint64 as data types '\n 'for the fast implmentation', _util.PerformanceWarning)\n use_kern = True\n\n def calc_mean_with_intermediate_float(input):\n sum = input.sum()\n count = input.size\n # Does not use `ndarray.mean()` here to return the same results as\n # SciPy does, especially in case `input`'s dtype is float16.\n return sum / cupy.asanyarray(count).astype(float)\n\n if labels is None:\n return calc_mean_with_intermediate_float(input)\n\n if not isinstance(labels, cupy.ndarray):\n raise TypeError('label must be cupy.ndarray')\n\n input, labels = cupy.broadcast_arrays(input, labels)\n\n if index is None:\n return calc_mean_with_intermediate_float(input[labels > 0])\n\n if cupy.isscalar(index):\n return calc_mean_with_intermediate_float(input[labels == index])\n\n if not isinstance(index, cupy.ndarray):\n if not isinstance(index, int):\n raise TypeError('index must be cupy.ndarray or a scalar int')\n else:\n return (input[labels == index]).mean(dtype=cupy.float64)\n\n return _mean_driver(input, labels, index, use_kern=use_kern)\n\n\ndef standard_deviation(input, labels=None, index=None):\n \"\"\"Calculates the standard deviation of the values of an n-D image array,\n optionally at specified sub-regions.\n\n Args:\n input (cupy.ndarray): Nd-image data to process.\n labels (cupy.ndarray or None): Labels defining sub-regions in `input`.\n If not None, must be same shape as `input`.\n index (cupy.ndarray or None): `labels` to include in output. If None\n (default), all values where `labels` is non-zero are used.\n\n Returns:\n standard_deviation (cupy.ndarray): standard deviation of values, for\n each sub-region if `labels` and `index` are specified.\n\n .. seealso:: :func:`scipy.ndimage.standard_deviation`\n \"\"\"\n return cupy.sqrt(variance(input, labels, index))\n\n\ndef _safely_castable_to_int(dt):\n \"\"\"Test whether the NumPy data type `dt` can be safely cast to an int.\"\"\"\n int_size = cupy.dtype(int).itemsize\n safe = (\n cupy.issubdtype(dt, cupy.signedinteger) and dt.itemsize <= int_size\n ) or (cupy.issubdtype(dt, cupy.unsignedinteger) and dt.itemsize < int_size)\n return safe\n\n\ndef _get_values(arrays, func):\n \"\"\"Concatenated result of applying func to a list of arrays.\n\n func should be cupy.min, cupy.max or cupy.median\n \"\"\"\n dtype = arrays[0].dtype\n return cupy.concatenate(\n [\n func(a, keepdims=True)\n if a.size != 0 else cupy.asarray([0], dtype=dtype)\n for a in arrays\n ]\n )\n\n\ndef _get_positions(arrays, position_arrays, arg_func):\n \"\"\"Concatenated positions from applying arg_func to arrays.\n\n arg_func should be cupy.argmin or cupy.argmax\n \"\"\"\n return cupy.concatenate(\n [\n pos[arg_func(a, keepdims=True)]\n if a.size != 0 else cupy.asarray([0], dtype=int)\n for pos, a in zip(position_arrays, arrays)\n ]\n )\n\n\ndef _select_via_looping(input, labels, idxs, positions, find_min,\n find_min_positions, find_max, find_max_positions,\n find_median):\n \"\"\"Internal helper routine for _select.\n\n With relatively few labels it is faster to call this function rather than\n using the implementation based on cupy.lexsort.\n \"\"\"\n find_positions = find_min_positions or find_max_positions\n\n # extract labeled regions into separate arrays\n arrays = []\n position_arrays = []\n for i in idxs:\n label_idx = labels == i\n arrays.append(input[label_idx])\n if find_positions:\n position_arrays.append(positions[label_idx])\n\n result = []\n # the order below matches the order expected by cupy.ndimage.extrema\n if find_min:\n result += [_get_values(arrays, cupy.min)]\n if find_min_positions:\n result += [_get_positions(arrays, position_arrays, cupy.argmin)]\n if find_max:\n result += [_get_values(arrays, cupy.max)]\n if find_max_positions:\n result += [_get_positions(arrays, position_arrays, cupy.argmax)]\n if find_median:\n result += [_get_values(arrays, cupy.median)]\n return result\n\n\ndef _select(input, labels=None, index=None, find_min=False, find_max=False,\n find_min_positions=False, find_max_positions=False,\n find_median=False):\n \"\"\"Return one or more of: min, max, min position, max position, median.\n\n If neither `labels` or `index` is provided, these are the global values\n in `input`. If `index` is None, but `labels` is provided, a global value\n across all non-zero labels is given. When both `labels` and `index` are\n provided, lists of values are provided for each labeled region specified\n in `index`. See further details in :func:`cupyx.scipy.ndimage.minimum`,\n etc.\n\n Used by minimum, maximum, minimum_position, maximum_position, extrema.\n \"\"\"\n find_positions = find_min_positions or find_max_positions\n positions = None\n if find_positions:\n positions = cupy.arange(input.size).reshape(input.shape)\n\n def single_group(vals, positions):\n result = []\n if find_min:\n result += [vals.min()]\n if find_min_positions:\n result += [positions[vals == vals.min()][0]]\n if find_max:\n result += [vals.max()]\n if find_max_positions:\n result += [positions[vals == vals.max()][0]]\n if find_median:\n result += [cupy.median(vals)]\n return result\n\n if labels is None:\n return single_group(input, positions)\n\n # ensure input and labels match sizes\n input, labels = cupy.broadcast_arrays(input, labels)\n\n if index is None:\n mask = labels > 0\n masked_positions = None\n if find_positions:\n masked_positions = positions[mask]\n return single_group(input[mask], masked_positions)\n\n if cupy.isscalar(index):\n mask = labels == index\n masked_positions = None\n if find_positions:\n masked_positions = positions[mask]\n return single_group(input[mask], masked_positions)\n\n index = cupy.asarray(index)\n\n safe_int = _safely_castable_to_int(labels.dtype)\n min_label = labels.min()\n max_label = labels.max()\n\n # Remap labels to unique integers if necessary, or if the largest label is\n # larger than the number of values.\n if (not safe_int or min_label < 0 or max_label > labels.size):\n # Remap labels, and indexes\n unique_labels, labels = cupy.unique(labels, return_inverse=True)\n idxs = cupy.searchsorted(unique_labels, index)\n\n # Make all of idxs valid\n idxs[idxs >= unique_labels.size] = 0\n found = unique_labels[idxs] == index\n else:\n # Labels are an integer type, and there aren't too many\n idxs = cupy.asanyarray(index, int).copy()\n found = (idxs >= 0) & (idxs <= max_label)\n\n idxs[~found] = max_label + 1\n\n input = input.ravel()\n labels = labels.ravel()\n if find_positions:\n positions = positions.ravel()\n\n using_cub = _core._accelerator.ACCELERATOR_CUB in \\\n cupy._core.get_routine_accelerators()\n\n if using_cub:\n # Cutoff values below were determined empirically for relatively large\n # input arrays.\n if find_positions or find_median:\n n_label_cutoff = 15\n else:\n n_label_cutoff = 30\n else:\n n_label_cutoff = 0\n\n if n_label_cutoff and len(idxs) <= n_label_cutoff:\n return _select_via_looping(\n input, labels, idxs, positions, find_min, find_min_positions,\n find_max, find_max_positions, find_median\n )\n\n order = cupy.lexsort(cupy.stack((input.ravel(), labels.ravel())))\n input = input[order]\n labels = labels[order]\n if find_positions:\n positions = positions[order]\n\n # Determine indices corresponding to the min or max value for each label\n label_change_index = cupy.searchsorted(labels,\n cupy.arange(1, max_label + 2))\n if find_min or find_min_positions or find_median:\n # index corresponding to the minimum value at each label\n min_index = label_change_index[:-1]\n if find_max or find_max_positions or find_median:\n # index corresponding to the maximum value at each label\n max_index = label_change_index[1:] - 1\n\n result = []\n # the order below matches the order expected by cupy.ndimage.extrema\n if find_min:\n mins = cupy.zeros(int(labels.max()) + 2, input.dtype)\n mins[labels[min_index]] = input[min_index]\n result += [mins[idxs]]\n if find_min_positions:\n minpos = cupy.zeros(labels.max().item() + 2, int)\n minpos[labels[min_index]] = positions[min_index]\n result += [minpos[idxs]]\n if find_max:\n maxs = cupy.zeros(int(labels.max()) + 2, input.dtype)\n maxs[labels[max_index]] = input[max_index]\n result += [maxs[idxs]]\n if find_max_positions:\n maxpos = cupy.zeros(labels.max().item() + 2, int)\n maxpos[labels[max_index]] = positions[max_index]\n result += [maxpos[idxs]]\n if find_median:\n locs = cupy.arange(len(labels))\n lo = cupy.zeros(int(labels.max()) + 2, int)\n lo[labels[min_index]] = locs[min_index]\n hi = cupy.zeros(int(labels.max()) + 2, int)\n hi[labels[max_index]] = locs[max_index]\n lo = lo[idxs]\n hi = hi[idxs]\n # lo is an index to the lowest value in input for each label,\n # hi is an index to the largest value.\n # move them to be either the same ((hi - lo) % 2 == 0) or next\n # to each other ((hi - lo) % 2 == 1), then average.\n step = (hi - lo) // 2\n lo += step\n hi -= step\n if input.dtype.kind in 'iub':\n # fix for https://github.com/scipy/scipy/issues/12836\n result += [(input[lo].astype(float) + input[hi].astype(float)) /\n 2.0]\n else:\n result += [(input[lo] + input[hi]) / 2.0]\n\n return result\n\n\ndef minimum(input, labels=None, index=None):\n \"\"\"Calculate the minimum of the values of an array over labeled regions.\n\n Args:\n input (cupy.ndarray):\n Array of values. For each region specified by `labels`, the\n minimal values of `input` over the region is computed.\n labels (cupy.ndarray, optional): An array of integers marking different\n regions over which the minimum value of `input` is to be computed.\n `labels` must have the same shape as `input`. If `labels` is not\n specified, the minimum over the whole array is returned.\n index (array_like, optional): A list of region labels that are taken\n into account for computing the minima. If `index` is None, the\n minimum over all elements where `labels` is non-zero is returned.\n\n Returns:\n cupy.ndarray: Array of minima of `input` over the regions\n determined by `labels` and whose index is in `index`. If `index` or\n `labels` are not specified, a 0-dimensional cupy.ndarray is\n returned: the minimal value of `input` if `labels` is None,\n and the minimal value of elements where `labels` is greater than\n zero if `index` is None.\n\n .. seealso:: :func:`scipy.ndimage.minimum`\n \"\"\"\n return _select(input, labels, index, find_min=True)[0]\n\n\ndef maximum(input, labels=None, index=None):\n \"\"\"Calculate the maximum of the values of an array over labeled regions.\n\n Args:\n input (cupy.ndarray):\n Array of values. For each region specified by `labels`, the\n maximal values of `input` over the region is computed.\n labels (cupy.ndarray, optional): An array of integers marking different\n regions over which the maximum value of `input` is to be computed.\n `labels` must have the same shape as `input`. If `labels` is not\n specified, the maximum over the whole array is returned.\n index (array_like, optional): A list of region labels that are taken\n into account for computing the maxima. If `index` is None, the\n maximum over all elements where `labels` is non-zero is returned.\n\n Returns:\n cupy.ndarray: Array of maxima of `input` over the regions\n determaxed by `labels` and whose index is in `index`. If `index` or\n `labels` are not specified, a 0-dimensional cupy.ndarray is\n returned: the maximal value of `input` if `labels` is None,\n and the maximal value of elements where `labels` is greater than\n zero if `index` is None.\n\n .. seealso:: :func:`scipy.ndimage.maximum`\n \"\"\"\n return _select(input, labels, index, find_max=True)[0]\n\n\ndef median(input, labels=None, index=None):\n \"\"\"Calculate the median of the values of an array over labeled regions.\n\n Args:\n input (cupy.ndarray):\n Array of values. For each region specified by `labels`, the\n median values of `input` over the region is computed.\n labels (cupy.ndarray, optional): An array of integers marking different\n regions over which the median value of `input` is to be computed.\n `labels` must have the same shape as `input`. If `labels` is not\n specified, the median over the whole array is returned.\n index (array_like, optional): A list of region labels that are taken\n into account for computing the medians. If `index` is None, the\n median over all elements where `labels` is non-zero is returned.\n\n Returns:\n cupy.ndarray: Array of medians of `input` over the regions\n determined by `labels` and whose index is in `index`. If `index` or\n `labels` are not specified, a 0-dimensional cupy.ndarray is\n returned: the median value of `input` if `labels` is None,\n and the median value of elements where `labels` is greater than\n zero if `index` is None.\n\n .. seealso:: :func:`scipy.ndimage.median`\n \"\"\"\n return _select(input, labels, index, find_median=True)[0]\n\n\ndef minimum_position(input, labels=None, index=None):\n \"\"\"Find the positions of the minimums of the values of an array at labels.\n\n For each region specified by `labels`, the position of the minimum\n value of `input` within the region is returned.\n\n Args:\n input (cupy.ndarray):\n Array of values. For each region specified by `labels`, the\n minimal values of `input` over the region is computed.\n labels (cupy.ndarray, optional): An array of integers marking different\n regions over which the position of the minimum value of `input` is\n to be computed. `labels` must have the same shape as `input`. If\n `labels` is not specified, the location of the first minimum over\n the whole array is returned.\n\n The `labels` argument only works when `index` is specified.\n index (array_like, optional): A list of region labels that are taken\n into account for finding the location of the minima. If `index` is\n None, the ``first`` minimum over all elements where `labels` is\n non-zero is returned.\n\n The `index` argument only works when `labels` is specified.\n\n Returns:\n Tuple of ints or list of tuples of ints that specify the location of\n minima of `input` over the regions determined by `labels` and whose\n index is in `index`.\n\n If `index` or `labels` are not specified, a tuple of ints is returned\n specifying the location of the first minimal value of `input`.\n\n .. note::\n When `input` has multiple identical minima within a labeled region,\n the coordinates returned are not guaranteed to match those returned by\n SciPy.\n\n .. seealso:: :func:`scipy.ndimage.minimum_position`\n \"\"\"\n dims = numpy.asarray(input.shape)\n # see numpy.unravel_index to understand this line.\n dim_prod = numpy.cumprod([1] + list(dims[:0:-1]))[::-1]\n\n result = _select(input, labels, index, find_min_positions=True)[0]\n\n # have to transfer result back to the CPU to return index tuples\n if result.ndim == 0:\n result = int(result) # synchronize\n else:\n result = cupy.asnumpy(result) # synchronize\n\n if cupy.isscalar(result):\n return tuple((result // dim_prod) % dims)\n\n return [tuple(v) for v in (result.reshape(-1, 1) // dim_prod) % dims]\n\n\ndef maximum_position(input, labels=None, index=None):\n \"\"\"Find the positions of the maximums of the values of an array at labels.\n\n For each region specified by `labels`, the position of the maximum\n value of `input` within the region is returned.\n\n Args:\n input (cupy.ndarray):\n Array of values. For each region specified by `labels`, the\n maximal values of `input` over the region is computed.\n labels (cupy.ndarray, optional): An array of integers marking different\n regions over which the position of the maximum value of `input` is\n to be computed. `labels` must have the same shape as `input`. If\n `labels` is not specified, the location of the first maximum over\n the whole array is returned.\n\n The `labels` argument only works when `index` is specified.\n index (array_like, optional): A list of region labels that are taken\n into account for finding the location of the maxima. If `index` is\n None, the ``first`` maximum over all elements where `labels` is\n non-zero is returned.\n\n The `index` argument only works when `labels` is specified.\n\n Returns:\n Tuple of ints or list of tuples of ints that specify the location of\n maxima of `input` over the regions determaxed by `labels` and whose\n index is in `index`.\n\n If `index` or `labels` are not specified, a tuple of ints is returned\n specifying the location of the first maximal value of `input`.\n\n .. note::\n When `input` has multiple identical maxima within a labeled region,\n the coordinates returned are not guaranteed to match those returned by\n SciPy.\n\n .. seealso:: :func:`scipy.ndimage.maximum_position`\n \"\"\"\n dims = numpy.asarray(input.shape)\n # see numpy.unravel_index to understand this line.\n dim_prod = numpy.cumprod([1] + list(dims[:0:-1]))[::-1]\n\n result = _select(input, labels, index, find_max_positions=True)[0]\n\n # have to transfer result back to the CPU to return index tuples\n if result.ndim == 0:\n result = int(result)\n else:\n result = cupy.asnumpy(result)\n\n if cupy.isscalar(result):\n return tuple((result // dim_prod) % dims)\n\n return [tuple(v) for v in (result.reshape(-1, 1) // dim_prod) % dims]\n\n\ndef extrema(input, labels=None, index=None):\n \"\"\"Calculate the minimums and maximums of the values of an array at labels,\n along with their positions.\n\n Args:\n input (cupy.ndarray): N-D image data to process.\n labels (cupy.ndarray, optional): Labels of features in input. If not\n None, must be same shape as `input`.\n index (int or sequence of ints, optional): Labels to include in output.\n If None (default), all values where non-zero `labels` are used.\n\n Returns:\n A tuple that contains the following values.\n\n **minimums (cupy.ndarray)**: Values of minimums in each feature.\n\n **maximums (cupy.ndarray)**: Values of maximums in each feature.\n\n **min_positions (tuple or list of tuples)**: Each tuple gives the N-D\n coordinates of the corresponding minimum.\n\n **max_positions (tuple or list of tuples)**: Each tuple gives the N-D\n coordinates of the corresponding maximum.\n\n .. seealso:: :func:`scipy.ndimage.extrema`\n \"\"\"\n dims = numpy.array(input.shape)\n # see numpy.unravel_index to understand this line.\n dim_prod = numpy.cumprod([1] + list(dims[:0:-1]))[::-1]\n\n minimums, min_positions, maximums, max_positions = _select(\n input,\n labels,\n index,\n find_min=True,\n find_max=True,\n find_min_positions=True,\n find_max_positions=True,\n )\n\n if min_positions.ndim == 0:\n # scalar output case\n min_positions = min_positions.item()\n max_positions = max_positions.item()\n return (\n minimums,\n maximums,\n tuple((min_positions // dim_prod) % dims),\n tuple((max_positions // dim_prod) % dims),\n )\n\n # convert indexes to tuples on the host\n min_positions = cupy.asnumpy(min_positions)\n max_positions = cupy.asnumpy(max_positions)\n min_positions = [\n tuple(v) for v in (min_positions.reshape(-1, 1) // dim_prod) % dims\n ]\n max_positions = [\n tuple(v) for v in (max_positions.reshape(-1, 1) // dim_prod) % dims\n ]\n\n return minimums, maximums, min_positions, max_positions\n\n\ndef center_of_mass(input, labels=None, index=None):\n \"\"\"\n Calculate the center of mass of the values of an array at labels.\n\n Args:\n input (cupy.ndarray): Data from which to calculate center-of-mass. The\n masses can either be positive or negative.\n labels (cupy.ndarray, optional): Labels for objects in `input`, as\n enerated by `ndimage.label`. Only used with `index`. Dimensions\n must be the same as `input`.\n index (int or sequence of ints, optional): Labels for which to\n calculate centers-of-mass. If not specified, all labels greater\n than zero are used. Only used with `labels`.\n\n Returns:\n tuple or list of tuples: Coordinates of centers-of-mass.\n\n .. seealso:: :func:`scipy.ndimage.center_of_mass`\n \"\"\"\n normalizer = sum(input, labels, index)\n grids = cupy.ogrid[[slice(0, i) for i in input.shape]]\n\n results = [\n sum(input * grids[dir].astype(float), labels, index) / normalizer\n for dir in range(input.ndim)\n ]\n\n # have to transfer 0-dim array back to CPU?\n # may want to modify to avoid this\n is_0dim_array = (\n isinstance(results[0], cupy.ndarray) and results[0].ndim == 0\n )\n if is_0dim_array:\n # tuple of 0-dimensional cupy arrays\n return tuple(res for res in results)\n # list of cupy coordinate arrays\n return [v for v in cupy.stack(results, axis=-1)]\n\n\ndef labeled_comprehension(\n input, labels, index, func, out_dtype, default, pass_positions=False\n):\n \"\"\"Array resulting from applying ``func`` to each labeled region.\n\n Roughly equivalent to [func(input[labels == i]) for i in index].\n\n Sequentially applies an arbitrary function (that works on array_like input)\n to subsets of an N-D image array specified by `labels` and `index`.\n The option exists to provide the function with positional parameters as the\n second argument.\n\n Args:\n input (cupy.ndarray): Data from which to select `labels` to process.\n labels (cupy.ndarray or None): Labels to objects in `input`. If not\n None, array must be same shape as `input`. If None, `func` is\n applied to raveled `input`.\n index (int, sequence of ints or None): Subset of `labels` to which to\n apply `func`. If a scalar, a single value is returned. If None,\n `func` is applied to all non-zero values of `labels`.\n func (callable): Python function to apply to `labels` from `input`.\n out_dtype (dtype): Dtype to use for `result`.\n default (int, float or None): Default return value when a element of\n `index` does not exist in `labels`.\n pass_positions (bool, optional): If True, pass linear indices to `func`\n as a second argument.\n\n Returns:\n cupy.ndarray: Result of applying `func` to each of `labels` to `input`\n in `index`.\n\n .. seealso:: :func:`scipy.ndimage.labeled_comprehension`\n \"\"\"\n as_scalar = cupy.isscalar(index)\n input = cupy.asarray(input)\n\n if pass_positions:\n positions = cupy.arange(input.size).reshape(input.shape)\n\n if labels is None:\n if index is not None:\n raise ValueError('index without defined labels')\n if not pass_positions:\n return func(input.ravel())\n else:\n return func(input.ravel(), positions.ravel())\n\n try:\n input, labels = cupy.broadcast_arrays(input, labels)\n except ValueError:\n raise ValueError(\n 'input and labels must have the same shape '\n '(excepting dimensions with width 1)'\n )\n\n if index is None:\n if not pass_positions:\n return func(input[labels > 0])\n else:\n return func(input[labels > 0], positions[labels > 0])\n\n index = cupy.atleast_1d(index)\n if cupy.any(index.astype(labels.dtype).astype(index.dtype) != index):\n raise ValueError(\n 'Cannot convert index values from <%s> to <%s> '\n '(labels.dtype) without loss of precision'\n % (index.dtype, labels.dtype)\n )\n\n index = index.astype(labels.dtype)\n\n # optimization: find min/max in index, and select those parts of labels,\n # input, and positions\n lo = index.min()\n hi = index.max()\n mask = (labels >= lo) & (labels <= hi)\n\n # this also ravels the arrays\n labels = labels[mask]\n input = input[mask]\n if pass_positions:\n positions = positions[mask]\n\n # sort everything by labels\n label_order = labels.argsort()\n labels = labels[label_order]\n input = input[label_order]\n if pass_positions:\n positions = positions[label_order]\n\n index_order = index.argsort()\n sorted_index = index[index_order]\n\n def do_map(inputs, output):\n \"\"\"labels must be sorted\"\"\"\n nidx = sorted_index.size\n\n # Find boundaries for each stretch of constant labels\n # This could be faster, but we already paid N log N to sort labels.\n lo = cupy.searchsorted(labels, sorted_index, side='left')\n hi = cupy.searchsorted(labels, sorted_index, side='right')\n\n for i, low, high in zip(range(nidx), lo, hi):\n if low == high:\n continue\n output[i] = func(*[inp[low:high] for inp in inputs])\n\n if out_dtype == object:\n temp = {i: default for i in range(index.size)}\n else:\n temp = cupy.empty(index.shape, out_dtype)\n if default is None and temp.dtype.kind in 'fc':\n default = numpy.nan # match NumPy floating-point None behavior\n temp[:] = default\n\n if not pass_positions:\n do_map([input], temp)\n else:\n do_map([input, positions], temp)\n\n if out_dtype == object:\n # use a list of arrays since object arrays are not supported\n index_order = cupy.asnumpy(index_order)\n output = [temp[i] for i in index_order.argsort()]\n else:\n output = cupy.zeros(index.shape, out_dtype)\n output[cupy.asnumpy(index_order)] = temp\n if as_scalar:\n output = output[0]\n return output\n\n\ndef histogram(input, min, max, bins, labels=None, index=None):\n \"\"\"Calculate the histogram of the values of an array, optionally at labels.\n\n Histogram calculates the frequency of values in an array within bins\n determined by `min`, `max`, and `bins`. The `labels` and `index`\n keywords can limit the scope of the histogram to specified sub-regions\n within the array.\n\n Args:\n input (cupy.ndarray): Data for which to calculate histogram.\n min (int): Minimum values of range of histogram bins.\n max (int): Maximum values of range of histogram bins.\n bins (int): Number of bins.\n labels (cupy.ndarray, optional): Labels for objects in `input`. If not\n None, must be same shape as `input`.\n index (int or sequence of ints, optional): Label or labels for which to\n calculate histogram. If None, all values where label is greater\n than zero are used.\n\n Returns:\n cupy.ndarray: Histogram counts.\n\n .. seealso:: :func:`scipy.ndimage.histogram`\n \"\"\"\n _bins = cupy.linspace(min, max, bins + 1)\n\n def _hist(vals):\n return cupy.histogram(vals, _bins)[0]\n\n return labeled_comprehension(\n input, labels, index, _hist, object, None, pass_positions=False\n )\n"
] | [
[
"numpy.add.reduce",
"numpy.asarray",
"numpy.indices",
"numpy.array",
"numpy.where"
]
] |
bolcom/probability | [
"4a11efad1ecd8a1336e4c9fdb0105efbf2375ad7",
"4a11efad1ecd8a1336e4c9fdb0105efbf2375ad7"
] | [
"tensorflow_probability/python/mcmc/replica_exchange_mc.py",
"tensorflow_probability/python/optimizer/sgld_test.py"
] | [
"# Copyright 2018 The TensorFlow Probability Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ============================================================================\n\"\"\"Replica Exchange Monte Carlo Transition Kernel.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport collections\n\nimport tensorflow.compat.v1 as tf1\nimport tensorflow.compat.v2 as tf\n\nfrom tensorflow_probability.python.mcmc import kernel as kernel_base\nfrom tensorflow_probability.python.mcmc.internal import util as mcmc_util\nfrom tensorflow_probability.python.util.seed_stream import SeedStream\n\n__all__ = [\n 'ReplicaExchangeMC',\n 'default_exchange_proposed_fn',\n]\n\nReplicaExchangeMCKernelResults = collections.namedtuple(\n 'ReplicaExchangeMCKernelResults',\n [\n # List of states for each replica. Each state may itself be a list of\n # state parts.\n 'replica_states',\n # List of KernelResults for each replica, post exchange.\n 'replica_results',\n # List of state/state-parts with pre-exchange samples from each replica.\n 'sampled_replica_states',\n # List of kernel-results with pre-exchange samples from each replica.\n 'sampled_replica_results',\n ])\n\n\ndef default_exchange_proposed_fn(prob_exchange):\n \"\"\"Default exchange proposal function, for replica exchange MC.\n\n With probability `prob_exchange` propose combinations of replica for exchange.\n When exchanging, create combinations of adjacent replicas in\n [Replica Exchange Monte Carlo](\n https://en.wikipedia.org/wiki/Parallel_tempering)\n\n ```\n exchange_fn = default_exchange_proposed_fn(prob_exchange=0.5)\n exchange_proposed = exchange_fn(num_replica=3)\n\n exchange_proposed.eval()\n ==> [[0, 1]] # 1 exchange, 0 <--> 1\n\n exchange_proposed.eval()\n ==> [] # 0 exchanges\n ```\n\n Args:\n prob_exchange: Scalar `Tensor` giving probability that any exchanges will\n be generated.\n\n Returns:\n default_exchange_proposed_fn_: Python callable which take a number of\n replicas (a Python integer), and return combinations of replicas for\n exchange as an [n, 2] integer `Tensor`, `0 <= n <= num_replica // 2`,\n with *unique* values in the set `{0, ..., num_replica}`.\n \"\"\"\n\n def default_exchange_proposed_fn_(num_replica, seed=None):\n \"\"\"Default function for `exchange_proposed_fn` of `kernel`.\"\"\"\n seed_stream = SeedStream(seed, 'default_exchange_proposed_fn')\n\n zero_start = tf.random.uniform([], seed=seed_stream()) > 0.5\n if num_replica % 2 == 0:\n\n def _exchange():\n flat_exchange = tf.range(num_replica)\n if num_replica > 2:\n start = tf.cast(~zero_start, dtype=tf.int32)\n end = num_replica - start\n flat_exchange = flat_exchange[start:end]\n return tf.reshape(flat_exchange, [tf.size(input=flat_exchange) // 2, 2])\n else:\n\n def _exchange():\n start = tf.cast(zero_start, dtype=tf.int32)\n end = num_replica - tf.cast(~zero_start, dtype=tf.int32)\n flat_exchange = tf.range(num_replica)[start:end]\n return tf.reshape(flat_exchange, [tf.size(input=flat_exchange) // 2, 2])\n\n def _null_exchange():\n return tf.reshape(tf.cast([], dtype=tf.int32), shape=[0, 2])\n\n return tf.cond(\n pred=tf.random.uniform([], seed=seed_stream()) < prob_exchange,\n true_fn=_exchange,\n false_fn=_null_exchange)\n\n return default_exchange_proposed_fn_\n\n\nclass ReplicaExchangeMC(kernel_base.TransitionKernel):\n \"\"\"Runs one step of the Replica Exchange Monte Carlo.\n\n [Replica Exchange Monte Carlo](\n https://en.wikipedia.org/wiki/Parallel_tempering) is a Markov chain\n Monte Carlo (MCMC) algorithm that is also known as Parallel Tempering. This\n algorithm performs multiple sampling with different temperatures in parallel,\n and exchanges those samplings according to the Metropolis-Hastings criterion.\n\n The `K` replicas are parameterized in terms of `inverse_temperature`'s,\n `(beta[0], beta[1], ..., beta[K-1])`. If the target distribution has\n probability density `p(x)`, the `kth` replica has density `p(x)**beta_k`.\n\n Typically `beta[0] = 1.0`, and `1.0 > beta[1] > beta[2] > ... > 0.0`.\n\n * `beta[0] == 1` ==> First replicas samples from the target density, `p`.\n * `beta[k] < 1`, for `k = 1, ..., K-1` ==> Other replicas sample from\n \"flattened\" versions of `p` (peak is less high, valley less low). These\n distributions are somewhat closer to a uniform on the support of `p`.\n\n Samples from adjacent replicas `i`, `i + 1` are used as proposals for each\n other in a Metropolis step. This allows the lower `beta` samples, which\n explore less dense areas of `p`, to occasionally be used to help the\n `beta == 1` chain explore new regions of the support.\n\n Samples from replica 0 are returned, and the others are discarded.\n\n #### Examples\n\n ##### Sampling from the Standard Normal Distribution.\n\n ```python\n import numpy as np\n import tensorflow as tf\n import tensorflow_probability as tfp\n tfd = tfp.distributions\n\n dtype = np.float32\n\n target = tfd.Normal(loc=dtype(0), scale=dtype(1))\n\n def make_kernel_fn(target_log_prob_fn, seed):\n return tfp.mcmc.HamiltonianMonteCarlo(\n target_log_prob_fn=target_log_prob_fn,\n seed=seed, step_size=1.0, num_leapfrog_steps=3)\n\n remc = tfp.mcmc.ReplicaExchangeMC(\n target_log_prob_fn=target.log_prob,\n inverse_temperatures=[1., 0.3, 0.1, 0.03],\n make_kernel_fn=make_kernel_fn,\n seed=42)\n\n samples, _ = tfp.mcmc.sample_chain(\n num_results=1000,\n current_state=dtype(1),\n kernel=remc,\n num_burnin_steps=500,\n parallel_iterations=1) # For determinism.\n\n sample_mean = tf.reduce_mean(samples, axis=0)\n sample_std = tf.sqrt(\n tf.reduce_mean(tf.squared_difference(samples, sample_mean),\n axis=0))\n with tf.Session() as sess:\n [sample_mean_, sample_std_] = sess.run([sample_mean, sample_std])\n\n print('Estimated mean: {}'.format(sample_mean_))\n print('Estimated standard deviation: {}'.format(sample_std_))\n ```\n\n ##### Sampling from a 2-D Mixture Normal Distribution.\n\n ```python\n import numpy as np\n import tensorflow as tf\n import tensorflow_probability as tfp\n import matplotlib.pyplot as plt\n tfd = tfp.distributions\n\n dtype = np.float32\n\n target = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(probs=[0.5, 0.5]),\n components_distribution=tfd.MultivariateNormalDiag(\n loc=[[-1., -1], [1., 1.]],\n scale_identity_multiplier=[0.1, 0.1]))\n\n def make_kernel_fn(target_log_prob_fn, seed):\n return tfp.mcmc.HamiltonianMonteCarlo(\n target_log_prob_fn=target_log_prob_fn,\n seed=seed, step_size=0.3, num_leapfrog_steps=3)\n\n remc = tfp.mcmc.ReplicaExchangeMC(\n target_log_prob_fn=target.log_prob,\n inverse_temperatures=[1., 0.3, 0.1, 0.03, 0.01],\n make_kernel_fn=make_kernel_fn,\n seed=42)\n\n samples, _ = tfp.mcmc.sample_chain(\n num_results=1000,\n # Start near the [1, 1] mode. Standard HMC would get stuck there.\n current_state=np.ones(2, dtype=dtype),\n kernel=remc,\n num_burnin_steps=500,\n parallel_iterations=1) # For determinism.\n\n with tf.Session() as sess:\n samples_ = sess.run(samples)\n\n plt.figure(figsize=(8, 8))\n plt.xlim(-2, 2)\n plt.ylim(-2, 2)\n plt.plot(samples_[:, 0], samples_[:, 1], '.')\n plt.show()\n ```\n\n \"\"\"\n\n def __init__(self,\n target_log_prob_fn,\n inverse_temperatures,\n make_kernel_fn,\n exchange_proposed_fn=default_exchange_proposed_fn(1.),\n seed=None,\n name=None):\n \"\"\"Instantiates this object.\n\n Args:\n target_log_prob_fn: Python callable which takes an argument like\n `current_state` (or `*current_state` if it's a list) and returns its\n (possibly unnormalized) log-density under the target distribution.\n inverse_temperatures: `1D` `Tensor of inverse temperatures to perform\n samplings with each replica. Must have statically known `shape`.\n `inverse_temperatures[0]` produces the states returned by samplers,\n and is typically == 1.\n make_kernel_fn: Python callable which takes target_log_prob_fn and seed\n args and returns a TransitionKernel instance.\n exchange_proposed_fn: Python callable which take a number of replicas, and\n return combinations of replicas for exchange.\n seed: Python integer to seed the random number generator.\n Default value: `None` (i.e., no seed).\n name: Python `str` name prefixed to Ops created by this function.\n Default value: `None` (i.e., \"remc_kernel\").\n\n Raises:\n ValueError: `inverse_temperatures` doesn't have statically known 1D shape.\n \"\"\"\n inverse_temperatures = tf.convert_to_tensor(\n value=inverse_temperatures, name='inverse_temperatures')\n\n # Note these are static checks, and don't need to be embedded in the graph.\n inverse_temperatures.shape.assert_is_fully_defined()\n inverse_temperatures.shape.assert_has_rank(1)\n\n self._seed_stream = SeedStream(seed, salt=name)\n self._seeded_mcmc = seed is not None\n self._parameters = dict(\n target_log_prob_fn=target_log_prob_fn,\n inverse_temperatures=inverse_temperatures,\n num_replica=tf.compat.dimension_value(inverse_temperatures.shape[0]),\n exchange_proposed_fn=exchange_proposed_fn,\n seed=seed,\n name=name)\n self.replica_kernels = []\n for i in range(self.num_replica):\n self.replica_kernels.append(\n make_kernel_fn(\n target_log_prob_fn=_replica_log_prob_fn(inverse_temperatures[i],\n target_log_prob_fn),\n seed=self._seed_stream()))\n\n @property\n def target_log_prob_fn(self):\n return self._parameters['target_log_prob_fn']\n\n @property\n def inverse_temperatures(self):\n return self._parameters['inverse_temperatures']\n\n @property\n def num_replica(self):\n return self._parameters['num_replica']\n\n @property\n def exchange_proposed_fn(self):\n return self._parameters['exchange_proposed_fn']\n\n @property\n def seed(self):\n return self._parameters['seed']\n\n @property\n def name(self):\n return self._parameters['name']\n\n @property\n def parameters(self):\n \"\"\"Return `dict` of ``__init__`` arguments and their values.\"\"\"\n return self._parameters\n\n @property\n def is_calibrated(self):\n return True\n\n def one_step(self, current_state, previous_kernel_results):\n \"\"\"Takes one step of the TransitionKernel.\n\n Args:\n current_state: `Tensor` or Python `list` of `Tensor`s representing the\n current state(s) of the Markov chain(s).\n previous_kernel_results: A (possibly nested) `tuple`, `namedtuple` or\n `list` of `Tensor`s representing internal calculations made within the\n previous call to this function (or as returned by `bootstrap_results`).\n\n Returns:\n next_state: `Tensor` or Python `list` of `Tensor`s representing the\n next state(s) of the Markov chain(s).\n kernel_results: A (possibly nested) `tuple`, `namedtuple` or `list` of\n `Tensor`s representing internal calculations made within this function.\n This inculdes replica states.\n \"\"\"\n # Key difficulty: The type of exchanges differs from one call to the\n # next...even the number of exchanges can differ.\n # As a result, exchanges must happen dynamically, in while loops.\n with tf1.name_scope(\n name=mcmc_util.make_name(self.name, 'remc', 'one_step'),\n values=[current_state, previous_kernel_results]):\n\n # Each replica does `one_step` to get pre-exchange states/KernelResults.\n sampled_replica_states, sampled_replica_results = zip(*[\n rk.one_step(previous_kernel_results.replica_states[i],\n previous_kernel_results.replica_results[i])\n for i, rk in enumerate(self.replica_kernels)\n ])\n sampled_replica_states = list(sampled_replica_states)\n sampled_replica_results = list(sampled_replica_results)\n\n states_are_lists = mcmc_util.is_list_like(sampled_replica_states[0])\n\n if not states_are_lists:\n sampled_replica_states = [[s] for s in sampled_replica_states]\n num_state_parts = len(sampled_replica_states[0])\n\n dtype = sampled_replica_states[0][0].dtype\n\n # Must put states into TensorArrays. Why? We will read/write states\n # dynamically with Tensor index `i`, and you cannot do this with lists.\n # old_states[k][i] is Tensor of (old) state part k, for replica i.\n # The `k` will be known statically, and `i` is a Tensor.\n old_states = [\n tf.TensorArray(\n dtype,\n size=self.num_replica,\n dynamic_size=False,\n clear_after_read=False,\n tensor_array_name='old_states',\n # State part k has same shape, regardless of replica. So use 0.\n element_shape=sampled_replica_states[0][k].shape)\n for k in range(num_state_parts)\n ]\n for k in range(num_state_parts):\n for i in range(self.num_replica):\n old_states[k] = old_states[k].write(i, sampled_replica_states[i][k])\n\n exchange_proposed = self.exchange_proposed_fn(\n self.num_replica, seed=self._seed_stream())\n exchange_proposed_n = tf.shape(input=exchange_proposed)[0]\n\n exchanged_states = self._get_exchanged_states(\n old_states, exchange_proposed, exchange_proposed_n,\n sampled_replica_states, sampled_replica_results)\n\n no_exchange_proposed, _ = tf1.setdiff1d(\n tf.range(self.num_replica), tf.reshape(exchange_proposed, [-1]))\n\n exchanged_states = self._insert_old_states_where_no_exchange_was_proposed(\n no_exchange_proposed, old_states, exchanged_states)\n\n next_replica_states = []\n for i in range(self.num_replica):\n next_replica_states_i = []\n for k in range(num_state_parts):\n next_replica_states_i.append(exchanged_states[k].read(i))\n next_replica_states.append(next_replica_states_i)\n\n if not states_are_lists:\n next_replica_states = [s[0] for s in next_replica_states]\n sampled_replica_states = [s[0] for s in sampled_replica_states]\n\n # Now that states are/aren't exchanged, bootstrap next kernel_results.\n # The viewpoint is that after each exchange, we are starting anew.\n next_replica_results = [\n rk.bootstrap_results(state)\n for rk, state in zip(self.replica_kernels, next_replica_states)\n ]\n\n next_state = next_replica_states[0] # Replica 0 is the returned state(s).\n\n kernel_results = ReplicaExchangeMCKernelResults(\n replica_states=next_replica_states,\n replica_results=next_replica_results,\n sampled_replica_states=sampled_replica_states,\n sampled_replica_results=sampled_replica_results,\n )\n\n return next_state, kernel_results\n\n def _get_exchanged_states(self, old_states, exchange_proposed,\n exchange_proposed_n, sampled_replica_states,\n sampled_replica_results):\n \"\"\"Get list of TensorArrays holding exchanged states, and zeros.\"\"\"\n with tf1.name_scope('get_exchanged_states'):\n\n target_log_probs = []\n for replica in range(self.num_replica):\n replica_log_prob = _get_field(sampled_replica_results[replica],\n 'target_log_prob')\n inverse_temp = self.inverse_temperatures[replica]\n target_log_probs.append(replica_log_prob / inverse_temp)\n target_log_probs = tf.stack(target_log_probs, axis=0)\n\n dtype = target_log_probs.dtype\n num_state_parts = len(sampled_replica_states[0])\n # exchanged_states[k][i] is Tensor of (new) state part k, for replica i.\n # The `k` will be known statically, and `i` is a Tensor.\n # We will insert values into indices `i` for every replica with a proposed\n # exchange.\n exchanged_states = [\n tf.TensorArray(\n dtype,\n size=self.num_replica,\n dynamic_size=False,\n tensor_array_name='exchanged_states',\n # State part k has same shape, regardless of replica. So use 0.\n element_shape=sampled_replica_states[0][k].shape)\n for k in range(num_state_parts)\n ]\n\n # Draw random variables here, to avoid sampling in the loop (and losing\n # reproducibility). This may mean we sample too many, but we will always\n # have enough.\n sample_shape = tf.concat(\n ([self.num_replica // 2], tf.shape(input=target_log_probs)[1:]),\n axis=0)\n log_uniforms = tf.math.log(\n tf.random.uniform(\n shape=sample_shape, dtype=dtype, seed=self._seed_stream()))\n\n def _swap(is_exchange_accepted, x, y):\n \"\"\"Swap batches of x, y where accepted.\"\"\"\n with tf1.name_scope('swap_where_exchange_accepted'):\n new_x = mcmc_util.choose(is_exchange_accepted, y, x)\n new_y = mcmc_util.choose(is_exchange_accepted, x, y)\n return new_x, new_y\n\n def cond(i, unused_exchanged_states):\n return i < exchange_proposed_n\n\n def body(i, exchanged_states):\n \"\"\"Body of while loop for exchanging states.\"\"\"\n # Propose exchange between replicas indexed by m and n.\n m, n = tf.unstack(exchange_proposed[i])\n\n # Construct log_accept_ratio: -temp_diff * target_log_prob_diff.\n # Note target_log_prob_diff = -EnergyDiff (common definition is in terms\n # of energy).\n temp_diff = self.inverse_temperatures[m] - self.inverse_temperatures[n]\n # Difference of target log probs may be +- Inf or NaN. We want the\n # product of this with the temperature difference to have \"alt value\" of\n # -Inf.\n log_accept_ratio = mcmc_util.safe_sum(\n [-temp_diff * target_log_probs[m], temp_diff * target_log_probs[n]])\n\n is_exchange_accepted = log_uniforms[i] < log_accept_ratio\n\n for k in range(num_state_parts):\n new_m, new_n = _swap(is_exchange_accepted, old_states[k].read(m),\n old_states[k].read(n))\n exchanged_states[k] = exchanged_states[k].write(m, new_m)\n exchanged_states[k] = exchanged_states[k].write(n, new_n)\n\n return i + 1, exchanged_states\n\n # At this point, exchanged_states[k] is a length num_replicas TensorArray.\n return tf.while_loop(\n cond=cond, body=body, loop_vars=[tf.constant(0),\n exchanged_states])[1] # Remove `i`\n\n def _insert_old_states_where_no_exchange_was_proposed(\n self, no_exchange_proposed, old_states, exchanged_states):\n with tf1.name_scope(\n 'insert_old_states_where_no_exchange_was_proposed'):\n\n def cond(j, unused_exchanged_states):\n return j < tf.size(input=no_exchange_proposed)\n\n def body(j, exchanged_states):\n replica = no_exchange_proposed[j]\n for k in range(len(old_states)): # k indexes state part\n exchanged_states[k] = exchanged_states[k].write(\n replica, old_states[k].read(replica))\n return j + 1, exchanged_states\n\n return tf.while_loop(\n cond=cond, body=body, loop_vars=[tf.constant(0),\n exchanged_states])[1] # Remove `j`\n\n def bootstrap_results(self, init_state):\n \"\"\"Returns an object with the same type as returned by `one_step`.\n\n Args:\n init_state: `Tensor` or Python `list` of `Tensor`s representing the\n initial state(s) of the Markov chain(s).\n\n Returns:\n kernel_results: A (possibly nested) `tuple`, `namedtuple` or `list` of\n `Tensor`s representing internal calculations made within this function.\n This inculdes replica states.\n \"\"\"\n with tf1.name_scope(\n name=mcmc_util.make_name(self.name, 'remc', 'bootstrap_results'),\n values=[init_state]):\n replica_results = [\n self.replica_kernels[i].bootstrap_results(init_state)\n for i in range(self.num_replica)\n ]\n\n init_state_parts = (\n list(init_state)\n if mcmc_util.is_list_like(init_state) else [init_state])\n\n # Convert all states parts to tensor...\n replica_states = [[\n tf.convert_to_tensor(value=s) for s in init_state_parts\n ] for i in range(self.num_replica)]\n\n if not mcmc_util.is_list_like(init_state):\n replica_states = [s[0] for s in replica_states]\n\n return ReplicaExchangeMCKernelResults(\n replica_states=replica_states,\n replica_results=replica_results,\n sampled_replica_states=replica_states,\n sampled_replica_results=replica_results,\n )\n\n\ndef _replica_log_prob_fn(inverse_temperature, target_log_prob_fn):\n \"\"\"Return a log probability function made considering temperature.\"\"\"\n\n def _replica_log_prob_fn_(*x):\n return inverse_temperature * target_log_prob_fn(*x)\n\n return _replica_log_prob_fn_\n\n\n# TODO(b/111801087) Use a more standardized API when available.\ndef _get_field(kernel_results, field_name):\n \"\"\"field_name from kernel_results or kernel_results.accepted_results.\"\"\"\n if hasattr(kernel_results, field_name):\n return getattr(kernel_results, field_name)\n if hasattr(kernel_results, 'accepted_results'):\n return getattr(kernel_results.accepted_results, field_name)\n raise TypeError('Cannot extract %s from %s' % (field_name, kernel_results))\n",
"# Copyright 2018 The TensorFlow Probability Authors.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n# ============================================================================\n\"\"\"Functional test for GradientDescent.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\n# Dependency imports\n\nimport numpy as np\nimport tensorflow.compat.v1 as tf1\nimport tensorflow.compat.v2 as tf\nimport tensorflow_probability as tfp\nfrom tensorflow_probability.python import distributions as tfd\nfrom tensorflow_probability.python.internal import test_case\nfrom tensorflow_probability.python.math import diag_jacobian\n\nfrom tensorflow.python.framework import test_util # pylint: disable=g-direct-tensorflow-import,g-import-not-at-top\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass StochasticGradientLangevinDynamicsOptimizerTest(test_case.TestCase):\n\n def testBasic(self):\n if tf.executing_eagerly():\n return\n\n for dtype in [tf.half, tf.float32, tf.float64]:\n with self.cached_session():\n var0 = tf.Variable([1.1, 2.1], dtype=dtype)\n var1 = tf.Variable([3., 4.], dtype=dtype)\n grads0 = tf.constant([0.1, 0.1], dtype=dtype)\n grads1 = tf.constant([0.01, 0.01], dtype=dtype)\n decay_rate = 0.53\n sgd_optimizer = tfp.optimizer.StochasticGradientLangevinDynamics(\n 3., preconditioner_decay_rate=decay_rate)\n sgd_op = sgd_optimizer.apply_gradients(\n zip([grads0, grads1], [var0, var1]))\n\n self.evaluate(tf1.global_variables_initializer())\n # Fetch params to validate initial values\n self.assertAllCloseAccordingToType([1.1, 2.1], self.evaluate(var0))\n self.assertAllCloseAccordingToType([3., 4.], self.evaluate(var1))\n # Run 1 step of sgd\n self.evaluate(sgd_op)\n # Validate updated params\n grads_scaled = (0.5 * 0.1 /\n np.sqrt(decay_rate + (1. - decay_rate) * 0.1**2 + 1e-8))\n # Note that `tfp.math.diag_jacobian(xs=var, ys=grad)` returns zero\n # tensor\n self.assertAllCloseAccordingToType(\n [1.1 - 3. * grads_scaled, 2.1 - 3. * grads_scaled],\n self.evaluate(var0))\n grads_scaled = (0.5 * 0.01 / np.sqrt(\n decay_rate + (1. - decay_rate) * 0.01**2 + 1e-8))\n self.assertAllCloseAccordingToType(\n [3. - 3. * grads_scaled, 4. - 3. * grads_scaled],\n self.evaluate(var1))\n self.assertAllCloseAccordingToType(\n 1, self.evaluate(sgd_optimizer.iterations))\n\n def testBasicMultiInstance(self):\n if tf.executing_eagerly():\n return\n\n for dtype in [tf.half, tf.float32, tf.float64]:\n with self.cached_session():\n var0 = tf.Variable([1.1, 2.1], dtype=dtype)\n var1 = tf.Variable([3., 4.], dtype=dtype)\n grads0 = tf.constant([0.1, 0.1], dtype=dtype)\n grads1 = tf.constant([0.01, 0.01], dtype=dtype)\n vara = tf.Variable([1.1, 2.1], dtype=dtype)\n varb = tf.Variable([3., 4.], dtype=dtype)\n gradsa = tf.constant([0.1, 0.1], dtype=dtype)\n gradsb = tf.constant([0.01, 0.01], dtype=dtype)\n decay_rate = 0.5\n sgd_optimizer = tfp.optimizer.StochasticGradientLangevinDynamics(\n 3., preconditioner_decay_rate=decay_rate)\n sgd_op = sgd_optimizer.apply_gradients(\n zip([grads0, grads1], [var0, var1]))\n sgd_optimizer2 = tfp.optimizer.StochasticGradientLangevinDynamics(\n 3., preconditioner_decay_rate=decay_rate)\n sgd_op2 = sgd_optimizer2.apply_gradients(\n zip([gradsa, gradsb], [vara, varb]))\n self.evaluate(tf1.global_variables_initializer())\n # Fetch params to validate initial values\n self.assertAllCloseAccordingToType([1.1, 2.1], self.evaluate(var0))\n self.assertAllCloseAccordingToType([3., 4.], self.evaluate(var1))\n self.assertAllCloseAccordingToType([1.1, 2.1], self.evaluate(vara))\n self.assertAllCloseAccordingToType([3., 4.], self.evaluate(varb))\n\n # Run 1 step of sgd\n self.evaluate(sgd_op)\n self.evaluate(sgd_op2)\n\n # Validate updated params\n grads_scaled = (0.5 * 0.1 /\n np.sqrt(decay_rate + (1. - decay_rate) * 0.1**2 + 1e-8))\n self.assertAllCloseAccordingToType(\n [1.1 - 3. * grads_scaled, 2.1 - 3. * grads_scaled],\n self.evaluate(var0))\n self.assertAllCloseAccordingToType(\n [1.1 - 3. * grads_scaled, 2.1 - 3. * grads_scaled],\n self.evaluate(vara))\n\n grads_scaled = (0.5 * 0.01 / np.sqrt(\n decay_rate + (1 - decay_rate) * 0.01**2 + 1e-8))\n self.assertAllCloseAccordingToType(\n [3. - 3. * grads_scaled, 4. - 3. * grads_scaled],\n self.evaluate(var1))\n self.assertAllCloseAccordingToType(\n [3. - 3. * grads_scaled, 4. - 3. * grads_scaled],\n self.evaluate(varb))\n self.assertAllCloseAccordingToType(\n 1, self.evaluate(sgd_optimizer.iterations))\n self.assertAllCloseAccordingToType(\n 1, self.evaluate(sgd_optimizer2.iterations))\n\n def testTensorLearningRate(self):\n if tf.executing_eagerly():\n return\n\n for dtype in [tf.half, tf.float32, tf.float64]:\n with self.cached_session():\n var0 = tf.Variable([1.1, 2.1], dtype=dtype)\n var1 = tf.Variable([3., 4.], dtype=dtype)\n grads0 = tf.constant([0.1, 0.1], dtype=dtype)\n grads1 = tf.constant([0.01, 0.01], dtype=dtype)\n lrate = tf.constant(3.0)\n decay_rate = 0.5\n sgd_op = tfp.optimizer.StochasticGradientLangevinDynamics(\n lrate, preconditioner_decay_rate=tf.constant(\n decay_rate)).apply_gradients(\n zip([grads0, grads1], [var0, var1]))\n self.evaluate(tf1.global_variables_initializer())\n # Fetch params to validate initial values\n self.assertAllCloseAccordingToType([1.1, 2.1], self.evaluate(var0))\n self.assertAllCloseAccordingToType([3., 4.], self.evaluate(var1))\n # Run 1 step of sgd\n self.evaluate(sgd_op)\n # Validate updated params\n grads_scaled = (0.5 * 0.1 /\n np.sqrt(decay_rate + (1. - decay_rate) * 0.1**2 + 1e-8))\n # Note that `tfp.math.diag_jacobian(xs=var, ys=grad)` returns zero\n # tensor\n self.assertAllCloseAccordingToType(\n [1.1 - 3. * grads_scaled, 2.1 - 3. * grads_scaled],\n self.evaluate(var0))\n grads_scaled = (0.5 * 0.01 / np.sqrt(\n decay_rate + (1. - decay_rate) * 0.01**2 + 1e-8))\n self.assertAllCloseAccordingToType(\n [3. - 3. * grads_scaled, 4. - 3. * grads_scaled],\n self.evaluate(var1))\n\n @test_util.run_deprecated_v1\n def testGradWrtRef(self):\n if tf.executing_eagerly():\n return\n\n for dtype in [tf.half, tf.float32, tf.float64]:\n with self.cached_session():\n opt = tfp.optimizer.StochasticGradientLangevinDynamics(3.0)\n values = [1., 3.]\n vars_ = [tf.Variable([v], dtype=dtype) for v in values]\n loss = lambda: vars_[0] + vars_[1] # pylint: disable=cell-var-from-loop\n grads_and_vars = opt._compute_gradients(loss, vars_)\n self.evaluate(tf1.global_variables_initializer())\n for grad, _ in grads_and_vars:\n self.assertAllCloseAccordingToType([1.], self.evaluate(grad))\n\n def testBurnin(self):\n if tf.executing_eagerly():\n return\n\n for burnin_dtype in [tf.int8, tf.int16, tf.int32, tf.int64]:\n with self.cached_session():\n var0 = tf.Variable([1.1, 2.1], dtype=tf.float32)\n grads0 = tf.constant([0.1, 0.1], dtype=tf.float32)\n decay_rate = 0.53\n sgd_optimizer = tfp.optimizer.StochasticGradientLangevinDynamics(\n 3.,\n preconditioner_decay_rate=decay_rate,\n burnin=tf.constant(10, dtype=burnin_dtype))\n sgd_op = sgd_optimizer.apply_gradients([(grads0, var0)])\n\n self.evaluate(tf1.global_variables_initializer())\n # Validate that iterations is initialized to 0.\n self.assertAllCloseAccordingToType(\n 0, self.evaluate(sgd_optimizer.iterations))\n # Run 1 step of sgd\n self.evaluate(sgd_op)\n # Validate that iterations is incremented.\n self.assertAllCloseAccordingToType(\n 1, self.evaluate(sgd_optimizer.iterations))\n\n def testWithGlobalStep(self):\n if tf.executing_eagerly():\n return\n\n for dtype in [tf.float32, tf.float64]:\n with self.cached_session():\n step = tf.Variable(0, dtype=tf.int64)\n\n var0 = tf.Variable([1.1, 2.1], dtype=dtype)\n var1 = tf.Variable([3., 4.], dtype=dtype)\n grads0 = tf.constant([0.1, 0.1], dtype=dtype)\n grads1 = tf.constant([0.01, 0.01], dtype=dtype)\n decay_rate = 0.1\n\n sgd_opt = tfp.optimizer.StochasticGradientLangevinDynamics(\n 3., preconditioner_decay_rate=decay_rate)\n sgd_opt.iterations = step\n sgd_op = sgd_opt.apply_gradients(zip([grads0, grads1], [var0, var1]))\n\n self.evaluate(tf1.global_variables_initializer())\n\n # Fetch params to validate initial values\n self.assertAllCloseAccordingToType([1.1, 2.1], self.evaluate(var0))\n self.assertAllCloseAccordingToType([3., 4.], self.evaluate(var1))\n # Run 1 step of sgd\n self.evaluate(sgd_op)\n\n # Validate updated params and step\n grads_scaled = (0.5 * 0.1 /\n np.sqrt(decay_rate + (1. - decay_rate) * 0.1**2 + 1e-8))\n # Note that `tfp.math.diag_jacobian(xs=var, ys=grad)` returns zero\n # tensor\n self.assertAllCloseAccordingToType(\n [1.1 - 3. * grads_scaled, 2.1 - 3. * grads_scaled],\n self.evaluate(var0))\n grads_scaled = (0.5 * 0.01 / np.sqrt(\n decay_rate + (1. - decay_rate) * 0.01**2 + 1e-8))\n self.assertAllCloseAccordingToType(\n [3. - 3. * grads_scaled, 4. - 3. * grads_scaled],\n self.evaluate(var1))\n self.assertAllCloseAccordingToType(1, self.evaluate(step))\n\n def testSparseBasic(self):\n if tf.executing_eagerly():\n return\n\n for dtype in [tf.half, tf.float32, tf.float64]:\n with self.cached_session():\n var0 = tf.Variable([[1.1], [2.1]], dtype=dtype)\n var1 = tf.Variable([[3.], [4.]], dtype=dtype)\n grads0 = tf.IndexedSlices(\n tf.constant([0.1], shape=[1, 1], dtype=dtype),\n tf.constant([0]), tf.constant([2, 1]))\n grads1 = tf.IndexedSlices(\n tf.constant([0.01], shape=[1, 1], dtype=dtype),\n tf.constant([1]), tf.constant([2, 1]))\n decay_rate = 0.9\n sgd_op = tfp.optimizer.StochasticGradientLangevinDynamics(\n 3., preconditioner_decay_rate=decay_rate).apply_gradients(\n zip([grads0, grads1], [var0, var1]))\n self.evaluate(tf1.global_variables_initializer())\n # Fetch params to validate initial values\n self.assertAllCloseAccordingToType([[1.1], [2.1]], self.evaluate(var0))\n self.assertAllCloseAccordingToType([[3.], [4.]], self.evaluate(var1))\n # Run 1 step of sgd\n self.evaluate(sgd_op)\n # Validate updated params\n grads_scaled = (0.5 * 0.1 /\n np.sqrt(decay_rate + (1. - decay_rate) * 0.1**2 + 1e-8))\n # Note that `tfp.math.diag_jacobian(xs=var, ys=grad)` returns zero\n # tensor\n self.assertAllCloseAccordingToType([[1.1 - 3. * grads_scaled], [2.1]],\n self.evaluate(var0))\n grads_scaled = (0.5 * 0.01 / np.sqrt(\n decay_rate + (1. - decay_rate) * 0.01**2 + 1e-8))\n self.assertAllCloseAccordingToType(\n [[3. - 3. * 0], [4. - 3. * grads_scaled]], self.evaluate(var1))\n\n def testPreconditionerComputedCorrectly(self):\n \"\"\"Test that SGLD step is computed correctly for a 3D Gaussian energy.\"\"\"\n if tf.executing_eagerly():\n return\n\n with self.cached_session():\n dtype = np.float32\n # Target function is the energy function of normal distribution\n true_mean = dtype([0, 0, 0])\n true_cov = dtype([[1, 0.25, 0.25], [0.25, 1, 0.25], [0.25, 0.25, 1]])\n # Target distribution is defined through the Cholesky decomposition\n chol = tf.linalg.cholesky(true_cov)\n target = tfd.MultivariateNormalTriL(loc=true_mean, scale_tril=chol)\n var_1 = tf.Variable(name='var_1', initial_value=[1., 1.])\n var_2 = tf.Variable(name='var_2', initial_value=[1.])\n\n var = [var_1, var_2]\n\n # Set up the learning rate and the optimizer\n learning_rate = .5\n optimizer_kernel = tfp.optimizer.StochasticGradientLangevinDynamics(\n learning_rate=learning_rate, burnin=1)\n\n # Target function\n def target_fn(x, y):\n # Stack the input tensors together\n z = tf.concat([x, y], axis=-1) - true_mean\n return -target.log_prob(z)\n\n grads = tf.gradients(ys=target_fn(*var), xs=var)\n\n # Update value of `var` with one iteration of the SGLD (without the\n # normal perturbation, since `burnin > 0`)\n step = optimizer_kernel.apply_gradients(zip(grads, var))\n\n # True theoretical value of `var` after one iteration\n decay_tensor = tf.cast(optimizer_kernel._decay_tensor, var[0].dtype)\n diagonal_bias = tf.cast(optimizer_kernel._diagonal_bias, var[0].dtype)\n learning_rate = tf.cast(optimizer_kernel._learning_rate, var[0].dtype)\n velocity = [(decay_tensor * tf.ones_like(v)\n + (1 - decay_tensor) * tf.square(g))\n for v, g in zip(var, grads)]\n preconditioner = [tf.math.rsqrt(vel + diagonal_bias) for vel in velocity]\n # Compute second order gradients\n _, grad_grads = diag_jacobian(\n xs=var,\n ys=grads)\n # Compute gradient of the preconditioner (compute the gradient manually)\n preconditioner_grads = [-(g * g_g * (1. - decay_tensor) * p**3.)\n for g, g_g, p in zip(grads, grad_grads,\n preconditioner)]\n\n # True theoretical value of `var` after one iteration\n var_true = [v - learning_rate * 0.5 * (p * g - p_g)\n for v, p, g, p_g in zip(var, preconditioner, grads,\n preconditioner_grads)]\n self.evaluate(tf1.global_variables_initializer())\n var_true_ = self.evaluate(var_true)\n self.evaluate(step)\n var_ = self.evaluate(var) # new `var` after one SGLD step\n self.assertAllClose(var_true_,\n var_, atol=0.001, rtol=0.001)\n\n def testDiffusionBehavesCorrectly(self):\n \"\"\"Test that for the SGLD finds minimum of the 3D Gaussian energy.\"\"\"\n if tf.executing_eagerly():\n return\n\n with self.cached_session():\n # Set up random seed for the optimizer\n tf1.set_random_seed(42)\n dtype = np.float32\n true_mean = dtype([0, 0, 0])\n true_cov = dtype([[1, 0.25, 0.25], [0.25, 1, 0.25], [0.25, 0.25, 1]])\n # Loss is defined through the Cholesky decomposition\n chol = tf.linalg.cholesky(true_cov)\n var_1 = tf.Variable(name='var_1', initial_value=[1., 1.])\n var_2 = tf.Variable(name='var_2', initial_value=[1.])\n\n # Loss function\n def loss_fn():\n var = tf.concat([var_1, var_2], axis=-1)\n loss_part = tf.linalg.cholesky_solve(chol, tf.expand_dims(var, -1))\n return tf.linalg.matvec(loss_part, var, transpose_a=True)\n\n # Set up the learning rate with a polynomial decay\n global_step = tf1.train.get_or_create_global_step()\n starter_learning_rate = .3\n end_learning_rate = 1e-4\n decay_steps = 1e4\n learning_rate = tf1.train.polynomial_decay(\n starter_learning_rate,\n global_step,\n decay_steps,\n end_learning_rate,\n power=1.)\n\n # Set up the optimizer\n optimizer_kernel = tfp.optimizer.StochasticGradientLangevinDynamics(\n learning_rate=learning_rate, preconditioner_decay_rate=0.99)\n optimizer_kernel.iterations = global_step\n optimizer = optimizer_kernel.minimize(loss_fn, var_list=[var_1, var_2])\n\n # Number of training steps\n training_steps = 5000\n # Record the steps as and treat them as samples\n samples = [np.zeros([training_steps, 2]), np.zeros([training_steps, 1])]\n self.evaluate(tf1.global_variables_initializer())\n for step in range(training_steps):\n self.evaluate(optimizer)\n sample = [self.evaluate(var_1), self.evaluate(var_2)]\n samples[0][step, :] = sample[0]\n samples[1][step, :] = sample[1]\n\n samples_ = np.concatenate(samples, axis=-1)\n sample_mean = np.mean(samples_, 0)\n self.assertAllClose(sample_mean, true_mean, atol=0.1, rtol=0.1)\n\nif __name__ == '__main__':\n tf.test.main()\n"
] | [
[
"tensorflow.compat.v2.stack",
"tensorflow.compat.v2.shape",
"tensorflow.compat.v2.size",
"tensorflow.compat.v2.unstack",
"tensorflow.compat.v2.convert_to_tensor",
"tensorflow.compat.v2.reshape",
"tensorflow.compat.v2.range",
"tensorflow.compat.v2.TensorArray",
"tensorflow.compat.v2.compat.dimension_value",
"tensorflow.compat.v2.constant",
"tensorflow.compat.v2.cast",
"tensorflow.compat.v1.name_scope"
],
[
"tensorflow.compat.v2.concat",
"tensorflow.compat.v2.square",
"tensorflow.compat.v2.ones_like",
"tensorflow.compat.v2.constant",
"tensorflow.compat.v2.linalg.cholesky",
"tensorflow.compat.v2.expand_dims",
"tensorflow.compat.v2.cast",
"tensorflow.compat.v2.Variable",
"numpy.mean",
"tensorflow.compat.v1.train.polynomial_decay",
"numpy.zeros",
"tensorflow.compat.v2.math.rsqrt",
"tensorflow.compat.v1.global_variables_initializer",
"tensorflow.compat.v2.executing_eagerly",
"tensorflow.compat.v2.linalg.matvec",
"tensorflow.compat.v2.test.main",
"tensorflow.compat.v1.set_random_seed",
"numpy.sqrt",
"numpy.concatenate",
"tensorflow.compat.v1.train.get_or_create_global_step"
]
] |
TencentYoutuResearch/PersonReID-ACT | [
"264b1b43f9424c297638ebf6f8f8ace09512ed29"
] | [
"selftrainingCT.py"
] | [
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\nfrom __future__ import print_function, absolute_import\nimport argparse\nimport time\nimport os.path as osp\nimport os\nimport numpy as np\nimport torch\nfrom torch import nn\nfrom torch.nn import init\nfrom torch.backends import cudnn\nfrom torch.utils.data import DataLoader\nfrom reid import datasets\nfrom reid import models\nfrom reid.dist_metric import DistanceMetric\nfrom reid.loss import TripletLoss\nfrom reid.trainers import CoTeaching\nfrom reid.evaluators import Evaluator, extract_features\nfrom reid.utils.data import transforms as T\nimport torch.nn.functional as F\nfrom reid.utils.data.preprocessor import Preprocessor\nfrom reid.utils.data.sampler import RandomIdentitySampler\nfrom reid.utils.serialization import load_checkpoint, save_checkpoint\n\nfrom sklearn.cluster import DBSCAN\nfrom reid.rerank import re_ranking\n\n\ndef calScores(clusters, labels):\n \"\"\"\n compute pair-wise precision pair-wise recall\n \"\"\"\n from scipy.special import comb\n if len(clusters) == 0:\n return 0, 0\n else:\n curCluster = []\n for curClus in clusters.values():\n curCluster.append(labels[curClus])\n TPandFP = sum([comb(len(val), 2) for val in curCluster])\n TP = 0\n for clusterVal in curCluster:\n for setMember in set(clusterVal):\n if sum(clusterVal == setMember) < 2: continue\n TP += comb(sum(clusterVal == setMember), 2)\n FP = TPandFP - TP\n # FN and TN\n TPandFN = sum([comb(labels.tolist().count(val), 2) for val in set(labels)])\n FN = TPandFN - TP\n # cal precision and recall\n precision, recall = TP / (TP + FP), TP / (TP + FN)\n fScore = 2 * precision * recall / (precision + recall)\n return precision, recall, fScore\n\n\ndef get_data(name, data_dir, height, width, batch_size,\n workers):\n root = osp.join(data_dir, name)\n\n dataset = datasets.create(name, root, num_val=0.1)\n\n normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225])\n\n # use all training and validation images in target dataset\n train_set = dataset.trainval\n num_classes = dataset.num_trainval_ids\n\n transformer = T.Compose([\n T.Resize((height, width)),\n T.ToTensor(),\n normalizer,\n ])\n\n extfeat_loader = DataLoader(\n Preprocessor(train_set, root=dataset.images_dir,\n transform=transformer),\n batch_size=batch_size, num_workers=workers,\n shuffle=False, pin_memory=True)\n\n test_loader = DataLoader(\n Preprocessor(list(set(dataset.query) | set(dataset.gallery)),\n root=dataset.images_dir, transform=transformer),\n batch_size=batch_size, num_workers=workers,\n shuffle=False, pin_memory=True)\n\n return dataset, num_classes, extfeat_loader, test_loader\n\n\ndef get_source_data(name, data_dir, height, width, batch_size,\n workers):\n root = osp.join(data_dir, name)\n\n dataset = datasets.create(name, root, num_val=0.1)\n\n normalizer = T.Normalize(mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225])\n\n # use all training images on source dataset\n train_set = dataset.train\n num_classes = dataset.num_train_ids\n\n transformer = T.Compose([\n T.Resize((height, width)),\n T.ToTensor(),\n normalizer,\n ])\n\n extfeat_loader = DataLoader(\n Preprocessor(train_set, root=dataset.images_dir,\n transform=transformer),\n batch_size=batch_size, num_workers=workers,\n shuffle=False, pin_memory=True)\n\n return dataset, extfeat_loader\n\n\ndef calDis(qFeature, gFeature): # 246s\n x, y = F.normalize(qFeature), F.normalize(gFeature)\n # x, y = qFeature, gFeature\n m, n = x.shape[0], y.shape[0]\n disMat = torch.pow(x, 2).sum(dim=1, keepdim=True).expand(m, n) + \\\n torch.pow(y, 2).sum(dim=1, keepdim=True).expand(n, m).t()\n disMat.addmm_(1, -2, x, y.t())\n return disMat.clamp_(min=1e-5)\n\n\ndef labelUnknown(knownFeat, allLab, unknownFeat):\n # allLab--label from known\n disMat = calDis(knownFeat, unknownFeat)\n labLoc = disMat.argmin(dim=0)\n return allLab[labLoc]\n\n\ndef labelNoise(feature, labels):\n # features and labels with -1\n noiseFeat, pureFeat = feature[labels == -1, :], feature[labels != -1, :]\n pureLabs = labels[labels != -1] # no outliers\n unLab = labelUnknown(pureFeat, pureLabs, noiseFeat)\n labels[labels == -1] = unLab\n return labels.numpy()\n\n\ndef getCenter(features, labels):\n allCenter = {}\n features = features[labels != -1, :]\n labels = labels[labels != -1]\n for pid in set(labels):\n allCenter[pid] = torch.from_numpy(features[labels == pid, :].mean(axis=0)).unsqueeze(0)\n return torch.cat(list(allCenter.values()))\n\n\ndef main(args):\n np.random.seed(args.seed)\n torch.manual_seed(args.seed)\n cudnn.benchmark = True\n\n # Create data loaders\n assert args.num_instances > 1, \"num_instances should be greater than 1\"\n assert args.batch_size % args.num_instances == 0, \\\n 'num_instances should divide batch_size'\n if args.height is None or args.width is None:\n args.height, args.width = (144, 56) if args.arch == 'inception' else \\\n (256, 128)\n\n # get source data\n src_dataset, src_extfeat_loader = \\\n get_source_data(args.src_dataset, args.data_dir, args.height,\n args.width, args.batch_size, args.workers)\n # get target data\n tgt_dataset, num_classes, tgt_extfeat_loader, test_loader = \\\n get_data(args.tgt_dataset, args.data_dir, args.height,\n args.width, args.batch_size, args.workers)\n\n # Create model\n # Hacking here to let the classifier be the number of source ids\n if args.src_dataset == 'dukemtmc':\n model = models.create(args.arch, num_classes=632, pretrained=False)\n coModel = models.create(args.arch, num_classes=632, pretrained=False)\n elif args.src_dataset == 'market1501':\n model = models.create(args.arch, num_classes=676, pretrained=False)\n coModel = models.create(args.arch, num_classes=676, pretrained=False)\n elif args.src_dataset == 'msmt17':\n model = models.create(args.arch, num_classes=1041, pretrained=False)\n coModel = models.create(args.arch, num_classes=1041, pretrained=False)\n elif args.src_dataset == 'cuhk03':\n model = models.create(args.arch, num_classes=1230, pretrained=False)\n coModel = models.create(args.arch, num_classes=1230, pretrained=False)\n else:\n raise RuntimeError('Please specify the number of classes (ids) of the network.')\n\n # Load from checkpoint\n if args.resume:\n print('Resuming checkpoints from finetuned model on another dataset...\\n')\n checkpoint = load_checkpoint(args.resume)\n model.load_state_dict(checkpoint['state_dict'], strict=False)\n coModel.load_state_dict(checkpoint['state_dict'], strict=False)\n else:\n raise RuntimeWarning('Not using a pre-trained model.')\n model = nn.DataParallel(model).cuda()\n coModel = nn.DataParallel(coModel).cuda()\n\n # Criterion\n criterion = [\n TripletLoss(args.margin, args.num_instances, isAvg=False, use_semi=False).cuda(),\n TripletLoss(args.margin, args.num_instances, isAvg=False, use_semi=False).cuda()\n ]\n optimizer = torch.optim.Adam(\n model.parameters(), lr=args.lr\n )\n coOptimizer = torch.optim.Adam(\n coModel.parameters(), lr=args.lr\n )\n\n optims = [optimizer, coOptimizer]\n\n # training stage transformer on input images\n normalizer = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n train_transformer = T.Compose([\n T.Resize((args.height, args.width)),\n T.RandomHorizontalFlip(),\n T.ToTensor(), normalizer,\n T.RandomErasing(probability=0.5, sh=0.2, r1=0.3)\n ])\n\n # # Start training\n for iter_n in range(args.iteration):\n if args.lambda_value == 0:\n source_features = 0\n else:\n # get source datas' feature\n source_features, _ = extract_features(model, src_extfeat_loader, print_freq=args.print_freq, numStripe=None)\n # synchronization feature order with src_dataset.train\n source_features = torch.cat([source_features[f].unsqueeze(0) for f, _, _ in src_dataset.train], 0)\n\n # extract training images' features\n print('Iteration {}: Extracting Target Dataset Features...'.format(iter_n + 1))\n target_features, _ = extract_features(model, tgt_extfeat_loader, print_freq=args.print_freq, numStripe=None)\n # synchronization feature order with dataset.train\n target_features = torch.cat([target_features[f].unsqueeze(0) for f, _, _ in tgt_dataset.trainval], 0)\n # calculate distance and rerank result\n print('Calculating feature distances...')\n target_features = target_features.numpy()\n rerank_dist = re_ranking(source_features, target_features, lambda_value=args.lambda_value)\n if iter_n == 0:\n # DBSCAN cluster\n tri_mat = np.triu(rerank_dist, 1) # tri_mat.dim=2\n tri_mat = tri_mat[np.nonzero(tri_mat)] # tri_mat.dim=1\n tri_mat = np.sort(tri_mat, axis=None)\n top_num = np.round(args.rho * tri_mat.size).astype(int)\n eps = tri_mat[:top_num].mean()\n print('eps in cluster: {:.3f}'.format(eps))\n cluster = DBSCAN(eps=eps, min_samples=4, metric='precomputed', n_jobs=8)\n # select & cluster images as training set of this epochs\n print('Clustering and labeling...')\n labels = cluster.fit_predict(rerank_dist)\n num_ids = len(set(labels)) - 1\n print('Iteration {} have {} training ids'.format(iter_n + 1, num_ids))\n # generate new dataset\n new_dataset = []\n # assign label for target ones\n newLab = labelNoise(torch.from_numpy(target_features), torch.from_numpy(labels))\n # unknownFeats = target_features[labels==-1,:]\n counter = 0\n from collections import defaultdict\n realIDs, fakeIDs = defaultdict(list), []\n for (fname, realID, cam), label in zip(tgt_dataset.trainval, newLab):\n # dont need to change codes in trainer.py _parsing_input function and sampler function after add 0\n new_dataset.append((fname, label, cam))\n realIDs[realID].append(counter)\n fakeIDs.append(label)\n counter += 1\n precision, recall, fscore = calScores(realIDs, np.asarray(fakeIDs))\n print('Iteration {} have {} training images'.format(iter_n + 1, len(new_dataset)))\n print(f'precision:{precision * 100}, recall:{100 * recall}, fscore:{100 * fscore}')\n train_loader = DataLoader(\n Preprocessor(new_dataset, root=tgt_dataset.images_dir, transform=train_transformer),\n batch_size=args.batch_size, num_workers=4,\n sampler=RandomIdentitySampler(new_dataset, args.num_instances),\n pin_memory=True, drop_last=True\n )\n trainer = CoTeaching(\n model, coModel, train_loader, criterion, optims\n )\n\n # Start training\n for epoch in range(args.epochs):\n trainer.train(epoch, remRate=0.2 + (0.8 / args.iteration) * (1 + iter_n)) # to at most 80%\n # test only\n evaluator = Evaluator(model, print_freq=args.print_freq)\n rank_score = evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery)\n\n # Evaluate\n rank_score = evaluator.evaluate(test_loader, tgt_dataset.query, tgt_dataset.gallery)\n save_checkpoint({\n 'state_dict': model.module.state_dict(),\n 'epoch': epoch + 1, 'best_top1': rank_score.market1501[0],\n }, True, fpath=osp.join(args.logs_dir, 'adapted.pth.tar'))\n return rank_score.map, rank_score.market1501[0]\n\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser(description=\"Triplet loss classification\")\n # data\n parser.add_argument('--src_dataset', type=str, default='dukemtmc',\n choices=datasets.names())\n parser.add_argument('--tgt_dataset', type=str, default='market1501',\n choices=datasets.names())\n parser.add_argument('--batch_size', type=int, default=64)\n parser.add_argument('--workers', type=int, default=4)\n parser.add_argument('--split', type=int, default=0)\n parser.add_argument('--noiseLam', type=float, default=0.5)\n parser.add_argument('--height', type=int,\n help=\"input height, default: 256 for resnet*, \"\n \"144 for inception\")\n parser.add_argument('--width', type=int,\n help=\"input width, default: 128 for resnet*, \"\n \"56 for inception\")\n parser.add_argument('--combine-trainval', action='store_true',\n help=\"train and val sets together for training, \"\n \"val set alone for validation\")\n parser.add_argument('--num_instances', type=int, default=4,\n help=\"each minibatch consist of \"\n \"(batch_size // num_instances) identities, and \"\n \"each identity has num_instances instances, \"\n \"default: 4\")\n # model\n parser.add_argument('--arch', type=str, default='resnet50',\n choices=models.names())\n # loss\n parser.add_argument('--margin', type=float, default=0.5,\n help=\"margin of the triplet loss, default: 0.5\")\n parser.add_argument('--lambda_value', type=float, default=0.1,\n help=\"balancing parameter, default: 0.1\")\n parser.add_argument('--rho', type=float, default=1.6e-3,\n help=\"rho percentage, default: 1.6e-3\")\n # optimizer\n parser.add_argument('--lr', type=float, default=6e-5,\n help=\"learning rate of all parameters\")\n # training configs\n parser.add_argument('--resume', type=str, metavar='PATH',\n default='')\n parser.add_argument('--evaluate', type=int, default=0,\n help=\"evaluation only\")\n parser.add_argument('--seed', type=int, default=1)\n parser.add_argument('--print_freq', type=int, default=1)\n parser.add_argument('--iteration', type=int, default=10)\n parser.add_argument('--epochs', type=int, default=30)\n # metric learning\n parser.add_argument('--dist_metric', type=str, default='euclidean',\n choices=['euclidean', 'kissme'])\n # misc\n parser.add_argument('--data_dir', type=str, metavar='PATH',\n default='')\n parser.add_argument('--logs_dir', type=str, metavar='PATH',\n default='')\n\n args = parser.parse_args()\n mean_ap, rank1 = main(args)\n"
] | [
[
"torch.pow",
"numpy.round",
"torch.nn.functional.normalize",
"torch.manual_seed",
"sklearn.cluster.DBSCAN",
"numpy.random.seed",
"numpy.asarray",
"torch.from_numpy",
"numpy.sort",
"torch.nn.DataParallel",
"numpy.nonzero",
"numpy.triu"
]
] |
Diego-II/Datadriven-GPVAD | [
"ef033eb317553dc60464e07d8b5ba4f67bcf4a8d"
] | [
"utils.py"
] | [
"#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n\nimport collections\nimport sys\nfrom loguru import logger\nfrom pprint import pformat\nfrom typing import List\n\nimport numpy as np\nimport pandas as pd\nimport scipy\nimport six\nimport sklearn.preprocessing as pre\nimport torch\nimport tqdm\nimport yaml\n\nimport augment\nimport dataset\n\n# Some defaults for non-specified arguments in yaml\nDEFAULT_ARGS = {\n 'outputpath': 'experiments',\n 'loss': 'BCELoss',\n 'batch_size': 64,\n 'num_workers': 4,\n 'epochs': 100,\n 'transforms': [],\n 'label_type':'soft',\n 'scheduler_args': {\n 'patience': 3,\n 'factor': 0.1,\n },\n 'early_stop': 7,\n 'optimizer': 'Adam',\n 'optimizer_args': {\n 'lr': 0.001,\n },\n 'threshold': None, #Default threshold for postprocessing function\n 'postprocessing': 'double',\n}\n\n\ndef parse_config_or_kwargs(config_file, **kwargs):\n \"\"\"parse_config_or_kwargs\n\n :param config_file: Config file that has parameters, yaml format\n :param **kwargs: Other alternative parameters or overwrites for config\n \"\"\"\n with open(config_file) as con_read:\n yaml_config = yaml.load(con_read, Loader=yaml.FullLoader)\n # values from config file are all possible params\n arguments = dict(yaml_config, **kwargs)\n # In case some arguments were not passed, replace with default ones\n for key, value in DEFAULT_ARGS.items():\n arguments.setdefault(key, value)\n return arguments\n\n\ndef find_contiguous_regions(activity_array):\n \"\"\"Find contiguous regions from bool valued numpy.array.\n Copy of https://dcase-repo.github.io/dcase_util/_modules/dcase_util/data/decisions.html#DecisionEncoder\n\n Reason is:\n 1. This does not belong to a class necessarily\n 2. Import DecisionEncoder requires sndfile over some other imports..which causes some problems on clusters\n\n \"\"\"\n\n # Find the changes in the activity_array\n change_indices = np.logical_xor(activity_array[1:],\n activity_array[:-1]).nonzero()[0]\n\n # Shift change_index with one, focus on frame after the change.\n change_indices += 1\n\n if activity_array[0]:\n # If the first element of activity_array is True add 0 at the beginning\n change_indices = np.r_[0, change_indices]\n\n if activity_array[-1]:\n # If the last element of activity_array is True, add the length of the array\n change_indices = np.r_[change_indices, activity_array.size]\n\n # Reshape the result into two columns\n return change_indices.reshape((-1, 2))\n\n\ndef split_train_cv(input_data, frac: float = 0.9, **kwargs):\n \"\"\"split_train_cv\n\n :param data_frame:\n :param frac:\n :type frac: float\n \"\"\"\n if isinstance(input_data, list):\n N = len(input_data)\n indicies = np.random.permutation(N)\n train_size = round(N * frac)\n cv_size = N - train_size\n train_idxs, cv_idxs = indicies[:train_size], indicies[cv_size:]\n input_data = np.array(input_data)\n return input_data[train_idxs].tolist(), input_data[cv_idxs].tolist()\n elif isinstance(input_data, pd.DataFrame):\n train_df = input_data.sample(frac=frac)\n cv_df = input_data[~input_data.index.isin(train_df.index)]\n return train_df, cv_df\n\n\ndef parse_transforms(transform_list):\n \"\"\"parse_transforms\n parses the config files transformation strings to coresponding methods\n\n :param transform_list: String list\n \"\"\"\n transforms = []\n for trans in transform_list:\n if trans == 'noise':\n transforms.append(augment.GaussianNoise(snr=25))\n elif trans == 'roll':\n transforms.append(augment.Roll(0, 10))\n elif trans == 'freqmask':\n transforms.append(augment.FreqMask(2, 8))\n elif trans == 'timemask':\n transforms.append(augment.TimeMask(2, 60))\n elif trans == 'crop':\n transforms.append(augment.RandomCrop(200))\n elif trans == 'randompad':\n transforms.append(augment.RandomPad(value=0., padding=25))\n elif trans == 'flipsign':\n transforms.append(augment.FlipSign())\n elif trans == 'shift':\n transforms.append(augment.Shift())\n return torch.nn.Sequential(*transforms)\n\n\ndef pprint_dict(in_dict, outputfun=sys.stdout.write, formatter='yaml'):\n \"\"\"pprint_dict\n\n :param outputfun: function to use, defaults to sys.stdout\n :param in_dict: dict to print\n \"\"\"\n if formatter == 'yaml':\n format_fun = yaml.dump\n elif formatter == 'pretty':\n format_fun = pformat\n for line in format_fun(in_dict).split('\\n'):\n outputfun(line)\n\n\ndef getfile_outlogger(outputfile):\n log_format = \"[<green>{time:YYYY-MM-DD HH:mm:ss}</green>] {message}\"\n logger.configure(handlers=[{\"sink\": sys.stderr, \"format\": log_format}])\n if outputfile:\n logger.add(outputfile, enqueue=True, format=log_format)\n return logger\n\n\ndef train_labelencoder(labels: pd.Series, sparse=True):\n \"\"\"encode_labels\n\n Encodes labels\n\n :param labels: pd.Series representing the raw labels e.g., Speech, Water\n :param encoder (optional): Encoder already fitted \n returns encoded labels (many hot) and the encoder\n \"\"\"\n assert isinstance(labels, pd.Series), \"Labels need to be series\"\n if isinstance(labels[0], six.string_types):\n # In case of using non processed strings, e.g., Vaccum, Speech\n label_array = labels.str.split(',').values.tolist()\n elif isinstance(labels[0], np.ndarray):\n # Encoder does not like to see numpy array\n label_array = [lab.tolist() for lab in labels]\n elif isinstance(labels[0], collections.Iterable):\n label_array = labels\n encoder = pre.MultiLabelBinarizer(sparse_output=sparse)\n encoder.fit(label_array)\n return encoder\n\n\ndef encode_labels(labels: pd.Series, encoder=None, sparse=True):\n \"\"\"encode_labels\n\n Encodes labels\n\n :param labels: pd.Series representing the raw labels e.g., Speech, Water\n :param encoder (optional): Encoder already fitted \n returns encoded labels (many hot) and the encoder\n \"\"\"\n assert isinstance(labels, pd.Series), \"Labels need to be series\"\n instance = labels.iloc[0]\n if isinstance(instance, six.string_types):\n # In case of using non processed strings, e.g., Vaccum, Speech\n label_array = labels.str.split(',').values.tolist()\n elif isinstance(instance, np.ndarray):\n # Encoder does not like to see numpy array\n label_array = [lab.tolist() for lab in labels]\n elif isinstance(instance, collections.Iterable):\n label_array = labels\n if not encoder:\n encoder = pre.MultiLabelBinarizer(sparse_output=sparse)\n encoder.fit(label_array)\n labels_encoded = encoder.transform(label_array)\n return labels_encoded, encoder\n\n # return pd.arrays.SparseArray(\n # [row.toarray().ravel() for row in labels_encoded]), encoder\n\n\ndef decode_with_timestamps(encoder: pre.MultiLabelBinarizer, labels: np.array):\n \"\"\"decode_with_timestamps\n Decodes the predicted label array (2d) into a list of\n [(Labelname, onset, offset), ...]\n\n :param encoder: Encoder during training\n :type encoder: pre.MultiLabelBinarizer\n :param labels: n-dim array\n :type labels: np.array\n \"\"\"\n if labels.ndim == 3:\n return [_decode_with_timestamps(encoder, lab) for lab in labels]\n else:\n return _decode_with_timestamps(encoder, labels)\n\n\ndef sma_filter(x, window_size, axis=1):\n \"\"\"sma_filter\n\n :param x: Input numpy array,\n :param window_size: filter size\n :param axis: over which axis ( usually time ) to apply\n \"\"\"\n # 1 is time axis\n kernel = np.ones((window_size, )) / window_size\n\n def moving_average(arr):\n return np.convolve(arr, kernel, 'same')\n\n return np.apply_along_axis(moving_average, axis, x)\n\n\ndef median_filter(x, window_size, threshold=0.5):\n \"\"\"median_filter\n\n :param x: input prediction array of shape (B, T, C) or (B, T).\n Input is a sequence of probabilities 0 <= x <= 1\n :param window_size: An integer to use \n :param threshold: Binary thresholding threshold\n \"\"\"\n x = binarize(x, threshold=threshold)\n if x.ndim == 3:\n size = (1, window_size, 1)\n elif x.ndim == 2 and x.shape[0] == 1:\n # Assume input is class-specific median filtering\n # E.g, Batch x Time [1, 501]\n size = (1, window_size)\n elif x.ndim == 2 and x.shape[0] > 1:\n # Assume input is standard median pooling, class-independent\n # E.g., Time x Class [501, 10]\n size = (window_size, 1)\n return scipy.ndimage.median_filter(x, size=size)\n\n\ndef _decode_with_timestamps(encoder, labels):\n result_labels = []\n for i, label_column in enumerate(labels.T):\n change_indices = find_contiguous_regions(label_column)\n # append [onset, offset] in the result list\n for row in change_indices:\n result_labels.append((encoder.classes_[i], row[0], row[1]))\n return result_labels\n\n\ndef inverse_transform_labels(encoder, pred):\n if pred.ndim == 3:\n return [encoder.inverse_transform(x) for x in pred]\n else:\n return encoder.inverse_transform(pred)\n\n\ndef binarize(pred, threshold=0.5):\n # Batch_wise\n if pred.ndim == 3:\n return np.array(\n [pre.binarize(sub, threshold=threshold) for sub in pred])\n else:\n return pre.binarize(pred, threshold=threshold)\n\n\ndef double_threshold(x, high_thres, low_thres, n_connect=1):\n \"\"\"double_threshold\n Helper function to calculate double threshold for n-dim arrays\n\n :param x: input array\n :param high_thres: high threshold value\n :param low_thres: Low threshold value\n :param n_connect: Distance of <= n clusters will be merged\n \"\"\"\n assert x.ndim <= 3, \"Whoops something went wrong with the input ({}), check if its <= 3 dims\".format(\n x.shape)\n if x.ndim == 3:\n apply_dim = 1\n elif x.ndim < 3:\n apply_dim = 0\n # x is assumed to be 3d: (batch, time, dim)\n # Assumed to be 2d : (time, dim)\n # Assumed to be 1d : (time)\n # time axis is therefore at 1 for 3d and 0 for 2d (\n return np.apply_along_axis(lambda x: _double_threshold(\n x, high_thres, low_thres, n_connect=n_connect),\n axis=apply_dim,\n arr=x)\n\n\ndef _double_threshold(x, high_thres, low_thres, n_connect=1, return_arr=True):\n \"\"\"_double_threshold\n Computes a double threshold over the input array\n\n :param x: input array, needs to be 1d\n :param high_thres: High threshold over the array\n :param low_thres: Low threshold over the array\n :param n_connect: Postprocessing, maximal distance between clusters to connect\n :param return_arr: By default this function returns the filtered indiced, but if return_arr = True it returns an array of tsame size as x filled with ones and zeros.\n \"\"\"\n assert x.ndim == 1, \"Input needs to be 1d\"\n high_locations = np.where(x > high_thres)[0]\n locations = x > low_thres\n encoded_pairs = find_contiguous_regions(locations)\n\n filtered_list = list(\n filter(\n lambda pair:\n ((pair[0] <= high_locations) & (high_locations <= pair[1])).any(),\n encoded_pairs))\n\n filtered_list = connect_(filtered_list, n_connect)\n if return_arr:\n zero_one_arr = np.zeros_like(x, dtype=int)\n for sl in filtered_list:\n zero_one_arr[sl[0]:sl[1]] = 1\n return zero_one_arr\n return filtered_list\n\n\ndef connect_clusters(x, n=1):\n if x.ndim == 1:\n return connect_clusters_(x, n)\n if x.ndim >= 2:\n return np.apply_along_axis(lambda a: connect_clusters_(a, n=n), -2, x)\n\n\ndef connect_clusters_(x, n=1):\n \"\"\"connect_clusters_\n Connects clustered predictions (0,1) in x with range n\n\n :param x: Input array. zero-one format\n :param n: Number of frames to skip until connection can be made\n \"\"\"\n assert x.ndim == 1, \"input needs to be 1d\"\n reg = find_contiguous_regions(x)\n start_end = connect_(reg, n=n)\n zero_one_arr = np.zeros_like(x, dtype=int)\n for sl in start_end:\n zero_one_arr[sl[0]:sl[1]] = 1\n return zero_one_arr\n\n\ndef connect_(pairs, n=1):\n \"\"\"connect_\n Connects two adjacent clusters if their distance is <= n\n\n :param pairs: Clusters of iterateables e.g., [(1,5),(7,10)]\n :param n: distance between two clusters \n \"\"\"\n if len(pairs) == 0:\n return []\n start_, end_ = pairs[0]\n new_pairs = []\n for i, (next_item, cur_item) in enumerate(zip(pairs[1:], pairs[0:])):\n end_ = next_item[1]\n if next_item[0] - cur_item[1] <= n:\n pass\n else:\n new_pairs.append((start_, cur_item[1]))\n start_ = next_item[0]\n new_pairs.append((start_, end_))\n return new_pairs\n\n\ndef predictions_to_time(df, ratio):\n df.onset = df.onset * ratio\n df.offset = df.offset * ratio\n return df\n\n\ndef estimate_scaler(dataloader, **scaler_args):\n\n scaler = pre.StandardScaler(**scaler_args)\n with tqdm.tqdm(total=len(dataloader),\n unit='batch',\n leave=False,\n desc='Estimating Scaler') as pbar:\n for batch in dataloader:\n feature = batch[0]\n # Flatten time and batch dim to one\n feature = feature.reshape(-1, feature.shape[-1])\n pbar.set_postfix(feature=feature.shape)\n pbar.update()\n scaler.partial_fit(feature)\n return scaler\n\n\ndef rescale_0_1(x):\n if x.ndim == 2:\n return pre.minmax_scale(x, axis=0)\n else:\n\n def min_max_scale(a):\n return pre.minmax_scale(a, axis=0)\n\ndef df_to_dict(df, index='filename', value='hdf5path'):\n return dict(zip(df[index],df[value]))\n"
] | [
[
"numpy.zeros_like",
"numpy.ones",
"scipy.ndimage.median_filter",
"numpy.random.permutation",
"sklearn.preprocessing.MultiLabelBinarizer",
"numpy.where",
"numpy.logical_xor",
"sklearn.preprocessing.minmax_scale",
"torch.nn.Sequential",
"numpy.apply_along_axis",
"sklearn.preprocessing.StandardScaler",
"sklearn.preprocessing.binarize",
"numpy.convolve",
"numpy.array"
]
] |
benJephunneh/opticspy | [
"a0b841f60f7c053b05444c0e8886cd4a99c4d082"
] | [
"opticspy/test/PSF.py"
] | [
"import numpy as np\nfrom numpy import sqrt as sqrt\nfrom numpy import cos as cos\nfrom numpy import sin as sin\nimport matplotlib.pyplot as plt\nfrom matplotlib import cm as cm\nfrom matplotlib.ticker import LinearLocator as LinearLocator\nfrom matplotlib.ticker import FormatStrFormatter as FormatStrFormatter\nfrom numpy.fft import fftshift as fftshift\nfrom numpy.fft import ifftshift as ifftshift\nfrom numpy.fft import fft2 as fft2\n\ndef apershow(obj):\n\tobj = -abs(obj)\n\tplt.imshow(obj)\n\tplt.set_cmap('Greys')\n\tplt.show()\n\nl1 = 100\n#Generate test surface matrix from a detector\nx = np.linspace(-1, 1, l1)\ny = np.linspace(-1, 1, l1)\n[X,Y] = np.meshgrid(x,y)\nr = sqrt(X**2+Y**2)\nZ = sqrt(14)*(8*X**4-8*X**2*r**2+r**4)*(6*r**2-5)\nfor i in range(len(Z)):\n\tfor j in range(len(Z)):\n\t\tif x[i]**2+y[j]**2>1:\n\t\t\tZ[i][j]=0\n\nfig = plt.figure(1)\nax = fig.gca(projection='3d')\nsurf = ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.RdYlGn,\n linewidth=0, antialiased=False, alpha = 0.6)\n\nv = max(abs(Z.max()),abs(Z.min()))\nax.set_zlim(-v*5, v*5)\ncset = ax.contourf(X, Y, Z, zdir='z', offset=-v*5, cmap=cm.RdYlGn)\nax.zaxis.set_major_locator(LinearLocator(10))\nax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))\nfig.colorbar(surf, shrink=1, aspect=30)\nplt.show()\n\nd = 400\nA = np.zeros([d,d])\nA[d/2-49:d/2+51,d/2-49:d/2+51] = Z\nplt.imshow(A)\nplt.show()\n\nabbe = np.exp(1j*2*np.pi*A)\nfor i in range(len(abbe)):\n\tfor j in range(len(abbe)):\n\t\tif abbe[i][j]==1:\n\t\t\tabbe[i][j]=0\nfig = plt.figure(2)\nAP = abs(fftshift(fft2(fftshift(abbe))))**2\nAP = AP/AP.max()\nplt.imshow(AP)\nplt.show()"
] | [
[
"numpy.fft.fftshift",
"numpy.zeros",
"matplotlib.pyplot.figure",
"matplotlib.ticker.LinearLocator",
"matplotlib.pyplot.set_cmap",
"numpy.exp",
"matplotlib.ticker.FormatStrFormatter",
"matplotlib.pyplot.imshow",
"matplotlib.pyplot.show",
"numpy.sqrt",
"numpy.meshgrid",
"numpy.linspace"
]
] |
yangzhou95/learn-tensorflow | [
"6def45659ebf7aa9f74f1efe1ff6465b8db5ee93"
] | [
"read_csv.py"
] | [
"# read csv to model\nimport tensorflow as tf\nimport numpy as np\nimport os\n\n\ndef read_csv(batch_size, file_name, record_defaults=1):\n fileName_queue=tf.train.string_input_producer(os.path.dirname(__file__)+\"/\"+file_name)\n reader = tf.TextLineReader(skip_header_lines=1)\n key, value=reader.read(fileName_queue,name='read_op')\n\n # decode_csv will convert a Tensor from type string (the text line) in\n # a tuple of tensor columns with the specified defaults, which also\n # sets teh data type for each column\n decoded=tf.decode_csv(records=value)\n\n # batch actually reads the file and loads \"batch size\" rows in a single tensor\n return tf.train.shuffle_batch(decoded, batch_size=batch_size, capacity=batch_size* 50, min_after_dequeue=batch_size)\n\n\ndef inputs():\n passenger_id, survived, pclass, name, sex, age, sibsp, parch, ticket, fare, cabin, embarked =\\\n read_csv(100,\"./data/train.csv\",)"
] | [
[
"tensorflow.decode_csv",
"tensorflow.TextLineReader",
"tensorflow.train.shuffle_batch"
]
] |
HusseinLezzaik/Consensus-Algorithm-for-2-Mobile-Robots | [
"ecdb28793cc1f5fa6cded752908105ec37e9bfc7"
] | [
"Real Topology Graph/GNN Model 2/Fully Connected Graph/test_n3_cyclic.py"
] | [
"\"\"\"\n\nConsensus Algorithm for 3 Mobile robots using MLP Model Cyclic Graph Implementation\n\nScene: Robot 1, Robot 2, Robot 3\n\nInputs: Mx, My, Phix, Phiy\nOutputs: Ux, Uy\n\n\"\"\"\nimport torch\nimport MLP_Model\nimport math\nimport numpy as np\nimport rclpy\nfrom rclpy.node import Node\nfrom tf2_msgs.msg import TFMessage\nfrom std_msgs.msg import Float32\nimport time\n\nL = 1\nd = 0.5\n\n# load model using dict\nFILE = \"model.pth\"\nloaded_model = MLP_Model.MLP()\nloaded_model.load_state_dict(torch.load(FILE))\nloaded_model.eval()\n\ndef euler_from_quaternion(x, y, z, w):\n \n t3 = +2.0 * (w * z + x * y)\n t4 = +1.0 - 2.0 * (y * y + z * z)\n yaw_z = math.atan2(t3, t4)\n \n return yaw_z # in radians\n \n \nclass MinimalPublisher(Node):\n\n def __init__(self):\n super().__init__('minimal_publisher1')\n self.publisher_l1 = self.create_publisher(Float32, '/leftMotorSpeedrobot1', 0) #Change according to topic in child script,String to Float32\n self.publisher_r1 = self.create_publisher(Float32, '/rightMotorSpeedrobot1',0) #Change according to topic in child script,String to Float32\n self.publisher_l2 = self.create_publisher(Float32, '/leftMotorSpeedrobot2', 0) #Change according to topic in child script,String to Float32\n self.publisher_r2 = self.create_publisher(Float32, '/rightMotorSpeedrobot2',0) #Change according to topic in child script,String to Float32\n self.publisher_l3 = self.create_publisher(Float32, '/leftMotorSpeedrobot3', 0) #Change according to topic in child script,String to Float32\n self.publisher_r3 = self.create_publisher(Float32, '/rightMotorSpeedrobot3',0) #Change according to topic in child script,String to Float32 \n self.subscription = self.create_subscription(\n TFMessage,\n '/tf',\n self.listener_callback,\n 0)\n\n \" Timer Callback \"\n \n #self.publisher_ = self.create_publisher(Float32(), 'topic', 10)\n timer_period = 0.01 # seconds\n self.timer = self.create_timer(timer_period, self.timer_callback)\n self.i = 0\n \n \" Parameters \"\n self.t = 0 # Just to intialized Phix's and Phiy's\n \n \" Initialize Phi's\"\n self.Phix1 = 0 # 1x1\n self.Phiy1 = 0 # 1x1\n self.Phix2 = 0 # 1x1\n self.Phiy2 = 0 # 1x1\n self.Phix3 = 0 # 1x1\n self.Phiy3 = 0 # 1x1 \n \n \" Mobile Robot 1 Parameters \"\n self.x1 = 0\n self.y1 = 0\n self.Theta1 = 0\n self.v1 = 0\n self.w1 = 0\n self.vL1 = 0\n self.vR1 = 0\n \n \" Mobile Robot 2 Parameters \"\n self.x2 = 0\n self.y2 = 0\n self.Theta2 = 0\n self.v2 = 0\n self.w2 = 0\n self.vL2 = 0 \n self.vR2 = 0\n\n \" Mobile Robot 3 Parameters \"\n self.x3 = 0\n self.y3 = 0\n self.Theta3 = 0\n self.v3 = 0\n self.w3 = 0\n self.vL3 =0 \n self.vR3 = 0\n \n def timer_callback(self):\n \n \" Calculate Mx1, My1, ...... Mx6, My6 \" \n # Initialize Phi's\n if self.t ==0:\n self.Phix1 = 0 # 1x1\n self.Phiy1 = 0 # 1x1\n self.Phix2 = 0 # 1x1\n self.Phiy2 = 0 # 1x1\n self.Phix3 = 0 # 1x1\n self.Phiy3 = 0 # 1x1\n self.t += 1 \n \n Mx1 = ( (self.x2 - self.x1) + (self.x3 - self.x1) )/2\n My1 = ( (self.y2 - self.y1) + (self.y3 - self.y1) )/2\n \n Mx2 = ( (self.x1 - self.x2) + (self.x3 - self.x2) )/2\n My2 = ( (self.y1 - self.y2) + (self.y3 - self.y2) )/2 \n\n Mx3 = ( (self.x2 - self.x3) + (self.x1 - self.x3) )/2\n My3 = ( (self.y2 - self.y3) + (self.y1 - self.y3) )/2 \n \n \" Use MLP to Predict control inputs \"\n \n relative_pose_1 = [ Mx1, My1, self.Phix1, self.Phiy1 ] # tensor data for MLP model\n relative_pose_2 = [ Mx2, My2, self.Phix2, self.Phiy2 ] # tensor data for MLP model\n relative_pose_3 = [ Mx3, My3, self.Phix3, self.Phiy3 ] # tensor data for MLP model\n\n\n u1_predicted = MLP_Model.predict(relative_pose_1, loaded_model) # predict control input u1, tensor\n u2_predicted = MLP_Model.predict(relative_pose_2, loaded_model) # predict control input u2, tensor\n u3_predicted = MLP_Model.predict(relative_pose_3, loaded_model) # predict control input u3, tensor \n\n self.Phix1 = ( u2_predicted[0][0] + u3_predicted[0][0] )/2 # 1x1\n self.Phiy1 = ( u2_predicted[0][1] + u3_predicted[0][1] )/2 # 1x1\n \n self.Phix2 = ( u1_predicted[0][0] + u3_predicted[0][0] )/2 # 1x1\n self.Phiy2 = ( u1_predicted[0][1] + u3_predicted[0][1] )/2 # 1x1\n \n self.Phix3 = ( u2_predicted[0][0] + u1_predicted[0][0] )/2 # 1x1\n self.Phiy3 = ( u2_predicted[0][1] + u1_predicted[0][1] )/2 # 1x1 \n \n u1_predicted_np = np.array([[ u1_predicted[0][0] ], [ u1_predicted[0][1] ]]) # from tensor to numpy array for calculation\n u2_predicted_np = np.array([[ u2_predicted[0][0] ], [ u2_predicted[0][1] ]]) # from tensor to numpy array for calculation\n u3_predicted_np = np.array([[ u3_predicted[0][0] ], [ u3_predicted[0][1] ]]) # from tensor to numpy array for calculation\n\n \" Calculate V1/W1, V2/W2, V3/W3, V4/W4, V5/W5, V6/W6 \"\n \n S1 = np.array([[self.v1], [self.w1]]) #2x1\n G1 = np.array([[1,0], [0,1/L]]) #2x2\n R1 = np.array([[math.cos(self.Theta1),math.sin(self.Theta1)],[-math.sin(self.Theta1),math.cos(self.Theta1)]]) #2x2\n S1 = np.dot(np.dot(G1, R1), u1_predicted_np) #2x1\n \n S2 = np.array([[self.v2], [self.w2]]) #2x1\n G2 = np.array([[1,0], [0,1/L]]) #2x2\n R2 = np.array([[math.cos(self.Theta2),math.sin(self.Theta2)],[-math.sin(self.Theta2),math.cos(self.Theta2)]]) #2x2\n S2 = np.dot(np.dot(G2, R2), u2_predicted_np) # 2x1\n \n S3 = np.array([[self.v3], [self.w3]]) #2x1\n G3 = np.array([[1,0], [0,1/L]]) #2x2\n R3 = np.array([[math.cos(self.Theta3),math.sin(self.Theta3)],[-math.sin(self.Theta3),math.cos(self.Theta3)]]) #2x2\n S3 = np.dot(np.dot(G3, R3), u3_predicted_np) # 2x1 \n \n \" Calculate VL1/VR1, VL2/VR2, VL3/VR3, VL4/VR4, VL5/VR5, VL6/VR6 \"\n \n D = np.array([[1/2,1/2],[-1/(2*d),1/(2*d)]]) #2x2\n Di = np.linalg.inv(D) #2x2\n\n Speed_L1 = np.array([[self.vL1], [self.vR1]]) # Vector 2x1 for Speed of Robot 1\n Speed_L2 = np.array([[self.vL2], [self.vR2]]) # Vector 2x1 for Speed of Robot 2\n Speed_L3 = np.array([[self.vL3], [self.vR3]]) # Vector 2x1 for Speed of Robot 3\n\n M1 = np.array([[S1[0]],[S1[1]]]).reshape(2,1) #2x1\n M2 = np.array([[S2[0]],[S2[1]]]).reshape(2,1) #2x1\n M3 = np.array([[S3[0]],[S3[1]]]).reshape(2,1) #2x1\n\n Speed_L1 = np.dot(Di, M1) # 2x1 (VL1, VR1)\n Speed_L2 = np.dot(Di, M2) # 2x1 (VL2, VR2)\n Speed_L3 = np.dot(Di, M3) # 2x1 (VL1, VR1)\n\n VL1 = float(Speed_L1[0])\n VR1 = float(Speed_L1[1])\n VL2 = float(Speed_L2[0])\n VR2 = float(Speed_L2[1])\n VL3 = float(Speed_L3[0])\n VR3 = float(Speed_L3[1]) \n \n \" Publish Speed Commands to Robot 1 \"\n \n msgl1 = Float32() \n msgr1 = Float32()\n msgl1.data = VL1\n msgr1.data = VR1\n self.publisher_l1.publish(msgl1)\n self.publisher_r1.publish(msgr1)\n\n \" Publish Speed Commands to Robot 2 \"\n \n msgl2 = Float32()\n msgr2 = Float32()\n msgl2.data = VL2\n msgr2.data = VR2\n self.publisher_l2.publish(msgl2)\n self.publisher_r2.publish(msgr2) \n \n \" Publish Speed Commands to Robot 3 \"\n \n msgl3 = Float32()\n msgr3 = Float32()\n msgl3.data = VL3\n msgr3.data = VR3\n self.publisher_l3.publish(msgl3)\n self.publisher_r3.publish(msgr3) \n \n self.i += 1\n \n def listener_callback(self, msg):\n \n if msg.transforms[0].child_frame_id == 'robot1' : \n self.x1 = msg.transforms[0].transform.translation.x\n self.y1 = msg.transforms[0].transform.translation.y\n self.xr1 = msg.transforms[0].transform.rotation.x\n self.yr1 = msg.transforms[0].transform.rotation.y\n self.zr1 = msg.transforms[0].transform.rotation.z\n self.wr1 = msg.transforms[0].transform.rotation.w\n self.Theta1 = euler_from_quaternion(self.xr1,self.yr1,self.zr1,self.wr1)\n \n if msg.transforms[0].child_frame_id == 'robot2' :\n self.x2 = msg.transforms[0].transform.translation.x\n self.y2 = msg.transforms[0].transform.translation.y\n self.xr2 = msg.transforms[0].transform.rotation.x\n self.yr2 = msg.transforms[0].transform.rotation.y\n self.zr2 = msg.transforms[0].transform.rotation.z\n self.wr2 = msg.transforms[0].transform.rotation.w\n self.Theta2 = euler_from_quaternion(self.xr2,self.yr2,self.zr2,self.wr2)\n\n if msg.transforms[0].child_frame_id == 'robot3' : \n self.x3 = msg.transforms[0].transform.translation.x\n self.y3 = msg.transforms[0].transform.translation.y\n self.xr3 = msg.transforms[0].transform.rotation.x\n self.yr3 = msg.transforms[0].transform.rotation.y\n self.zr3 = msg.transforms[0].transform.rotation.z\n self.wr3 = msg.transforms[0].transform.rotation.w\n self.Theta3 = euler_from_quaternion(self.xr3,self.yr3,self.zr3,self.wr3) \n \n \ndef main(args=None):\n rclpy.init(args=args)\n minimal_publisher = MinimalPublisher()\n time.sleep(5)\n rclpy.spin(minimal_publisher)\n minimal_publisher.destroy_node()\n rclpy.shutdown()\n\n\nif __name__ == '__main__':\n main()\n \n\n"
] | [
[
"numpy.array",
"numpy.linalg.inv",
"numpy.dot",
"torch.load"
]
] |
thunlp/MetaAdaptRank | [
"5e80520b003b0a3a5fad817edf65cf76222438dd"
] | [
"metaranker/losses/pairwise.py"
] | [
"import torch\nfrom torch import nn\nfrom torch.autograd import Variable\n\nclass PairWise(nn.Module):\n def __init__(\n self, \n margin=1\n ):\n super(PairWise, self).__init__()\n self.tanh = nn.Tanh()\n self.loss_fct = nn.MarginRankingLoss(\n margin=margin, \n reduction='none'\n )\n def forward(\n self, \n pos_score, \n neg_score,\n ):\n pos_score = self.tanh(pos_score)\n neg_score = self.tanh(neg_score)\n # compute loss\n batch_loss = self.loss_fct(\n pos_score, \n neg_score, \n target=torch.ones(pos_score.size()).to(pos_score.device)\n )\n return batch_loss"
] | [
[
"torch.nn.MarginRankingLoss",
"torch.nn.Tanh"
]
] |
WLM1ke/poptimizer | [
"084ac14ca6212a5b14bea5bbc9bb575da077ffb0"
] | [
"poptimizer/portfolio/optimizer.py"
] | [
"\"\"\"Оптимизатор портфеля.\"\"\"\nimport numpy as np\nimport pandas as pd\nfrom scipy import stats\n\nfrom poptimizer import config\nfrom poptimizer.portfolio import metrics\nfrom poptimizer.portfolio.portfolio import CASH, Portfolio\n\n\nclass Optimizer:\n \"\"\"Предлагает сделки для улучшения метрики портфеля.\"\"\"\n\n def __init__(self, portfolio: Portfolio, p_value: float = config.P_VALUE):\n \"\"\"Учитывается градиент, его ошибку и ликвидность бумаг.\n\n :param portfolio:\n Оптимизируемый портфель.\n :param p_value:\n Требуемая значимость отклонения градиента от нуля.\n \"\"\"\n self._portfolio = portfolio\n self._p_value = p_value\n self._metrics = metrics.MetricsResample(portfolio)\n\n def __str__(self) -> str:\n \"\"\"Информация о позициях, градиенты которых значимо отличны от 0.\"\"\"\n df = self._for_trade()\n forecasts = self.metrics.count\n blocks = [\n \"\\nОПТИМИЗАЦИЯ ПОРТФЕЛЯ\",\n f\"\\nforecasts = {forecasts}\",\n f\"p-value = {self._p_value:.2%}\",\n f\"\\n{df}\",\n ]\n return \"\\n\".join(blocks)\n\n @property\n def portfolio(self) -> Portfolio:\n \"\"\"Оптимизируемый портфель.\"\"\"\n return self._portfolio\n\n @property\n def metrics(self) -> metrics.MetricsResample:\n \"\"\"Метрики портфеля.\"\"\"\n return self._metrics\n\n def _for_trade(self) -> pd.DataFrame:\n \"\"\"Осуществляет расчет доверительного интервала для среднего.\"\"\"\n p_value = self._p_value / (len(self._portfolio.index) - 2)\n\n conf_int = self.metrics.all_gradients.iloc[:-2]\n conf_int = conf_int.apply(\n lambda grad: _grad_conf_int(grad, p_value),\n axis=1,\n result_type=\"expand\",\n )\n conf_int.columns = [\"LOWER\", \"UPPER\"]\n conf_int[\"COSTS\"] = self._costs()\n conf_int[\"PRIORITY\"] = conf_int[\"LOWER\"] - conf_int[\"COSTS\"]\n\n for_sale = conf_int[\"UPPER\"] < 0\n for_sale = for_sale & (self._portfolio.shares.iloc[:-2] > 0) # noqa: WPS465\n for_sale = conf_int[for_sale]\n for_sale = for_sale.assign(PRIORITY=lambda df: df[\"UPPER\"])\n\n good_purchase = conf_int[\"PRIORITY\"] > 0 # noqa: WPS465\n good_purchase = conf_int[good_purchase]\n\n return pd.concat(\n [\n good_purchase,\n for_sale,\n ],\n axis=0,\n ).sort_values(\"PRIORITY\", ascending=False)\n\n def _costs(self) -> pd.DataFrame:\n \"\"\"Удельные торговые издержки.\n\n Полностью распределяются на покупаемую позицию с учетом ее последующего закрытия. Состоят из\n двух составляющих - комиссии и воздействия на рынок. Для учета воздействия на рынок\n используется Rule of thumb, trading one day’s volume moves the price by about one day’s\n volatility\n\n https://arxiv.org/pdf/1705.00109.pdf\n\n Размер операций на покупку условно выбран равным текущему кэшу, а на последующую продажу\n текущая позиция плюс кэш за вычетом уже учтенных издержек на продажу текущей позиции.\n\n Было решено отказаться от расчета производной так как для нулевых позиций издержки воздействия\n небольшие, но быстро нарастают с объемом. Расчет для условной сделки в размере кэша сразу\n отсекает совсем неликвидных кандидатов на покупку.\n \"\"\"\n port = self._portfolio\n\n cash = port.weight[CASH] / port.turnover_factor\n weight = port.weight / port.turnover_factor\n weight_cash = weight + cash\n\n impact_scale = 1.5\n\n return (\n # Размер рыночного воздействие в дневном СКО для дневного оборот\n config.MARKET_IMPACT_FACTOR\n # Дневное СКО\n * (self.metrics.std / config.YEAR_IN_TRADING_DAYS ** 0.5)\n # Зависимость общих издержек от воздействия пропорционален степени 1.5 от нормированного на\n # дневной оборот объема. Совершается покупка на кэш сейчас и увеличиваются издержки на\n # ликвидацию позиции\n * (cash ** impact_scale + (weight_cash ** impact_scale - weight ** impact_scale))\n # Делим на объем операции для получения удельных издержек\n / cash\n # Умножаем на коэффициент пересчета в годовые значения\n * (config.YEAR_IN_TRADING_DAYS / config.FORECAST_DAYS)\n # Обычные издержки в две стороны\n + config.COSTS * 2\n )\n\n\ndef _grad_conf_int(forecasts, p_value) -> tuple[float, float]:\n interval = stats.bootstrap(\n (forecasts,),\n np.median,\n confidence_level=(1 - p_value),\n random_state=0,\n ).confidence_interval\n\n return interval.low, interval.high\n"
] | [
[
"scipy.stats.bootstrap",
"pandas.concat"
]
] |
Olek-Donaldson/astropy | [
"ed9ec69007bd540bcf476def57c5231e5e7c1240"
] | [
"astropy/modeling/tests/test_models.py"
] | [
"# Licensed under a 3-clause BSD style license - see LICENSE.rst\n\n\"\"\"\nTests for model evaluation.\nCompare the results of some models with other programs.\n\"\"\"\n# pylint: disable=invalid-name, no-member\nimport pytest\nimport numpy as np\n\nfrom numpy.testing import assert_allclose, assert_equal\n\nfrom astropy import units as u\nfrom astropy.modeling import fitting, models\nfrom astropy.modeling.models import Gaussian2D\nfrom astropy.modeling.core import FittableModel\nfrom astropy.modeling.parameters import Parameter\nfrom astropy.modeling.polynomial import PolynomialBase\nfrom astropy.utils import minversion\nfrom astropy.tests.helper import assert_quantity_allclose\nfrom astropy.utils import NumpyRNGContext\nfrom .example_models import models_1D, models_2D\n\ntry:\n import scipy\n HAS_SCIPY = True\nexcept ImportError:\n HAS_SCIPY = False\n\n\[email protected]('not HAS_SCIPY')\ndef test_custom_model(amplitude=4, frequency=1):\n\n def sine_model(x, amplitude=4, frequency=1):\n \"\"\"\n Model function\n \"\"\"\n return amplitude * np.sin(2 * np.pi * frequency * x)\n\n def sine_deriv(x, amplitude=4, frequency=1):\n \"\"\"\n Jacobian of model function, e.g. derivative of the function with\n respect to the *parameters*\n \"\"\"\n da = np.sin(2 * np.pi * frequency * x)\n df = 2 * np.pi * x * amplitude * np.cos(2 * np.pi * frequency * x)\n return np.vstack((da, df))\n\n SineModel = models.custom_model(sine_model, fit_deriv=sine_deriv)\n\n x = np.linspace(0, 4, 50)\n sin_model = SineModel()\n\n sin_model.evaluate(x, 5., 2.)\n sin_model.fit_deriv(x, 5., 2.)\n\n np.random.seed(0)\n data = sin_model(x) + np.random.rand(len(x)) - 0.5\n fitter = fitting.LevMarLSQFitter()\n model = fitter(sin_model, x, data)\n assert np.all((np.array([model.amplitude.value, model.frequency.value]) -\n np.array([amplitude, frequency])) < 0.001)\n\n\ndef test_custom_model_init():\n @models.custom_model\n def SineModel(x, amplitude=4, frequency=1):\n \"\"\"Model function\"\"\"\n\n return amplitude * np.sin(2 * np.pi * frequency * x)\n\n sin_model = SineModel(amplitude=2., frequency=0.5)\n assert sin_model.amplitude == 2.\n assert sin_model.frequency == 0.5\n\n\ndef test_custom_model_defaults():\n @models.custom_model\n def SineModel(x, amplitude=4, frequency=1):\n \"\"\"Model function\"\"\"\n\n return amplitude * np.sin(2 * np.pi * frequency * x)\n\n sin_model = SineModel()\n assert SineModel.amplitude.default == 4\n assert SineModel.frequency.default == 1\n\n assert sin_model.amplitude == 4\n assert sin_model.frequency == 1\n\n\ndef test_inconsistent_input_shapes():\n g = Gaussian2D()\n x = np.arange(-1., 1, .2)\n y = x.copy()\n # check scalar input broadcasting works\n assert np.abs(g(x, 0) - g(x, 0 * x)).sum() == 0\n # but not array broadcasting\n x.shape = (10, 1)\n y.shape = (1, 10)\n with pytest.raises(ValueError):\n g(x, y)\n\n\ndef test_custom_model_bounding_box():\n \"\"\"Test bounding box evaluation for a 3D model\"\"\"\n\n def ellipsoid(x, y, z, x0=13, y0=10, z0=8, a=4, b=3, c=2, amp=1):\n rsq = ((x - x0) / a) ** 2 + ((y - y0) / b) ** 2 + ((z - z0) / c) ** 2\n val = (rsq < 1) * amp\n return val\n\n class Ellipsoid3D(models.custom_model(ellipsoid)):\n @property\n def bounding_box(self):\n return ((self.z0 - self.c, self.z0 + self.c),\n (self.y0 - self.b, self.y0 + self.b),\n (self.x0 - self.a, self.x0 + self.a))\n\n model = Ellipsoid3D()\n bbox = model.bounding_box\n\n zlim, ylim, xlim = bbox\n dz, dy, dx = np.diff(bbox) / 2\n z1, y1, x1 = np.mgrid[slice(zlim[0], zlim[1] + 1),\n slice(ylim[0], ylim[1] + 1),\n slice(xlim[0], xlim[1] + 1)]\n z2, y2, x2 = np.mgrid[slice(zlim[0] - dz, zlim[1] + dz + 1),\n slice(ylim[0] - dy, ylim[1] + dy + 1),\n slice(xlim[0] - dx, xlim[1] + dx + 1)]\n\n arr = model(x2, y2, z2)\n sub_arr = model(x1, y1, z1)\n\n # check for flux agreement\n assert abs(arr.sum() - sub_arr.sum()) < arr.sum() * 1e-7\n\n\nclass Fittable2DModelTester:\n \"\"\"\n Test class for all two dimensional parametric models.\n\n Test values have to be defined in example_models.py. It currently test the\n model with different input types, evaluates the model at different\n positions and assures that it gives the correct values. And tests if the\n model works with non-linear fitters.\n\n This can be used as a base class for user defined model testing.\n \"\"\"\n\n def setup_class(self):\n self.N = 100\n self.M = 100\n self.eval_error = 0.0001\n self.fit_error = 0.1\n self.x = 5.3\n self.y = 6.7\n self.x1 = np.arange(1, 10, .1)\n self.y1 = np.arange(1, 10, .1)\n self.y2, self.x2 = np.mgrid[:10, :8]\n\n def test_input2D(self, model_class, test_parameters):\n \"\"\"Test model with different input types.\"\"\"\n\n model = create_model(model_class, test_parameters)\n model(self.x, self.y)\n model(self.x1, self.y1)\n model(self.x2, self.y2)\n\n def test_eval2D(self, model_class, test_parameters):\n \"\"\"Test model values add certain given points\"\"\"\n\n model = create_model(model_class, test_parameters)\n x = test_parameters['x_values']\n y = test_parameters['y_values']\n z = test_parameters['z_values']\n assert np.all(np.abs(model(x, y) - z) < self.eval_error)\n\n def test_bounding_box2D(self, model_class, test_parameters):\n \"\"\"Test bounding box evaluation\"\"\"\n\n model = create_model(model_class, test_parameters)\n\n # testing setter\n model.bounding_box = ((-5, 5), (-5, 5))\n assert model.bounding_box == ((-5, 5), (-5, 5))\n\n model.bounding_box = None\n with pytest.raises(NotImplementedError):\n model.bounding_box\n\n # test the exception of dimensions don't match\n with pytest.raises(ValueError):\n model.bounding_box = (-5, 5)\n\n del model.bounding_box\n\n try:\n bbox = model.bounding_box\n except NotImplementedError:\n pytest.skip(\"Bounding_box is not defined for model.\")\n\n ylim, xlim = bbox\n dy, dx = np.diff(bbox)/2\n y1, x1 = np.mgrid[slice(ylim[0], ylim[1] + 1),\n slice(xlim[0], xlim[1] + 1)]\n y2, x2 = np.mgrid[slice(ylim[0] - dy, ylim[1] + dy + 1),\n slice(xlim[0] - dx, xlim[1] + dx + 1)]\n\n arr = model(x2, y2)\n sub_arr = model(x1, y1)\n\n # check for flux agreement\n assert abs(arr.sum() - sub_arr.sum()) < arr.sum() * 1e-7\n\n @pytest.mark.skipif('not HAS_SCIPY')\n def test_fitter2D(self, model_class, test_parameters):\n \"\"\"Test if the parametric model works with the fitter.\"\"\"\n\n x_lim = test_parameters['x_lim']\n y_lim = test_parameters['y_lim']\n\n parameters = test_parameters['parameters']\n model = create_model(model_class, test_parameters)\n\n if isinstance(parameters, dict):\n parameters = [parameters[name] for name in model.param_names]\n\n if \"log_fit\" in test_parameters:\n if test_parameters['log_fit']:\n x = np.logspace(x_lim[0], x_lim[1], self.N)\n y = np.logspace(y_lim[0], y_lim[1], self.N)\n else:\n x = np.linspace(x_lim[0], x_lim[1], self.N)\n y = np.linspace(y_lim[0], y_lim[1], self.N)\n xv, yv = np.meshgrid(x, y)\n\n np.random.seed(0)\n # add 10% noise to the amplitude\n noise = np.random.rand(self.N, self.N) - 0.5\n data = model(xv, yv) + 0.1 * parameters[0] * noise\n fitter = fitting.LevMarLSQFitter()\n new_model = fitter(model, xv, yv, data)\n\n params = [getattr(new_model, name) for name in new_model.param_names]\n fixed = [param.fixed for param in params]\n expected = np.array([val for val, fixed in zip(parameters, fixed)\n if not fixed])\n fitted = np.array([param.value for param in params\n if not param.fixed])\n assert_allclose(fitted, expected,\n atol=self.fit_error)\n\n @pytest.mark.skipif('not HAS_SCIPY')\n def test_deriv_2D(self, model_class, test_parameters):\n \"\"\"\n Test the derivative of a model by fitting with an estimated and\n analytical derivative.\n \"\"\"\n\n x_lim = test_parameters['x_lim']\n y_lim = test_parameters['y_lim']\n\n if model_class.fit_deriv is None:\n pytest.skip(\"Derivative function is not defined for model.\")\n if issubclass(model_class, PolynomialBase):\n pytest.skip(\"Skip testing derivative of polynomials.\")\n\n if \"log_fit\" in test_parameters:\n if test_parameters['log_fit']:\n x = np.logspace(x_lim[0], x_lim[1], self.N)\n y = np.logspace(y_lim[0], y_lim[1], self.M)\n else:\n x = np.linspace(x_lim[0], x_lim[1], self.N)\n y = np.linspace(y_lim[0], y_lim[1], self.M)\n xv, yv = np.meshgrid(x, y)\n\n try:\n model_with_deriv = create_model(model_class, test_parameters,\n use_constraints=False,\n parameter_key='deriv_initial')\n model_no_deriv = create_model(model_class, test_parameters,\n use_constraints=False,\n parameter_key='deriv_initial')\n model = create_model(model_class, test_parameters,\n use_constraints=False,\n parameter_key='deriv_initial')\n except KeyError:\n model_with_deriv = create_model(model_class, test_parameters,\n use_constraints=False)\n model_no_deriv = create_model(model_class, test_parameters,\n use_constraints=False)\n model = create_model(model_class, test_parameters,\n use_constraints=False)\n\n # add 10% noise to the amplitude\n rsn = np.random.RandomState(1234567890)\n amplitude = test_parameters['parameters'][0]\n n = 0.1 * amplitude * (rsn.rand(self.M, self.N) - 0.5)\n\n data = model(xv, yv) + n\n fitter_with_deriv = fitting.LevMarLSQFitter()\n new_model_with_deriv = fitter_with_deriv(model_with_deriv, xv, yv,\n data)\n fitter_no_deriv = fitting.LevMarLSQFitter()\n new_model_no_deriv = fitter_no_deriv(model_no_deriv, xv, yv, data,\n estimate_jacobian=True)\n assert_allclose(new_model_with_deriv.parameters,\n new_model_no_deriv.parameters,\n rtol=0.1)\n\n\nclass Fittable1DModelTester:\n \"\"\"\n Test class for all one dimensional parametric models.\n\n Test values have to be defined in example_models.py. It currently test the\n model with different input types, evaluates the model at different\n positions and assures that it gives the correct values. And tests if the\n model works with non-linear fitters.\n\n This can be used as a base class for user defined model testing.\n \"\"\"\n\n def setup_class(self):\n self.N = 100\n self.M = 100\n self.eval_error = 0.0001\n self.fit_error = 0.1\n self.x = 5.3\n self.y = 6.7\n self.x1 = np.arange(1, 10, .1)\n self.y1 = np.arange(1, 10, .1)\n self.y2, self.x2 = np.mgrid[:10, :8]\n\n @pytest.mark.filterwarnings(r'ignore:.*:RuntimeWarning')\n def test_input1D(self, model_class, test_parameters):\n \"\"\"Test model with different input types.\"\"\"\n\n model = create_model(model_class, test_parameters)\n model(self.x)\n model(self.x1)\n model(self.x2)\n\n def test_eval1D(self, model_class, test_parameters):\n \"\"\"\n Test model values at certain given points\n \"\"\"\n model = create_model(model_class, test_parameters)\n x = test_parameters['x_values']\n y = test_parameters['y_values']\n assert_allclose(model(x), y, atol=self.eval_error)\n\n def test_bounding_box1D(self, model_class, test_parameters):\n \"\"\"Test bounding box evaluation\"\"\"\n\n model = create_model(model_class, test_parameters)\n\n # testing setter\n model.bounding_box = (-5, 5)\n model.bounding_box = None\n\n with pytest.raises(NotImplementedError):\n model.bounding_box\n\n del model.bounding_box\n\n # test exception if dimensions don't match\n with pytest.raises(ValueError):\n model.bounding_box = 5\n\n try:\n bbox = model.bounding_box\n except NotImplementedError:\n pytest.skip(\"Bounding_box is not defined for model.\")\n\n if isinstance(model, models.Lorentz1D) or isinstance(model, models.Drude1D):\n rtol = 0.01 # 1% agreement is enough due to very extended wings\n ddx = 0.1 # Finer sampling to \"integrate\" flux for narrow peak\n else:\n rtol = 1e-7\n ddx = 1\n\n dx = np.diff(bbox) / 2\n x1 = np.mgrid[slice(bbox[0], bbox[1] + 1, ddx)]\n x2 = np.mgrid[slice(bbox[0] - dx, bbox[1] + dx + 1, ddx)]\n arr = model(x2)\n sub_arr = model(x1)\n\n # check for flux agreement\n assert abs(arr.sum() - sub_arr.sum()) < arr.sum() * rtol\n\n @pytest.mark.skipif('not HAS_SCIPY')\n def test_fitter1D(self, model_class, test_parameters):\n \"\"\"\n Test if the parametric model works with the fitter.\n \"\"\"\n x_lim = test_parameters['x_lim']\n parameters = test_parameters['parameters']\n model = create_model(model_class, test_parameters)\n\n if isinstance(parameters, dict):\n parameters = [parameters[name] for name in model.param_names]\n\n if \"log_fit\" in test_parameters:\n if test_parameters['log_fit']:\n x = np.logspace(x_lim[0], x_lim[1], self.N)\n else:\n x = np.linspace(x_lim[0], x_lim[1], self.N)\n\n np.random.seed(0)\n # add 10% noise to the amplitude\n relative_noise_amplitude = 0.01\n data = ((1 + relative_noise_amplitude * np.random.randn(len(x))) *\n model(x))\n fitter = fitting.LevMarLSQFitter()\n new_model = fitter(model, x, data)\n\n # Only check parameters that were free in the fit\n params = [getattr(new_model, name) for name in new_model.param_names]\n fixed = [param.fixed for param in params]\n expected = np.array([val for val, fixed in zip(parameters, fixed)\n if not fixed])\n fitted = np.array([param.value for param in params\n if not param.fixed])\n assert_allclose(fitted, expected, atol=self.fit_error)\n\n @pytest.mark.skipif('not HAS_SCIPY')\n @pytest.mark.filterwarnings(r'ignore:.*:RuntimeWarning')\n def test_deriv_1D(self, model_class, test_parameters):\n \"\"\"\n Test the derivative of a model by comparing results with an estimated\n derivative.\n \"\"\"\n\n x_lim = test_parameters['x_lim']\n\n if model_class.fit_deriv is None:\n pytest.skip(\"Derivative function is not defined for model.\")\n if issubclass(model_class, PolynomialBase):\n pytest.skip(\"Skip testing derivative of polynomials.\")\n\n if \"log_fit\" in test_parameters:\n if test_parameters['log_fit']:\n x = np.logspace(x_lim[0], x_lim[1], self.N)\n else:\n x = np.linspace(x_lim[0], x_lim[1], self.N)\n\n parameters = test_parameters['parameters']\n model_with_deriv = create_model(model_class, test_parameters,\n use_constraints=False)\n model_no_deriv = create_model(model_class, test_parameters,\n use_constraints=False)\n\n # add 10% noise to the amplitude\n rsn = np.random.RandomState(1234567890)\n n = 0.1 * parameters[0] * (rsn.rand(self.N) - 0.5)\n\n data = model_with_deriv(x) + n\n fitter_with_deriv = fitting.LevMarLSQFitter()\n new_model_with_deriv = fitter_with_deriv(model_with_deriv, x, data)\n fitter_no_deriv = fitting.LevMarLSQFitter()\n new_model_no_deriv = fitter_no_deriv(model_no_deriv, x, data,\n estimate_jacobian=True)\n assert_allclose(new_model_with_deriv.parameters,\n new_model_no_deriv.parameters, atol=0.15)\n\n\ndef create_model(model_class, test_parameters, use_constraints=True,\n parameter_key='parameters'):\n \"\"\"Create instance of model class.\"\"\"\n\n constraints = {}\n if issubclass(model_class, PolynomialBase):\n return model_class(**test_parameters[parameter_key])\n elif issubclass(model_class, FittableModel):\n if \"requires_scipy\" in test_parameters and not HAS_SCIPY:\n pytest.skip(\"SciPy not found\")\n if use_constraints:\n if 'constraints' in test_parameters:\n constraints = test_parameters['constraints']\n return model_class(*test_parameters[parameter_key], **constraints)\n\n\[email protected](r'ignore:Model is linear in parameters.*')\[email protected](r'ignore:The fit may be unsuccessful.*')\[email protected](('model_class', 'test_parameters'),\n sorted(models_1D.items(), key=lambda x: str(x[0])))\nclass TestFittable1DModels(Fittable1DModelTester):\n pass\n\n\[email protected](r'ignore:Model is linear in parameters.*')\[email protected](('model_class', 'test_parameters'),\n sorted(models_2D.items(), key=lambda x: str(x[0])))\nclass TestFittable2DModels(Fittable2DModelTester):\n pass\n\n\ndef test_ShiftModel():\n # Shift by a scalar\n m = models.Shift(42)\n assert m(0) == 42\n assert_equal(m([1, 2]), [43, 44])\n\n # Shift by a list\n m = models.Shift([42, 43], n_models=2)\n assert_equal(m(0), [42, 43])\n assert_equal(m([1, 2], model_set_axis=False),\n [[43, 44], [44, 45]])\n\n\ndef test_ScaleModel():\n # Scale by a scalar\n m = models.Scale(42)\n assert m(0) == 0\n assert_equal(m([1, 2]), [42, 84])\n\n # Scale by a list\n m = models.Scale([42, 43], n_models=2)\n assert_equal(m(0), [0, 0])\n assert_equal(m([1, 2], model_set_axis=False),\n [[42, 84], [43, 86]])\n\n\ndef test_voigt_model():\n \"\"\"\n Currently just tests that the model peaks at its origin.\n Regression test for https://github.com/astropy/astropy/issues/3942\n \"\"\"\n\n m = models.Voigt1D(x_0=5, amplitude_L=10, fwhm_L=0.5, fwhm_G=0.9)\n x = np.arange(0, 10, 0.01)\n y = m(x)\n assert y[500] == y.max() # y[500] is right at the center\n\n\ndef test_model_instance_repr():\n m = models.Gaussian1D(1.5, 2.5, 3.5)\n assert repr(m) == '<Gaussian1D(amplitude=1.5, mean=2.5, stddev=3.5)>'\n\n\[email protected](\"not HAS_SCIPY\")\ndef test_tabular_interp_1d():\n \"\"\"\n Test Tabular1D model.\n \"\"\"\n points = np.arange(0, 5)\n values = [1., 10, 2, 45, -3]\n LookupTable = models.tabular_model(1)\n model = LookupTable(points=points, lookup_table=values)\n xnew = [0., .7, 1.4, 2.1, 3.9]\n ans1 = [1., 7.3, 6.8, 6.3, 1.8]\n assert_allclose(model(xnew), ans1)\n # Test evaluate without passing `points`.\n model = LookupTable(lookup_table=values)\n assert_allclose(model(xnew), ans1)\n # Test bounds error.\n xextrap = [0., .7, 1.4, 2.1, 3.9, 4.1]\n with pytest.raises(ValueError):\n model(xextrap)\n # test extrapolation and fill value\n model = LookupTable(lookup_table=values, bounds_error=False,\n fill_value=None)\n assert_allclose(model(xextrap),\n [1., 7.3, 6.8, 6.3, 1.8, -7.8])\n\n # Test unit support\n xnew = xnew * u.nm\n ans1 = ans1 * u.nJy\n model = LookupTable(points=points*u.nm, lookup_table=values*u.nJy)\n assert_quantity_allclose(model(xnew), ans1)\n assert_quantity_allclose(model(xnew.to(u.nm)), ans1)\n assert model.bounding_box == (0 * u.nm, 4 * u.nm)\n\n # Test fill value unit conversion and unitless input on table with unit\n model = LookupTable([1, 2, 3], [10, 20, 30] * u.nJy, bounds_error=False,\n fill_value=1e-33*(u.W / (u.m * u.m * u.Hz)))\n assert_quantity_allclose(model(np.arange(5)),\n [100, 10, 20, 30, 100] * u.nJy)\n\n\[email protected](\"not HAS_SCIPY\")\ndef test_tabular_interp_2d():\n table = np.array([\n [-0.04614432, -0.02512547, -0.00619557, 0.0144165, 0.0297525],\n [-0.04510594, -0.03183369, -0.01118008, 0.01201388, 0.02496205],\n [-0.05464094, -0.02804499, -0.00960086, 0.01134333, 0.02284104],\n [-0.04879338, -0.02539565, -0.00440462, 0.01795145, 0.02122417],\n [-0.03637372, -0.01630025, -0.00157902, 0.01649774, 0.01952131]])\n\n points = np.arange(0, 5)\n points = (points, points)\n\n xnew = np.array([0., .7, 1.4, 2.1, 3.9])\n LookupTable = models.tabular_model(2)\n model = LookupTable(points, table)\n znew = model(xnew, xnew)\n result = np.array(\n [-0.04614432, -0.03450009, -0.02241028, -0.0069727, 0.01938675])\n assert_allclose(znew, result, atol=1e-7)\n\n # test 2D arrays as input\n a = np.arange(12).reshape((3, 4))\n y, x = np.mgrid[:3, :4]\n t = models.Tabular2D(lookup_table=a)\n r = t(y, x)\n assert_allclose(a, r)\n\n with pytest.raises(ValueError):\n model = LookupTable(points=([1.2, 2.3], [1.2, 6.7], [3, 4]))\n with pytest.raises(ValueError):\n model = LookupTable(lookup_table=[1, 2, 3])\n with pytest.raises(NotImplementedError):\n model = LookupTable(n_models=2)\n with pytest.raises(ValueError):\n model = LookupTable(([1, 2], [3, 4]), [5, 6])\n with pytest.raises(ValueError):\n model = LookupTable(([1, 2] * u.m, [3, 4]), [[5, 6], [7, 8]])\n with pytest.raises(ValueError):\n model = LookupTable(points, table, bounds_error=False,\n fill_value=1*u.Jy)\n\n # Test unit support\n points = points[0] * u.nm\n points = (points, points)\n xnew = xnew * u.nm\n model = LookupTable(points, table * u.nJy)\n result = result * u.nJy\n assert_quantity_allclose(model(xnew, xnew), result, atol=1e-7*u.nJy)\n xnew = xnew.to(u.m)\n assert_quantity_allclose(model(xnew, xnew), result, atol=1e-7*u.nJy)\n bbox = (0 * u.nm, 4 * u.nm)\n bbox = (bbox, bbox)\n assert model.bounding_box == bbox\n\n\[email protected](\"not HAS_SCIPY\")\ndef test_tabular_nd():\n a = np.arange(24).reshape((2, 3, 4))\n x, y, z = np.mgrid[:2, :3, :4]\n tab = models.tabular_model(3)\n t = tab(lookup_table=a)\n result = t(x, y, z)\n assert_allclose(a, result)\n\n with pytest.raises(ValueError):\n models.tabular_model(0)\n\n\ndef test_with_bounding_box():\n \"\"\"\n Test the option to evaluate a model respecting\n its bunding_box.\n \"\"\"\n p = models.Polynomial2D(2) & models.Polynomial2D(2)\n m = models.Mapping((0, 1, 0, 1)) | p\n with NumpyRNGContext(1234567):\n m.parameters = np.random.rand(12)\n\n m.bounding_box = ((3, 9), (1, 8))\n x, y = np.mgrid[:10, :10]\n a, b = m(x, y)\n aw, bw = m(x, y, with_bounding_box=True)\n ind = (~np.isnan(aw)).nonzero()\n assert_allclose(a[ind], aw[ind])\n assert_allclose(b[ind], bw[ind])\n\n aw, bw = m(x, y, with_bounding_box=True, fill_value=1000)\n ind = (aw != 1000).nonzero()\n assert_allclose(a[ind], aw[ind])\n assert_allclose(b[ind], bw[ind])\n\n # test the order of bbox is not reversed for 1D models\n p = models.Polynomial1D(1, c0=12, c1=2.3)\n p.bounding_box = (0, 5)\n assert(p(1) == p(1, with_bounding_box=True))\n\n t3 = models.Shift(10) & models.Scale(2) & models.Shift(-1)\n t3.bounding_box = ((4.3, 6.9), (6, 15), (-1, 10))\n assert_allclose(t3([1, 1], [7, 7], [3, 5], with_bounding_box=True),\n [[np.nan, 11], [np.nan, 14], [np.nan, 4]])\n\n trans3 = models.Shift(10) & models.Scale(2) & models.Shift(-1)\n trans3.bounding_box = ((4.3, 6.9), (6, 15), (-1, 10))\n assert_allclose(trans3(1, 7, 5, with_bounding_box=True), [11, 14, 4])\n\n\[email protected](\"not HAS_SCIPY\")\ndef test_tabular_with_bounding_box():\n points = np.arange(5)\n values = np.array([1.5, 3.4, 6.7, 7, 32])\n t = models.Tabular1D(points, values)\n result = t(1, with_bounding_box=True)\n\n assert result == 3.4\n assert t.inverse(result, with_bounding_box=True) == 1.\n\n\[email protected](\"not HAS_SCIPY\")\ndef test_tabular_bounding_box_with_units():\n points = np.arange(5)*u.pix\n lt = np.arange(5)*u.AA\n t = models.Tabular1D(points, lt)\n result = t(1*u.pix, with_bounding_box=True)\n\n assert result == 1.*u.AA\n assert t.inverse(result, with_bounding_box=True) == 1*u.pix\n\n\[email protected](\"not HAS_SCIPY\")\ndef test_tabular1d_inverse():\n \"\"\"Test that the Tabular1D inverse is defined\"\"\"\n points = np.arange(5)\n values = np.array([1.5, 3.4, 6.7, 7, 32])\n t = models.Tabular1D(points, values)\n result = t.inverse((3.4, 6.7))\n assert_allclose(result, np.array((1., 2.)))\n\n # Check that it works for descending values in lookup_table\n t2 = models.Tabular1D(points, values[::-1])\n assert_allclose(t2.inverse.points[0], t2.lookup_table[::-1])\n\n result2 = t2.inverse((7, 6.7))\n assert_allclose(result2, np.array((1., 2.)))\n\n # Check that it errors on double-valued lookup_table\n points = np.arange(5)\n values = np.array([1.5, 3.4, 3.4, 32, 25])\n t = models.Tabular1D(points, values)\n with pytest.raises(NotImplementedError):\n t.inverse((3.4, 7.))\n\n # Check that Tabular2D.inverse raises an error\n table = np.arange(5*5).reshape(5, 5)\n points = np.arange(0, 5)\n points = (points, points)\n t3 = models.Tabular2D(points=points, lookup_table=table)\n with pytest.raises(NotImplementedError):\n t3.inverse((3, 3))\n\n # Check that it uses the same kwargs as the original model\n points = np.arange(5)\n values = np.array([1.5, 3.4, 6.7, 7, 32])\n t = models.Tabular1D(points, values)\n with pytest.raises(ValueError):\n t.inverse(100)\n t = models.Tabular1D(points, values, bounds_error=False, fill_value=None)\n result = t.inverse(100)\n assert_allclose(t(result), 100)\n\n\[email protected](\"not HAS_SCIPY\")\ndef test_tabular_module_name():\n \"\"\"\n The module name must be set manually because\n these classes are created dynamically.\n \"\"\"\n for model in [models.Tabular1D, models.Tabular2D]:\n assert model.__module__ == \"astropy.modeling.tabular\"\n\n\nclass classmodel(FittableModel):\n f = Parameter(default=1)\n x = Parameter(default=0)\n y = Parameter(default=2)\n\n def __init__(self, f=f.default, x=x.default, y=y.default):\n super().__init__(f, x, y)\n\n def evaluate(self):\n pass\n\n\nclass subclassmodel(classmodel):\n f = Parameter(default=3, fixed=True)\n x = Parameter(default=10)\n y = Parameter(default=12)\n h = Parameter(default=5)\n\n def __init__(self, f=f.default, x=x.default, y=y.default, h=h.default):\n super().__init__(f, x, y)\n\n def evaluate(self):\n pass\n\n\ndef test_parameter_inheritance():\n b = subclassmodel()\n assert b.param_names == ('f', 'x', 'y', 'h')\n assert b.h == 5\n assert b.f == 3\n assert b.f.fixed == True\n"
] | [
[
"numpy.vstack",
"numpy.logspace",
"numpy.diff",
"numpy.random.seed",
"numpy.cos",
"numpy.arange",
"numpy.random.RandomState",
"numpy.random.rand",
"numpy.testing.assert_allclose",
"numpy.array",
"numpy.sin",
"numpy.meshgrid",
"numpy.linspace",
"numpy.isnan"
]
] |
davidbrochart/pythran | [
"24b6c8650fe99791a4091cbdc2c24686e86aa67c"
] | [
"pythran/tests/cases/lapl3d.py"
] | [
"#runas: import numpy as np ; N = 500 ; X = np.random.randn(N,N,3); laplacien(X)\n#pythran export laplacien(float64[][][3])\n\nimport numpy as np\ndef laplacien(image):\n out_image = np.abs(4*image[1:-1,1:-1] -\n image[0:-2,1:-1] - image[2:,1:-1] -\n image[1:-1,0:-2] - image[1:-1,2:])\n valmax = np.max(out_image)\n valmax = max(1.,valmax)+1.E-9\n out_image /= valmax\n return out_image\n"
] | [
[
"numpy.max",
"numpy.abs"
]
] |
richardrl/ray | [
"cf53b351471716e7bfa71d36368ebea9b0e219c5"
] | [
"rllib/agents/dqn/tests/test_dqn.py"
] | [
"import numpy as np\nimport unittest\n\nimport ray\nimport ray.rllib.agents.dqn as dqn\nfrom ray.rllib.utils.framework import try_import_tf\nfrom ray.rllib.utils.test_utils import check, framework_iterator, \\\n check_compute_action\n\ntf = try_import_tf()\n\n\nclass TestDQN(unittest.TestCase):\n @classmethod\n def setUpClass(cls) -> None:\n ray.init()\n\n @classmethod\n def tearDownClass(cls) -> None:\n ray.shutdown()\n\n def test_dqn_compilation(self):\n \"\"\"Test whether a DQNTrainer can be built on all frameworks.\"\"\"\n config = dqn.DEFAULT_CONFIG.copy()\n config[\"num_workers\"] = 2\n num_iterations = 1\n\n for fw in framework_iterator(config):\n # Double-dueling DQN.\n plain_config = config.copy()\n trainer = dqn.DQNTrainer(config=plain_config, env=\"CartPole-v0\")\n for i in range(num_iterations):\n results = trainer.train()\n print(results)\n\n check_compute_action(trainer)\n\n # Rainbow.\n # TODO(sven): Add torch once DQN-torch supports distributional-Q.\n if fw == \"torch\":\n continue\n rainbow_config = config.copy()\n rainbow_config[\"num_atoms\"] = 10\n rainbow_config[\"noisy\"] = True\n rainbow_config[\"double_q\"] = True\n rainbow_config[\"dueling\"] = True\n rainbow_config[\"n_step\"] = 5\n trainer = dqn.DQNTrainer(config=rainbow_config, env=\"CartPole-v0\")\n for i in range(num_iterations):\n results = trainer.train()\n print(results)\n\n check_compute_action(trainer)\n\n def test_dqn_exploration_and_soft_q_config(self):\n \"\"\"Tests, whether a DQN Agent outputs exploration/softmaxed actions.\"\"\"\n config = dqn.DEFAULT_CONFIG.copy()\n config[\"num_workers\"] = 0 # Run locally.\n config[\"env_config\"] = {\"is_slippery\": False, \"map_name\": \"4x4\"}\n obs = np.array(0)\n\n # Test against all frameworks.\n for _ in framework_iterator(config):\n # Default EpsilonGreedy setup.\n trainer = dqn.DQNTrainer(config=config, env=\"FrozenLake-v0\")\n # Setting explore=False should always return the same action.\n a_ = trainer.compute_action(obs, explore=False)\n for _ in range(50):\n a = trainer.compute_action(obs, explore=False)\n check(a, a_)\n # explore=None (default: explore) should return different actions.\n actions = []\n for _ in range(50):\n actions.append(trainer.compute_action(obs))\n check(np.std(actions), 0.0, false=True)\n\n # Low softmax temperature. Behaves like argmax\n # (but no epsilon exploration).\n config[\"exploration_config\"] = {\n \"type\": \"SoftQ\",\n \"temperature\": 0.000001\n }\n trainer = dqn.DQNTrainer(config=config, env=\"FrozenLake-v0\")\n # Due to the low temp, always expect the same action.\n actions = [trainer.compute_action(obs)]\n for _ in range(50):\n actions.append(trainer.compute_action(obs))\n check(np.std(actions), 0.0, decimals=3)\n\n # Higher softmax temperature.\n config[\"exploration_config\"][\"temperature\"] = 1.0\n trainer = dqn.DQNTrainer(config=config, env=\"FrozenLake-v0\")\n\n # Even with the higher temperature, if we set explore=False, we\n # should expect the same actions always.\n a_ = trainer.compute_action(obs, explore=False)\n for _ in range(50):\n a = trainer.compute_action(obs, explore=False)\n check(a, a_)\n\n # Due to the higher temp, expect different actions avg'ing\n # around 1.5.\n actions = []\n for _ in range(300):\n actions.append(trainer.compute_action(obs))\n check(np.std(actions), 0.0, false=True)\n\n # With Random exploration.\n config[\"exploration_config\"] = {\"type\": \"Random\"}\n config[\"explore\"] = True\n trainer = dqn.DQNTrainer(config=config, env=\"FrozenLake-v0\")\n actions = []\n for _ in range(300):\n actions.append(trainer.compute_action(obs))\n check(np.std(actions), 0.0, false=True)\n\n\nif __name__ == \"__main__\":\n import pytest\n import sys\n sys.exit(pytest.main([\"-v\", __file__]))\n"
] | [
[
"numpy.array",
"numpy.std"
]
] |
oliver0922/yolo3dstereo | [
"24c37c4574eedd85593a0060b7c317b3e08c0460"
] | [
"visualDet3D/data/kitti/kittidata.py"
] | [
"'''\nFile Created: Sunday, 17th March 2019 3:58:52 pm\nAuthor: Peng YUN ([email protected])\nCopyright 2018 - 2019 RAM-Lab, RAM-Lab\n'''\nimport os\nimport math\nimport numpy as np\nfrom numpy.linalg import inv\nfrom .utils import read_image, read_pc_from_bin, _lidar2leftcam, _leftcam2lidar, _leftcam2imgplane\n# KITTI\nclass KittiCalib:\n '''\n class storing KITTI calib data\n self.data(None/dict):keys: 'P0', 'P1', 'P2', 'P3', 'R0_rect', 'Tr_velo_to_cam', 'Tr_imu_to_velo'\n self.R0_rect(np.array): [4,4]\n self.Tr_velo_to_cam(np.array): [4,4]\n '''\n def __init__(self, calib_path):\n self.path = calib_path\n self.data = None\n\n def read_calib_file(self):\n '''\n read KITTI calib file\n '''\n calib = dict()\n with open(self.path, 'r') as f:\n str_list = f.readlines()\n str_list = [itm.rstrip() for itm in str_list if itm != '\\n']\n for itm in str_list:\n calib[itm.split(':')[0]] = itm.split(':')[1]\n for k, v in calib.items():\n calib[k] = [float(itm) for itm in v.split()]\n self.data = calib\n\n self.P2 = np.array(self.data['P2']).reshape(3,4)\n self.P3 = np.array(self.data['P3']).reshape(3,4)\n\n R0_rect = np.zeros([4, 4])\n R0_rect[0:3, 0:3] = np.array(self.data['R0_rect']).reshape(3, 3)\n R0_rect[3, 3] = 1\n self.R0_rect = R0_rect\n\n Tr_velo_to_cam = np.zeros([4, 4])\n Tr_velo_to_cam[0:3, :] = np.array(self.data['Tr_velo_to_cam']).reshape(3, 4)\n Tr_velo_to_cam[3, 3] = 1\n self.Tr_velo_to_cam = Tr_velo_to_cam\n\n return self\n \n def leftcam2lidar(self, pts):\n '''\n transform the pts from the left camera frame to lidar frame\n pts_lidar = Tr_velo_to_cam^{-1} @ R0_rect^{-1} @ pts_cam\n inputs:\n pts(np.array): [#pts, 3]\n points in the left camera frame\n '''\n if self.data is None:\n print(\"read_calib_file should be read first\")\n raise RuntimeError\n return _leftcam2lidar(pts, self.Tr_velo_to_cam, self.R0_rect)\n\n def lidar2leftcam(self, pts):\n '''\n transform the pts from the lidar frame to the left camera frame\n pts_cam = R0_rect @ Tr_velo_to_cam @ pts_lidar\n inputs:\n pts(np.array): [#pts, 3]\n points in the lidar frame\n '''\n if self.data is None:\n print(\"read_calib_file should be read first\")\n raise RuntimeError\n return _lidar2leftcam(pts, self.Tr_velo_to_cam, self.R0_rect)\n\n def leftcam2imgplane(self, pts):\n '''\n project the pts from the left camera frame to left camera plane\n pixels = P2 @ pts_cam\n inputs:\n pts(np.array): [#pts, 3]\n points in the left camera frame\n '''\n if self.data is None:\n print(\"read_calib_file should be read first\")\n raise RuntimeError\n return _leftcam2imgplane(pts, self.P2)\n\nclass KittiLabel:\n '''\n class storing KITTI 3d object detection label\n self.data ([KittiObj])\n '''\n def __init__(self, label_path=None):\n self.path = label_path\n self.data = None\n\n def read_label_file(self, no_dontcare=True):\n '''\n read KITTI label file\n '''\n self.data = []\n with open(self.path, 'r') as f:\n str_list = f.readlines()\n str_list = [itm.rstrip() for itm in str_list if itm != '\\n']\n for s in str_list:\n self.data.append(KittiObj(s))\n if no_dontcare:\n self.data = list(filter(lambda obj: obj.type != \"DontCare\", self.data))\n return self\n #self.data=[Kittiobj(pedestrain 0,3 ,...),Kittiobj(car 0,6,53...)]\n\n def __str__(self):\n '''\n TODO: Unit TEST\n '''\n s = ''\n for obj in self.data:\n s += obj.__str__() + '\\n'\n return s\n\n def equal(self, label, acc_cls, rtol):\n '''\n equal oprator for KittiLabel\n inputs:\n label: KittiLabel\n acc_cls: list [str]\n ['Car', 'Van']\n eot: float\n Notes: O(N^2)\n '''\n if len(self.data) != len(label.data):\n return False\n if len(self.data) == 0:\n return True\n bool_list = []\n for obj1 in self.data:\n bool_obj1 = False\n for obj2 in label.data:\n bool_obj1 = bool_obj1 or obj1.equal(obj2, acc_cls, rtol)\n bool_list.append(bool_obj1)\n return any(bool_list)\n\n def isempty(self):\n '''\n return True if self.data = None or self.data = []\n '''\n return self.data is None or len(self.data) == 0\n\nclass KittiObj():\n '''\n class storing a KITTI 3d object\n '''\n def __init__(self, s=None):\n self.type = None\n self.truncated = None\n self.occluded = None\n self.alpha = None\n self.bbox_l = None\n self.bbox_t = None\n self.bbox_r = None\n self.bbox_b = None\n self.h = None\n self.w = None\n self.l = None\n self.x = None\n self.y = None\n self.z = None\n self.ry = None\n self.score = None\n if s is None:\n return\n if len(s.split()) == 15: # data\n self.truncated, self.occluded, self.alpha,\\\n self.bbox_l, self.bbox_t, self.bbox_r, self.bbox_b, \\\n self.h, self.w, self.l, self.x, self.y, self.z, self.ry = \\\n [float(itm) for itm in s.split()[1:]]\n self.type = s.split()[0]\n elif len(s.split()) == 16: # result\n self.truncated, self.occluded, self.alpha,\\\n self.bbox_l, self.bbox_t, self.bbox_r, self.bbox_b, \\\n self.h, self.w, self.l, self.x, self.y, self.z, self.ry, self.score = \\\n [float(itm) for itm in s.split()[1:]]\n self.type = s.split()[0]\n else:\n raise NotImplementedError\n\n def __str__(self):\n if self.score is None:\n return \"{} {:.2f} {} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f}\".format(\n self.type, self.truncated, int(self.occluded), self.alpha,\\\n self.bbox_l, self.bbox_t, self.bbox_r, self.bbox_b, \\\n self.h, self.w, self.l, self.x, self.y, self.z, self.ry)\n else:\n return \"{} {:.2f} {} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f} {:.2f}\".format(\n self.type, self.truncated, int(self.occluded), self.alpha,\\\n self.bbox_l, self.bbox_t, self.bbox_r, self.bbox_b, \\\n self.h, self.w, self.l, self.x, self.y, self.z, self.ry, self.score)\n\nclass KittiData:\n '''\n class storing a frame of KITTI data\n '''\n def __init__(self, root_dir, idx, output_dict=None):\n '''\n inputs:\n root_dir(str): kitti dataset dir\n idx(str %6d): data index e.g. \"000000\"\n output_dict: decide what to output\n '''\n self.calib_path = os.path.join(root_dir, \"calib\", idx+'.txt')\n self.image2_path = os.path.join(root_dir, \"image_2\", idx+'.png')\n self.image3_path = os.path.join(root_dir, 'image_3', idx+'.png')\n self.label2_path = os.path.join(root_dir, \"label_2\", idx+'.txt')\n self.velodyne_path = os.path.join(root_dir, \"velodyne\", idx+'.bin')\n self.output_dict = output_dict\n if self.output_dict is None:\n self.output_dict = {\n \"calib\": True,\n \"image\": True,\n \"image_3\": False,\n \"label\": True,\n \"velodyne\": True\n }\n\n def read_data(self):\n '''\n read data\n returns:\n calib(KittiCalib)\n image(np.array): [w, h, 3]\n label(KittiLabel)\n pc(np.array): [# of points, 4]\n point cloud in lidar frame.\n [x, y, z]\n ^x\n |\n y<----.z\n '''\n \n calib = KittiCalib(self.calib_path).read_calib_file() if self.output_dict[\"calib\"] else None\n image = read_image(self.image2_path) if self.output_dict[\"image\"] else None\n label = KittiLabel(self.label2_path).read_label_file() if self.output_dict[\"label\"] else None\n pc = read_pc_from_bin(self.velodyne_path) if self.output_dict[\"velodyne\"] else None\n if 'image_3' in self.output_dict and self.output_dict['image_3']:\n image_3 = read_image(self.image3_path) if self.output_dict[\"image_3\"] else None\n\n return calib, image, image_3, label, pc\n else:\n return calib, image, label, pc\n"
] | [
[
"numpy.array",
"numpy.zeros"
]
] |
side-projects-42/INTERVIEW-PREP-COMPLETE | [
"627a3315cee4bbc38a0e81c256f27f928eac2d63"
] | [
"notes-n-resources/Data-Structures-N-Algo/_DS-n-Algos/_Another-One/sorts/random_normaldistribution_quicksort.py"
] | [
"from __future__ import print_function\nfrom random import randint\nfrom tempfile import TemporaryFile\nimport numpy as np\nimport math\n\n\ndef _inPlaceQuickSort(A, start, end):\n count = 0\n if start < end:\n pivot = randint(start, end)\n temp = A[end]\n A[end] = A[pivot]\n A[pivot] = temp\n\n p, count = _inPlacePartition(A, start, end)\n count += _inPlaceQuickSort(A, start, p - 1)\n count += _inPlaceQuickSort(A, p + 1, end)\n return count\n\n\ndef _inPlacePartition(A, start, end):\n\n count = 0\n pivot = randint(start, end)\n temp = A[end]\n A[end] = A[pivot]\n A[pivot] = temp\n newPivotIndex = start - 1\n for index in range(start, end):\n\n count += 1\n if A[index] < A[end]: # check if current val is less than pivot value\n newPivotIndex = newPivotIndex + 1\n temp = A[newPivotIndex]\n A[newPivotIndex] = A[index]\n A[index] = temp\n\n temp = A[newPivotIndex + 1]\n A[newPivotIndex + 1] = A[end]\n A[end] = temp\n return newPivotIndex + 1, count\n\n\noutfile = TemporaryFile()\np = 100 # 1000 elements are to be sorted\n\n\nmu, sigma = 0, 1 # mean and standard deviation\nX = np.random.normal(mu, sigma, p)\nnp.save(outfile, X)\nprint(\"The array is\")\nprint(X)\n\n\noutfile.seek(0) # using the same array\nM = np.load(outfile)\nr = len(M) - 1\nz = _inPlaceQuickSort(M, 0, r)\n\nprint(\n \"No of Comparisons for 100 elements selected from a standard normal distribution is :\"\n)\nprint(z)\n"
] | [
[
"numpy.random.normal",
"numpy.save",
"numpy.load"
]
] |
itayhubara/AcceleratedSparseNeuralTraining | [
"425897dec9c7ef185841d7000c4418ebb1c95896"
] | [
"prune/pruning_method_utils.py"
] | [
"import torch\n\n\ndef validate_tensor_shape_2d_4d(t):\n shape = t.shape\n if len(shape) not in (2, 4):\n raise ValueError(\n \"Only 2D and 4D tensor shapes are supported. Found \"\n \"Found tensor of shape {} with {} dims\".format(shape, len(shape))\n )\n\n\ndef pad_inner_dims(t, pad_to):\n \"\"\" return padded-to-block tensor \"\"\"\n inner_flattened = t.view(t.shape[0], -1)\n co, inners = inner_flattened.shape\n pad_required = pad_to > 1 and inners % pad_to != 0\n pad_size = pad_to - inners % pad_to if pad_required else 0\n pad = torch.zeros(co, pad_size).to(inner_flattened.data)\n t_padded = torch.cat((inner_flattened, pad), 1)\n return t_padded\n\n\ndef clip_padding(t, orig_shape):\n \"\"\" return tensor with clipped padding \"\"\"\n co = orig_shape[0]\n inners = 1\n for s in orig_shape[1:]:\n inners *= s\n t_clipped = t.view(co, -1)[:, :inners]\n return t_clipped\n\n\ndef permute_to_nhwc(t):\n \"\"\" for 4D tensors, convert data layout from NCHW to NHWC \"\"\"\n res = t.permute(0, 2, 3, 1).contiguous() if t.dim() == 4 else t\n return res\n\n\ndef permute_to_nchw(t):\n \"\"\" for 4D tensors, convert data layout from NHWC to NCHW \"\"\"\n res = t.permute(0, 3, 1, 2).contiguous() if t.dim() == 4 else t\n return res\n"
] | [
[
"torch.zeros",
"torch.cat"
]
] |
SamIlic/Web-Scraping | [
"fae1e0b000adda18abff44e4c60fbad77e872314"
] | [
"ERC/ERC/spiders/ICOBench.py"
] | [
"# -*- coding: utf-8 -*-\nimport scrapy # needed to scrape\nimport xlrd # used to easily import xlsx file \nimport json\nimport re\nimport pandas as pd\nimport numpy as np\nfrom openpyxl import load_workbook\nimport datetime\n#from datetime import timedelta\n\n\n\n\nclass ICObench(scrapy.Spider):\n name = 'ICOBench' # Name of Script\n \n # file_path = r\"/Users/YoungFreeesh/Visual Studio Code/_Python/Web Scraping/ERC/Data/COINS.xlsx\"\n file_path = r\"/Users/YoungFreeesh/Visual Studio Code/_Python/Web Scraping/ERC/Data/MASTER-1000.xlsx\"\n MASTER_Coin_df = pd.read_excel(file_path, sheet_name = \"Summary\") # read all data from \"Top ERC-20\"\n headers = list(MASTER_Coin_df.columns.values) # get the headers --> ERC-20 Token, Ticker, ID, CoinMarketCap URL, Market Cap (yyyy-mm-dd) \n \n # URLs\n URLs = MASTER_Coin_df['CoinMarketCap URL']\n temp_urls = URLs.values.tolist()\n temp_urls = [url + \"historical-data/\" for url in temp_urls]\n\n\n\n\n print(\"``````````````````````````````````````````````````````````````````````````````\")\n # start_urls = ['https://icobench.com/ico/tezos'] # TEST\n start_urls = temp_urls\n print(\"``````````````````````````````````````````````````````````````````````````````\")\n\n################################################################################################\n################################################################################################\n\n \"\"\"\n Scrape data from ICO-bench for all cryptos in MASTER-1000\n \"\"\"\n def parse(self, response):\n self.logger.info('A response has arrived from %s', response.url)\n print(\"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\")\n print(\"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\")\n print(\"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\")\n print(\"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\")\n print(\"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\")\n print(\"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\")\n \n # Get Ticker\n tickerTemp = response.css(\"body > div.container.main-section > div > div.col-lg-10.padding-top-1x > div.details-panel.flex-container.bottom-margin-2x > div.details-panel-item--header.flex-container > h1 > span::text\").extract()[0]\n \n\n\n\n # \"\"\"\n # Run after the Scrapy is done scraping/crawling\n # \"\"\"\n # def closed( self, reason ):\n # # Get Time stamp for market cap\n # timeStamp = str(datetime.datetime.today().strftime(' (%Y-%m-%d)')) # Today, as an Integer\n \n # ### Sanity Check\n # print(\"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\")\n # print('Name: ',len(token_name_List))\n # print('Ticker: ',len(ticker_List))\n # print('Rolling Monthly: ', len(rolling_avg_volume_monthly_List))\n # print('Rolling Weekly: ', len(rolling_avg_volume_weekly_List))\n # print('Rank: ', len(scraped_rank_List))\n # print(\"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\")\n \n # ### Append rolling average columns to MASTER_ERC_df\n # # Rolling_df = pd.DataFrame()\n # # Rolling_df['Ticker'] = ticker_List\n # # Rolling_df['Volume: Monthly Rolling Avg'] = rolling_avg_volume_monthly_List\n # # Rolling_df['Market Cap: Monthly Rolling Avg'] = rolling_avg_volume_weekly_List\n \n\n # Rolling_df = pd.DataFrame(list(zip(token_name_List,\n # ticker_List,\n # rolling_avg_volume_monthly_List,\n # rolling_avg_volume_weekly_List\n # )),\n # columns=['Name',\n # 'Ticker',\n # 'Daily Volume ($): Monthly Rolling Avg',\n # 'Daily Volume ($): Weekly Rolling Avg'],\n # index=scraped_rank_List)\n # Rolling_df.index.name = \"CMC Rank\" + timeStamp # Rename Index\n\n # # Sort DataFrame by Index\n # Rolling_df=Rolling_df.sort_index() # Sort by CMC Rank (index)\n\n # print(Rolling_df)\n\n # ### Create new Tab in \"MASTER ERC-20.xlsx\"\n # # fileName = \"MASTER ERC-20 Rolling\" #+ timeStamp\n # file_path_HardDrive = r\"/Users/YoungFreeesh/Visual Studio Code/_Python/Web Scraping/ERC/Data/MASTER-1000.xlsx\"\n # writer_HardDrive = pd.ExcelWriter(file_path_HardDrive, engine='openpyxl')\n\n # # Write to new sheet in existing workbook\n # book_HardDrive = load_workbook(file_path_HardDrive)\n # writer_HardDrive.book = book_HardDrive\n\n # # Write Sheet\n # Rolling_df.to_excel(writer_HardDrive, startrow= 0 , index=True, sheet_name= 'Rolling Averages' + timeStamp) # write to \"MASTER-Ercot.xlsx\" spreadsheet\n\n # writer_HardDrive.save()\n # writer_HardDrive.close()\n\n\n\n\n\n\n\n\n"
] | [
[
"pandas.read_excel"
]
] |
BeylierMPG/Reinforcement-Learning | [
"17495386e36a27c5fc617e24221baf0fc5743c91"
] | [
"algos/models/ddqn_cnn.py"
] | [
"import torch\nimport torch.nn as nn\nimport torch.autograd as autograd \nimport torch.nn.functional as F\n\n\nclass DDQNCnn(nn.Module):\n def __init__(self, input_shape, num_actions):\n super(DDQNCnn, self).__init__()\n self.input_shape = input_shape\n self.num_actions = num_actions\n \n self.conv_1 = nn.Sequential(\n nn.Conv2d(input_shape[0], 32, kernel_size=8, stride=4),\n nn.ReLU()\n )\n \n self.conv_2 = nn.Sequential(\n nn.Conv2d(32, 64, kernel_size=4, stride=2),\n nn.ReLU()\n )\n \n self.conv_3 = nn.Sequential(\n nn.Conv2d(64, 64, kernel_size=3, stride=1),\n nn.ReLU()\n )\n \n self.advantage = nn.Sequential(\n nn.Linear(3136, 512),\n nn.ReLU(),\n nn.Linear(512, self.num_actions)\n )\n\n self.value = nn.Sequential(\n nn.Linear(3136, 512),\n nn.ReLU(),\n nn.Linear(512, 1)\n )\n\n\n def forward(self, x):\n x = self.conv_1(x)\n x = self.conv_2(x)\n x = self.conv_3(x)\n x = x.view(x.size(0), -1)\n advantage = self.advantage(x)\n value = self.value(x)\n return value + advantage - advantage.mean()\n \n def feature_size(self):\n return self.features(autograd.Variable(torch.zeros(1, *self.input_shape))).view(1, -1).size(1)"
] | [
[
"torch.nn.Linear",
"torch.nn.ReLU",
"torch.nn.Conv2d",
"torch.zeros"
]
] |
lepoeme20/vision | [
"eac3dc7bab436725b0ba65e556d3a6ffd43c24e1"
] | [
"torchvision/prototype/datasets/utils/_internal.py"
] | [
"import enum\nimport functools\nimport gzip\nimport io\nimport lzma\nimport mmap\nimport os\nimport os.path\nimport pathlib\nimport pickle\nimport platform\nfrom typing import BinaryIO\nfrom typing import (\n Sequence,\n Callable,\n Union,\n Any,\n Tuple,\n TypeVar,\n Iterator,\n Dict,\n Optional,\n IO,\n Sized,\n)\nfrom typing import cast\n\nimport numpy as np\nimport PIL.Image\nimport torch\nimport torch.distributed as dist\nimport torch.utils.data\nfrom torchdata.datapipes.iter import IoPathFileLister, IoPathFileLoader, IterDataPipe, ShardingFilter\nfrom torchdata.datapipes.utils import StreamWrapper\n\n\n__all__ = [\n \"INFINITE_BUFFER_SIZE\",\n \"BUILTIN_DIR\",\n \"read_mat\",\n \"image_buffer_from_array\",\n \"SequenceIterator\",\n \"MappingIterator\",\n \"Enumerator\",\n \"getitem\",\n \"path_accessor\",\n \"path_comparator\",\n \"Decompressor\",\n \"fromfile\",\n \"read_flo\",\n \"hint_sharding\",\n]\n\nK = TypeVar(\"K\")\nD = TypeVar(\"D\")\n\n# pseudo-infinite until a true infinite buffer is supported by all datapipes\nINFINITE_BUFFER_SIZE = 1_000_000_000\n\nBUILTIN_DIR = pathlib.Path(__file__).parent.parent / \"_builtin\"\n\n\ndef read_mat(buffer: io.IOBase, **kwargs: Any) -> Any:\n try:\n import scipy.io as sio\n except ImportError as error:\n raise ModuleNotFoundError(\"Package `scipy` is required to be installed to read .mat files.\") from error\n\n if isinstance(buffer, StreamWrapper):\n buffer = buffer.file_obj\n\n return sio.loadmat(buffer, **kwargs)\n\n\ndef image_buffer_from_array(array: np.ndarray, *, format: str = \"png\") -> io.BytesIO:\n image = PIL.Image.fromarray(array)\n buffer = io.BytesIO()\n image.save(buffer, format=format)\n buffer.seek(0)\n return buffer\n\n\nclass SequenceIterator(IterDataPipe[D]):\n def __init__(self, datapipe: IterDataPipe[Sequence[D]]):\n self.datapipe = datapipe\n\n def __iter__(self) -> Iterator[D]:\n for sequence in self.datapipe:\n yield from iter(sequence)\n\n\nclass MappingIterator(IterDataPipe[Union[Tuple[K, D], D]]):\n def __init__(self, datapipe: IterDataPipe[Dict[K, D]], *, drop_key: bool = False) -> None:\n self.datapipe = datapipe\n self.drop_key = drop_key\n\n def __iter__(self) -> Iterator[Union[Tuple[K, D], D]]:\n for mapping in self.datapipe:\n yield from iter(mapping.values() if self.drop_key else mapping.items())\n\n\nclass Enumerator(IterDataPipe[Tuple[int, D]]):\n def __init__(self, datapipe: IterDataPipe[D], start: int = 0) -> None:\n self.datapipe = datapipe\n self.start = start\n\n def __iter__(self) -> Iterator[Tuple[int, D]]:\n yield from enumerate(self.datapipe, self.start)\n\n\ndef _getitem_closure(obj: Any, *, items: Tuple[Any, ...]) -> Any:\n for item in items:\n obj = obj[item]\n return obj\n\n\ndef getitem(*items: Any) -> Callable[[Any], Any]:\n return functools.partial(_getitem_closure, items=items)\n\n\ndef _path_attribute_accessor(path: pathlib.Path, *, name: str) -> D:\n return cast(D, getattr(path, name))\n\n\ndef _path_accessor_closure(data: Tuple[str, Any], *, getter: Callable[[pathlib.Path], D]) -> D:\n return getter(pathlib.Path(data[0]))\n\n\ndef path_accessor(getter: Union[str, Callable[[pathlib.Path], D]]) -> Callable[[Tuple[str, Any]], D]:\n if isinstance(getter, str):\n getter = functools.partial(_path_attribute_accessor, name=getter)\n\n return functools.partial(_path_accessor_closure, getter=getter)\n\n\ndef _path_comparator_closure(data: Tuple[str, Any], *, accessor: Callable[[Tuple[str, Any]], D], value: D) -> bool:\n return accessor(data) == value\n\n\ndef path_comparator(getter: Union[str, Callable[[pathlib.Path], D]], value: D) -> Callable[[Tuple[str, Any]], bool]:\n return functools.partial(_path_comparator_closure, accessor=path_accessor(getter), value=value)\n\n\nclass CompressionType(enum.Enum):\n GZIP = \"gzip\"\n LZMA = \"lzma\"\n\n\nclass Decompressor(IterDataPipe[Tuple[str, io.IOBase]]):\n types = CompressionType\n\n _DECOMPRESSORS = {\n types.GZIP: lambda file: gzip.GzipFile(fileobj=file),\n types.LZMA: lambda file: lzma.LZMAFile(file),\n }\n\n def __init__(\n self,\n datapipe: IterDataPipe[Tuple[str, io.IOBase]],\n *,\n type: Optional[Union[str, CompressionType]] = None,\n ) -> None:\n self.datapipe = datapipe\n if isinstance(type, str):\n type = self.types(type.upper())\n self.type = type\n\n def _detect_compression_type(self, path: str) -> CompressionType:\n if self.type:\n return self.type\n\n # TODO: this needs to be more elaborate\n ext = os.path.splitext(path)[1]\n if ext == \".gz\":\n return self.types.GZIP\n elif ext == \".xz\":\n return self.types.LZMA\n else:\n raise RuntimeError(\"FIXME\")\n\n def __iter__(self) -> Iterator[Tuple[str, io.IOBase]]:\n for path, file in self.datapipe:\n type = self._detect_compression_type(path)\n decompressor = self._DECOMPRESSORS[type]\n yield path, decompressor(file)\n\n\nclass PicklerDataPipe(IterDataPipe):\n def __init__(self, source_datapipe: IterDataPipe[Tuple[str, IO[bytes]]]) -> None:\n self.source_datapipe = source_datapipe\n\n def __iter__(self) -> Iterator[Any]:\n for _, fobj in self.source_datapipe:\n data = pickle.load(fobj)\n for _, d in enumerate(data):\n yield d\n\n\nclass SharderDataPipe(torch.utils.data.datapipes.iter.grouping.ShardingFilterIterDataPipe):\n def __init__(self, source_datapipe: IterDataPipe) -> None:\n super().__init__(source_datapipe)\n self.rank = 0\n self.world_size = 1\n if dist.is_available() and dist.is_initialized():\n self.rank = dist.get_rank()\n self.world_size = dist.get_world_size()\n self.apply_sharding(self.world_size, self.rank)\n\n def __iter__(self) -> Iterator[Any]:\n num_workers = self.world_size\n worker_id = self.rank\n worker_info = torch.utils.data.get_worker_info()\n if worker_info is not None:\n worker_id = worker_id + worker_info.id * num_workers\n num_workers *= worker_info.num_workers\n self.apply_sharding(num_workers, worker_id)\n yield from super().__iter__()\n\n\nclass TakerDataPipe(IterDataPipe):\n def __init__(self, source_datapipe: IterDataPipe, num_take: int) -> None:\n super().__init__()\n self.source_datapipe = source_datapipe\n self.num_take = num_take\n self.world_size = 1\n if dist.is_available() and dist.is_initialized():\n self.world_size = dist.get_world_size()\n\n def __iter__(self) -> Iterator[Any]:\n num_workers = self.world_size\n worker_info = torch.utils.data.get_worker_info()\n if worker_info is not None:\n num_workers *= worker_info.num_workers\n\n # TODO: this is weird as it drops more elements than it should\n num_take = self.num_take // num_workers\n\n for i, data in enumerate(self.source_datapipe):\n if i < num_take:\n yield data\n else:\n break\n\n def __len__(self) -> int:\n num_take = self.num_take // self.world_size\n if isinstance(self.source_datapipe, Sized):\n if len(self.source_datapipe) < num_take:\n num_take = len(self.source_datapipe)\n # TODO: might be weird to not take `num_workers` into account\n return num_take\n\n\ndef _make_sharded_datapipe(root: str, dataset_size: int) -> IterDataPipe[Dict[str, Any]]:\n dp = IoPathFileLister(root=root)\n dp = SharderDataPipe(dp)\n dp = dp.shuffle(buffer_size=INFINITE_BUFFER_SIZE)\n dp = IoPathFileLoader(dp, mode=\"rb\")\n dp = PicklerDataPipe(dp)\n # dp = dp.cycle(2)\n dp = TakerDataPipe(dp, dataset_size)\n return dp\n\n\ndef _read_mutable_buffer_fallback(file: BinaryIO, count: int, item_size: int) -> bytearray:\n # A plain file.read() will give a read-only bytes, so we convert it to bytearray to make it mutable\n return bytearray(file.read(-1 if count == -1 else count * item_size))\n\n\ndef fromfile(\n file: BinaryIO,\n *,\n dtype: torch.dtype,\n byte_order: str,\n count: int = -1,\n) -> torch.Tensor:\n \"\"\"Construct a tensor from a binary file.\n\n .. note::\n\n This function is similar to :func:`numpy.fromfile` with two notable differences:\n\n 1. This function only accepts an open binary file, but not a path to it.\n 2. This function has an additional ``byte_order`` parameter, since PyTorch's ``dtype``'s do not support that\n concept.\n\n .. note::\n\n If the ``file`` was opened in update mode, i.e. \"r+b\" or \"w+b\", reading data is much faster. Be aware that as\n long as the file is still open, inplace operations on the returned tensor will reflect back to the file.\n\n Args:\n file (IO): Open binary file.\n dtype (torch.dtype): Data type of the underlying data as well as of the returned tensor.\n byte_order (str): Byte order of the data. Can be \"little\" or \"big\" endian.\n count (int): Number of values of the returned tensor. If ``-1`` (default), will read the complete file.\n \"\"\"\n byte_order = \"<\" if byte_order == \"little\" else \">\"\n char = \"f\" if dtype.is_floating_point else (\"i\" if dtype.is_signed else \"u\")\n item_size = (torch.finfo if dtype.is_floating_point else torch.iinfo)(dtype).bits // 8\n np_dtype = byte_order + char + str(item_size)\n\n buffer: Union[memoryview, bytearray]\n if platform.system() != \"Windows\":\n # PyTorch does not support tensors with underlying read-only memory. In case\n # - the file has a .fileno(),\n # - the file was opened for updating, i.e. 'r+b' or 'w+b',\n # - the file is seekable\n # we can avoid copying the data for performance. Otherwise we fall back to simply .read() the data and copy it\n # to a mutable location afterwards.\n try:\n buffer = memoryview(mmap.mmap(file.fileno(), 0))[file.tell() :]\n # Reading from the memoryview does not advance the file cursor, so we have to do it manually.\n file.seek(*(0, io.SEEK_END) if count == -1 else (count * item_size, io.SEEK_CUR))\n except (PermissionError, io.UnsupportedOperation):\n buffer = _read_mutable_buffer_fallback(file, count, item_size)\n else:\n # On Windows just trying to call mmap.mmap() on a file that does not support it, may corrupt the internal state\n # so no data can be read afterwards. Thus, we simply ignore the possible speed-up.\n buffer = _read_mutable_buffer_fallback(file, count, item_size)\n\n # We cannot use torch.frombuffer() directly, since it only supports the native byte order of the system. Thus, we\n # read the data with np.frombuffer() with the correct byte order and convert it to the native one with the\n # successive .astype() call.\n return torch.from_numpy(np.frombuffer(buffer, dtype=np_dtype, count=count).astype(np_dtype[1:], copy=False))\n\n\ndef read_flo(file: BinaryIO) -> torch.Tensor:\n if file.read(4) != b\"PIEH\":\n raise ValueError(\"Magic number incorrect. Invalid .flo file\")\n\n width, height = fromfile(file, dtype=torch.int32, byte_order=\"little\", count=2)\n flow = fromfile(file, dtype=torch.float32, byte_order=\"little\", count=height * width * 2)\n return flow.reshape((height, width, 2)).permute((2, 0, 1))\n\n\ndef hint_sharding(datapipe: IterDataPipe[D]) -> IterDataPipe[D]:\n return ShardingFilter(datapipe)\n"
] | [
[
"scipy.io.loadmat",
"torch.distributed.get_rank",
"torch.distributed.get_world_size",
"torch.distributed.is_available",
"torch.distributed.is_initialized",
"torch.utils.data.get_worker_info",
"numpy.frombuffer"
]
] |
USEPA/LCIAformatter | [
"e803dccf81b1f7d7441e576909cdac3f823b40ce"
] | [
"lciafmt/recipe.py"
] | [
"# recipe.py (lciafmt)\n# !/usr/bin/env python3\n# coding=utf-8\n\"\"\"\nThis module contains functions needed to compile LCIA methods from the\nReCiPe model\n\"\"\"\n\nimport pandas as pd\nimport openpyxl\n\nimport lciafmt.cache as cache\nimport lciafmt.df as dfutil\nimport lciafmt.xls as xls\n\nfrom .util import datapath, aggregate_factors_for_primary_contexts, log,\\\n format_cas\n\n\ncontexts = {\n 'urban air': 'air/urban',\n 'urban air': 'air/urban',\n 'Urban air': 'air/urban',\n 'Rural air': 'air/rural',\n 'rural air': 'air/rural',\n 'agricultural soil': 'soil/agricultural',\n 'Agricultural soil': 'soil/agricultural',\n 'industrial soil': 'soil/industrial',\n 'Industrial soil': 'soil/industrial',\n 'freshwater': 'water/freshwater',\n 'Freshwater': 'water/freshwater',\n 'fresh water': 'water/freshwater',\n 'seawater': 'water/sea water',\n 'sea water': 'water/sea water',\n 'Sea water': 'water/sea water',\n 'marine water': 'water/sea water'}\nflowables_split = pd.read_csv(datapath + 'ReCiPe2016_split.csv')\n\n\ndef get(add_factors_for_missing_contexts=True, endpoint=True,\n summary=False, file=None, url=None) -> pd.DataFrame:\n \"\"\"Generate a method for ReCiPe 2016 in standard format.\n\n :param add_factors_for_missing_contexts: bool, if True generates average\n factors for unspecified contexts\n :param endpoint: bool, if True generates endpoint indicators from midpoints\n :param summary: bool, if True aggregates endpoint methods into\n summary indicators\n :param file: str, alternate filepath for method, defaults to file stored\n in cache\n :param url: str, alternate url for method, defaults to url in method config\n :return: DataFrame of method in standard format\n \"\"\"\n log.info(\"getting method ReCiPe 2016\")\n f = file\n if f is None:\n fname = \"recipe_2016.xlsx\"\n if url is None:\n url = (\"http://www.rivm.nl/sites/default/files/2018-11/\" +\n \"ReCiPe2016_CFs_v1.1_20180117.xlsx\")\n f = cache.get_or_download(fname, url)\n df = _read(f)\n if add_factors_for_missing_contexts:\n log.info(\"adding average factors for primary contexts\")\n df = aggregate_factors_for_primary_contexts(df)\n\n if endpoint:\n endpoint_df, endpoint_df_by_flow = _read_endpoints(f)\n log.info(\"converting midpoints to endpoints\")\n # first assesses endpoint factors that are specific to flowables\n flowdf = df.merge(endpoint_df_by_flow, how=\"inner\",\n on=[\"Method\", \"Flowable\"])\n flowdf.rename(columns={'Indicator_x': 'Indicator',\n 'Indicator_y': 'EndpointIndicator'},\n inplace=True)\n # next apply endpoint factors by indicator\n df2 = df.merge(endpoint_df, how=\"inner\", on=[\"Method\", \"Indicator\"])\n df2 = df2.append(flowdf, ignore_index=True, sort=False)\n # reformat dataframe and apply conversion\n df2['Characterization Factor'] = df2['Characterization Factor'] * df2['EndpointConversion']\n df2['Method'] = df2['EndpointMethod']\n df2['Indicator'] = df2['EndpointIndicator']\n df2['Indicator unit'] = df2['EndpointUnit']\n df2.drop(columns=['EndpointMethod', 'EndpointIndicator',\n 'EndpointUnit', 'EndpointConversion'],\n inplace=True)\n df = df.append(df2, ignore_index=True, sort=False)\n\n log.info(\"handling manual replacements\")\n \"\"\"due to substances listed more than once with the same name but\n different CAS, this replaces all instances of the Original Flowable with\n a New Flowable based on a csv input file according to the CAS\"\"\"\n for index, row in flowables_split.iterrows():\n newCAS = format_cas(row['CAS'])\n newFlow = row['New Flowable']\n df.loc[df['CAS No'] == newCAS, 'Flowable'] = newFlow\n\n length = len(df)\n df.drop_duplicates(keep='first', inplace=True)\n length = length - len(df)\n log.info(f\"{length} duplicate entries removed\")\n\n if summary:\n log.info(\"summarizing endpoint categories\")\n endpoint_categories = df.groupby(['Method', 'Method UUID',\n 'Indicator unit', 'Flowable',\n 'Flow UUID', 'Context', 'Unit',\n 'CAS No', 'Location',\n 'Location UUID', 'EndpointCategory'],\n as_index=False)['Characterization Factor'].sum()\n endpoint_categories['Indicator'] = endpoint_categories['EndpointCategory']\n endpoint_categories['Indicator UUID'] = \"\"\n endpoint_categories.drop(columns=['EndpointCategory'], inplace=True)\n\n # To append endpoint categories to exisiting endpointLCIA,\n # set append = True, otherwise replaces endpoint LCIA\n append = False\n if append:\n log.info(\"appending endpoint categories\")\n df = pd.concat([df, endpoint_categories], sort=False)\n else:\n log.info(\"applying endpoint categories\")\n df = endpoint_categories\n\n # reorder columns in DF\n df = df.reindex(columns=[\"Method\", \"Method UUID\", \"Indicator\",\n \"Indicator UUID\", \"Indicator unit\", \"Flowable\",\n \"Flow UUID\", \"Context\", \"Unit\", \"CAS No\",\n \"Location\", \"Location UUID\",\n \"Characterization Factor\"])\n return df\n\n\ndef _read(file: str) -> pd.DataFrame:\n log.info(f\"read ReCiPe 2016 from file {file}\")\n wb = openpyxl.load_workbook(file, read_only=True, data_only=True)\n records = []\n for name in wb.sheetnames:\n if _eqstr(name, \"Version\") or _eqstr(\n name, \"Midpoint to endpoint factors\"):\n continue\n _read_mid_points(wb[name], records)\n\n return dfutil.data_frame(records)\n\n\ndef _read_endpoints(file: str) -> pd.DataFrame:\n log.info(f\"reading endpoint factors from file {file}\")\n wb = openpyxl.load_workbook(file, read_only=True, data_only=True)\n endpoint_cols = ['Method', 'EndpointMethod', 'EndpointIndicator',\n 'EndpointUnit', 'EndpointConversion']\n endpoint = pd.DataFrame(columns=endpoint_cols)\n endpoints = []\n perspectives = [\"I\", \"H\", \"E\"]\n indicator = \"\"\n indicator_unit = \"\"\n sheet = wb['Midpoint to endpoint factors']\n start_row, data_col, with_perspectives = _find_data_start(sheet)\n # impact categories in column 1\n flow_col = 0\n\n endpoint_factor_count = 0\n for row in sheet.iter_rows(min_row=start_row):\n indicator = xls.cell_str(row[flow_col])\n indicator_unit = xls.cell_str(row[flow_col+1])\n for i in range(0, 3):\n val = xls.cell_f64(row[data_col + i])\n if val == 0.0:\n continue\n endpoints.append(\"ReCiPe 2016 - Midpoint/\" + perspectives[i])\n endpoints.append(\"ReCiPe 2016 - Endpoint/\" + perspectives[i])\n endpoints.append(indicator)\n endpoints.append(indicator_unit)\n endpoints.append(val)\n to_add = pd.Series(endpoints, index=endpoint_cols)\n endpoint = endpoint.append(to_add, ignore_index=True)\n endpoints = []\n endpoint_factor_count += 1\n log.debug(\"extracted %i endpoint factors\", endpoint_factor_count)\n\n log.info(\"processing endpoint factors\")\n endpoint.loc[endpoint['EndpointUnit'].str.contains('daly', case=False), 'EndpointUnit'] = 'DALY'\n endpoint.loc[endpoint['EndpointUnit'].str.contains('species', case=False), 'EndpointUnit'] = 'species-year'\n endpoint.loc[endpoint['EndpointUnit'].str.contains('USD', case=False), 'EndpointUnit'] = 'USD2013'\n\n endpoint_map = pd.read_csv(datapath + 'ReCiPe2016_endpoint_to_midpoint.csv')\n endpoint = endpoint.merge(endpoint_map, how=\"left\", on='EndpointIndicator')\n\n # split into two dataframes\n endpoint_by_flow = endpoint[endpoint['FlowFlag'] == 1]\n endpoint_by_flow = endpoint_by_flow.drop(columns='FlowFlag')\n endpoint_by_flow.rename(columns={'EndpointIndicator': 'Flowable'},\n inplace=True)\n endpoint = endpoint[endpoint['FlowFlag'].isna()]\n endpoint = endpoint.drop(columns='FlowFlag')\n # return endpoint and endpoint by flow\n return endpoint, endpoint_by_flow\n\n\ndef _read_mid_points(sheet: openpyxl.worksheet.worksheet.Worksheet,\n records: list):\n log.debug(\"try to read midpoint factors from sheet %s\", sheet.title)\n\n start_row, data_col, with_perspectives = _find_data_start(sheet)\n if start_row < 0:\n log.debug(\"could not find a value column in sheet %s\", sheet.title)\n return\n\n flow_col = _find_flow_column(sheet)\n if flow_col < 0:\n return\n\n cas_col = _find_cas_column(sheet)\n indicator_unit, flow_unit, unit_col = _determine_units(sheet)\n compartment, compartment_col = _determine_compartments(sheet)\n\n perspectives = [\"I\", \"H\", \"E\"]\n factor_count = 0\n for row in sheet.iter_rows(min_row=start_row):\n if compartment_col > -1:\n compartment = xls.cell_str(row[compartment_col])\n if compartment in contexts:\n compartment = contexts[compartment]\n if unit_col > -1:\n flow_unit = xls.cell_str(row[unit_col])\n if \"/\" in flow_unit:\n flow_unit = flow_unit.split(\"/\")[1].strip()\n cas = \"\"\n if cas_col > -1:\n cas = format_cas(xls.cell_f64(row[cas_col]))\n\n if with_perspectives:\n for i in range(0, 3):\n val = xls.cell_f64(row[data_col + i])\n if val == 0.0:\n continue\n dfutil.record(records,\n method=\"ReCiPe 2016 - Midpoint/\" + perspectives[i],\n indicator=sheet.title,\n indicator_unit=indicator_unit,\n flow=xls.cell_str(row[flow_col]),\n flow_category=compartment,\n flow_unit=flow_unit,\n cas_number=cas,\n factor=val)\n factor_count += 1\n else:\n val = xls.cell_f64(row[data_col])\n if val == 0.0:\n continue\n for p in perspectives:\n dfutil.record(records,\n method=\"ReCiPe 2016 - Midpoint/\" + p,\n indicator=sheet.title,\n indicator_unit=indicator_unit,\n flow=xls.cell_str(row[flow_col]),\n flow_category=compartment,\n flow_unit=flow_unit,\n cas_number=cas,\n factor=val)\n factor_count += 1\n log.debug(\"extracted %i factors\", factor_count)\n\n\ndef _find_data_start(sheet: openpyxl.worksheet.worksheet.Worksheet) -> (int, int, bool):\n for row in sheet.iter_rows():\n for cell in row:\n s = xls.cell_str(cell)\n if s is None or s == \"\":\n continue\n if _eqstr(s, \"I\") or _containstr(s, \"Individualist\") or _containstr(s, \"Individualistic\"):\n return cell.row + 1, cell.column - 1, True\n if _eqstr(s, \"all perspectives\"):\n return cell.row + 1, cell.column - 1, False\n return -1, -1\n\n\ndef _find_flow_column(sheet: openpyxl.worksheet.worksheet.Worksheet) -> int:\n if _containstr(sheet.title, \"land\", \"occupation\"):\n ncol = 1\n return ncol\n ncol = -1\n for row in sheet.iter_rows():\n for cell in row:\n s = xls.cell_str(cell)\n if _containstr(s, \"name\") or _containstr(s, \"substance\"):\n ncol = cell.column - 1\n log.debug(\"identified column %i %s for flow names\", ncol, s)\n break\n if ncol < 0:\n log.debug(\"no 'name' column in %s, take col=0 for that\", sheet.title)\n ncol = 0\n return ncol\n\n\ndef _find_cas_column(sheet: openpyxl.worksheet.worksheet.Worksheet) -> int:\n ccol = -1\n for row in sheet.iter_rows():\n for cell in row:\n s = xls.cell_str(cell)\n if _eqstr(s, \"cas\"):\n ccol = cell.column - 1\n log.debug(\"identified column %i %s for CAS numbers\", ccol, s)\n break\n return ccol\n\n\ndef _determine_units(sheet: openpyxl.worksheet.worksheet.Worksheet) -> (str, str, int):\n indicator_unit = \"?\"\n flow_unit = \"?\"\n unit_col = -1\n row, col, _ = _find_data_start(sheet)\n row -= 2\n\n if row > 0:\n s = xls.cell_str(sheet.cell(row=row, column=col + 1))\n if s is not None and s != \"\":\n if \"/\" in s:\n parts = s.strip(\" ()\").split(\"/\")\n indicator_unit = parts[0].strip()\n flow_unit = parts[1].strip()\n else:\n indicator_unit = s.strip()\n\n for count, row in enumerate(sheet.iter_rows()):\n if count > 5:\n break\n for cell in row:\n s = xls.cell_str(cell)\n if _eqstr(s, \"Unit\"):\n unit_col = cell.column - 1\n break\n\n if indicator_unit != \"?\":\n log.debug(\"determined indicator unit: %s\", indicator_unit)\n elif _containstr(sheet.title, \"land\", \"transformation\"):\n log.debug(\"unknown indicator unit; assuming it is m2\")\n indicator_unit = \"m2\"\n elif _containstr(sheet.title, \"land\", \"occupation\"):\n log.debug(\"unknown indicator unit; assuming it is m2*a\")\n indicator_unit = \"m2*a\"\n elif _containstr(sheet.title, \"water\", \"consumption\"):\n log.debug(\"unknown indicator unit; assuming it is m3\")\n indicator_unit = \"m3\"\n else:\n log.debug(\"unknown indicator unit\")\n\n if _containstr(flow_unit, \"kg\"):\n flow_unit = \"kg\"\n\n if unit_col > -1:\n log.debug(\"take units from column %i\", unit_col)\n elif flow_unit != \"?\":\n log.debug(\"determined flow unit: %s\", flow_unit)\n elif _containstr(sheet.title, \"land\", \"transformation\"):\n log.debug(\"unknown flow unit; assume it is m2\")\n flow_unit = \"m2\"\n elif _containstr(sheet.title, \"land\", \"occupation\"):\n log.debug(\"unknown flow unit; assuming it is m2*a\")\n flow_unit = \"m2*a\"\n elif _containstr(sheet.title, \"water\", \"consumption\"):\n log.debug(\"unknown flow unit; assuming it is m3\")\n flow_unit = \"m3\"\n else:\n log.debug(\"unknown flow unit; assuming it is 'kg'\")\n flow_unit = \"kg\"\n\n return indicator_unit, flow_unit, unit_col\n\n\ndef _determine_compartments(sheet: openpyxl.worksheet.worksheet.Worksheet) -> (str, int):\n compartment_col = -1\n for count, row in enumerate(sheet.iter_rows()):\n if count > 5:\n break\n for cell in row:\n s = xls.cell_str(cell)\n if _containstr(s, \"compartment\") or _containstr(\n s, \"name\", \"in\", \"ReCiPe\"):\n compartment_col = cell.column - 1\n break\n\n if compartment_col > -1:\n log.debug(\"found compartment column %i\", compartment_col)\n return \"\", compartment_col\n\n elif _containstr(sheet.title, \"global\", \"warming\") \\\n or _containstr(sheet.title, \"ozone\") \\\n or _containstr(sheet.title, \"particulate\") \\\n or _containstr(sheet.title, \"acidification\"):\n log.debug(\"no compartment column; assuming 'air'\")\n return \"air\", -1\n\n elif _containstr(sheet.title, \"mineral\", \"resource\", \"scarcity\"):\n log.debug(\"no compartment column; assuming 'resource/ground'\")\n return \"resource/ground\", -1\n\n elif _containstr(sheet.title, \"fossil\", \"resource\", \"scarcity\"):\n log.debug(\"no compartment column; assuming 'resource'\")\n return \"resource\", -1\n\n if _containstr(sheet.title, \"water\", \"consumption\"):\n log.debug(\"no compartment column; assuming 'resource/fresh water'\")\n return \"resource/fresh water\", -1\n\n log.debug(\"no compartment column\")\n return \"\", -1\n\n\ndef _eqstr(s1: str, s2: str) -> bool:\n if s1 is None or s2 is None:\n return False\n return s1.strip().lower() == s2.strip().lower()\n\n\ndef _containstr(s: str, *words) -> bool:\n if s is None:\n return False\n base = s.lower()\n for w in words:\n if not isinstance(w, str):\n return False\n if w.lower().strip() not in base:\n return False\n return True\n"
] | [
[
"pandas.read_csv",
"pandas.Series",
"pandas.DataFrame",
"pandas.concat"
]
] |
youngwoon/robot-learning | [
"70da64466fd02dc4cfc97ad9e123c893fc17acd3"
] | [
"networks/encoder.py"
] | [
"\"\"\"\nCode reference:\n https://github.com/MishaLaskin/rad/blob/master/encoder.py\n\"\"\"\n\nimport gym.spaces\nimport torch\nimport torch.nn as nn\n\nfrom .utils import CNN, MLP, flatten_ac\n\n\nclass Encoder(nn.Module):\n def __init__(self, config, ob_space):\n super().__init__()\n\n self._encoder_type = config.encoder_type\n self._ob_space = ob_space\n\n self.base = nn.ModuleDict()\n encoder_output_dim = 0\n for k, v in ob_space.spaces.items():\n if len(v.shape) in [3, 4]:\n if self._encoder_type == \"mlp\":\n self.base[k] = None\n encoder_output_dim += gym.spaces.flatdim(v)\n else:\n if len(v.shape) == 3:\n image_dim = v.shape[0]\n elif len(v.shape) == 4:\n image_dim = v.shape[0] * v.shape[1]\n self.base[k] = CNN(config, image_dim)\n encoder_output_dim += self.base[k].output_dim\n elif len(v.shape) == 1:\n self.base[k] = None\n encoder_output_dim += gym.spaces.flatdim(v)\n else:\n raise ValueError(\"Check the shape of observation %s (%s)\" % (k, v))\n\n self.output_dim = encoder_output_dim\n\n def forward(self, ob, detach_conv=False):\n encoder_outputs = []\n for k, v in ob.items():\n if self.base[k] is not None:\n if isinstance(self.base[k], CNN):\n if v.max() > 1.0:\n v = v.float() / 255.0\n encoder_outputs.append(\n self.base[k](v, detach_conv=detach_conv)\n )\n else:\n encoder_outputs.append(v.flatten(start_dim=1))\n out = torch.cat(encoder_outputs, dim=-1)\n assert len(out.shape) == 2\n return out\n\n def copy_conv_weights_from(self, source):\n \"\"\" Tie convolutional layers \"\"\"\n for k in self.base.keys():\n if self.base[k] is not None:\n self.base[k].copy_conv_weights_from(source.base[k])\n"
] | [
[
"torch.nn.ModuleDict",
"torch.cat"
]
] |
benduffy1/MONAI | [
"2fef7ff5c064a9ff6b6d6b4f2323180afed99934"
] | [
"monai/networks/blocks/dints_block.py"
] | [
"# Copyright (c) MONAI Consortium\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# http://www.apache.org/licenses/LICENSE-2.0\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\nfrom typing import Tuple, Union\n\nimport torch\n\nfrom monai.networks.layers.factories import Conv\nfrom monai.networks.layers.utils import get_act_layer, get_norm_layer\n\n__all__ = [\"FactorizedIncreaseBlock\", \"FactorizedReduceBlock\", \"P3DActiConvNormBlock\", \"ActiConvNormBlock\"]\n\n\nclass FactorizedIncreaseBlock(torch.nn.Sequential):\n \"\"\"\n Up-sampling the features by two using linear interpolation and convolutions.\n \"\"\"\n\n def __init__(\n self,\n in_channel: int,\n out_channel: int,\n spatial_dims: int = 3,\n act_name: Union[Tuple, str] = \"RELU\",\n norm_name: Union[Tuple, str] = \"INSTANCE\",\n ):\n \"\"\"\n Args:\n in_channel: number of input channels\n out_channel: number of output channels\n spatial_dims: number of spatial dimensions\n act_name: activation layer type and arguments.\n norm_name: feature normalization type and arguments.\n \"\"\"\n super().__init__()\n self._in_channel = in_channel\n self._out_channel = out_channel\n self._spatial_dims = spatial_dims\n if self._spatial_dims not in (2, 3):\n raise ValueError(\"spatial_dims must be 2 or 3.\")\n\n conv_type = Conv[Conv.CONV, self._spatial_dims]\n mode = \"trilinear\" if self._spatial_dims == 3 else \"bilinear\"\n self.add_module(\"up\", torch.nn.Upsample(scale_factor=2, mode=mode, align_corners=True))\n self.add_module(\"acti\", get_act_layer(name=act_name))\n self.add_module(\n \"conv\",\n conv_type(\n in_channels=self._in_channel,\n out_channels=self._out_channel,\n kernel_size=1,\n stride=1,\n padding=0,\n groups=1,\n bias=False,\n dilation=1,\n ),\n )\n self.add_module(\n \"norm\", get_norm_layer(name=norm_name, spatial_dims=self._spatial_dims, channels=self._out_channel)\n )\n\n\nclass FactorizedReduceBlock(torch.nn.Module):\n \"\"\"\n Down-sampling the feature by 2 using stride.\n The length along each spatial dimension must be a multiple of 2.\n \"\"\"\n\n def __init__(\n self,\n in_channel: int,\n out_channel: int,\n spatial_dims: int = 3,\n act_name: Union[Tuple, str] = \"RELU\",\n norm_name: Union[Tuple, str] = \"INSTANCE\",\n ):\n \"\"\"\n Args:\n in_channel: number of input channels\n out_channel: number of output channels.\n spatial_dims: number of spatial dimensions.\n act_name: activation layer type and arguments.\n norm_name: feature normalization type and arguments.\n \"\"\"\n super().__init__()\n self._in_channel = in_channel\n self._out_channel = out_channel\n self._spatial_dims = spatial_dims\n if self._spatial_dims not in (2, 3):\n raise ValueError(\"spatial_dims must be 2 or 3.\")\n\n conv_type = Conv[Conv.CONV, self._spatial_dims]\n\n self.act = get_act_layer(name=act_name)\n self.conv_1 = conv_type(\n in_channels=self._in_channel,\n out_channels=self._out_channel // 2,\n kernel_size=1,\n stride=2,\n padding=0,\n groups=1,\n bias=False,\n dilation=1,\n )\n self.conv_2 = conv_type(\n in_channels=self._in_channel,\n out_channels=self._out_channel - self._out_channel // 2,\n kernel_size=1,\n stride=2,\n padding=0,\n groups=1,\n bias=False,\n dilation=1,\n )\n self.norm = get_norm_layer(name=norm_name, spatial_dims=self._spatial_dims, channels=self._out_channel)\n\n def forward(self, x: torch.Tensor) -> torch.Tensor:\n \"\"\"\n The length along each spatial dimension must be a multiple of 2.\n \"\"\"\n x = self.act(x)\n if self._spatial_dims == 3:\n out = torch.cat([self.conv_1(x), self.conv_2(x[:, :, 1:, 1:, 1:])], dim=1)\n else:\n out = torch.cat([self.conv_1(x), self.conv_2(x[:, :, 1:, 1:])], dim=1)\n out = self.norm(out)\n return out\n\n\nclass P3DActiConvNormBlock(torch.nn.Sequential):\n \"\"\"\n -- (act) -- (conv) -- (norm) --\n \"\"\"\n\n def __init__(\n self,\n in_channel: int,\n out_channel: int,\n kernel_size: int,\n padding: int,\n mode: int = 0,\n act_name: Union[Tuple, str] = \"RELU\",\n norm_name: Union[Tuple, str] = \"INSTANCE\",\n ):\n \"\"\"\n Args:\n in_channel: number of input channels.\n out_channel: number of output channels.\n kernel_size: kernel size to be expanded to 3D.\n padding: padding size to be expanded to 3D.\n mode: mode for the anisotropic kernels:\n\n - 0: ``(k, k, 1)``, ``(1, 1, k)``,\n - 1: ``(k, 1, k)``, ``(1, k, 1)``,\n - 2: ``(1, k, k)``. ``(k, 1, 1)``.\n\n act_name: activation layer type and arguments.\n norm_name: feature normalization type and arguments.\n \"\"\"\n super().__init__()\n self._in_channel = in_channel\n self._out_channel = out_channel\n self._p3dmode = int(mode)\n\n conv_type = Conv[Conv.CONV, 3]\n\n if self._p3dmode == 0: # (k, k, 1), (1, 1, k)\n kernel_size0 = (kernel_size, kernel_size, 1)\n kernel_size1 = (1, 1, kernel_size)\n padding0 = (padding, padding, 0)\n padding1 = (0, 0, padding)\n elif self._p3dmode == 1: # (k, 1, k), (1, k, 1)\n kernel_size0 = (kernel_size, 1, kernel_size)\n kernel_size1 = (1, kernel_size, 1)\n padding0 = (padding, 0, padding)\n padding1 = (0, padding, 0)\n elif self._p3dmode == 2: # (1, k, k), (k, 1, 1)\n kernel_size0 = (1, kernel_size, kernel_size)\n kernel_size1 = (kernel_size, 1, 1)\n padding0 = (0, padding, padding)\n padding1 = (padding, 0, 0)\n else:\n raise ValueError(\"`mode` must be 0, 1, or 2.\")\n\n self.add_module(\"acti\", get_act_layer(name=act_name))\n self.add_module(\n \"conv\",\n conv_type(\n in_channels=self._in_channel,\n out_channels=self._in_channel,\n kernel_size=kernel_size0,\n stride=1,\n padding=padding0,\n groups=1,\n bias=False,\n dilation=1,\n ),\n )\n self.add_module(\n \"conv_1\",\n conv_type(\n in_channels=self._in_channel,\n out_channels=self._out_channel,\n kernel_size=kernel_size1,\n stride=1,\n padding=padding1,\n groups=1,\n bias=False,\n dilation=1,\n ),\n )\n self.add_module(\"norm\", get_norm_layer(name=norm_name, spatial_dims=3, channels=self._out_channel))\n\n\nclass ActiConvNormBlock(torch.nn.Sequential):\n \"\"\"\n -- (Acti) -- (Conv) -- (Norm) --\n \"\"\"\n\n def __init__(\n self,\n in_channel: int,\n out_channel: int,\n kernel_size: int = 3,\n padding: int = 1,\n spatial_dims: int = 3,\n act_name: Union[Tuple, str] = \"RELU\",\n norm_name: Union[Tuple, str] = \"INSTANCE\",\n ):\n \"\"\"\n Args:\n in_channel: number of input channels.\n out_channel: number of output channels.\n kernel_size: kernel size of the convolution.\n padding: padding size of the convolution.\n spatial_dims: number of spatial dimensions.\n act_name: activation layer type and arguments.\n norm_name: feature normalization type and arguments.\n \"\"\"\n super().__init__()\n self._in_channel = in_channel\n self._out_channel = out_channel\n self._spatial_dims = spatial_dims\n\n conv_type = Conv[Conv.CONV, self._spatial_dims]\n self.add_module(\"acti\", get_act_layer(name=act_name))\n self.add_module(\n \"conv\",\n conv_type(\n in_channels=self._in_channel,\n out_channels=self._out_channel,\n kernel_size=kernel_size,\n stride=1,\n padding=padding,\n groups=1,\n bias=False,\n dilation=1,\n ),\n )\n self.add_module(\n \"norm\", get_norm_layer(name=norm_name, spatial_dims=self._spatial_dims, channels=self._out_channel)\n )\n"
] | [
[
"torch.nn.Upsample"
]
] |
awsm-research/LineVul | [
"246baf18c1932094564a10c9b81efb21914b2978"
] | [
"bow_rf/rf_main.py"
] | [
"import pandas as pd\nfrom sklearn.feature_extraction.text import TfidfVectorizer\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.metrics import f1_score, precision_score, recall_score\nimport pickle\nimport numpy as np\n\n\n# load train, val data\ntrain = pd.read_csv('../data/big-vul_dataset/train.csv')\nval = pd.read_csv('../data/big-vul_dataset/val.csv')\n# use train + val data to fit the model\ntrain_data = pd.concat([train, val])\n# load test data\ntest_data = pd.read_csv('../data/big-vul_dataset/test.csv')\n# textual code data\nX_train = train_data[\"processed_func\"]\nX_test = test_data[\"processed_func\"]\n# labels\ny_train = train_data[\"target\"]\ny_test = test_data[\"target\"]\n# apply BoW feature extraction\nvectorizer = TfidfVectorizer(norm='l2', max_features=1000)\nvectorizer = vectorizer.fit(X_train)\nX_train = vectorizer.transform(X_train).todense()\nX_test = vectorizer.transform(X_test).todense()\n# train the model\nrf = RandomForestClassifier(n_estimators=1000,\n n_jobs=-1,\n verbose=1)\nrf.fit(X_train, y_train)\npreds = rf.predict(X_test)\nf1 = f1_score(y_true=y_test, y_pred=preds)\nprecision = precision_score(y_true=y_test, y_pred=preds)\nrecall = recall_score(y_true=y_test, y_pred=preds)\nprint(f\"F1 Score: {f1}\")\nprint(f\"Precision: {precision}\")\nprint(f\"Recall: {recall}\")\n\nwith open('./saved_models/best_f1_rf.pkl', 'wb') as f:\n pickle.dump(rf, f)\n\nprint(\"done\")\n"
] | [
[
"pandas.read_csv",
"sklearn.feature_extraction.text.TfidfVectorizer",
"sklearn.metrics.f1_score",
"sklearn.metrics.precision_score",
"pandas.concat",
"sklearn.ensemble.RandomForestClassifier",
"sklearn.metrics.recall_score"
]
] |
robcalon/PyETM | [
"323418ad57b2df7d47f2495919c943db28ca55cc"
] | [
"pyETM/curves/hourly_hydrogen_curves.py"
] | [
"import io\nimport pandas\n\nclass HourlyHydrogenCurves:\n \n @property\n def hourly_hydrogen_curves(self):\n \n # get hourly hydrogen curves\n if self._hourly_hydrogen_curves is None:\n self.get_hourly_hydrogen_curves()\n \n return self._hourly_hydrogen_curves\n \n def get_hourly_hydrogen_curves(self):\n \"\"\"get the hourly hydrogen curves\"\"\"\n \n # raise without scenario id\n self._raise_scenario_id()\n \n # prepare post\n headers = {'Connection':'close'}\n post = f'/scenarios/{self.scenario_id}/curves/hydrogen'\n \n # request response and extract data\n resp = self.get(post, headers=headers)\n data = io.StringIO(resp)\n \n # convert data to dataframe and set DateTime\n curves = pandas.read_csv(data, index_col='Time', \n parse_dates=True).asfreq('H')\n curves.index.name = 'DateTime'\n \n # set corresponsing parameter property\n self._hourly_hydrogen_curves = curves\n \n return curves"
] | [
[
"pandas.read_csv"
]
] |
mengwanguc/torchvision-meng | [
"395942756b0b29053d25b50cdef86f709601453e"
] | [
"torchvision/models/squeezenet.py"
] | [
"import time\nimport torch\nimport torch.nn as nn\nimport torch.nn.init as init\nfrom .utils import load_state_dict_from_url\nfrom typing import Any\n\n__all__ = ['SqueezeNet', 'squeezenet1_0', 'squeezenet1_1']\n\nmodel_urls = {\n 'squeezenet1_0': 'https://download.pytorch.org/models/squeezenet1_0-a815701f.pth',\n 'squeezenet1_1': 'https://download.pytorch.org/models/squeezenet1_1-f364aa15.pth',\n}\n\n\nclass Fire(nn.Module):\n\n def __init__(\n self,\n inplanes: int,\n squeeze_planes: int,\n expand1x1_planes: int,\n expand3x3_planes: int\n ) -> None:\n super(Fire, self).__init__()\n self.inplanes = inplanes\n self.squeeze = nn.Conv2d(inplanes, squeeze_planes, kernel_size=1)\n self.squeeze_activation = nn.ReLU(inplace=True)\n self.expand1x1 = nn.Conv2d(squeeze_planes, expand1x1_planes,\n kernel_size=1)\n self.expand1x1_activation = nn.ReLU(inplace=True)\n self.expand3x3 = nn.Conv2d(squeeze_planes, expand3x3_planes,\n kernel_size=3, padding=1)\n self.expand3x3_activation = nn.ReLU(inplace=True)\n\n def forward(self, x: torch.Tensor) -> torch.Tensor:\n x = self.squeeze_activation(self.squeeze(x))\n return torch.cat([\n self.expand1x1_activation(self.expand1x1(x)),\n self.expand3x3_activation(self.expand3x3(x))\n ], 1)\n\n\nclass SqueezeNet(nn.Module):\n\n def __init__(\n self,\n version: str = '1_0',\n num_classes: int = 1000\n ) -> None:\n super(SqueezeNet, self).__init__()\n self.num_classes = num_classes\n if version == '1_0':\n self.features = nn.Sequential(\n nn.Conv2d(3, 96, kernel_size=7, stride=2),\n nn.ReLU(inplace=True),\n nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),\n Fire(96, 16, 64, 64),\n Fire(128, 16, 64, 64),\n Fire(128, 32, 128, 128),\n nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),\n Fire(256, 32, 128, 128),\n Fire(256, 48, 192, 192),\n Fire(384, 48, 192, 192),\n Fire(384, 64, 256, 256),\n nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),\n Fire(512, 64, 256, 256),\n )\n elif version == '1_1':\n self.features = nn.Sequential(\n nn.Conv2d(3, 64, kernel_size=3, stride=2),\n nn.ReLU(inplace=True),\n nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),\n Fire(64, 16, 64, 64),\n Fire(128, 16, 64, 64),\n nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),\n Fire(128, 32, 128, 128),\n Fire(256, 32, 128, 128),\n nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),\n Fire(256, 48, 192, 192),\n Fire(384, 48, 192, 192),\n Fire(384, 64, 256, 256),\n Fire(512, 64, 256, 256),\n )\n else:\n # FIXME: Is this needed? SqueezeNet should only be called from the\n # FIXME: squeezenet1_x() functions\n # FIXME: This checking is not done for the other models\n raise ValueError(\"Unsupported SqueezeNet version {version}:\"\n \"1_0 or 1_1 expected\".format(version=version))\n\n # Final convolution is initialized differently from the rest\n final_conv = nn.Conv2d(512, self.num_classes, kernel_size=1)\n self.classifier = nn.Sequential(\n nn.Dropout(p=0.5),\n final_conv,\n nn.ReLU(inplace=True),\n nn.AdaptiveAvgPool2d((1, 1))\n )\n\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n if m is final_conv:\n init.normal_(m.weight, mean=0.0, std=0.01)\n else:\n init.kaiming_uniform_(m.weight)\n if m.bias is not None:\n init.constant_(m.bias, 0)\n\n def forward(self, x: torch.Tensor) -> torch.Tensor:\n end = time.time()\n x = self.features(x)\n x = self.classifier(x)\n res = torch.flatten(x, 1)\n single_forward_time = time.time() - end\n print(\"squeezenet single_forward_time: {}\".format(single_forward_time))\n return res\n\ndef _squeezenet(version: str, pretrained: bool, progress: bool, **kwargs: Any) -> SqueezeNet:\n model = SqueezeNet(version, **kwargs)\n if pretrained:\n arch = 'squeezenet' + version\n state_dict = load_state_dict_from_url(model_urls[arch],\n progress=progress)\n model.load_state_dict(state_dict)\n return model\n\n\ndef squeezenet1_0(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> SqueezeNet:\n r\"\"\"SqueezeNet model architecture from the `\"SqueezeNet: AlexNet-level\n accuracy with 50x fewer parameters and <0.5MB model size\"\n <https://arxiv.org/abs/1602.07360>`_ paper.\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n progress (bool): If True, displays a progress bar of the download to stderr\n \"\"\"\n return _squeezenet('1_0', pretrained, progress, **kwargs)\n\n\ndef squeezenet1_1(pretrained: bool = False, progress: bool = True, **kwargs: Any) -> SqueezeNet:\n r\"\"\"SqueezeNet 1.1 model from the `official SqueezeNet repo\n <https://github.com/DeepScale/SqueezeNet/tree/master/SqueezeNet_v1.1>`_.\n SqueezeNet 1.1 has 2.4x less computation and slightly fewer parameters\n than SqueezeNet 1.0, without sacrificing accuracy.\n\n Args:\n pretrained (bool): If True, returns a model pre-trained on ImageNet\n progress (bool): If True, displays a progress bar of the download to stderr\n \"\"\"\n return _squeezenet('1_1', pretrained, progress, **kwargs)\n"
] | [
[
"torch.nn.MaxPool2d",
"torch.nn.init.constant_",
"torch.nn.AdaptiveAvgPool2d",
"torch.flatten",
"torch.nn.init.normal_",
"torch.nn.Conv2d",
"torch.nn.init.kaiming_uniform_",
"torch.nn.ReLU",
"torch.nn.Dropout"
]
] |
ncilfone/mabwiser | [
"329125d4110312d6001e9486e1cb3490a90565c4"
] | [
"tests/test_lints.py"
] | [
"# -*- coding: utf-8 -*-\n\nimport datetime\nimport math\n\nimport numpy as np\nimport pandas as pd\nfrom sklearn.preprocessing import StandardScaler\n\nfrom mabwiser.mab import LearningPolicy\nfrom tests.test_base import BaseTest\n\n\nclass LinTSTest(BaseTest):\n\n def test_alpha0_0001(self):\n arm, mab = self.predict(arms=[1, 2, 3],\n decisions=[1, 1, 1, 2, 2, 2, 3, 3, 3, 1],\n rewards=[0, 0, 0, 0, 0, 0, 1, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=0.0001, scale=True),\n context_history=np.array([[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]]),\n contexts=np.array([[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]]),\n seed=123456,\n num_run=3,\n is_predict=True)\n\n self.assertEqual(len(arm), 3)\n self.assertEqual(arm, [[2, 3], [2, 3], [3, 3]])\n\n def test_alpha0_0001_expectations(self):\n exps, mab = self.predict(arms=[1, 2, 3],\n decisions=[1, 1, 1, 2, 2, 2, 3, 3, 3, 1],\n rewards=[0, 0, 0, 0, 0, 0, 1, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=0.0001, scale=True),\n context_history=np.array([[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]]),\n contexts=np.array([[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]]),\n seed=123456,\n num_run=1,\n is_predict=False)\n\n self.assertListAlmostEqual(exps[0].values(),\n [-0.23459369004297587, 0.0002702455674444537, 4.588547880979047e-05])\n self.assertListAlmostEqual(exps[1].values(),\n [-0.192811601170233, -2.3415795345448245e-05, 0.00016619626256880228])\n\n def test_alpha1(self):\n arm, mab = self.predict(arms=[1, 2, 3],\n decisions=[1, 1, 1, 2, 2, 3, 3, 3, 3, 3],\n rewards=[0, 0, 1, 0, 0, 0, 0, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1),\n context_history=np.array([[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]]),\n contexts=np.array([[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]]),\n seed=123456,\n num_run=1,\n is_predict=True)\n self.assertEqual(len(arm), 2)\n self.assertEqual(arm, [2, 3])\n\n def test_alpha1_expectations(self):\n exps, mab = self.predict(arms=[1, 2, 3],\n decisions=[1, 1, 1, 2, 2, 3, 3, 3, 3, 3],\n rewards=[0, 0, 1, 0, 0, 0, 0, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1),\n context_history=np.array([[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]]),\n contexts=np.array([[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]]),\n seed=123456,\n num_run=1,\n is_predict=False)\n self.assertListAlmostEqual(exps[0].values(), [-0.6029872358950072, 3.105765259323796, 1.0208598325762464])\n self.assertListAlmostEqual(exps[1].values(), [0.572141413757231, 0.45473267178654997, 1.773376616755168])\n\n def test_np(self):\n\n arm, mab = self.predict(arms=[1, 2, 3],\n decisions=np.asarray([1, 1, 1, 2, 2, 3, 3, 3, 3, 3]),\n rewards=np.asarray([0, 0, 1, 0, 0, 0, 0, 1, 1, 1]),\n learning_policy=LearningPolicy.LinTS(alpha=1),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=3,\n is_predict=True)\n\n self.assertEqual(len(arm), 3)\n self.assertEqual(arm, [[2, 3], [2, 1], [3, 1]])\n\n def test_df(self):\n\n df = pd.DataFrame({'decisions': [1, 1, 1, 2, 2, 3, 3, 3, 3, 3],\n 'rewards': [0, 0, 1, 0, 0, 0, 0, 1, 1, 1]})\n\n arm, mab = self.predict(arms=[1, 2, 3],\n decisions=df['decisions'],\n rewards=df['rewards'],\n learning_policy=LearningPolicy.LinTS(alpha=1),\n context_history=pd.DataFrame([[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]]),\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=3,\n is_predict=True)\n\n self.assertEqual(len(arm), 3)\n self.assertEqual(arm, [[2, 3], [2, 1], [3, 1]])\n\n def test_df_list(self):\n\n df = pd.DataFrame({'decisions': [1, 1, 1, 2, 2, 3, 3, 3, 3, 3],\n 'rewards': [0, 0, 1, 0, 0, 0, 0, 1, 1, 1]})\n\n arm, mab = self.predict(arms=[1, 2, 3],\n decisions=df['decisions'],\n rewards=[0, 0, 1, 0, 0, 0, 0, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=3,\n is_predict=True)\n\n self.assertEqual(len(arm), 3)\n self.assertEqual(arm, [[2, 3], [2, 1], [3, 1]])\n\n def test_lints_t1(self):\n\n arm, mab = self.predict(arms=[1, 2, 3],\n decisions=[1, 1, 1, 3, 2, 2, 3, 1, 3, 1],\n rewards=[0, 1, 1, 0, 1, 0, 1, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=0.24),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=4,\n is_predict=True)\n\n self.assertEqual(len(arm), 4)\n self.assertEqual(arm, [[2, 1], [2, 1], [2, 1], [1, 2]])\n\n def test_lints_t2(self):\n\n arm, mab = self.predict(arms=[1, 2, 3],\n decisions=[1, 1, 1, 3, 2, 2, 3, 1, 3, 1],\n rewards=[0, 1, 1, 0, 1, 0, 1, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1.5),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=71,\n num_run=4,\n is_predict=True)\n\n self.assertEqual(len(arm), 4)\n self.assertEqual(arm, [[3, 1], [2, 1], [2, 3], [3, 3]])\n\n def test_lints_t3(self):\n\n arm, mab = self.predict(arms=[1, 2, 4],\n decisions=[1, 1, 4, 4, 2, 2, 1, 1, 4, 2, 1, 4, 1, 2, 4, 1],\n rewards=[7, 9, 10, 20, 2, 5, 8, 15, 17, 11, 0, 5, 2, 9, 3, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1.25),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0], [0, 1, 4, 3, 5], [0, 1, 2, 4, 5],\n [1, 2, 1, 1, 3], [0, 2, 1, 0, 0], [0, 2, 2, 3, 5], [1, 3, 1, 1, 1]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=4,\n is_predict=True)\n\n self.assertEqual(len(arm), 4)\n self.assertEqual(arm, [[4, 4], [4, 4], [1, 4], [1, 4]])\n\n def test_lints_t4(self):\n\n arm, mab = self.predict(arms=[1, 2, 4],\n decisions=[1, 1, 4, 4, 2, 2, 1, 1, 4, 2, 1, 4, 1, 2, 4, 1],\n rewards=[7, 9, 10, 20, 2, 5, 8, 15, 17, 11, 0, 5, 2, 9, 3, 1],\n learning_policy=LearningPolicy.LinTS(alpha=2),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0], [0, 1, 4, 3, 5], [0, 1, 2, 4, 5],\n [1, 2, 1, 1, 3], [0, 2, 1, 0, 0], [0, 2, 2, 3, 5], [1, 3, 1, 1, 1]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=23,\n num_run=4,\n is_predict=True)\n\n self.assertEqual(len(arm), 4)\n self.assertEqual(arm, [[4, 4], [1, 4], [4, 4], [4, 4]])\n\n def test_lints_t5(self):\n\n arm, mab = self.predict(arms=['one', 'two', 'three'],\n decisions=['one', 'one', 'one', 'three', 'two', 'two', 'three', 'one', 'three', 'two'],\n rewards=[1, 0, 1, 0, 1, 0, 1, 1, 1, 0],\n learning_policy=LearningPolicy.LinTS(alpha=1),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=23,\n num_run=4,\n is_predict=True)\n\n self.assertEqual(len(arm), 4)\n self.assertEqual(arm, [['two', 'two'], ['three', 'two'], ['two', 'two'], ['one', 'two']])\n\n def test_lints_t6(self):\n\n arm, mab = self.predict(arms=['one', 'two', 'three'],\n decisions=['one', 'one', 'one', 'three', 'two', 'two', 'three', 'one', 'three', 'two',\n 'one'],\n rewards=[2, 7, 7, 9, 1, 3, 1, 2, 6, 4, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1.25),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0], [0, 1, 4, 3, 5]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=17,\n num_run=4,\n is_predict=True)\n\n self.assertEqual(len(arm), 4)\n self.assertEqual(arm, [['three', 'one'], ['two', 'one'], ['two', 'one'], ['three', 'one']])\n\n def test_lints_t7(self):\n\n arm, mab = self.predict(arms=['a', 'b', 'c'],\n decisions=['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c', 'a', 'a'],\n rewards=[-1.25, 12, 0.7, 10, 12, 9.2, -1, -10, 4, 0, 1],\n learning_policy=LearningPolicy.UCB1(alpha=1.25),\n seed=123456,\n num_run=4,\n is_predict=True)\n\n self.assertEqual(len(arm), 4)\n self.assertEqual(arm, ['b', 'b', 'b', 'b'])\n\n def test_lints_t8(self):\n\n arm, mab = self.predict(arms=['a', 'b', 'c'],\n decisions=['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c', 'a'],\n rewards=[-1.25, 0.7, 12, 10, 12, 9.2, -1, -10, 4, 0],\n learning_policy=LearningPolicy.LinTS(alpha=0.5),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=9,\n num_run=4,\n is_predict=True)\n\n self.assertEqual(len(arm), 4)\n self.assertEqual(arm, [['c', 'c'], ['c', 'c'], ['c', 'c'], ['c', 'c']])\n\n def test_lints_t9(self):\n\n # Dates to test\n a = datetime.datetime(2018, 1, 1)\n b = datetime.datetime(2017, 7, 31)\n c = datetime.datetime(2018, 9, 15)\n\n arm, mab = self.predict(arms=[a, b, c],\n decisions=[a, b, c, a, b, c, a, b, c, a],\n rewards=[1.25, 0.7, 12, 10, 1.43, 0.2, -1, -10, 4, 0],\n learning_policy=LearningPolicy.LinTS(alpha=0.25),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=4,\n is_predict=True)\n\n self.assertEqual(len(arm), 4)\n self.assertEqual(arm, [[c, c], [c, c], [c, c], [c, c]])\n\n def test_lints_t10(self):\n\n # Dates to test\n a = datetime.datetime(2018, 1, 1)\n b = datetime.datetime(2017, 7, 31)\n c = datetime.datetime(2018, 9, 15)\n\n arm, mab = self.predict(arms=[a, b, c],\n decisions=[a, b, c, a, b, c, a, b, c, a, b, b, a],\n rewards=[7, 12, 1, -10, 5, 1, 2, 9, 3, 3, 6, 7, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0], [0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=71,\n num_run=4,\n is_predict=True)\n\n self.assertEqual(len(arm), 4)\n self.assertEqual(arm, [[b, b], [b, b], [b, b], [b, b]])\n\n def test_unused_arm_scale(self):\n\n arms, mab = self.predict(arms=[1, 2, 3, 4],\n decisions=[1, 1, 1, 2, 2, 3, 3, 3, 3, 3],\n rewards=[0, 0, 1, 0, 0, 0, 0, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1, scale=True),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=1,\n is_predict=True)\n\n self.assertEqual(arms, [4, 3])\n\n def test_unused_arm(self):\n\n exps, mab = self.predict(arms=[1, 2, 3, 4],\n decisions=[1, 1, 1, 2, 2, 3, 3, 3, 3, 3],\n rewards=[0, 0, 1, 0, 0, 0, 0, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=1,\n is_predict=False)\n\n self.assertListAlmostEqual(exps[0].values(), [-0.6029872358950072, 3.10576525932379,\n 1.0208598325762497, 4.45334163892619])\n self.assertListAlmostEqual(exps[1].values(), [0.5721414137572303, 0.4547326717865491,\n 1.773376616755162, -1.4333556875425306])\n\n def test_unused_arm2(self):\n\n arms, mab = self.predict(arms=[1, 2, 3, 4],\n decisions=[1, 1, 1, 2, 2, 3, 3, 3, 3, 3],\n rewards=[0, 0, 1, 0, 0, 0, 0, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=1,\n is_predict=True)\n\n self.assertEqual(arms, [4, 3])\n\n def test_unused_arm_scaled(self):\n\n context_history = np.array([[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]], dtype='float64')\n scaler = StandardScaler()\n scaled_contexts = scaler.fit_transform(context_history)\n scaled_predict = scaler.transform(np.array([[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]], dtype='float64'))\n\n exps, mab = self.predict(arms=[1, 2, 3, 4],\n decisions=[1, 1, 1, 2, 2, 3, 3, 3, 3, 3],\n rewards=[0, 0, 1, 0, 0, 0, 0, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1),\n context_history=scaled_contexts,\n contexts=scaled_predict,\n seed=123456,\n num_run=1,\n is_predict=False)\n\n self.assertListAlmostEqual(exps[0].values(), [-0.6846042491588905, 1.8728586982060706,\n 0.39597711947956443, 2.326370889902805])\n self.assertListAlmostEqual(exps[1].values(), [-0.9156881567627143, -1.01000793116177,\n 1.6774048483779203, 0.6624211256038636])\n\n def test_unused_arm_scaled2(self):\n\n context_history = np.array([[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]], dtype='float64')\n scaler = StandardScaler()\n scaled_contexts = scaler.fit_transform(context_history)\n scaled_predict = scaler.transform(np.array([[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]], dtype='float64'))\n\n arms, mab = self.predict(arms=[1, 2, 3, 4],\n decisions=[1, 1, 1, 2, 2, 3, 3, 3, 3, 3],\n rewards=[0, 0, 1, 0, 0, 0, 0, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1),\n context_history=scaled_contexts,\n contexts=scaled_predict,\n seed=7,\n num_run=1,\n is_predict=True)\n\n self.assertEqual(arms, [3, 3])\n\n def test_fit_twice(self):\n\n arm, mab = self.predict(arms=[1, 2, 3, 4],\n decisions=[1, 1, 1, 2, 2, 3, 3, 3, 3, 3],\n rewards=[0, 0, 1, 0, 0, 0, 0, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=1,\n is_predict=True)\n\n self.assertEqual(arm, [4, 3])\n\n b_1 = mab._imp.arm_to_model[1].beta\n self.assertTrue(math.isclose(-0.0825688, b_1[0], abs_tol=0.00001))\n\n b_3 = mab._imp.arm_to_model[3].beta\n self.assertTrue(math.isclose(0.023696, b_3[0], abs_tol=0.00001))\n\n self.assertTrue(4 in mab._imp.arm_to_model.keys())\n\n # Fit again\n decisions2 = [1, 3, 4]\n rewards2 = [0, 1, 1]\n context_history2 = [[0, 1, 1, 1, 1], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0]]\n mab.fit(decisions2, rewards2, context_history2)\n\n b_1 = mab._imp.arm_to_model[1].beta\n self.assertEqual(b_1[0], 0)\n\n b_2 = mab._imp.arm_to_model[2].beta\n self.assertEqual(b_2[0], 0)\n\n b_3 = mab._imp.arm_to_model[3].beta\n self.assertTrue(math.isclose(b_3[0], 0.16667, abs_tol=0.00001))\n\n b_4 = mab._imp.arm_to_model[4].beta\n self.assertEqual(b_4[0], 0)\n\n def test_partial_fit(self):\n\n arm, mab = self.predict(arms=[1, 2, 3, 4],\n decisions=[1, 1, 1, 2, 2, 3, 3, 3, 3, 3],\n rewards=[0, 0, 1, 0, 0, 0, 0, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=1),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=1,\n is_predict=True)\n\n self.assertEqual(arm, [4, 3])\n\n b_1 = mab._imp.arm_to_model[1].beta\n self.assertTrue(math.isclose(-0.0825688, b_1[0], abs_tol=0.00001))\n\n b_3 = mab._imp.arm_to_model[3].beta\n self.assertTrue(math.isclose(0.023696, b_3[0], abs_tol=0.00001))\n\n self.assertTrue(4 in mab._imp.arm_to_model.keys())\n\n # Fit again\n decisions2 = [1, 3, 4]\n rewards2 = [0, 1, 1]\n context_history2 = [[0, 1, 1, 1, 1], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0]]\n mab.partial_fit(decisions2, rewards2, context_history2)\n\n b_1 = mab._imp.arm_to_model[1].beta\n self.assertTrue(math.isclose(-0.05142857, b_1[0], abs_tol=0.00001))\n b_2 = mab._imp.arm_to_model[2].beta\n self.assertEqual(b_2[0], 0)\n\n b_3 = mab._imp.arm_to_model[3].beta\n self.assertTrue(math.isclose(b_3[0], 0.22099152, abs_tol=0.00001))\n\n b_4 = mab._imp.arm_to_model[4].beta\n self.assertEqual(b_4[0], 0)\n\n def test_add_arm(self):\n arm, mab = self.predict(arms=[1, 2, 3],\n decisions=[1, 1, 1, 3, 2, 2, 3, 1, 3, 1],\n rewards=[0, 1, 1, 0, 1, 0, 1, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=0.24),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=4,\n is_predict=True)\n mab.add_arm(4)\n self.assertTrue(4 in mab.arms)\n self.assertTrue(4 in mab._imp.arms)\n self.assertTrue(4 in mab._imp.arm_to_expectation.keys())\n self.assertTrue(mab._imp.arm_to_model[4] is not None)\n\n def test_remove_arm(self):\n arm, mab = self.predict(arms=[1, 2, 3],\n decisions=[1, 1, 1, 3, 2, 2, 3, 1, 3, 1],\n rewards=[0, 1, 1, 0, 1, 0, 1, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=0.24),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=4,\n is_predict=True)\n mab.remove_arm(3)\n self.assertTrue(3 not in mab.arms)\n self.assertTrue(3 not in mab._imp.arms)\n self.assertTrue(3 not in mab._imp.arm_to_expectation)\n self.assertTrue(3 not in mab._imp.arm_to_model)\n\n def test_warm_start(self):\n _, mab = self.predict(arms=[1, 2, 3],\n decisions=[1, 1, 1, 1, 2, 2, 2, 1, 2, 1],\n rewards=[0, 1, 1, 0, 1, 0, 1, 1, 1, 1],\n learning_policy=LearningPolicy.LinTS(alpha=0.24),\n context_history=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1], [0, 0, 1, 0, 0],\n [0, 2, 2, 3, 5], [1, 3, 1, 1, 1], [0, 0, 0, 0, 0],\n [0, 1, 4, 3, 5], [0, 1, 2, 4, 5], [1, 2, 1, 1, 3],\n [0, 2, 1, 0, 0]],\n contexts=[[0, 1, 2, 3, 5], [1, 1, 1, 1, 1]],\n seed=123456,\n num_run=4,\n is_predict=True)\n\n # Before warm start\n self.assertEqual(mab._imp.trained_arms, [1, 2])\n self.assertDictEqual(mab._imp.arm_to_expectation, {1: 0.0, 2: 0.0, 3: 0.0})\n self.assertListAlmostEqual(mab._imp.arm_to_model[1].beta, [0.19635284, 0.11556404, 0.57675997, 0.30597964, -0.39100933])\n self.assertListAlmostEqual(mab._imp.arm_to_model[3].beta, [0, 0, 0, 0, 0])\n\n # Warm start\n mab.warm_start(arm_to_features={1: [0, 1], 2: [0, 0], 3: [0.5, 0.5]}, distance_quantile=0.5)\n self.assertListAlmostEqual(mab._imp.arm_to_model[3].beta, [0.19635284, 0.11556404, 0.57675997, 0.30597964, -0.39100933])\n"
] | [
[
"numpy.array",
"pandas.DataFrame",
"numpy.asarray",
"sklearn.preprocessing.StandardScaler"
]
] |
BrianOfrim/boja | [
"6571fbbfb7f015e96e80e822d9dc96b4636b4119"
] | [
"vision/predict/predict_spin.py"
] | [
"import os\n\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport PySpin\nimport torch\nimport torchvision.transforms.functional as F\n\nfrom .._file_utils import get_highest_numbered_file\nfrom .._image_utils import RGB8Image, draw_bboxes\nfrom .. import _models\nfrom .._s3_utils import s3_bucket_exists, s3_download_highest_numbered_file\nfrom .._settings import (\n DEFAULT_LOCAL_DATA_DIR,\n DEFAULT_S3_DATA_DIR,\n LABEL_FILE_NAME,\n MODEL_STATE_DIR_NAME,\n MODEL_STATE_FILE_TYPE,\n NETWORKS,\n)\n\n\nmatplotlib.use(\"TKAgg\")\n\nINFERENCE_WINDOW_NAME = \"Inference\"\n\n\ndef get_newest_saved_model_path(model_dir_path: str, filter_keyword=None) -> str:\n return get_highest_numbered_file(\n model_dir_path, MODEL_STATE_FILE_TYPE, filter_keyword\n )\n\n\ndef get_newest_image(cam, pixel_format):\n try:\n spinnaker_image = cam.GetNextImage()\n retrieved_image = RGB8Image(\n spinnaker_image.GetWidth(),\n spinnaker_image.GetHeight(),\n pixel_format,\n spinnaker_image.GetData().copy(),\n )\n spinnaker_image.Release()\n return retrieved_image\n except ValueError as err:\n print(err)\n return None\n\n\ndef key_press(event, continue_streaming):\n\n if event.key == \"escape\":\n continue_streaming[0] = False\n\n\ndef display_images(\n cam, labels, network_type, saved_model_file_path, threshold=0.5\n) -> None:\n device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n\n # get the model using our helper function\n model = _models.__dict__[network_type](\n len(labels),\n box_score_thresh=threshold,\n min_size=600,\n max_size=800,\n box_nms_thresh=0.3,\n )\n\n print(\"Loading model state from: %s\" % saved_model_file_path)\n\n checkpoint = torch.load(saved_model_file_path, map_location=device)\n model.load_state_dict(checkpoint[\"model\"])\n\n # move model to the right device\n model.to(device)\n\n model.eval()\n\n # create plots\n fig, inference_ax = plt.subplots()\n\n fig.canvas.set_window_title(\"Predict\")\n\n continue_streaming = [True]\n\n fig.canvas.mpl_connect(\n \"key_press_event\", lambda event: key_press(event, continue_streaming)\n )\n\n print(\"Model state loaded\")\n\n label_colors = plt.get_cmap(\"hsv\")(np.linspace(0, 0.9, len(labels)))\n\n print(\"Starting inference\")\n\n print(\"Starting live stream.\")\n cam.AcquisitionMode.SetValue(PySpin.AcquisitionMode_Continuous)\n cam.BeginAcquisition()\n\n pixel_format = cam.PixelFormat.GetCurrentEntry().GetSymbolic()\n\n while continue_streaming[0]:\n retrieved_image = get_newest_image(cam, pixel_format)\n\n if retrieved_image is None:\n break\n\n image_data = RGB8Image.to_bgr(retrieved_image.get_data())\n\n tensor_image = F.to_tensor(image_data)\n tensor_image = tensor_image.to(device)\n\n outputs = []\n with torch.no_grad():\n outputs = model([tensor_image])\n\n outputs = [\n {k: v.to(torch.device(\"cpu\")) for k, v in t.items()} for t in outputs\n ]\n\n # filter out the background labels and scores bellow threshold\n filtered_output = [\n (outputs[0][\"boxes\"][j], outputs[0][\"labels\"][j], outputs[0][\"scores\"][j],)\n for j in range(len(outputs[0][\"boxes\"]))\n if outputs[0][\"scores\"][j] > threshold and outputs[0][\"labels\"][j] > 0\n ]\n\n inference_boxes, inference_labels, inference_scores = (\n zip(*filtered_output) if len(filtered_output) > 0 else ([], [], [])\n )\n\n inference_ax.clear()\n\n inference_ax.imshow(image_data)\n\n draw_bboxes(\n inference_ax,\n inference_boxes,\n inference_labels,\n labels,\n label_colors,\n inference_scores,\n )\n\n plt.pause(0.001)\n\n print(\"Ending live stream\")\n cam.EndAcquisition()\n\n\ndef apply_camera_settings(cam, framerate=30.0) -> None:\n # Configure newest only buffer handling\n s_node_map = cam.GetTLStreamNodeMap()\n\n # Retrieve Buffer Handling Mode Information\n handling_mode = PySpin.CEnumerationPtr(\n s_node_map.GetNode(\"StreamBufferHandlingMode\")\n )\n handling_mode_entry = handling_mode.GetEntryByName(\"NewestOnly\")\n handling_mode.SetIntValue(handling_mode_entry.GetValue())\n\n # Set stream buffer Count Mode to manual\n stream_buffer_count_mode = PySpin.CEnumerationPtr(\n s_node_map.GetNode(\"StreamBufferCountMode\")\n )\n stream_buffer_count_mode_manual = PySpin.CEnumEntryPtr(\n stream_buffer_count_mode.GetEntryByName(\"Manual\")\n )\n stream_buffer_count_mode.SetIntValue(stream_buffer_count_mode_manual.GetValue())\n\n # Retrieve and modify Stream Buffer Count\n buffer_count = PySpin.CIntegerPtr(s_node_map.GetNode(\"StreamBufferCountManual\"))\n\n buffer_count.SetValue(3)\n\n # Display Buffer Info\n print(\"Buffer Handling Mode: %s\" % handling_mode_entry.GetDisplayName())\n print(\"Buffer Count: %d\" % buffer_count.GetValue())\n print(\"Maximum Buffer Count: %d\" % buffer_count.GetMax())\n\n # Configure frame rate\n cam.AcquisitionFrameRateEnable.SetValue(True)\n cam.AcquisitionFrameRate.SetValue(min(framerate, cam.AcquisitionFrameRate.GetMax()))\n print(\"Acquisition frame rate set to: %3.1f\" % cam.AcquisitionFrameRate.GetValue())\n\n\ndef main(args):\n\n use_s3 = True if args.s3_bucket_name is not None else False\n\n if use_s3:\n if not s3_bucket_exists(args.s3_bucket_name):\n use_s3 = False\n print(\n \"Bucket: %s either does not exist or you do not have access to it\"\n % args.s3_bucket_name\n )\n else:\n print(\"Bucket: %s exists and you have access to it\" % args.s3_bucket_name)\n\n if use_s3:\n # Get the newest model\n s3_download_highest_numbered_file(\n args.s3_bucket_name,\n \"/\".join([args.s3_data_dir, MODEL_STATE_DIR_NAME]),\n os.path.join(args.local_data_dir, MODEL_STATE_DIR_NAME),\n MODEL_STATE_FILE_TYPE,\n args.network,\n )\n\n label_file_path = os.path.join(args.local_data_dir, LABEL_FILE_NAME)\n if not os.path.isfile(label_file_path):\n print(\"Missing file %s\" % label_file_path)\n return\n\n # read in the category labels\n labels = open(label_file_path).read().splitlines()\n\n if len(labels) == 0:\n print(\"No label categories found in %s\" % label_file_path)\n return\n\n # Add the background as the first class\n labels.insert(0, \"background\")\n\n print(\"Labels found:\")\n print(labels)\n\n saved_model_file_path = (\n args.model_path\n if args.model_path is not None\n else get_newest_saved_model_path(\n os.path.join(args.local_data_dir, MODEL_STATE_DIR_NAME), args.network,\n )\n )\n\n if saved_model_file_path is None:\n print(\"No saved model state found\")\n return\n\n # Retrieve singleton reference to system object\n system = PySpin.System.GetInstance()\n\n # Retrieve list of cameras from the system\n cam_list = system.GetCameras()\n\n num_cameras = cam_list.GetSize()\n\n print(\"Number of cameras detected: %d\" % num_cameras)\n # Finish if there are no cameras\n if num_cameras == 0:\n # Clear camera list before releasing system\n cam_list.Clear()\n\n # Release system instance\n system.ReleaseInstance()\n\n print(\"Not enough cameras!\")\n input(\"Done! Press Enter to exit...\")\n return\n\n cam = cam_list.GetByIndex(0)\n\n cam.Init()\n\n apply_camera_settings(cam)\n\n display_images(cam, labels, args.network, saved_model_file_path, args.threshold)\n\n cam.DeInit()\n\n del cam\n cam_list.Clear()\n system.ReleaseInstance()\n print(\"Exiting.\")\n\n\nif __name__ == \"__main__\":\n\n import argparse\n\n parser = argparse.ArgumentParser()\n\n parser.add_argument(\"--s3_bucket_name\", type=str)\n parser.add_argument(\n \"--s3_data_dir\",\n type=str,\n default=DEFAULT_S3_DATA_DIR,\n help=\"Prefix of the s3 data objects\",\n )\n parser.add_argument(\n \"--local_data_dir\", type=str, default=DEFAULT_LOCAL_DATA_DIR,\n )\n parser.add_argument(\"--model_path\", type=str, help=\"The model to load\")\n parser.add_argument(\n \"--network\",\n type=str,\n choices=NETWORKS,\n default=NETWORKS[0],\n help=\"The neural network to use for object detection\",\n )\n parser.add_argument(\n \"--threshold\",\n type=float,\n default=0.5,\n help=\"The threshold above which to display predicted bounding boxes\",\n )\n parser.add_argument(\n \"--frame_rate\", type=float, default=30.0,\n )\n\n args = parser.parse_args()\n\n main(args)\n\n"
] | [
[
"matplotlib.pyplot.pause",
"torch.load",
"torch.no_grad",
"matplotlib.pyplot.subplots",
"torch.cuda.is_available",
"matplotlib.pyplot.get_cmap",
"matplotlib.use",
"torch.device"
]
] |
tolleybot/tensorflow-face-detection | [
"97ddd30107efa87184e1d26d61a747b7a58cf0f8"
] | [
"server.py"
] | [
"from imagezmq import imagezmq\nimport argparse\nimport numpy as np\nimport tensorflow as tf\nimport cv2\nimport time\n\nfrom utils import label_map_util\nfrom utils import visualization_utils_color as vis_util\n\n# Path to frozen detection graph. This is the actual model that is used for the object detection.\nPATH_TO_CKPT = './model/frozen_inference_graph_face.pb'\n\n# List of the strings that is used to add correct label for each box.\nPATH_TO_LABELS = './protos/face_label_map.pbtxt'\n\nNUM_CLASSES = 2\n\nlabel_map = label_map_util.load_labelmap(PATH_TO_LABELS)\ncategories = label_map_util.convert_label_map_to_categories(label_map, max_num_classes=NUM_CLASSES,\n use_display_name=True)\ncategory_index = label_map_util.create_category_index(categories)\n\n\nclass TensoflowFaceDector(object):\n def __init__(self, PATH_TO_CKPT):\n \"\"\"Tensorflow detector\n \"\"\"\n\n self.detection_graph = tf.Graph()\n with self.detection_graph.as_default():\n od_graph_def = tf.GraphDef()\n with tf.gfile.GFile(PATH_TO_CKPT, '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\n with self.detection_graph.as_default():\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n self.sess = tf.Session(graph=self.detection_graph, config=config)\n self.windowNotSet = True\n\n def run(self, image):\n \"\"\"image: bgr image\n return (boxes, scores, classes, num_detections)\n \"\"\"\n\n image_np = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n\n\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 # 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 image_tensor = self.detection_graph.get_tensor_by_name('image_tensor:0')\n # Each box represents a part of the image where a particular object was detected.\n boxes = self.detection_graph.get_tensor_by_name('detection_boxes:0')\n # Each score represent how level of confidence for each of the objects.\n # Score is shown on the result image, together with the class label.\n scores = self.detection_graph.get_tensor_by_name('detection_scores:0')\n classes = self.detection_graph.get_tensor_by_name('detection_classes:0')\n num_detections = self.detection_graph.get_tensor_by_name('num_detections:0')\n # Actual detection.\n start_time = time.time()\n (boxes, scores, classes, num_detections) = self.sess.run(\n [boxes, scores, classes, num_detections],\n feed_dict={image_tensor: image_np_expanded})\n elapsed_time = time.time() - start_time\n print('inference time cost: {}'.format(elapsed_time))\n\n return (boxes, scores, classes, num_detections)\n\ndef predict(model_data_path, port):\n \"\"\" starts are server\"\"\"\n\n tDetector = TensoflowFaceDector(model_data_path)\n\n # setup our server\n image_hub = imagezmq.ImageHub(open_port='tcp://*:' + port)\n\n print(\"Server Started on port {}..\\n\".format(port))\n\n while True:\n _, image = image_hub.recv_image()\n\n (boxes, scores, classes, num_detections) = tDetector.run(image)\n\n vis_util.visualize_boxes_and_labels_on_image_array(\n image,\n np.squeeze(boxes),\n np.squeeze(classes).astype(np.int32),\n np.squeeze(scores),\n category_index,\n use_normalized_coordinates=True,\n line_thickness=4)\n\n image_hub.send_image('OK', image)\n\n\ndef main():\n # Parse arguments\n parser = argparse.ArgumentParser()\n parser.add_argument('--port', help='Directory of images to predict', default='5555', type=str)\n\n args = parser.parse_args()\n\n # if args.test:\n print(\"Starting up server..\\n\")\n # serversample(args.port)\n # else:\n predict(PATH_TO_CKPT, args.port)\n\n\nif __name__ == '__main__':\n main()\n"
] | [
[
"numpy.squeeze",
"tensorflow.gfile.GFile",
"tensorflow.Graph",
"numpy.expand_dims",
"tensorflow.Session",
"tensorflow.import_graph_def",
"tensorflow.ConfigProto",
"tensorflow.GraphDef"
]
] |
chrisburr/hist | [
"d10132ab8d03f41152f0b934a18291ce699453b2"
] | [
"src/hist/basehist.py"
] | [
"# -*- coding: utf-8 -*-\nfrom .axestuple import NamedAxesTuple\nfrom .quick_construct import MetaConstructor\nfrom .utils import set_family, HIST_FAMILY\nfrom .storage import Storage\n\nimport warnings\nimport functools\nimport operator\nimport histoprint\n\nimport numpy as np\nimport boost_histogram as bh\n\nfrom typing import Callable, Optional, Tuple, Union, Dict, Any, TYPE_CHECKING\nfrom .svgplots import html_hist, svg_hist_1d, svg_hist_1d_c, svg_hist_2d, svg_hist_nd\n\n\nif TYPE_CHECKING:\n from mplhep.plot import Hist1DArtists, Hist2DArtists\n import matplotlib.axes\n\n\n@set_family(HIST_FAMILY)\nclass BaseHist(bh.Histogram, metaclass=MetaConstructor):\n __slots__ = ()\n\n def __init__(self, *args, storage: Optional[Storage] = None, metadata=None):\n \"\"\"\n Initialize BaseHist object. Axis params can contain the names.\n \"\"\"\n self._hist: Any = None\n self.axes: NamedAxesTuple\n\n if len(args):\n if isinstance(storage, type):\n msg = (\n f\"Please use '{storage.__name__}()' instead of '{storage.__name__}'\"\n )\n warnings.warn(msg)\n storage = storage()\n super().__init__(*args, storage=storage, metadata=metadata)\n valid_names = [ax.name for ax in self.axes if ax.name]\n if len(valid_names) != len(set(valid_names)):\n raise KeyError(\n f\"{self.__class__.__name__} instance cannot contain axes with duplicated names\"\n )\n for i, ax in enumerate(self.axes):\n # label will return name if label is not set, so this is safe\n if not ax.label:\n ax.label = f\"Axis {i}\"\n\n def _generate_axes_(self) -> NamedAxesTuple:\n \"\"\"\n This is called to fill in the axes. Subclasses can override it if they need\n to change the axes tuple.\n \"\"\"\n\n return NamedAxesTuple(self._axis(i) for i in range(self.ndim))\n\n def _repr_html_(self):\n if self.ndim == 1:\n if self.axes[0].options.circular:\n return str(html_hist(self, svg_hist_1d_c))\n else:\n return str(html_hist(self, svg_hist_1d))\n elif self.ndim == 2:\n return str(html_hist(self, svg_hist_2d))\n elif self.ndim > 2:\n return str(html_hist(self, svg_hist_nd))\n return str(self)\n\n def _name_to_index(self, name: str) -> int:\n \"\"\"\n Transform axis name to axis index, given axis name, return axis \\\n index.\n \"\"\"\n for index, axis in enumerate(self.axes):\n if name == axis.name:\n return index\n\n raise ValueError(\"The axis names could not be found\")\n\n def project(self, *args: Union[int, str]):\n \"\"\"\n Projection of axis idx.\n \"\"\"\n int_args = [self._name_to_index(a) if isinstance(a, str) else a for a in args]\n return super().project(*int_args)\n\n def fill(\n self, *args, weight=None, sample=None, threads: Optional[int] = None, **kwargs\n ):\n \"\"\"\n Insert data into the histogram using names and indices, return\n a Hist object.\n \"\"\"\n\n data_dict = {\n self._name_to_index(k) if isinstance(k, str) else k: v\n for k, v in kwargs.items()\n }\n\n if set(data_dict) != set(range(len(args), self.ndim)):\n raise TypeError(\"All axes must be accounted for in fill\")\n\n data = (data_dict[i] for i in range(len(args), self.ndim))\n\n total_data = tuple(args) + tuple(data) # Python 2 can't unpack twice\n return super().fill(*total_data, weight=weight, sample=sample, threads=threads)\n\n def _loc_shortcut(self, x):\n \"\"\"\n Convert some specific indices to location.\n \"\"\"\n\n if isinstance(x, slice):\n return slice(\n self._loc_shortcut(x.start),\n self._loc_shortcut(x.stop),\n self._step_shortcut(x.step),\n )\n elif isinstance(x, complex):\n if x.real % 1 != 0:\n raise ValueError(\"The real part should be an integer\")\n else:\n return bh.loc(x.imag, int(x.real))\n elif isinstance(x, str):\n return bh.loc(x)\n else:\n return x\n\n def _step_shortcut(self, x):\n \"\"\"\n Convert some specific indices to step.\n \"\"\"\n\n if isinstance(x, complex):\n if x.real != 0:\n raise ValueError(\"The step should not have real part\")\n elif x.imag % 1 != 0:\n raise ValueError(\"The imaginary part should be an integer\")\n else:\n return bh.rebin(int(x.imag))\n else:\n return x\n\n def _index_transform(self, index):\n \"\"\"\n Auxiliary function for __getitem__ and __setitem__.\n \"\"\"\n\n if isinstance(index, dict):\n new_indices = {\n (\n self._name_to_index(k) if isinstance(k, str) else k\n ): self._loc_shortcut(v)\n for k, v in index.items()\n }\n if len(new_indices) != len(index):\n raise ValueError(\n \"Duplicate index keys, numbers and names cannot overlap\"\n )\n return new_indices\n\n elif not hasattr(index, \"__iter__\"):\n index = (index,)\n\n return tuple(self._loc_shortcut(v) for v in index)\n\n def __getitem__(self, index):\n \"\"\"\n Get histogram item.\n \"\"\"\n\n return super().__getitem__(self._index_transform(index))\n\n def __setitem__(self, index, value):\n \"\"\"\n Set histogram item.\n \"\"\"\n\n return super().__setitem__(self._index_transform(index), value)\n\n def density(self) -> np.ndarray:\n \"\"\"\n Density numpy array.\n \"\"\"\n total = self.sum() * functools.reduce(operator.mul, self.axes.widths)\n return self.view() / np.where(total > 0, total, 1)\n\n def show(self, **kwargs):\n \"\"\"\n Pretty print histograms to the console.\n \"\"\"\n\n return histoprint.print_hist(self, **kwargs)\n\n def plot(self, *args, **kwargs) -> \"Union[Hist1DArtists, Hist2DArtists]\":\n \"\"\"\n Plot method for BaseHist object.\n \"\"\"\n if self.ndim == 1:\n return self.plot1d(*args, **kwargs)\n elif self.ndim == 2:\n return self.plot2d(*args, **kwargs)\n else:\n raise NotImplementedError(\"Please project to 1D or 2D before calling plot\")\n\n def plot1d(\n self,\n *,\n ax: \"Optional[matplotlib.axes.Axes]\" = None,\n **kwargs,\n ) -> \"Hist1DArtists\":\n \"\"\"\n Plot1d method for BaseHist object.\n \"\"\"\n\n import hist.plot\n\n return hist.plot.histplot(self, ax=ax, **kwargs)\n\n def plot2d(\n self,\n *,\n ax: \"Optional[matplotlib.axes.Axes]\" = None,\n **kwargs,\n ) -> \"Hist2DArtists\":\n \"\"\"\n Plot2d method for BaseHist object.\n \"\"\"\n\n import hist.plot\n\n return hist.plot.hist2dplot(self, ax=ax, **kwargs)\n\n def plot2d_full(\n self,\n *,\n ax_dict: \"Optional[Dict[str, matplotlib.axes.Axes]]\" = None,\n **kwargs,\n ) -> \"Tuple[Hist2DArtists, Hist1DArtists, Hist1DArtists]\":\n \"\"\"\n Plot2d_full method for BaseHist object.\n\n Pass a dict of axes to ``ax_dict``, otherwise, the current figure will be used.\n \"\"\"\n # Type judgement\n\n import hist.plot\n\n return hist.plot.plot2d_full(self, ax_dict=ax_dict, **kwargs)\n\n def plot_pull(\n self,\n func: Callable,\n *,\n ax_dict: \"Optional[Dict[str, matplotlib.axes.Axes]]\" = None,\n **kwargs,\n ) -> \"Tuple[matplotlib.axes.Axes, matplotlib.axes.Axes]\":\n \"\"\"\n Plot_pull method for BaseHist object.\n \"\"\"\n\n import hist.plot\n\n return hist.plot.plot_pull(self, func, ax_dict=ax_dict, **kwargs)\n"
] | [
[
"numpy.where"
]
] |
GZHermit/video_analyst | [
"6233b19320e3d07b95fb1f782efd89b052a8cf4e"
] | [
"demo/main/video/sot_video.py"
] | [
"# -*- coding: utf-8 -*\n\nfrom paths import ROOT_PATH # isort:skip\nfrom videoanalyst.config.config import cfg\nfrom videoanalyst.config.config import specify_task\nfrom videoanalyst.model import builder as model_builder\nfrom videoanalyst.pipeline import builder as pipeline_builder\nfrom videoanalyst.utils import complete_path_wt_root_in_cfg\nfrom videoanalyst.pipeline.utils.bbox import xywh2xyxy, xyxy2xywh\n\nimport argparse\nfrom loguru import logger\n\nimport cv2\nimport numpy as np\nimport time\nimport torch\n\nfont_size = 0.5\nfont_width = 1\n\n\ndef make_parser():\n parser = argparse.ArgumentParser(\n description=\"press s to select the target box,\\n \\\n then press enter or space to confirm it or press c to cancel it,\\n \\\n press c to stop track and press q to exit program\")\n parser.add_argument(\n \"-cfg\",\n \"--config\",\n default=\"experiments/siamfcpp/test/got10k/siamfcpp_alexnet-got.yaml\",\n type=str,\n help='experiment configuration')\n parser.add_argument(\"-d\",\n \"--device\",\n default=\"cpu\",\n type=str,\n help=\"torch.device, cuda or cpu\")\n parser.add_argument(\"-v\",\n \"--video\",\n type=str,\n default=\"webcam\",\n help=\"path to input video file, default is webcam\")\n parser.add_argument(\"-o\",\n \"--output\",\n type=str,\n default=\"\",\n help=\"path to dump the track video\")\n return parser\n\n\ndef main(args):\n root_cfg = cfg\n root_cfg.merge_from_file(args.config)\n logger.info(\"Load experiment configuration at: %s\" % args.config)\n\n # resolve config\n root_cfg = complete_path_wt_root_in_cfg(root_cfg, ROOT_PATH)\n root_cfg = root_cfg.test\n task, task_cfg = specify_task(root_cfg)\n task_cfg.freeze()\n window_name = task_cfg.exp_name\n # build model\n model = model_builder.build(task, task_cfg.model)\n # build pipeline\n pipeline = pipeline_builder.build(task, task_cfg.pipeline, model)\n dev = torch.device(args.device)\n pipeline.set_device(dev)\n init_box = None\n template = None\n vw = None\n\n if args.video == \"webcam\":\n logger.info(\"[INFO] starting video stream...\")\n vs = cv2.VideoCapture(0)\n vs.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc('M', 'J', 'P', 'G'))\n else:\n vs = cv2.VideoCapture(args.video)\n if args.output:\n fourcc = cv2.VideoWriter_fourcc(*'MJPG')\n width, height = vs.get(3), vs.get(4)\n vw = cv2.VideoWriter(args.output, fourcc, 25, (int(width), int(height)))\n while vs.isOpened():\n ret, frame = vs.read()\n if ret:\n if init_box is not None:\n time_a = time.time()\n rect_pred = pipeline.update(frame)\n show_frame = frame.copy()\n time_cost = time.time() - time_a\n bbox_pred = xywh2xyxy(rect_pred)\n bbox_pred = tuple(map(int, bbox_pred))\n cv2.putText(show_frame,\n \"track cost: {:.4f} s\".format(time_cost), (128, 20),\n cv2.FONT_HERSHEY_COMPLEX, font_size, (0, 0, 255),\n font_width)\n cv2.rectangle(show_frame, bbox_pred[:2], bbox_pred[2:],\n (0, 255, 0))\n if template is not None:\n show_frame[:128, :128] = template\n else:\n show_frame = frame\n cv2.imshow(window_name, show_frame)\n if vw is not None:\n vw.write(show_frame)\n key = cv2.waitKey(30) & 0xFF\n if key == ord(\"q\"):\n break\n # if the 's' key is selected, we are going to \"select\" a bounding\n # box to track\n elif key == ord(\"s\"):\n # select the bounding box of the object we want to track (make\n # sure you press ENTER or SPACE after selecting the ROI)\n box = cv2.selectROI(window_name,\n frame,\n fromCenter=False,\n showCrosshair=True)\n if box[2] > 0 and box[3] > 0:\n init_box = box\n template = cv2.resize(\n frame[box[1]:box[1] + box[3], box[0]:box[0] + box[2]],\n (128, 128))\n pipeline.init(frame, init_box)\n elif key == ord(\"c\"):\n init_box = None\n template = None\n vs.release()\n if vw is not None:\n vw.release()\n cv2.destroyAllWindows()\n\n\nif __name__ == \"__main__\":\n parser = make_parser()\n args = parser.parse_args()\n main(args)\n"
] | [
[
"torch.device"
]
] |
jarekczek/codeforces | [
"6214d75991979c12e6e315a3eff7de21a57fae56"
] | [
"python/plot_colors.py"
] | [
"from datetime import date\nimport dateutil.parser\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\ndf = pd.read_csv('colors_2010_2022_6.txt', delimiter=\"\\t\")\ndf = df[df['reportDate'] >= '2018']\nprint(df.head())\n#df = df.set_index('reportDate')\ndates = sorted(df['reportDate'].unique())\nprint(dates)\n\ndf2 = pd.DataFrame(index=dates)\ndf2['total'] = df[df['color'] == 'total'].set_index('reportDate')['count']\nprint(df2.head())\n\ndf3 = df[df['color'] == 'total']\n#print(df3.head())\ncolors = sorted(df['color'].unique())\nfor color in colors:\n print(color)\n df2[color] = df[df['color'] == color].set_index('reportDate')['count']\n df2[color + '_rel'] = 100.0 * df2[color] / df2['total']\n\ndf2[colors[0] + '_cumul'] = df2[colors[0] + '_rel']\nfor i in range(1, len(colors)):\n print(colors[i])\n df2[colors[i] + '_cumul'] = df2[colors[i] + '_rel'] + df2[colors[i-1] + '_cumul']\n \ndef dateToNumber(strDate):\n d = dateutil.parser.parse(strDate)\n dJan = date(d.year, 1, 1)\n return d.year + (d.toordinal() - dJan.toordinal()) / 365.0\n \ndf2['dateNumber'] = df2.apply(lambda row: dateToNumber(row.name), axis=1)\nprint(df2.head())\n \nplt.clf()\nplt.plot(df2['dateNumber'], df2['total'], linestyle='dotted', color='black', markevery=1)\nplt.plot(df2['dateNumber'], df2['0000_gray'], color='#808080')\nplt.plot(df2['dateNumber'], df2['1200_green'], color='#008000')\nplt.plot(df2['dateNumber'], df2['1400_cyan'], color='#03a89e')\nplt.plot(df2['dateNumber'], df2['1600_blue'], color='#0000c0')\nplt.plot(df2['dateNumber'], df2['1900_violet'], color='#a000a0')\nplt.plot(df2['dateNumber'], df2['2100_orange'], color='#ff8c00')\nplt.plot(df2['dateNumber'], df2['2600_red'], color='#ff0000')\nplt.savefig('total.png')\n\nplt.clf()\nplt.plot(df2['dateNumber'], df2['0000_gray_rel'], color='#808080')\nplt.plot(df2['dateNumber'], df2['1200_green_rel'], color='#008000')\nplt.plot(df2['dateNumber'], df2['1400_cyan_rel'], color='#03a89e')\nplt.plot(df2['dateNumber'], df2['1600_blue_rel'], color='#0000c0')\nplt.plot(df2['dateNumber'], df2['1900_violet_rel'], color='#a000a0')\nplt.plot(df2['dateNumber'], df2['2100_orange_rel'], color='#ff8c00')\nplt.plot(df2['dateNumber'], df2['2600_red_rel'], color='#ff0000')\nplt.savefig('total_rel.png')\n\nplt.clf()\nplt.plot(df2['dateNumber'], df2['0000_gray_cumul'], color='#808080')\nplt.plot(df2['dateNumber'], df2['1200_green_cumul'], color='#008000')\nplt.plot(df2['dateNumber'], df2['1400_cyan_cumul'], color='#03a89e')\nplt.plot(df2['dateNumber'], df2['1600_blue_cumul'], color='#0000c0')\nplt.plot(df2['dateNumber'], df2['1900_violet_cumul'], color='#a000a0')\nplt.plot(df2['dateNumber'], df2['2100_orange_cumul'], color='#ff8c00')\nplt.plot(df2['dateNumber'], df2['2600_red_cumul'], color='#ff0000')\nplt.savefig('total_rel_cumul.png')\n\nprint(\"ok\")\n"
] | [
[
"pandas.read_csv",
"matplotlib.pyplot.savefig",
"pandas.DataFrame",
"matplotlib.pyplot.clf",
"matplotlib.pyplot.plot"
]
] |
nbren12/nn_atmos_param | [
"cb138f0b211fd5743e56ad659aec38c082d2b3ac"
] | [
"lib/torch/loss.py"
] | [
"import torch\nfrom toolz import curry\n\n\n@curry\ndef weighted_loss(weight, x, y):\n # return torch.mean(torch.pow(x - y, 2).mul(weight.float()))\n return torch.mean(torch.abs(x - y).mul(weight.float()))\n\n\n@curry\ndef dynamic_loss(truth, pred, weights=None):\n x = truth['prognostic']\n y = pred['prognostic']\n\n total_loss = 0\n # time series loss\n for key in y:\n w = weights.get(key, 1.0)\n total_loss += weighted_loss(w, x[key], y[key]) / len(y)\n\n return total_loss\n"
] | [
[
"torch.abs"
]
] |
Vrekrer/magdynlab | [
"f5149d3213a37c7c18f39876c3e2367fc7deb9e8"
] | [
"controllers/resistance_controller.py"
] | [
"# coding=utf-8\n\n# Author: Diego González Chávez\n# email : [email protected] / [email protected]\n#\n# Resistance Controller\n#\n# TODO:\n# Make documentation\n\nimport time\nimport numpy\n\n__all__ = ['ResistanceController']\n\n\nclass ResistanceController(object):\n\n# Controllador de SourceMeter para medidas de resistencia\n\n def __init__(self, source_meter):\n self.SM = source_meter\n self.SM.sense_mode = '4-Wire'\n self.Mode('Current')\n \n def Mode(self, mode):\n if mode == 'Voltage':\n self.SM.source_function = 'Voltage'\n self.SM.sense_function = 'Current'\n self.SM.source_value = 1E-3\n elif mode == 'Current':\n self.SM.source_function = 'Current'\n self.SM.sense_function = 'Voltage'\n self.SM.source_value = 50E-6\n \n \n def getResistance(self, n = 5, iniDelay = 0.1, measDelay = 0.01):\n vsIn = numpy.zeros(n)\n out = self.SM.output\n self.SM.output = 'ON'\n\n time.sleep(iniDelay)\n sv = self.SM.source_value\n svs = numpy.linspace(-sv, sv, n)\n \n for i in range(n):\n time.sleep(measDelay)\n self.SM.source_value = svs[i]\n vsIn[i] = self.SM.sense_value\n self.SM.output = out\n X = numpy.polyfit(svs, vsIn, 1)[0]\n if 'VOLT' in self.SM.sense_function:\n return 1/X\n else:\n return X\n"
] | [
[
"numpy.polyfit",
"numpy.linspace",
"numpy.zeros"
]
] |
phc-health/covid-data-model | [
"13c5084d631cf2dd33a7fe558c212dbd32b686e6"
] | [
"tests/libs/datasets/timeseries_test.py"
] | [
"import dataclasses\nimport datetime\nimport io\nimport pathlib\nimport pickle\n\nimport pytest\nimport pandas as pd\nimport numpy as np\nimport structlog\n\nfrom datapublic.common_fields import CommonFields\nfrom datapublic.common_fields import DemographicBucket\nfrom datapublic.common_fields import FieldName\nfrom datapublic.common_fields import PdFields\n\nfrom datapublic.common_test_helpers import to_dict\n\nfrom libs import github_utils\nfrom libs.datasets import AggregationLevel\nfrom libs.datasets import dataset_pointer\nfrom libs.datasets import taglib\n\nfrom libs.datasets import timeseries\nfrom libs.datasets.taglib import TagType\nfrom libs.datasets.taglib import UrlStr\nfrom libs.pipeline import Region\nfrom tests import test_helpers\nfrom tests.dataset_utils_test import read_csv_and_index_fips\nfrom tests.dataset_utils_test import read_csv_and_index_fips_date\nfrom tests.test_helpers import TimeseriesLiteral\n\n\n# turns all warnings into errors for this module\npytestmark = pytest.mark.filterwarnings(\"error\", \"ignore::libs.pipeline.BadFipsWarning\")\n\n\ndef _make_dataset_pointer(tmpdir, filename: str = \"somefile.csv\") -> dataset_pointer.DatasetPointer:\n # The fixture passes in a py.path, which is not the type in DatasetPointer.\n path = pathlib.Path(tmpdir) / filename\n\n fake_git_summary = github_utils.GitSummary(sha=\"abcdef\", branch=\"main\", is_dirty=True)\n\n return dataset_pointer.DatasetPointer(\n dataset_type=dataset_pointer.DatasetType.MULTI_REGION,\n path=path,\n model_git_info=fake_git_summary,\n updated_at=datetime.datetime.utcnow(),\n )\n\n\[email protected](\"include_na_at_end\", [False, True])\ndef test_remove_padded_nans(include_na_at_end):\n rows = [\n {\"date\": \"2020-02-01\", \"cases\": pd.NA},\n {\"date\": \"2020-02-02\", \"cases\": pd.NA},\n {\"date\": \"2020-02-03\", \"cases\": 1},\n {\"date\": \"2020-02-04\", \"cases\": pd.NA},\n {\"date\": \"2020-02-05\", \"cases\": 2},\n {\"date\": \"2020-02-06\", \"cases\": 3},\n ]\n if include_na_at_end:\n rows += [{\"date\": \"2020-02-07\", \"cases\": pd.NA}]\n\n df = pd.DataFrame(rows)\n\n results = timeseries._remove_padded_nans(df, [\"cases\"])\n expected_series = pd.Series([1, pd.NA, 2, 3], name=\"cases\")\n\n pd.testing.assert_series_equal(results.cases, expected_series)\n\n\ndef test_multi_region_to_from_timeseries_and_latest_values(tmp_path: pathlib.Path):\n # TODO(tom): Replace csv with test_helpers builders and uncomment assert in add_fips_static_df\n ts_df = read_csv_and_index_fips_date(\n \"fips,county,aggregate_level,date,m1,m2\\n\"\n \"97111,Bar County,county,2020-04-02,2,\\n\"\n \"97222,Foo County,county,2020-04-01,,10\\n\"\n \"01,,state,2020-04-01,,20\\n\"\n ).reset_index()\n latest_values_df = read_csv_and_index_fips(\n \"fips,county,aggregate_level,c1,c2\\n\"\n \"97111,Bar County,county,3,\\n\"\n \"97222,Foo County,county,4,10.5\\n\"\n \"01,,state,,123.4\\n\"\n ).reset_index()\n multiregion = (\n timeseries.MultiRegionDataset.from_fips_timeseries_df(ts_df)\n .add_fips_static_df(latest_values_df)\n .add_provenance_csv(\n io.StringIO(\"location_id,variable,provenance\\n\" \"iso1:us#fips:97111,m1,ts197111prov\\n\")\n )\n )\n region_97111 = multiregion.get_one_region(Region.from_fips(\"97111\"))\n assert region_97111.date_indexed.at[\"2020-04-02\", \"m1\"] == 2\n assert region_97111.latest[\"c1\"] == 3\n assert multiregion.get_one_region(Region.from_fips(\"01\")).latest[\"c2\"] == 123.4\n\n csv_path = tmp_path / \"multiregion.csv\"\n multiregion.to_csv(csv_path)\n multiregion_loaded = timeseries.MultiRegionDataset.from_csv(csv_path)\n region_97111 = multiregion_loaded.get_one_region(Region.from_fips(\"97111\"))\n assert region_97111.date_indexed.at[\"2020-04-02\", \"m1\"] == 2\n assert region_97111.latest[\"c1\"] == 3\n assert region_97111.region.fips == \"97111\"\n assert multiregion_loaded.get_one_region(Region.from_fips(\"01\")).latest[\"c2\"] == 123.4\n test_helpers.assert_dataset_like(\n multiregion, multiregion_loaded, drop_na_latest=True, drop_na_timeseries=True\n )\n\n\ndef test_multi_region_get_one_region():\n ts = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,county,aggregate_level,date,m1,m2\\n\"\n \"iso1:us#fips:97111,Bar County,county,2020-04-02,2,\\n\"\n \"iso1:us#fips:97222,Foo County,county,2020-04-01,,10\\n\"\n \"iso1:us#fips:97111,Bar County,county,,3,\\n\"\n \"iso1:us#fips:97222,Foo County,county,,,11\\n\"\n )\n )\n region_97111_ts = ts.get_one_region(Region.from_fips(\"97111\"))\n assert to_dict([\"date\"], region_97111_ts.data[[\"date\", \"m1\", \"m2\"]]) == {\n pd.to_datetime(\"2020-04-02\"): {\"m1\": 2}\n }\n assert region_97111_ts.latest[\"m1\"] == 3\n assert region_97111_ts.region.fips == \"97111\"\n\n region_97222_ts = ts.get_one_region(Region.from_fips(\"97222\"))\n assert to_dict([\"date\"], region_97222_ts.data) == {\n pd.to_datetime(\"2020-04-01\"): {\"m2\": 10, \"location_id\": \"iso1:us#fips:97222\",}\n }\n assert region_97222_ts.latest[\"m2\"] == 11\n\n\ndef test_multi_region_get_counties_and_places():\n ds_in = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,county,aggregate_level,date,m1,m2\\n\"\n \"iso1:us#fips:97111,Bar County,county,2020-04-02,2,\\n\"\n \"iso1:us#fips:97111,Bar County,county,2020-04-03,3,\\n\"\n \"iso1:us#fips:97222,Foo County,county,2020-04-01,,10\\n\"\n \"iso1:us#fips:9711122,,place,2020-04-02,5,60\\n\"\n \"iso1:us#fips:97,Great State,state,2020-04-01,1,2\\n\"\n \"iso1:us#fips:97111,Bar County,county,,3,\\n\"\n \"iso1:us#fips:9711122,,place,,3,\\n\"\n \"iso1:us#fips:97222,Foo County,county,,,10\\n\"\n \"iso1:us#fips:97,Great State,state,,1,2\\n\"\n )\n )\n ds_out = ds_in.get_counties_and_places(\n after=pd.to_datetime(\"2020-04-01\")\n ).timeseries.reset_index()\n assert to_dict([\"location_id\", \"date\"], ds_out[[\"location_id\", \"date\", \"m1\"]]) == {\n (\"iso1:us#fips:97111\", pd.to_datetime(\"2020-04-02\")): {\"m1\": 2},\n (\"iso1:us#fips:97111\", pd.to_datetime(\"2020-04-03\")): {\"m1\": 3},\n (\"iso1:us#fips:9711122\", pd.to_datetime(\"2020-04-02\")): {\"m1\": 5},\n }\n\n\ndef test_multi_region_groupby():\n ts = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,county,aggregate_level,date,m1,m2\\n\"\n \"iso1:us#fips:97222,Foo County,county,2020-04-01,,10\\n\"\n \"iso1:us#fips:97222,Foo County,county,2020-04-02,,20\\n\"\n \"iso1:us#fips:97,Great State,state,2020-04-01,1,2\\n\"\n \"iso1:us#fips:97222,Foo County,county,,,20\\n\"\n \"iso1:us#fips:97,Great State,state,,1,2\\n\"\n )\n )\n\n assert ts.groupby_region()[\"m2\"].last().to_dict() == {\n \"iso1:us#fips:97\": 2,\n \"iso1:us#fips:97222\": 20,\n }\n\n\ndef test_one_region_dataset():\n bar_county_row = {\n \"location_id\": \"iso1:us#fips:97111\",\n \"county\": \"Bar County\",\n \"aggregate_level\": \"county\",\n \"date\": \"2020-04-02\",\n \"m1\": 2,\n \"m2\": pd.NA,\n }\n ts = timeseries.OneRegionTimeseriesDataset(\n Region.from_fips(\"97111\"), pd.DataFrame([bar_county_row]), {}, pd.DataFrame([])\n )\n assert ts.has_one_region() == True\n\n foo_county_row = {\n \"location_id\": \"iso1:us#fips:97222\",\n \"county\": \"Foo County\",\n \"aggregate_level\": \"county\",\n \"date\": \"2020-04-01\",\n \"m1\": pd.NA,\n \"m2\": 10,\n }\n with pytest.raises(ValueError):\n timeseries.OneRegionTimeseriesDataset(\n Region.from_fips(\"97222\"),\n pd.DataFrame([bar_county_row, foo_county_row]),\n {},\n pd.DataFrame([]),\n )\n\n with structlog.testing.capture_logs() as logs:\n ts = timeseries.OneRegionTimeseriesDataset(\n Region.from_fips(\"97111\"),\n pd.DataFrame([], columns=\"location_id county aggregate_level date m1 m2\".split()),\n {},\n pd.DataFrame([]),\n )\n assert [l[\"event\"] for l in logs] == [\"Creating OneRegionTimeseriesDataset with zero regions\"]\n assert ts.empty\n\n\ndef test_multiregion_provenance():\n m1 = FieldName(\"m1\")\n m2 = FieldName(\"m2\")\n\n region_97111 = Region.from_fips(\"97111\")\n region_97222 = Region.from_fips(\"97222\")\n region_03 = Region.from_fips(\"03\")\n ds = test_helpers.build_dataset(\n {\n region_97111: {m1: TimeseriesLiteral([1, 2, None], provenance=\"src11\")},\n region_97222: {\n m1: TimeseriesLiteral([None, None, 3], provenance=\"src21\"),\n m2: TimeseriesLiteral([10, None, 30], provenance=\"src22\"),\n },\n region_03: {\n m1: TimeseriesLiteral([None, None, 4], provenance=\"src31\"),\n m2: TimeseriesLiteral([None, None, 40], provenance=\"src32\"),\n },\n },\n )\n\n # Use loc[...].at[...] as work-around for https://github.com/pandas-dev/pandas/issues/26989\n assert ds.provenance.loc[region_97111.location_id].at[\"m1\"] == \"src11\"\n assert ds.get_one_region(region_97111).provenance[\"m1\"] == [\"src11\"]\n assert ds.provenance.loc[region_97222.location_id].at[\"m2\"] == \"src22\"\n assert ds.get_one_region(region_97222).provenance[\"m2\"] == [\"src22\"]\n assert ds.provenance.loc[region_03.location_id].at[\"m2\"] == \"src32\"\n assert ds.get_one_region(region_03).provenance[\"m2\"] == [\"src32\"]\n\n counties = ds.get_counties_and_places(after=pd.to_datetime(\"2020-04-01\"))\n assert region_03.location_id not in counties.provenance.index\n assert counties.provenance.loc[region_97222.location_id].at[\"m1\"] == \"src21\"\n assert counties.get_one_region(region_97222).provenance[\"m1\"] == [\"src21\"]\n\n\ndef test_one_region_multiple_provenance():\n tag1 = test_helpers.make_tag(date=\"2020-04-01\")\n tag2 = test_helpers.make_tag(date=\"2020-04-02\")\n one_region = test_helpers.build_one_region_dataset(\n {\n CommonFields.ICU_BEDS: TimeseriesLiteral(\n [0, 2, 4], annotation=[tag1, tag2], provenance=[\"prov1\", \"prov2\"],\n ),\n CommonFields.CASES: [100, 200, 300],\n }\n )\n\n assert set(one_region.annotations_all_bucket(CommonFields.ICU_BEDS)) == {tag1, tag2}\n assert sorted(one_region.provenance[CommonFields.ICU_BEDS]) == [\"prov1\", \"prov2\"]\n\n\ndef test_add_aggregate_level():\n ts_df = read_csv_and_index_fips_date(\"fips,date,m1,m2\\n\" \"36061,2020-04-02,2,\\n\").reset_index()\n multiregion = timeseries.MultiRegionDataset.from_fips_timeseries_df(ts_df)\n assert multiregion.geo_data.aggregate_level.to_list() == [\"county\"]\n\n\ndef test_fips_not_in_geo_data_csv_raises():\n df = test_helpers.read_csv_str(\n \" location_id, date, cases\\n\"\n \"iso1:us#fips:06010, 2020-04-01, 100\\n\",\n skip_spaces=True,\n )\n\n with pytest.raises(AssertionError):\n timeseries.MultiRegionDataset.from_timeseries_df(df)\n\n\ndef test_append_regions():\n ts_fips = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1,m2\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2,\\n\"\n \"iso1:us#fips:97111,2020-04-03,Bar County,county,3,\\n\"\n \"iso1:us#fips:97222,2020-04-04,Foo County,county,,11\\n\"\n \"iso1:us#fips:97111,,Bar County,county,3,\\n\"\n \"iso1:us#fips:97222,,Foo County,county,,11\\n\"\n )\n ).add_provenance_csv(\n io.StringIO(\"location_id,variable,provenance\\n\" \"iso1:us#fips:97111,m1,prov97111m1\\n\")\n )\n ts_cbsa = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,m2\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,2\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,3\\n\"\n \"iso1:us#cbsa:20300,2020-04-03,4\\n\"\n \"iso1:us#cbsa:10100,,3\\n\"\n \"iso1:us#cbsa:20300,,4\\n\"\n )\n ).add_provenance_csv(\n io.StringIO(\"location_id,variable,provenance\\n\" \"iso1:us#cbsa:20300,m1,prov20200m2\\n\")\n )\n # Check that merge is symmetric\n ts_merged_1 = ts_fips.append_regions(ts_cbsa)\n ts_merged_2 = ts_cbsa.append_regions(ts_fips)\n test_helpers.assert_dataset_like(ts_merged_1, ts_merged_2)\n\n ts_expected = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1,m2\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,,2\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,,3\\n\"\n \"iso1:us#cbsa:20300,2020-04-03,,,,4\\n\"\n \"iso1:us#cbsa:10100,,,,,3\\n\"\n \"iso1:us#cbsa:20300,,,,,4\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2,\\n\"\n \"iso1:us#fips:97111,2020-04-03,Bar County,county,3,\\n\"\n \"iso1:us#fips:97222,2020-04-04,Foo County,county,,11\\n\"\n \"iso1:us#fips:97111,,Bar County,county,3,\\n\"\n \"iso1:us#fips:97222,,Foo County,county,,11\\n\"\n )\n ).add_provenance_csv(\n io.StringIO(\n \"location_id,variable,provenance\\n\"\n \"iso1:us#fips:97111,m1,prov97111m1\\n\"\n \"iso1:us#cbsa:20300,m1,prov20200m2\\n\"\n )\n )\n test_helpers.assert_dataset_like(ts_merged_1, ts_expected)\n\n\ndef test_append_regions_with_buckets():\n region_cbsa = Region.from_cbsa_code(\"10100\")\n region_la = Region.from_fips(\"06037\")\n region_sf = Region.from_fips(\"06075\")\n m1 = FieldName(\"m1\")\n m2 = FieldName(\"m2\")\n age_40s = DemographicBucket(\"age:40-49\")\n data_county = {\n region_la: {\n m1: {\n age_40s: TimeseriesLiteral([1, 2], annotation=[test_helpers.make_tag()]),\n DemographicBucket.ALL: [2, 3],\n }\n },\n region_sf: {m1: [3, 4]},\n }\n data_cbsa = {region_cbsa: {m2: [5, 6]}}\n ds_county = test_helpers.build_dataset(data_county)\n ds_cbsa = test_helpers.build_dataset(data_cbsa)\n\n ds_out_1 = ds_county.append_regions(ds_cbsa)\n ds_out_2 = ds_cbsa.append_regions(ds_county)\n\n ds_expected = test_helpers.build_dataset({**data_cbsa, **data_county})\n\n test_helpers.assert_dataset_like(ds_out_1, ds_expected)\n test_helpers.assert_dataset_like(ds_out_2, ds_expected)\n\n\ndef test_append_regions_duplicate_region_raises():\n ts1 = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1,m2\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2,\\n\"\n )\n )\n ts2 = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1,m2\\n\"\n \"iso1:us#fips:97111,2020-04-03,Bar County,county,2,\\n\"\n )\n )\n with pytest.raises(ValueError):\n ts1.append_regions(ts2)\n\n\ndef test_timeseries_long():\n \"\"\"Test timeseries_long where all data has bucket `all`\"\"\"\n region_cbsa = Region.from_cbsa_code(\"10100\")\n region_county = Region.from_fips(\"97111\")\n ds = test_helpers.build_dataset(\n {\n region_county: {FieldName(\"m1\"): [2, None, 4]},\n region_cbsa: {FieldName(\"m2\"): [2, 3, None]},\n },\n start_date=\"2020-04-02\",\n )\n\n expected = test_helpers.read_csv_str(\n \" location_id, date,variable,value\\n\"\n \"iso1:us#cbsa:10100,2020-04-02, m2, 2\\n\"\n \"iso1:us#cbsa:10100,2020-04-03, m2, 3\\n\"\n \"iso1:us#fips:97111,2020-04-02, m1, 2\\n\"\n \"iso1:us#fips:97111,2020-04-04, m1, 4\\n\",\n skip_spaces=True,\n dtype={\"value\": float},\n )\n long_series = ds.timeseries_bucketed_long\n assert long_series.index.names == [\n CommonFields.LOCATION_ID,\n PdFields.DEMOGRAPHIC_BUCKET,\n CommonFields.DATE,\n PdFields.VARIABLE,\n ]\n assert long_series.name == PdFields.VALUE\n long_df = long_series.xs(\"all\", level=PdFields.DEMOGRAPHIC_BUCKET).reset_index()\n pd.testing.assert_frame_equal(long_df, expected, check_like=True)\n\n\ndef test_timeseries_bucketed_long():\n region_cbsa = Region.from_cbsa_code(\"10100\")\n region_county = Region.from_fips(\"97111\")\n bucket_age_0 = DemographicBucket(\"age:0-9\")\n bucket_age_10 = DemographicBucket(\"age:10-19\")\n bucket_all = DemographicBucket(\"all\")\n ds = test_helpers.build_dataset(\n {\n region_county: {\n FieldName(\"m1\"): {\n bucket_age_0: [4, 5, 6],\n bucket_age_10: [None, None, 7],\n bucket_all: [2, None, 4],\n }\n },\n region_cbsa: {FieldName(\"m2\"): [2, 3, None]},\n },\n start_date=\"2020-04-02\",\n )\n\n expected = test_helpers.read_csv_str(\n \" location_id,demographic_bucket, date,variable,value\\n\"\n \"iso1:us#cbsa:10100, all,2020-04-02, m2, 2\\n\"\n \"iso1:us#cbsa:10100, all,2020-04-03, m2, 3\\n\"\n \"iso1:us#fips:97111, age:0-9,2020-04-02, m1, 4\\n\"\n \"iso1:us#fips:97111, age:0-9,2020-04-03, m1, 5\\n\"\n \"iso1:us#fips:97111, age:0-9,2020-04-04, m1, 6\\n\"\n \"iso1:us#fips:97111, age:10-19,2020-04-04, m1, 7\\n\"\n \"iso1:us#fips:97111, all,2020-04-02, m1, 2\\n\"\n \"iso1:us#fips:97111, all,2020-04-04, m1, 4\\n\",\n skip_spaces=True,\n dtype={\"value\": float},\n )\n long_series = ds.timeseries_bucketed_long\n assert long_series.index.names == [\n CommonFields.LOCATION_ID,\n PdFields.DEMOGRAPHIC_BUCKET,\n CommonFields.DATE,\n PdFields.VARIABLE,\n ]\n assert long_series.name == PdFields.VALUE\n pd.testing.assert_frame_equal(long_series.reset_index(), expected, check_like=True)\n\n\ndef test_timeseries_distribution_long():\n bucket_age_0 = DemographicBucket(\"age:0-9\")\n bucket_age_10 = DemographicBucket(\"age:10-19\")\n bucket_all = DemographicBucket(\"all\")\n bucket_blueman = DemographicBucket(\"color;gender:blue;man\")\n ds = test_helpers.build_default_region_dataset(\n {\n FieldName(\"m1\"): {\n bucket_age_0: [1, 2, 3],\n bucket_age_10: [None, None, 4],\n bucket_all: [5, None, 6],\n bucket_blueman: [7, None, None],\n }\n }\n )\n\n long_series = ds.timeseries_distribution_long\n assert long_series.name == PdFields.VALUE\n assert long_series.index.names == [\n CommonFields.LOCATION_ID,\n PdFields.DEMOGRAPHIC_BUCKET,\n CommonFields.DATE,\n PdFields.DISTRIBUTION,\n PdFields.VARIABLE,\n ]\n expected = test_helpers.read_csv_str(\n \" location_id, demographic_bucket, date,distribution,variable,value\\n\"\n \"iso1:us#fips:97222, age:0-9,2020-04-01, age, m1, 1\\n\"\n \"iso1:us#fips:97222, age:0-9,2020-04-02, age, m1, 2\\n\"\n \"iso1:us#fips:97222, age:0-9,2020-04-03, age, m1, 3\\n\"\n \"iso1:us#fips:97222, age:10-19,2020-04-03, age, m1, 4\\n\"\n \"iso1:us#fips:97222, all,2020-04-01, all, m1, 5\\n\"\n \"iso1:us#fips:97222, all,2020-04-03, all, m1, 6\\n\"\n \"iso1:us#fips:97222,color;gender:blue;man,2020-04-01,color;gender, m1, 7\\n\",\n skip_spaces=True,\n dtype={\"value\": float},\n )\n pd.testing.assert_frame_equal(long_series.reset_index(), expected, check_like=True)\n\n\ndef test_timeseries_wide_dates():\n region_cbsa = Region.from_cbsa_code(\"10100\")\n region_fips = Region.from_fips(\"97111\")\n m1 = FieldName(\"m1\")\n m2 = FieldName(\"m2\")\n ds = test_helpers.build_dataset(\n {region_cbsa: {m2: [2, 3]}, region_fips: {m1: [2, None, 4]}},\n static_by_region_then_field_name={region_fips: {CommonFields.COUNTY: \"Bar County\", m1: 4}},\n start_date=\"2020-04-02\",\n )\n\n # TODO(tom): Delete this test of _timeseries_not_bucketed_wide_dates which is no longer\n # accessed from outside timeseries when there are other tests for from_timeseries_wide_dates_df\n ds_wide = ds._timeseries_not_bucketed_wide_dates\n assert ds_wide.index.names == [CommonFields.LOCATION_ID, PdFields.VARIABLE]\n assert ds_wide.columns.names == [CommonFields.DATE]\n\n expected = (\n pd.read_csv(\n io.StringIO(\n \"location_id,variable,2020-04-02,2020-04-03,2020-04-04\\n\"\n \"iso1:us#cbsa:10100,m2,2,3,\\n\"\n \"iso1:us#fips:97111,m1,2,,4\\n\"\n ),\n )\n .set_index(ds_wide.index.names)\n .rename_axis(columns=\"date\")\n .astype(float)\n )\n expected.columns = pd.to_datetime(expected.columns)\n\n pd.testing.assert_frame_equal(ds_wide, expected)\n\n # Recreate the dataset using `from_timeseries_wide_dates_df`.\n ds_recreated = timeseries.MultiRegionDataset.from_timeseries_wide_dates_df(\n ds_wide\n ).add_static_values(ds.static.reset_index())\n test_helpers.assert_dataset_like(ds, ds_recreated)\n\n assert ds.get_timeseries_not_bucketed_wide_dates(m1).loc[region_fips.location_id, :].replace(\n {np.nan: None}\n ).to_list() == [2, None, 4]\n assert ds.get_timeseries_bucketed_wide_dates(m1).loc[\n (region_fips.location_id, DemographicBucket.ALL), :\n ].replace({np.nan: None}).to_list() == [2, None, 4]\n\n\ndef test_timeseries_wide_dates_empty():\n m1 = FieldName(\"m1\")\n ds = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1,m2\\n\"\n \"iso1:us#cbsa:10100,,,,,3\\n\"\n \"iso1:us#fips:97111,,Bar County,county,4,\\n\"\n )\n )\n\n assert ds.get_timeseries_not_bucketed_wide_dates(m1).empty\n assert ds.get_timeseries_bucketed_wide_dates(m1).empty\n assert ds.get_timeseries_not_bucketed_wide_dates(CommonFields.CASES).empty\n assert ds.get_timeseries_bucketed_wide_dates(CommonFields.CASES).empty\n\n\ndef test_write_read_wide_dates_csv_compare_literal(tmpdir):\n pointer = _make_dataset_pointer(tmpdir)\n\n region_as = Region.from_state(\"AS\")\n region_sf = Region.from_fips(\"06075\")\n metrics_as = {\n CommonFields.ICU_BEDS: TimeseriesLiteral([0, 2, 4], provenance=\"pt_src1\"),\n CommonFields.CASES: [100, 200, 300],\n }\n metrics_sf = {\n CommonFields.DEATHS: TimeseriesLiteral([1, 2, None], provenance=\"pt_src2\"),\n CommonFields.CASES: [None, 210, 310],\n }\n dataset_in = test_helpers.build_dataset({region_as: metrics_as, region_sf: metrics_sf})\n\n dataset_in.write_to_dataset_pointer(pointer)\n\n # Compare written file with a string literal so a test fails if something changes in how the\n # file is written. The literal contains spaces to align the columns in the source.\n assert pointer.path_wide_dates().read_text() == (\n \" location_id,variable,demographic_bucket,provenance,2020-04-03,2020-04-02,2020-04-01\\n\"\n \"iso1:us#iso2:us-as, cases, all, , 300, 200, 100\\n\"\n \"iso1:us#iso2:us-as,icu_beds, all, pt_src1, 4, 2, 0\\n\"\n \"iso1:us#iso2:us-ca#fips:06075,cases, all, , 310, 210,\\n\"\n \"iso1:us#iso2:us-ca#fips:06075,deaths, all, pt_src2, , 2, 1\\n\"\n ).replace(\" \", \"\")\n\n dataset_read = timeseries.MultiRegionDataset.read_from_pointer(pointer)\n test_helpers.assert_dataset_like(dataset_read, dataset_in)\n\n # Check that a file without the demographic_bucket column (as written before\n # https://github.com/covid-projections/covid-data-model/pull/1021) can be read.\n pointer.path_wide_dates().write_text(\n \" location_id,variable,provenance,2020-04-03,2020-04-02,2020-04-01\\n\"\n \" iso1:us#iso2:us-as, cases, , 300, 200, 100\\n\"\n \" iso1:us#iso2:us-as,icu_beds, pt_src1, 4, 2, 0\\n\"\n \"iso1:us#iso2:us-ca#fips:06075, cases, , 310, 210,\\n\"\n \"iso1:us#iso2:us-ca#fips:06075, deaths, pt_src2, , 2, 1\\n\".replace(\n \" \", \"\"\n )\n )\n dataset_without_bucket_read = timeseries.MultiRegionDataset.read_from_pointer(pointer)\n test_helpers.assert_dataset_like(dataset_without_bucket_read, dataset_in)\n\n\ndef test_write_read_wide_dates_csv_with_annotation(tmpdir):\n pointer = _make_dataset_pointer(tmpdir)\n\n region = Region.from_state(\"AS\")\n metrics = {\n CommonFields.ICU_BEDS: TimeseriesLiteral(\n [0, 2, 4],\n annotation=[\n test_helpers.make_tag(date=\"2020-04-01\"),\n test_helpers.make_tag(TagType.ZSCORE_OUTLIER, date=\"2020-04-02\"),\n ],\n ),\n CommonFields.CASES: [100, 200, 300],\n }\n dataset_in = test_helpers.build_dataset({region: metrics})\n\n dataset_in.write_to_dataset_pointer(pointer)\n dataset_read = timeseries.MultiRegionDataset.read_from_pointer(pointer)\n\n test_helpers.assert_dataset_like(dataset_read, dataset_in)\n\n\ndef test_write_read_dataset_pointer_with_provenance_list(tmpdir):\n pointer = _make_dataset_pointer(tmpdir)\n\n dataset_in = test_helpers.build_default_region_dataset(\n {\n CommonFields.ICU_BEDS: TimeseriesLiteral(\n [0, 2, 4],\n annotation=[\n test_helpers.make_tag(date=\"2020-04-01\"),\n test_helpers.make_tag(date=\"2020-04-02\"),\n ],\n provenance=[\"prov1\", \"prov2\"],\n ),\n CommonFields.CASES: [100, 200, 300],\n }\n )\n\n dataset_in.write_to_dataset_pointer(pointer)\n dataset_read = timeseries.MultiRegionDataset.read_from_pointer(pointer)\n\n test_helpers.assert_dataset_like(dataset_read, dataset_in)\n\n\ndef test_write_read_wide_with_buckets(tmpdir):\n pointer = _make_dataset_pointer(tmpdir)\n\n all_bucket = DemographicBucket(\"all\")\n age_20s = DemographicBucket(\"age:20-29\")\n age_30s = DemographicBucket(\"age:30-39\")\n region_as = Region.from_state(\"AS\")\n region_sf = Region.from_fips(\"06075\")\n metrics_as = {\n CommonFields.ICU_BEDS: TimeseriesLiteral(\n [0, 2, 4],\n annotation=[\n test_helpers.make_tag(date=\"2020-04-01\"),\n test_helpers.make_tag(TagType.ZSCORE_OUTLIER, date=\"2020-04-02\"),\n ],\n ),\n CommonFields.CASES: [100, 200, 300],\n }\n metrics_sf = {\n CommonFields.CASES: {\n age_20s: TimeseriesLiteral([3, 4, 5], source=taglib.Source(type=\"MySource\")),\n age_30s: [4, 5, 6],\n all_bucket: [1, 2, 3],\n }\n }\n dataset_in = test_helpers.build_dataset({region_as: metrics_as, region_sf: metrics_sf})\n\n dataset_in.write_to_dataset_pointer(pointer)\n dataset_read = timeseries.MultiRegionDataset.read_from_pointer(pointer)\n\n test_helpers.assert_dataset_like(dataset_read, dataset_in)\n\n\ndef test_timeseries_drop_stale_timeseries_entire_region():\n ds_in = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1,m2\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,,2\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,,3\\n\"\n \"iso1:us#cbsa:10100,,,,,3\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2,\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,4,\\n\"\n \"iso1:us#fips:97111,,Bar County,county,4,\\n\"\n )\n )\n\n ds_out = ds_in.drop_stale_timeseries(pd.to_datetime(\"2020-04-04\"))\n\n ds_expected = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1,m2\\n\"\n \"iso1:us#cbsa:10100,,,,,3\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2,\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,4,\\n\"\n \"iso1:us#fips:97111,,Bar County,county,4,\\n\"\n )\n )\n test_helpers.assert_dataset_like(ds_out, ds_expected)\n\n\ndef test_timeseries_drop_stale_timeseries_one_metric():\n csv_in = (\n \"location_id,date,county,aggregate_level,m1,m2\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,11,2\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,,3\\n\"\n \"iso1:us#cbsa:10100,,,,,3\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2,\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,4,\\n\"\n \"iso1:us#fips:97111,,Bar County,county,4,\\n\"\n )\n ds_in = timeseries.MultiRegionDataset.from_csv(io.StringIO(csv_in)).add_provenance_csv(\n io.StringIO(\n \"location_id,variable,provenance\\n\"\n \"iso1:us#cbsa:10100,m1,m1-10100prov\\n\"\n \"iso1:us#cbsa:10100,m2,m2-10100prov\\n\"\n \"iso1:us#fips:97111,m1,m1-97111prov\\n\"\n )\n )\n\n ds_out = ds_in.drop_stale_timeseries(pd.to_datetime(\"2020-04-03\"))\n\n # The only timeseries that is stale with cutoff of 4/3 is the CBSA m1. The expected\n # dataset is the same as the input with \"11\" removed from the timeseries and\n # corresponding provenance removed.\n ds_expected = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(csv_in.replace(\",11,\", \",,\"))\n ).add_provenance_csv(\n io.StringIO(\n \"location_id,variable,provenance\\n\"\n \"iso1:us#cbsa:10100,m2,m2-10100prov\\n\"\n \"iso1:us#fips:97111,m1,m1-97111prov\\n\"\n )\n )\n test_helpers.assert_dataset_like(ds_out, ds_expected)\n\n\ndef test_timeseries_drop_stale_timeseries_with_tag():\n region = Region.from_state(\"TX\")\n values_recent = [100, 200, 300, 400]\n values_stale = [100, 200, None, None]\n ts_recent = TimeseriesLiteral(values_recent, annotation=[test_helpers.make_tag()])\n ts_stale = TimeseriesLiteral(values_stale, annotation=[test_helpers.make_tag()])\n\n dataset_in = test_helpers.build_dataset(\n {region: {CommonFields.CASES: ts_recent, CommonFields.DEATHS: ts_stale}}\n )\n\n dataset_out = dataset_in.drop_stale_timeseries(pd.to_datetime(\"2020-04-03\"))\n\n assert len(dataset_out.tag) == 1\n # drop_stale_timeseries preserves the empty DEATHS column so add it to dataset_expected\n dataset_expected = test_helpers.build_dataset(\n {region: {CommonFields.CASES: ts_recent}}, timeseries_columns=[CommonFields.DEATHS]\n )\n test_helpers.assert_dataset_like(dataset_out, dataset_expected)\n\n\ndef test_append_region_and_get_regions_subset_with_tag():\n region_tx = Region.from_state(\"TX\")\n region_sf = Region.from_fips(\"06075\")\n values = [100, 200, 300, 400]\n ts_with_tag = TimeseriesLiteral(values, annotation=[test_helpers.make_tag()])\n\n dataset_tx = test_helpers.build_dataset({region_tx: {CommonFields.CASES: ts_with_tag}})\n dataset_sf = test_helpers.build_dataset({region_sf: {CommonFields.CASES: ts_with_tag}})\n\n dataset_appended = dataset_tx.append_regions(dataset_sf)\n\n assert len(dataset_appended.tag) == 2\n dataset_tx_and_sf = test_helpers.build_dataset(\n {region_tx: {CommonFields.CASES: ts_with_tag}, region_sf: {CommonFields.CASES: ts_with_tag}}\n )\n test_helpers.assert_dataset_like(dataset_appended, dataset_tx_and_sf)\n\n dataset_out = dataset_tx_and_sf.get_regions_subset([region_tx])\n assert len(dataset_out.tag) == 1\n test_helpers.assert_dataset_like(dataset_out, dataset_tx)\n\n\ndef test_one_region_annotations():\n region_tx = Region.from_state(\"TX\")\n region_sf = Region.from_fips(\"06075\")\n values = [100, 200, 300, 400]\n tag1 = test_helpers.make_tag(date=\"2020-04-01\")\n tag2a = test_helpers.make_tag(date=\"2020-04-02\")\n tag2b = test_helpers.make_tag(date=\"2020-04-03\")\n\n dataset_tx_and_sf = test_helpers.build_dataset(\n {\n region_tx: {CommonFields.CASES: (TimeseriesLiteral(values, annotation=[tag1]))},\n region_sf: {CommonFields.CASES: (TimeseriesLiteral(values, annotation=[tag2a, tag2b]))},\n }\n )\n\n # get_one_region and iter_one_regions use separate code to split up the tags. Test both of them.\n one_region_tx = dataset_tx_and_sf.get_one_region(region_tx)\n assert one_region_tx.annotations_all_bucket(CommonFields.CASES) == [tag1]\n one_region_sf = dataset_tx_and_sf.get_one_region(region_sf)\n assert one_region_sf.annotations_all_bucket(CommonFields.CASES) == [\n tag2a,\n tag2b,\n ]\n assert set(one_region_sf.sources_all_bucket(CommonFields.CASES)) == set()\n\n assert {\n region: one_region_dataset.annotations_all_bucket(CommonFields.CASES)\n for region, one_region_dataset in dataset_tx_and_sf.iter_one_regions()\n } == {region_sf: [tag2a, tag2b], region_tx: [tag1],}\n\n\ndef test_one_region_empty_annotations():\n one_region = test_helpers.build_one_region_dataset({CommonFields.CASES: [100, 200, 300]})\n\n assert one_region.annotations_all_bucket(CommonFields.CASES) == []\n assert one_region.source_url == {}\n assert one_region.provenance == {}\n assert set(one_region.sources_all_bucket(CommonFields.ICU_BEDS)) == set()\n assert set(one_region.sources_all_bucket(CommonFields.CASES)) == set()\n\n\ndef test_one_region_tag_objects_series():\n values = [100, 200]\n tag1 = test_helpers.make_tag(TagType.ZSCORE_OUTLIER, date=\"2020-04-01\")\n tag2a = test_helpers.make_tag(date=\"2020-04-02\")\n tag2b = test_helpers.make_tag(date=\"2020-04-03\")\n\n one_region = test_helpers.build_one_region_dataset(\n {\n CommonFields.CASES: TimeseriesLiteral(values, annotation=[tag1]),\n CommonFields.ICU_BEDS: TimeseriesLiteral(values, provenance=\"prov1\"),\n CommonFields.DEATHS: TimeseriesLiteral(values, annotation=[tag2a, tag2b]),\n }\n )\n\n assert isinstance(one_region.tag_objects_series, pd.Series)\n assert one_region.tag.index.equals(one_region.tag_objects_series.index)\n assert set(one_region.tag_objects_series.reset_index().itertuples(index=False)) == {\n (CommonFields.CASES, DemographicBucket.ALL, tag1.tag_type, tag1),\n (\n CommonFields.ICU_BEDS,\n DemographicBucket.ALL,\n \"provenance\",\n taglib.ProvenanceTag(source=\"prov1\"),\n ),\n (CommonFields.DEATHS, DemographicBucket.ALL, tag2a.tag_type, tag2a),\n (CommonFields.DEATHS, DemographicBucket.ALL, tag2b.tag_type, tag2b),\n }\n\n\ndef test_one_region_tag_objects_series_empty():\n one_region = test_helpers.build_one_region_dataset({CommonFields.CASES: [1, 2, 3]})\n assert one_region.tag.empty\n assert isinstance(one_region.tag_objects_series, pd.Series)\n assert one_region.tag_objects_series.empty\n\n\ndef test_timeseries_tag_objects_series():\n values = [100, 200]\n tag1 = test_helpers.make_tag(TagType.ZSCORE_OUTLIER, date=\"2020-04-01\")\n tag2a = test_helpers.make_tag(date=\"2020-04-02\")\n tag2b = test_helpers.make_tag(date=\"2020-04-03\")\n url_str = UrlStr(\"http://foo.com/1\")\n source_obj = taglib.Source(\"source_with_url\", url=url_str)\n\n ds = test_helpers.build_default_region_dataset(\n {\n CommonFields.CASES: TimeseriesLiteral(values, annotation=[tag1]),\n CommonFields.ICU_BEDS: TimeseriesLiteral(values, source=source_obj),\n CommonFields.DEATHS: TimeseriesLiteral(values, annotation=[tag2a, tag2b]),\n CommonFields.TOTAL_TESTS: values,\n }\n )\n\n assert isinstance(ds.tag_objects_series, pd.Series)\n assert ds.tag.index.equals(ds.tag_objects_series.index)\n location_id = test_helpers.DEFAULT_REGION.location_id\n assert set(ds.tag_objects_series.reset_index().itertuples(index=False)) == {\n (location_id, CommonFields.CASES, DemographicBucket.ALL, tag1.tag_type, tag1),\n (location_id, CommonFields.ICU_BEDS, DemographicBucket.ALL, TagType.SOURCE, source_obj),\n (location_id, CommonFields.DEATHS, DemographicBucket.ALL, tag2a.tag_type, tag2a),\n (location_id, CommonFields.DEATHS, DemographicBucket.ALL, tag2b.tag_type, tag2b),\n }\n\n\ndef test_timeseries_latest_values():\n dataset = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1,m2\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,,2\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,10,3\\n\"\n \"iso1:us#cbsa:10100,2020-04-04,,,,1\\n\"\n \"iso1:us#cbsa:10100,,,,,4\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2,\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,4,\\n\"\n \"iso1:us#fips:97111,,Bar County,county,5,\\n\"\n )\n )\n\n # Check bulk access via _timeseries_latest_values\n expected = pd.read_csv(\n io.StringIO(\"location_id,m1,m2\\n\" \"iso1:us#cbsa:10100,10,1\\n\" \"iso1:us#fips:97111,4,\\n\")\n )\n latest_from_timeseries = dataset._timeseries_latest_values().reset_index()\n pd.testing.assert_frame_equal(\n latest_from_timeseries, expected, check_like=True, check_dtype=False\n )\n\n # Check access to timeseries latests values via get_one_region\n region_10100 = dataset.get_one_region(Region.from_cbsa_code(\"10100\"))\n assert region_10100.latest == {\n \"aggregate_level\": \"cbsa\",\n \"county\": None,\n \"country\": \"USA\",\n \"fips\": \"10100\",\n \"state\": None,\n \"m1\": 10, # Derived from timeseries\n \"m2\": 4, # Explicitly in recent values\n }\n region_97111 = dataset.get_one_region(Region.from_fips(\"97111\"))\n assert region_97111.latest == {\n \"aggregate_level\": \"county\",\n \"county\": \"Bar County\",\n \"country\": \"USA\",\n \"fips\": \"97111\",\n \"state\": \"ZZ\",\n \"m1\": 5,\n \"m2\": None,\n }\n\n\ndef test_timeseries_latest_values_copied_to_static():\n dataset = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,t1,s1\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,,2\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,10,3\\n\"\n \"iso1:us#cbsa:10100,2020-04-04,,,,1\\n\"\n \"iso1:us#cbsa:10100,,,,,4\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2,\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,4,\\n\"\n \"iso1:us#fips:97111,,Bar County,county,,\\n\"\n )\n )\n\n # Check access to latest values as copied to static\n t1 = FieldName(\"t1\")\n s1 = FieldName(\"s1\")\n dataset_t1_latest_in_static = dataset.latest_in_static(t1)\n assert dataset_t1_latest_in_static.static.loc[\"iso1:us#cbsa:10100\", t1] == 10\n assert dataset_t1_latest_in_static.static.loc[\"iso1:us#fips:97111\", t1] == 4\n\n # Trying to copy the latest values of s1 fails because s1 already has a real value in static.\n # See also longer comment where the ValueError is raised.\n with pytest.raises(ValueError):\n dataset.latest_in_static(s1)\n\n\ndef test_join_columns():\n ts_1 = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,\\n\"\n \"iso1:us#cbsa:10100,,,,\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,4\\n\"\n \"iso1:us#fips:97111,,Bar County,county,4\\n\"\n )\n ).add_provenance_csv(\n io.StringIO(\n \"location_id,variable,provenance\\n\"\n \"iso1:us#cbsa:10100,m1,ts110100prov\\n\"\n \"iso1:us#fips:97111,m1,ts197111prov\\n\"\n )\n )\n ts_2 = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m2\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,2\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,3\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,\\n\"\n )\n ).add_provenance_csv(\n io.StringIO(\n \"location_id,variable,provenance\\n\"\n \"iso1:us#cbsa:10100,m2,ts110100prov\\n\"\n \"iso1:us#fips:97111,m2,ts197111prov\\n\"\n )\n )\n ts_expected = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1,m2\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,,2\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,,3\\n\"\n \"iso1:us#cbsa:10100,,,,,\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2,\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,4,\\n\"\n \"iso1:us#fips:97111,,Bar County,county,4,\\n\"\n )\n ).add_provenance_csv(\n io.StringIO(\n \"location_id,variable,provenance\\n\"\n \"iso1:us#cbsa:10100,m1,ts110100prov\\n\"\n \"iso1:us#cbsa:10100,m2,ts110100prov\\n\"\n \"iso1:us#fips:97111,m1,ts197111prov\\n\"\n \"iso1:us#fips:97111,m2,ts197111prov\\n\"\n )\n )\n ts_joined = ts_1.join_columns(ts_2)\n test_helpers.assert_dataset_like(ts_joined, ts_expected, drop_na_latest=True)\n\n ts_joined = ts_2.join_columns(ts_1)\n test_helpers.assert_dataset_like(ts_joined, ts_expected, drop_na_latest=True)\n\n with pytest.raises(ValueError):\n # Raises because the same column is in both datasets\n ts_2.join_columns(ts_2)\n\n # geo attributes, such as aggregation level and county name, generally appear in geo-data.csv\n # instead of MultiRegionDataset so they don't need special handling in join_columns.\n\n\ndef test_join_columns_missing_regions():\n ts_1 = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,\\n\"\n \"iso1:us#cbsa:10100,,,,\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,4\\n\"\n \"iso1:us#fips:97111,,Bar County,county,4\\n\"\n )\n )\n ts_2 = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m2\\n\" \"iso1:us#cbsa:10100,2020-04-02,,,2\\n\"\n )\n )\n ts_expected = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1,m2\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,,2\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,,\\n\"\n \"iso1:us#cbsa:10100,,,,,\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2,\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,4,\\n\"\n \"iso1:us#fips:97111,,Bar County,county,4,\\n\"\n )\n )\n ts_joined = ts_1.join_columns(ts_2)\n test_helpers.assert_dataset_like(ts_joined, ts_expected, drop_na_latest=True)\n\n\ndef test_join_columns_with_buckets():\n m1 = FieldName(\"m1\")\n m2 = FieldName(\"m2\")\n age20s = DemographicBucket(\"age:20-29\")\n\n m1_data = {m1: {age20s: [1, 2, 3]}}\n ds_1 = test_helpers.build_default_region_dataset(m1_data)\n m2_data = {m2: {age20s: [4, 5, 6], DemographicBucket.ALL: [7, 8, 9]}}\n ds_2 = test_helpers.build_default_region_dataset(m2_data)\n\n with pytest.raises(ValueError):\n ds_1.join_columns(ds_1)\n\n ds_expected = test_helpers.build_default_region_dataset({**m1_data, **m2_data})\n\n ds_joined = ds_1.join_columns(ds_2)\n test_helpers.assert_dataset_like(ds_joined, ds_expected)\n\n\ndef test_join_columns_with_static():\n m1 = FieldName(\"m1\")\n m2 = FieldName(\"m2\")\n\n ds_1 = test_helpers.build_default_region_dataset({}, static={m1: 1})\n ds_2 = test_helpers.build_default_region_dataset({}, static={m2: 2})\n\n with pytest.raises(ValueError):\n ds_1.join_columns(ds_1)\n\n ds_expected = test_helpers.build_default_region_dataset({}, static={m1: 1, m2: 2})\n\n ds_joined = ds_1.join_columns(ds_2)\n test_helpers.assert_dataset_like(ds_joined, ds_expected)\n\n ds_joined = ds_2.join_columns(ds_1)\n test_helpers.assert_dataset_like(ds_joined, ds_expected)\n\n\ndef test_iter_one_region():\n ts = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,\\n\"\n \"iso1:us#cbsa:10100,,,,\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,4\\n\"\n \"iso1:us#fips:97111,,Bar County,county,4\\n\"\n # 97222 does not have a row of latest data to make sure it still works\n \"iso1:us#fips:97222,2020-04-02,No Recent County,county,3\\n\"\n \"iso1:us#fips:97222,2020-04-04,No Recent County,county,5\\n\"\n )\n )\n assert {region.location_id for region, _ in ts.iter_one_regions()} == {\n \"iso1:us#cbsa:10100\",\n \"iso1:us#fips:97111\",\n \"iso1:us#fips:97222\",\n }\n for it_region, it_one_region in ts.iter_one_regions():\n one_region = ts.get_one_region(it_region)\n assert (one_region.data.fillna(\"\") == it_one_region.data.fillna(\"\")).all(axis=None)\n assert one_region.latest == it_one_region.latest\n assert one_region.provenance == it_one_region.provenance\n assert one_region.region == it_region\n assert one_region.region == it_one_region.region\n\n\ndef test_drop_regions_without_population():\n cbsa_with_pop = Region.from_cbsa_code(\"10100\")\n fips_with_pop = Region.from_fips(\"97111\")\n cbsa_without_pop = Region.from_cbsa_code(\"20300\")\n fips_without_pop = Region.from_fips(\"97222\")\n m1 = FieldName(\"m1\")\n regions_with_pop = [cbsa_with_pop, fips_with_pop]\n all_regions = regions_with_pop + [cbsa_without_pop, fips_without_pop]\n static_populations = {r: {CommonFields.POPULATION: 80_000} for r in regions_with_pop}\n ts_in = test_helpers.build_dataset(\n {r: {m1: [1]} for r in all_regions}, static_by_region_then_field_name=static_populations,\n )\n ts_expected = test_helpers.build_dataset(\n {r: {m1: [1]} for r in regions_with_pop},\n static_by_region_then_field_name=static_populations,\n )\n with structlog.testing.capture_logs() as logs:\n ts_out = timeseries.drop_regions_without_population(\n ts_in, [fips_without_pop.location_id], structlog.get_logger()\n )\n test_helpers.assert_dataset_like(ts_out, ts_expected)\n\n assert [l[\"event\"] for l in logs] == [\"Dropping unexpected regions without populaton\"]\n assert [l[\"location_ids\"] for l in logs] == [[cbsa_without_pop.location_id]]\n\n\ndef test_merge_provenance():\n ts = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,\\n\"\n \"iso1:us#cbsa:10100,,,,\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,4\\n\"\n \"iso1:us#fips:97111,,Bar County,county,4\\n\"\n )\n ).add_provenance_csv(\n io.StringIO(\"location_id,variable,provenance\\n\" \"iso1:us#cbsa:10100,m1,ts110100prov\\n\")\n )\n\n with pytest.raises(NotImplementedError):\n ts.add_provenance_csv(\n io.StringIO(\"location_id,variable,provenance\\n\" \"iso1:us#fips:97111,m1,ts197111prov\\n\")\n )\n\n\ndef test_append_tags():\n region_sf = Region.from_fips(\"06075\")\n cases_values = [100, 200, 300, 400]\n metrics_sf = {\n CommonFields.POSITIVE_TESTS: TimeseriesLiteral([1, 2, 3, 4], provenance=\"pt_src2\"),\n CommonFields.CASES: cases_values,\n }\n dataset_in = test_helpers.build_dataset({region_sf: metrics_sf})\n tag_sf_cases = test_helpers.make_tag(TagType.CUMULATIVE_TAIL_TRUNCATED, date=\"2020-04-02\")\n tag_df = test_helpers.make_tag_df(\n region_sf, CommonFields.CASES, DemographicBucket.ALL, [tag_sf_cases]\n )\n dataset_out = dataset_in.append_tag_df(tag_df)\n metrics_sf[CommonFields.CASES] = TimeseriesLiteral(cases_values, annotation=[tag_sf_cases])\n dataset_expected = test_helpers.build_dataset({region_sf: metrics_sf})\n\n test_helpers.assert_dataset_like(dataset_out, dataset_expected)\n\n\ndef test_add_provenance_all_with_tags():\n \"\"\"Checks that add_provenance_all (and add_provenance_series that it calls) fails when tags\n already exist.\"\"\"\n region = Region.from_state(\"TX\")\n cases_values = [100, 200, 300, 400]\n timeseries = TimeseriesLiteral(cases_values, annotation=[(test_helpers.make_tag())])\n dataset_in = test_helpers.build_dataset({region: {CommonFields.CASES: timeseries}})\n\n with pytest.raises(NotImplementedError):\n dataset_in.add_provenance_all(\"prov_prov\")\n\n\ndef test_join_columns_with_tags():\n \"\"\"Checks that join_columns preserves tags.\"\"\"\n region = Region.from_state(\"TX\")\n cases_values = [100, 200, 300, 400]\n ts_lit = TimeseriesLiteral(cases_values, annotation=[test_helpers.make_tag()])\n dataset_cases = test_helpers.build_dataset({region: {CommonFields.CASES: ts_lit}})\n dataset_deaths = test_helpers.build_dataset({region: {CommonFields.DEATHS: ts_lit}})\n\n dataset_out = dataset_cases.join_columns(dataset_deaths)\n\n assert len(dataset_out.tag) == 2\n # The following checks that the tags in `ts_lit` have been preserved.\n dataset_expected = test_helpers.build_dataset(\n {region: {CommonFields.CASES: ts_lit, CommonFields.DEATHS: ts_lit}}\n )\n\n test_helpers.assert_dataset_like(dataset_out, dataset_expected)\n\n\ndef test_drop_column_with_tags():\n region = Region.from_state(\"TX\")\n cases_values = [100, 200, 300, 400]\n ts_lit = TimeseriesLiteral(cases_values, annotation=[test_helpers.make_tag()])\n\n dataset_in = test_helpers.build_dataset(\n {region: {CommonFields.CASES: ts_lit, CommonFields.DEATHS: ts_lit}}\n )\n\n dataset_out = dataset_in.drop_column_if_present(CommonFields.DEATHS)\n\n assert len(dataset_out.tag) == 1\n dataset_expected = test_helpers.build_dataset({region: {CommonFields.CASES: ts_lit}})\n test_helpers.assert_dataset_like(dataset_out, dataset_expected)\n\n\ndef test_drop_na_columns():\n tag = test_helpers.make_tag()\n timeseries_real = {\n CommonFields.CASES: TimeseriesLiteral([1, 2], annotation=[tag]),\n }\n static_real = {CommonFields.STAFFED_BEDS: 3}\n ds = test_helpers.build_default_region_dataset(\n # Adds CASES with real values, which won't be dropped, and a tag for DEATHS, that will be\n # dropped.\n {**timeseries_real, CommonFields.DEATHS: TimeseriesLiteral([], annotation=[tag])},\n static=static_real,\n )\n # The test_helper functions don't do a good job of creating fields that are all NA so the\n # following inserts time series DEATHS and static ICU_BEDS, then asserts that they were\n # inserted.\n timeseries_bucketed_with_na = ds.timeseries_bucketed.copy()\n timeseries_bucketed_with_na.loc[:, CommonFields.DEATHS] = np.nan\n static_with_na = ds.static.copy()\n static_with_na.loc[:, CommonFields.ICU_BEDS] = np.nan\n ds = dataclasses.replace(\n ds, timeseries_bucketed=timeseries_bucketed_with_na, static=static_with_na\n )\n assert CommonFields.DEATHS in ds.timeseries_bucketed.columns\n assert CommonFields.ICU_BEDS in ds.static.columns\n\n dataset_out = ds.drop_na_columns()\n\n dataset_expected = test_helpers.build_default_region_dataset(\n timeseries_real, static=static_real\n )\n test_helpers.assert_dataset_like(dataset_out, dataset_expected)\n\n\ndef test_drop_na_columns_no_tags():\n timeseries_real = {CommonFields.CASES: [1, 2]}\n tag = test_helpers.make_tag()\n ds = test_helpers.build_default_region_dataset(\n # Add a tag for DEATHS, that will be dropped.\n {**timeseries_real, CommonFields.DEATHS: TimeseriesLiteral([], annotation=[tag])}\n )\n # The test_helper functions don't do a good job of creating fields that are all NA so the\n # following inserts time series DEATHS and static ICU_BEDS, then asserts that they were\n # inserted.\n timeseries_bucketed_with_na = ds.timeseries_bucketed.copy()\n timeseries_bucketed_with_na.loc[:, CommonFields.DEATHS] = np.nan\n ds = dataclasses.replace(ds, timeseries_bucketed=timeseries_bucketed_with_na)\n assert CommonFields.DEATHS in ds.timeseries_bucketed.columns\n\n dataset_out = ds.drop_na_columns()\n\n dataset_expected = test_helpers.build_default_region_dataset(timeseries_real)\n test_helpers.assert_dataset_like(dataset_out, dataset_expected)\n\n\ndef test_drop_column_with_tags_and_bucket():\n age_40s = DemographicBucket(\"age:40-49\")\n ts_lit = TimeseriesLiteral([10, 20, 30], annotation=[test_helpers.make_tag()])\n data_cases = {CommonFields.CASES: {age_40s: ts_lit, DemographicBucket.ALL: ts_lit}}\n data_deaths = {CommonFields.DEATHS: {age_40s: ts_lit}}\n\n dataset_in = test_helpers.build_default_region_dataset({**data_cases, **data_deaths})\n assert len(dataset_in.tag) == 3\n\n dataset_out = dataset_in.drop_column_if_present(CommonFields.DEATHS)\n\n assert len(dataset_out.tag) == 2\n dataset_expected = test_helpers.build_default_region_dataset({**data_cases})\n test_helpers.assert_dataset_like(dataset_out, dataset_expected)\n\n\ndef test_timeseries_empty_timeseries_and_static():\n # Check that empty dataset creates a MultiRegionDataset\n # and that get_one_region raises expected exception.\n dataset = timeseries.MultiRegionDataset.new_without_timeseries()\n with pytest.raises(timeseries.RegionLatestNotFound):\n dataset.get_one_region(Region.from_fips(\"01001\"))\n\n\ndef test_timeseries_empty():\n # Check that empty geodata_timeseries_df creates a MultiRegionDataset\n # and that get_one_region raises expected exception.\n dataset = timeseries.MultiRegionDataset.from_timeseries_df(\n pd.DataFrame([], columns=[CommonFields.LOCATION_ID, CommonFields.DATE])\n )\n with pytest.raises(timeseries.RegionLatestNotFound):\n dataset.get_one_region(Region.from_fips(\"01001\"))\n\n\ndef test_timeseries_empty_static_not_empty():\n # Check that empty timeseries does not prevent static data working as expected.\n dataset = timeseries.MultiRegionDataset.from_timeseries_df(\n pd.DataFrame([], columns=[CommonFields.LOCATION_ID, CommonFields.DATE])\n ).add_static_values(pd.DataFrame([{\"location_id\": \"iso1:us#fips:97111\", \"m1\": 1234}]))\n assert dataset.get_one_region(Region.from_fips(\"97111\")).latest[\"m1\"] == 1234\n\n\ndef test_from_timeseries_df_fips_location_id_mismatch():\n df = test_helpers.read_csv_str(\n \" location_id, fips, date,m1\\n\"\n \"iso1:us#iso2:us-tx#fips:48197,48201,2020-04-02, 2\\n\"\n \"iso1:us#iso2:us-tx#fips:48201,48201,2020-04-02, 2\\n\",\n skip_spaces=True,\n )\n with pytest.warns(timeseries.ExtraColumnWarning, match=\"48201\"):\n timeseries.MultiRegionDataset.from_timeseries_df(df)\n\n\ndef test_from_timeseries_df_no_fips_no_warning():\n df = test_helpers.read_csv_str(\n \" location_id, fips, date,m1\\n\"\n \" iso1:us, ,2020-04-02, 2\\n\",\n skip_spaces=True,\n )\n timeseries.MultiRegionDataset.from_timeseries_df(df)\n\n\ndef test_from_timeseries_df_fips_state_mismatch():\n df = test_helpers.read_csv_str(\n \" location_id,state, date,m1\\n\"\n \"iso1:us#iso2:us-tx#fips:48197, TX,2020-04-02, 2\\n\"\n \"iso1:us#iso2:us-tx#fips:48201, IL,2020-04-02, 2\\n\",\n skip_spaces=True,\n )\n with pytest.warns(timeseries.ExtraColumnWarning, match=\"48201\"):\n timeseries.MultiRegionDataset.from_timeseries_df(df)\n\n\ndef test_from_timeseries_df_bad_level():\n df = test_helpers.read_csv_str(\n \" location_id, aggregate_level, date,m1\\n\"\n \"iso1:us#iso2:us-tx#fips:48201, county,2020-04-02, 2\\n\"\n \"iso1:us#iso2:us-tx#fips:48197, state,2020-04-02, 2\\n\"\n \" iso1:us#iso2:us-tx, state,2020-04-02, 2\\n\",\n skip_spaces=True,\n )\n with pytest.warns(timeseries.ExtraColumnWarning, match=\"48197\"):\n timeseries.MultiRegionDataset.from_timeseries_df(df)\n\n\ndef test_combined_timeseries():\n ds1 = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,2.2\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,3.3\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,4\\n\"\n )\n ).add_provenance_csv(\n io.StringIO(\"location_id,variable,provenance\\n\" \"iso1:us#cbsa:10100,m1,ds110100prov\\n\")\n )\n ds2 = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,,,333\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,,,333\\n\"\n \"iso1:us#fips:97222,2020-04-03,Foo County,county,30\\n\"\n \"iso1:us#fips:97222,2020-04-04,Foo County,county,40\\n\"\n )\n ).add_provenance_csv(\n io.StringIO(\"location_id,variable,provenance\\n\" \"iso1:us#cbsa:10100,m1,ds110100prov\\n\")\n )\n combined = timeseries.combined_datasets({FieldName(\"m1\"): [ds1, ds2]}, {})\n expected = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,m1\\n\"\n \"iso1:us#cbsa:10100,2020-04-02,2.2\\n\"\n \"iso1:us#cbsa:10100,2020-04-03,3.3\\n\"\n \"iso1:us#fips:97111,2020-04-02,2\\n\"\n \"iso1:us#fips:97111,2020-04-04,4\\n\"\n \"iso1:us#fips:97222,2020-04-03,30\\n\"\n \"iso1:us#fips:97222,2020-04-04,40\\n\"\n )\n ).add_provenance_csv(\n io.StringIO(\"location_id,variable,provenance\\n\" \"iso1:us#cbsa:10100,m1,ds110100prov\\n\")\n )\n\n test_helpers.assert_dataset_like(expected, combined)\n\n\ndef test_combined_annotation():\n ts1a = TimeseriesLiteral(\n [0, 2, 4],\n annotation=[\n test_helpers.make_tag(date=\"2020-04-01\"),\n test_helpers.make_tag(date=\"2020-04-02\"),\n ],\n )\n ts1b = [100, 200, 300]\n ds1 = test_helpers.build_default_region_dataset(\n {CommonFields.ICU_BEDS: ts1a, CommonFields.CASES: ts1b}\n )\n ts2a = TimeseriesLiteral([1, 3, 5], annotation=[test_helpers.make_tag(date=\"2020-04-01\")],)\n ts2b = [150, 250, 350]\n ds2 = test_helpers.build_default_region_dataset(\n {CommonFields.ICU_BEDS: ts2a, CommonFields.CASES: ts2b}\n )\n combined = timeseries.combined_datasets(\n {CommonFields.ICU_BEDS: [ds1, ds2], CommonFields.CASES: [ds2, ds1]}, {}\n )\n\n expected = test_helpers.build_default_region_dataset(\n {CommonFields.ICU_BEDS: ts1a, CommonFields.CASES: ts2b}\n )\n\n test_helpers.assert_dataset_like(combined, expected)\n\n\ndef test_combined_missing_field():\n ts1 = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m1\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,2\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,4\\n\"\n )\n )\n ts2 = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,m2\\n\"\n \"iso1:us#fips:97111,2020-04-02,Bar County,county,111\\n\"\n \"iso1:us#fips:97111,2020-04-04,Bar County,county,111\\n\"\n )\n )\n # m1 is output, m2 is dropped.\n field_source_map = {FieldName(\"m1\"): [ts1, ts2]}\n\n # Check that combining finishes and produces the expected result.\n combined_1 = timeseries.combined_datasets(field_source_map, {})\n expected = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,m1\\n\"\n \"iso1:us#fips:97111,2020-04-02,2\\n\"\n \"iso1:us#fips:97111,2020-04-04,4\\n\"\n )\n )\n test_helpers.assert_dataset_like(expected, combined_1)\n\n # Because there is only one source for the output timeseries reversing the source list\n # produces the same output.\n combined_2 = timeseries.combined_datasets(\n {name: list(reversed(source_list)) for name, source_list in field_source_map.items()}, {}\n )\n test_helpers.assert_dataset_like(expected, combined_2)\n\n\ndef test_combined_static():\n ds1 = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,s1\\n\"\n \"iso1:us#cbsa:10100,,,,\\n\"\n \"iso1:us#fips:97222,,Foo County,county,22\\n\"\n )\n )\n ds2 = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,date,county,aggregate_level,s1\\n\"\n \"iso1:us#cbsa:10100,,,,111\\n\"\n \"iso1:us#fips:97222,,Foo County,county,222\\n\"\n )\n )\n combined = timeseries.combined_datasets({}, {FieldName(\"s1\"): [ds1, ds2]})\n expected = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\"location_id,date,s1\\n\" \"iso1:us#cbsa:10100,,111\\n\" \"iso1:us#fips:97222,,22\\n\")\n )\n\n test_helpers.assert_dataset_like(expected, combined, drop_na_timeseries=True)\n\n\ndef test_timeseries_rows():\n ts = timeseries.MultiRegionDataset.from_csv(\n io.StringIO(\n \"location_id,county,aggregate_level,date,m1,m2,population\\n\"\n \"iso1:us#iso2:us-tx,Texas,state,2020-04-01,4,2,\\n\"\n \"iso1:us#iso2:us-tx,Texas,state,2020-04-02,4,4,\\n\"\n \"iso1:us#iso2:us-tx,Texas,state,,,,2500\\n\"\n \"iso1:us#iso2:us-az,Arizona,state,2020-04-01,8,20,\\n\"\n \"iso1:us#iso2:us-az,Arizona,state,2020-04-02,12,40,\\n\"\n \"iso1:us#iso2:us-az,Arizona,state,,,,7500\\n\"\n )\n )\n\n rows = ts.timeseries_rows()\n expected = test_helpers.read_csv_str(\n \" location_id,variable,demographic_bucket,2020-04-02,2020-04-01\\n\"\n \"iso1:us#iso2:us-az, m1, all, 12, 8\\n\"\n \"iso1:us#iso2:us-az, m2, all, 40, 20\\n\"\n \"iso1:us#iso2:us-tx, m1, all, 4, 4\\n\"\n \"iso1:us#iso2:us-tx, m2, all, 4, 2\\n\",\n skip_spaces=True,\n ).set_index([CommonFields.LOCATION_ID, PdFields.VARIABLE, PdFields.DEMOGRAPHIC_BUCKET])\n pd.testing.assert_frame_equal(rows, expected, check_dtype=False, check_exact=False)\n\n\ndef test_multi_region_dataset_get_subset():\n region_us = Region.from_iso1(\"us\")\n region_tx = Region.from_state(\"TX\")\n region_county = Region.from_fips(\"97222\")\n region_cbsa = Region.from_cbsa_code(\"10100\")\n m1 = FieldName(\"m1\")\n m2 = FieldName(\"m2\")\n ds = test_helpers.build_dataset(\n {\n region_us: {m1: [100], m2: [200]},\n region_tx: {m1: [4], m2: [2]},\n region_county: {m1: [1], m2: [2]},\n region_cbsa: {m1: [1], m2: [2], CommonFields.POPULATION: [20_000]},\n },\n static_by_region_then_field_name={\n region_us: {CommonFields.POPULATION: 10_000},\n region_tx: {CommonFields.POPULATION: 5_000},\n region_county: {CommonFields.POPULATION: 1_000},\n },\n )\n\n subset = ds.get_subset(aggregation_level=AggregationLevel.COUNTRY)\n assert subset.static.at[\"iso1:us\", CommonFields.POPULATION] == 10000\n\n subset = ds.get_subset(fips=\"97222\")\n assert subset.timeseries.at[(\"iso1:us#fips:97222\", \"2020-04-01\"), \"m2\"] == 2\n\n subset = ds.get_subset(state=\"TX\")\n assert subset.static.at[\"iso1:us#iso2:us-tx\", CommonFields.POPULATION] == 5000\n\n subset = ds.get_subset(states=[\"TX\"])\n assert subset.static.at[\"iso1:us#iso2:us-tx\", CommonFields.POPULATION] == 5000\n\n subset = ds.get_subset(location_id_matches=r\"\\A(iso1\\:us|iso1\\:us\\#cbsa.+)\\Z\")\n assert {r.location_id for r, _ in subset.iter_one_regions()} == {\n \"iso1:us\",\n \"iso1:us#cbsa:10100\",\n }\n\n\ndef test_multi_region_dataset_get_subset_with_buckets():\n # Make some regions at different levels\n region_us = Region.from_iso1(\"us\")\n region_tx = Region.from_state(\"TX\")\n region_la = Region.from_fips(\"06037\")\n age_40s = DemographicBucket(\"age:40-49\")\n data_us = {region_us: {CommonFields.CASES: [100, 200]}}\n data_tx = {region_tx: {CommonFields.CASES: [10, 20]}}\n data_la = {region_la: {CommonFields.CASES: {DemographicBucket.ALL: [5, 10], age_40s: [1, 2]}}}\n ds = test_helpers.build_dataset({**data_us, **data_tx, **data_la})\n\n ds_expected = test_helpers.build_dataset({**data_us, **data_la})\n test_helpers.assert_dataset_like(ds.get_regions_subset([region_us, region_la]), ds_expected)\n test_helpers.assert_dataset_like(ds.partition_by_region(exclude=[region_tx])[0], ds_expected)\n\n\ndef test_write_read_dataset_pointer_with_source_url(tmpdir):\n pointer = _make_dataset_pointer(tmpdir)\n url_str1 = UrlStr(\"http://foo.com/1\")\n url_str2 = UrlStr(\"http://foo.com/2\")\n url_str3 = UrlStr(\"http://foo.com/3\")\n\n ts1a = TimeseriesLiteral(\n [0, 2, 4],\n annotation=[\n test_helpers.make_tag(date=\"2020-04-01\"),\n test_helpers.make_tag(date=\"2020-04-02\"),\n ],\n source_url=url_str1,\n )\n ts1b = TimeseriesLiteral([100, 200, 300], source_url=[url_str2, url_str3])\n dataset_in = test_helpers.build_default_region_dataset(\n {CommonFields.ICU_BEDS: ts1a, CommonFields.CASES: ts1b}\n )\n\n dataset_in.write_to_dataset_pointer(pointer)\n\n dataset_read = timeseries.MultiRegionDataset.read_from_pointer(pointer)\n\n test_helpers.assert_dataset_like(dataset_read, dataset_in)\n source_url_read = dataset_read.get_one_region(test_helpers.DEFAULT_REGION).source_url\n assert source_url_read[CommonFields.ICU_BEDS] == [url_str1]\n # Copy to a set because the order of the URLs in the source_url may change.\n assert set(source_url_read[CommonFields.CASES]) == {url_str2, url_str3}\n\n\ndef test_pickle():\n ts = TimeseriesLiteral(\n [0, 2, 4],\n annotation=[\n test_helpers.make_tag(date=\"2020-04-01\"),\n test_helpers.make_tag(date=\"2020-04-02\"),\n ],\n source_url=UrlStr(\"http://public.com\"),\n )\n ds_in = test_helpers.build_default_region_dataset({CommonFields.CASES: ts})\n\n ds_out = pickle.loads(pickle.dumps(ds_in))\n\n test_helpers.assert_dataset_like(ds_in, ds_out)\n\n\ndef test_make_source_tags():\n url_str = UrlStr(\"http://foo.com/1\")\n\n ts_prov_only = TimeseriesLiteral(\n [0, 2, 4], annotation=[test_helpers.make_tag(date=\"2020-04-01\"),], provenance=\"prov_only\",\n )\n ts_with_url = TimeseriesLiteral([3, 5, 7], provenance=\"prov_with_url\", source_url=url_str)\n dataset_in = test_helpers.build_default_region_dataset(\n {CommonFields.ICU_BEDS: ts_prov_only, CommonFields.CASES: ts_with_url}\n )\n\n dataset_out = timeseries.make_source_tags(dataset_in)\n\n source_tag_prov_only = taglib.Source(\"prov_only\")\n ts_prov_only_expected = TimeseriesLiteral(\n [0, 2, 4],\n annotation=[test_helpers.make_tag(date=\"2020-04-01\"),],\n source=source_tag_prov_only,\n )\n source_tag_prov_with_url = taglib.Source(\"prov_with_url\", url=url_str)\n ts_with_url_expected = TimeseriesLiteral([3, 5, 7], source=source_tag_prov_with_url,)\n dataset_expected = test_helpers.build_default_region_dataset(\n {CommonFields.ICU_BEDS: ts_prov_only_expected, CommonFields.CASES: ts_with_url_expected}\n )\n test_helpers.assert_dataset_like(dataset_out, dataset_expected)\n\n one_region = dataset_out.get_one_region(test_helpers.DEFAULT_REGION)\n assert one_region.sources_all_bucket(CommonFields.ICU_BEDS) == [source_tag_prov_only]\n assert one_region.sources_all_bucket(CommonFields.CASES) == [source_tag_prov_with_url]\n\n\ndef test_make_source_tags_no_urls():\n # There was a bug where `./run.py data update` failed at the very end when no timeseries had\n # a source_url. This tests for it.\n ts_prov_only = TimeseriesLiteral(\n [0, 2, 4], annotation=[test_helpers.make_tag(date=\"2020-04-01\"),], provenance=\"prov_only\",\n )\n dataset_in = test_helpers.build_default_region_dataset({CommonFields.ICU_BEDS: ts_prov_only})\n\n dataset_out = timeseries.make_source_tags(dataset_in)\n\n source_tag_prov_only = taglib.Source(\"prov_only\")\n ts_prov_only_expected = TimeseriesLiteral(\n [0, 2, 4],\n annotation=[test_helpers.make_tag(date=\"2020-04-01\"),],\n source=source_tag_prov_only,\n )\n dataset_expected = test_helpers.build_default_region_dataset(\n {CommonFields.ICU_BEDS: ts_prov_only_expected}\n )\n test_helpers.assert_dataset_like(dataset_out, dataset_expected)\n\n one_region = dataset_out.get_one_region(test_helpers.DEFAULT_REGION)\n assert one_region.sources_all_bucket(CommonFields.ICU_BEDS) == [source_tag_prov_only]\n\n\ndef test_make_source_url_tags():\n url_str = UrlStr(\"http://foo.com/1\")\n\n source_tag_prov_only = taglib.Source(\"prov_only\")\n ts_prov_only = TimeseriesLiteral(\n [0, 2, 4],\n annotation=[test_helpers.make_tag(date=\"2020-04-01\"),],\n source=source_tag_prov_only,\n )\n source_tag_prov_with_url = taglib.Source(\"prov_with_url\", url=url_str)\n ts_with_url = TimeseriesLiteral([3, 5, 7], source=source_tag_prov_with_url,)\n dataset_in = test_helpers.build_default_region_dataset(\n {CommonFields.ICU_BEDS: ts_prov_only, CommonFields.CASES: ts_with_url}\n )\n\n dataset_out = timeseries.make_source_url_tags(dataset_in)\n\n ts_with_url_expected = TimeseriesLiteral(\n [3, 5, 7], source=source_tag_prov_with_url, source_url=url_str\n )\n dataset_expected = test_helpers.build_default_region_dataset(\n {CommonFields.ICU_BEDS: ts_prov_only, CommonFields.CASES: ts_with_url_expected}\n )\n test_helpers.assert_dataset_like(dataset_out, dataset_expected)\n\n\ndef test_make_source_url_tags_no_source_tags():\n dataset_in = test_helpers.build_default_region_dataset({CommonFields.CASES: [1, 2, 3]})\n dataset_out = timeseries.make_source_url_tags(dataset_in)\n assert dataset_in == dataset_out\n\n\ndef test_make_source_url_tags_has_source_url():\n url_str = UrlStr(\"http://foo.com/1\")\n dataset_in = test_helpers.build_default_region_dataset(\n {CommonFields.CASES: TimeseriesLiteral([1, 2, 3], source_url=url_str)}\n )\n with pytest.raises(AssertionError):\n timeseries.make_source_url_tags(dataset_in)\n\n\ndef test_check_timeseries_structure_empty():\n timeseries._check_timeseries_wide_vars_structure(\n timeseries.EMPTY_TIMESERIES_WIDE_VARIABLES_DF, bucketed=False\n )\n timeseries._check_timeseries_wide_vars_structure(\n timeseries.EMPTY_TIMESERIES_BUCKETED_WIDE_VARIABLES_DF, bucketed=True\n )\n\n\ndef test_make_and_pickle_demographic_data():\n location_id = test_helpers.DEFAULT_REGION.location_id\n date_0 = test_helpers.DEFAULT_START_DATE\n date_1 = pd.to_datetime(test_helpers.DEFAULT_START_DATE) + pd.to_timedelta(1, unit=\"day\")\n m1 = FieldName(\"m1\")\n age20s = DemographicBucket(\"age:20-29\")\n age30s = DemographicBucket(\"age:30-39\")\n all = DemographicBucket(\"all\")\n\n ds = test_helpers.build_default_region_dataset(\n {m1: {age20s: [1, 2, 3], age30s: [5, 6, 7], all: [8, 9, None]}}\n )\n\n assert ds.timeseries_bucketed.at[(location_id, age30s, date_0), m1] == 5\n assert ds.timeseries_bucketed.at[(location_id, all, date_1), m1] == 9\n\n ds_unpickled = pickle.loads(pickle.dumps(ds))\n\n test_helpers.assert_dataset_like(ds, ds_unpickled)\n\n\ndef test_combine_demographic_data_basic():\n m1 = FieldName(\"m1\")\n age20s = DemographicBucket(\"age:20-29\")\n age30s = DemographicBucket(\"age:30-39\")\n age40s = DemographicBucket(\"age:40-49\")\n ds1 = test_helpers.build_default_region_dataset(\n {m1: {age20s: [21, 22, 23], age30s: [31, 32, 33],}}\n )\n ds2 = test_helpers.build_default_region_dataset(\n {m1: {age30s: [32, 33, 34], age40s: [42, 43, 44],}}\n )\n\n combined = timeseries.combined_datasets({m1: [ds1, ds2]}, {})\n test_helpers.assert_dataset_like(combined, ds1)\n\n combined = timeseries.combined_datasets({m1: [ds2, ds1]}, {})\n test_helpers.assert_dataset_like(combined, ds2)\n\n\ndef test_combine_demographic_data_multiple_distributions():\n \"\"\"All time-series within a variable are treated as a unit when combining\"\"\"\n m1 = FieldName(\"m1\")\n m2 = FieldName(\"m2\")\n all = DemographicBucket(\"all\")\n age_20s = DemographicBucket(\"age:20-29\")\n age_30s = DemographicBucket(\"age:30-39\")\n region_ak = Region.from_state(\"AK\")\n region_ca = Region.from_state(\"CA\")\n\n ds1 = test_helpers.build_dataset(\n {\n region_ak: {m1: {all: TimeseriesLiteral([1.1, 2.1], provenance=\"ds1_ak_m1_all\")}},\n region_ca: {m1: {age_20s: TimeseriesLiteral([2.1, 3.1], provenance=\"ds1_ca_m1_20s\")}},\n }\n )\n\n ds2 = test_helpers.build_dataset(\n {\n region_ak: {m1: {all: TimeseriesLiteral([1, 2], provenance=\"ds2_ak_m1_all\")}},\n region_ca: {\n m1: {\n age_30s: TimeseriesLiteral([3, 4], provenance=\"ds2_ca_m1_30s\"),\n all: TimeseriesLiteral([5, 6], provenance=\"ds2_ca_m1_all\"),\n },\n m2: {age_30s: TimeseriesLiteral([6, 7], provenance=\"ds2_ca_m2_30s\")},\n },\n }\n )\n\n combined = timeseries.combined_datasets({m1: [ds1, ds2], m2: [ds1, ds2]}, {})\n\n ds_expected = test_helpers.build_dataset(\n {\n region_ak: {m1: {all: TimeseriesLiteral([1.1, 2.1], provenance=\"ds1_ak_m1_all\")}},\n region_ca: {\n m1: {\n age_20s: TimeseriesLiteral([2.1, 3.1], provenance=\"ds1_ca_m1_20s\"),\n all: TimeseriesLiteral([5, 6], provenance=\"ds2_ca_m1_all\"),\n },\n m2: {age_30s: TimeseriesLiteral([6, 7], provenance=\"ds2_ca_m2_30s\")},\n },\n }\n )\n test_helpers.assert_dataset_like(combined, ds_expected)\n\n\ndef test_bucketed_latest_missing_location_id(nyc_region: Region):\n dataset = test_helpers.build_default_region_dataset({CommonFields.CASES: [1, 2, 3]})\n # nyc_region = Region.from_fips(\"97222\")\n output = dataset._bucketed_latest_for_location_id(nyc_region.location_id)\n expected = pd.DataFrame(\n [],\n index=pd.MultiIndex.from_tuples([], names=[PdFields.DEMOGRAPHIC_BUCKET]),\n columns=pd.Index([CommonFields.CASES], name=\"variable\"),\n dtype=\"float\",\n )\n pd.testing.assert_frame_equal(expected, output)\n\n\ndef test_bucketed_latest(nyc_region: Region):\n m1 = FieldName(\"m1\")\n age20s = DemographicBucket(\"age:20-29\")\n age30s = DemographicBucket(\"age:30-39\")\n\n dataset = test_helpers.build_default_region_dataset(\n {m1: {age20s: [21, 22, 23], age30s: [31, 32, 33],}}\n )\n bucketed_latest = dataset._bucketed_latest_for_location_id(\n test_helpers.DEFAULT_REGION.location_id\n )\n expected = pd.DataFrame(\n [{\"m1\": 23}, {\"m1\": 33}],\n index=pd.Index([age20s, age30s], name=PdFields.DEMOGRAPHIC_BUCKET),\n columns=pd.Index([m1], name=\"variable\"),\n )\n pd.testing.assert_frame_equal(bucketed_latest, expected)\n\n\ndef test_one_region_demographic_distributions():\n m1 = FieldName(\"m1\")\n age20s = DemographicBucket(\"age:20-29\")\n age30s = DemographicBucket(\"age:30-39\")\n dataset = test_helpers.build_default_region_dataset(\n {m1: {age20s: [21, 22, 23], age30s: [31, 32, 33], DemographicBucket.ALL: [20, 21, 22]}}\n )\n one_region = dataset.get_one_region(test_helpers.DEFAULT_REGION)\n\n expected = {m1: {\"age\": {\"20-29\": 23, \"30-39\": 33}}}\n assert one_region.demographic_distributions_by_field == expected\n\n\ndef test_one_region_demographic_distributions_overlapping_buckets():\n m1 = FieldName(\"m1\")\n m2 = FieldName(\"m2\")\n age20s = DemographicBucket(\"age:20-29\")\n age30s = DemographicBucket(\"age:30-39\")\n # Presumably 25 to 29 is from a different age distribution as it overlaps with age bucket above.\n # Make sure that different age bucketing doesn't polute other variables.\n age25to29 = DemographicBucket(\"age:25-29\")\n\n dataset = test_helpers.build_default_region_dataset(\n {\n m1: {age20s: [21, 22, 23], age30s: [31, 32, 33], DemographicBucket.ALL: [20, 21, 22]},\n m2: {DemographicBucket.ALL: [20, 21, 22], age25to29: [20, 21, 22]},\n },\n )\n one_region = dataset.get_one_region(test_helpers.DEFAULT_REGION)\n expected = {m1: {\"age\": {\"20-29\": 23, \"30-39\": 33}}, m2: {\"age\": {\"25-29\": 22}}}\n\n assert one_region.demographic_distributions_by_field == expected\n\n\ndef test_print_stats():\n all_bucket = DemographicBucket(\"all\")\n age_20s = DemographicBucket(\"age:20-29\")\n age_30s = DemographicBucket(\"age:30-39\")\n\n test_helpers.build_default_region_dataset(\n {\n CommonFields.ICU_BEDS: TimeseriesLiteral(\n [0, 2, 4], annotation=[test_helpers.make_tag(date=\"2020-04-01\"),],\n ),\n CommonFields.CASES: [100, 200, 300],\n }\n ).print_stats(\"DS1\")\n\n test_helpers.build_default_region_dataset(\n {\n CommonFields.CASES: {\n age_20s: TimeseriesLiteral([3, 4, 5], source=taglib.Source(type=\"MySource\")),\n age_30s: [4, 5, 6],\n all_bucket: [1, 2, 3],\n }\n }\n ).print_stats(\"DS2\")\n\n\ndef test_static_and_geo_data():\n region_chi = Region.from_fips(\"17031\")\n ds = test_helpers.build_default_region_dataset(\n {CommonFields.CASES: [0]}, static={CommonFields.POPULATION: 5}, region=region_chi\n )\n assert ds.static_and_geo_data.loc[region_chi.location_id, CommonFields.COUNTY] == \"Cook County\"\n assert ds.static_and_geo_data.loc[region_chi.location_id, CommonFields.POPULATION] == 5\n\n\ndef test_add_tag_all_bucket():\n region_tx = Region.from_state(\"TX\")\n region_la = Region.from_fips(\"06037\")\n age_40s = DemographicBucket(\"age:40-49\")\n data_tx = {region_tx: {CommonFields.CASES: [10, 20]}}\n data_la = {region_la: {CommonFields.CASES: {DemographicBucket.ALL: [5, 10], age_40s: [1, 2]}}}\n\n tag = test_helpers.make_tag(date=\"2020-04-01\")\n ds = test_helpers.build_dataset({**data_tx, **data_la}).add_tag_all_bucket(tag)\n\n expected_tx = {region_tx: {CommonFields.CASES: TimeseriesLiteral([10, 20], annotation=[tag])}}\n expected_la = {\n region_la: {\n CommonFields.CASES: {\n DemographicBucket.ALL: TimeseriesLiteral([5, 10], annotation=[tag]),\n age_40s: [1, 2],\n }\n }\n }\n ds_expected = test_helpers.build_dataset({**expected_tx, **expected_la})\n test_helpers.assert_dataset_like(ds, ds_expected)\n\n\ndef test_add_tag_without_timeseries(tmpdir):\n \"\"\"Create a dataset with a tag for a timeseries that doesn't exist.\"\"\"\n pointer = _make_dataset_pointer(tmpdir)\n\n region_tx = Region.from_state(\"TX\")\n region_la = Region.from_fips(\"06037\")\n data_tx = {region_tx: {CommonFields.CASES: [10, 20]}}\n\n tag_collection = taglib.TagCollection()\n tag = test_helpers.make_tag(date=\"2020-04-01\")\n tag_collection.add(\n tag,\n location_id=region_la.location_id,\n variable=CommonFields.CASES,\n bucket=DemographicBucket.ALL,\n )\n\n dataset = test_helpers.build_dataset({**data_tx}).append_tag_df(tag_collection.as_dataframe())\n\n # Check that the tag was created for region_la, which doesn't have any timeseries data.\n assert set(\n dataset.tag_objects_series.xs(region_la.location_id, level=CommonFields.LOCATION_ID)\n ) == {tag}\n\n # Check that tag location_id are included in location_ids property.\n assert set(dataset.location_ids) == {region_la.location_id, region_tx.location_id}\n\n # Check that the tag still exists after writing and reading from disk.\n dataset.write_to_dataset_pointer(pointer)\n dataset_read = timeseries.MultiRegionDataset.read_from_pointer(pointer)\n test_helpers.assert_dataset_like(dataset, dataset_read)\n\n\ndef test_variables():\n # Make a dataset with CASES, DEATHS and ICU_BEDS each appearing in only one of timeseries,\n # static and tag data. This make sure variable names are merged from all three places.\n region_97111 = Region.from_fips(\"97111\")\n tag_collection = taglib.TagCollection()\n tag_collection.add(\n test_helpers.make_tag(),\n location_id=region_97111.location_id,\n variable=CommonFields.DEATHS,\n bucket=DemographicBucket.ALL,\n )\n ds = test_helpers.build_dataset(\n {region_97111: {CommonFields.CASES: [1, 2, None]}},\n static_by_region_then_field_name={region_97111: {CommonFields.ICU_BEDS: 10}},\n ).append_tag_df(tag_collection.as_dataframe())\n assert set(ds.variables.to_list()) == {\n CommonFields.CASES,\n CommonFields.ICU_BEDS,\n CommonFields.DEATHS,\n }\n\n\ndef test_variables_empty():\n assert timeseries.MultiRegionDataset.new_without_timeseries().variables.to_list() == []\n\n\ndef test_static_long():\n region_cbsa = Region.from_cbsa_code(\"10100\")\n region_fips = Region.from_fips(\"97111\")\n m1 = FieldName(\"m1\")\n ds = test_helpers.build_dataset(\n {},\n static_by_region_then_field_name={\n region_fips: {CommonFields.CAN_LOCATION_PAGE_URL: \"http://can.do\", m1: 4},\n region_cbsa: {CommonFields.CASES: 3},\n },\n )\n # Use loc[level0].at[level1] as work-around for\n # https://github.com/pandas-dev/pandas/issues/26989\n # TODO(tom): Change to `at[level0, level1]` after upgrading to Pandas >=1.1\n assert (\n ds.static_long.loc[region_fips.location_id].at[CommonFields.CAN_LOCATION_PAGE_URL]\n == \"http://can.do\"\n )\n assert ds.static_long.loc[region_fips.location_id].at[m1] == 4\n assert ds.static_long.loc[region_cbsa.location_id].at[CommonFields.CASES] == 3\n\n ds_empty_static = timeseries.MultiRegionDataset.new_without_timeseries()\n assert ds_empty_static.static_long.empty\n assert ds_empty_static.static_long.name == ds.static_long.name\n assert ds_empty_static.static_long.index.names == ds.static_long.index.names\n\n\ndef test_delta_timeseries_removed():\n # This tests time series being removed only, not tags or static values.\n region_tx = Region.from_state(\"TX\")\n region_la = Region.from_fips(\"06037\")\n age_40s = DemographicBucket(\"age:40-49\")\n data_tx = {region_tx: {CommonFields.CASES: [10, 20]}}\n data_la_a = {region_la: {CommonFields.CASES: {DemographicBucket.ALL: [5, 10], age_40s: [1, 2]}}}\n\n ds_a = test_helpers.build_dataset({**data_tx, **data_la_a})\n\n data_la_b = {region_la: {CommonFields.CASES: {DemographicBucket.ALL: [5, 10]}}}\n ds_b = test_helpers.build_dataset({**data_tx, **data_la_b})\n\n delta = timeseries.MultiRegionDatasetDiff(old=ds_a, new=ds_b)\n ds_out = delta.timeseries_removed\n\n ds_expected = test_helpers.build_dataset({region_la: {CommonFields.CASES: {age_40s: [1, 2]}}})\n\n test_helpers.assert_dataset_like(ds_out, ds_expected)\n\n\ndef test_drop_observations_after():\n age_40s = DemographicBucket(\"age:40-49\")\n ds_in = test_helpers.build_default_region_dataset(\n {\n CommonFields.CASES: {DemographicBucket.ALL: [5, 10], age_40s: [1, 2, 3]},\n # Check that observation is dropped even when not a True value (ie 0).\n CommonFields.DEATHS: [0, 0, 0],\n # Check what happens when there are no real valued observations after dropping,\n # though the behaviour probably doesn't matter.\n CommonFields.ICU_BEDS: [None, None, 10],\n }\n )\n\n ds_out = timeseries.drop_observations(ds_in, after=datetime.date(2020, 4, 2))\n\n tag = test_helpers.make_tag(taglib.TagType.DROP_FUTURE_OBSERVATION, after=\"2020-04-02\")\n ds_expected = test_helpers.build_default_region_dataset(\n {\n CommonFields.CASES: {\n DemographicBucket.ALL: [5, 10],\n age_40s: TimeseriesLiteral([1, 2], annotation=[tag]),\n },\n CommonFields.DEATHS: TimeseriesLiteral([0, 0], annotation=[tag]),\n CommonFields.ICU_BEDS: TimeseriesLiteral([], annotation=[tag]),\n }\n )\n\n test_helpers.assert_dataset_like(ds_out, ds_expected)\n\n\ndef test_pickle_test_dataset_size(tmp_path: pathlib.Path):\n pkl_path = tmp_path / \"testfile.pkl.gz\"\n test_dataset = test_helpers.load_test_dataset()\n test_dataset.get_timeseries_not_bucketed_wide_dates(CommonFields.CASES)\n test_dataset.to_compressed_pickle(pkl_path)\n assert pkl_path.stat().st_size < 800_000\n\n loaded_dataset = timeseries.MultiRegionDataset.from_compressed_pickle(pkl_path)\n\n test_helpers.assert_dataset_like(test_dataset, loaded_dataset)\n"
] | [
[
"pandas.Series",
"pandas.Index",
"pandas.DataFrame",
"pandas.to_datetime",
"pandas.MultiIndex.from_tuples",
"pandas.testing.assert_series_equal",
"pandas.to_timedelta",
"pandas.testing.assert_frame_equal"
]
] |
amanvell/faro | [
"2c4e5b86406937e1dd3fa9f339cfbca2325d98d6"
] | [
"src/faro/FaceWorker.py"
] | [
"'''\nMIT License\n\nCopyright 2019 Oak Ridge National Laboratory\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n\nCreated on Feb 5, 2019\n\n@author: bolme\n'''\n\nimport faro.proto.face_service_pb2 as fsd\nimport faro.proto.geometry_pb2 as geo\nimport faro.proto.proto_types as pt\nimport numpy as np\nimport scipy as sp\nimport scipy.spatial as spat \n\n# Standard scores can be computed by the client which may offer \n# performance benefits. In some cases scores can only be computed \n# on the server.\nSCORE_L1 = \"SCORE_L1\" # L1 Distance / Cityblock\nSCORE_L2 = \"SCORE_L2\" # Euclidean\nSCORE_DOT = \"SCORE_DOT\" # Simple dot product.\nSCORE_SERVER = \"SCORE_SERVER\" # A non-standard, custom, or proprietary score / Requires computation on the server.\n\nSTATUS_READY = \"STATUS_READY\"\n\n\nclass FaceWorker(object):\n '''\n Workers handle requests for one process in a multiprocessing system.\n \n In general the methods will be called in the order: detect, locate, align, \n extract, and score. Not all of these methods need to do something. Some\n deep learning algorithms do not require alignment for example. Also, in \n some cases detection, location, and alignment might all occur together.\n In that case it should be implemented in detect and the other methods will\n do nothing but may still be called to maintain a consistant interface.\n \n Scores are assumed to be distances where smaller indicates a better match.\n '''\n\n\n def __init__(self, options):\n '''\n Constructor\n '''\n \n def detect(self):\n '''Run a face detector and return rectangles.'''\n raise NotImplementedError(\"Abstract Method Called.\")\n \n def locate(self):\n '''Locate facial features.'''\n raise NotImplementedError(\"Abstract Method Called.\")\n \n def align(self):\n '''Align the images to a standard size and orientation to allow \n recognition.'''\n raise NotImplementedError(\"Abstract Method Called.\")\n \n def extract(self):\n '''Extract a template that allows the face to be matched.'''\n raise NotImplementedError(\"Abstract Method Called.\")\n \n def score(self,score_request):\n '''Compare templates to produce scores.'''\n score_type = self.scoreType()\n result = geo.Matrix()\n \n # Check that this is a known score type\n if score_type not in [fsd.L1,fsd.L2,fsd.NEG_DOT]:\n raise NotImplementedError(\"Score type <%s> not implemented.\"%(score_type,))\n \n # Check to make sure the probe and gallery records are correct\n if min(len(score_request.face_probes.face_records),len(score_request.template_probes.templates)) != 0:\n raise ValueError(\"probes argument cannot have both face_probes and template_probes defined.\")\n if max(len(score_request.face_probes.face_records),len(score_request.template_probes.templates)) == 0:\n raise ValueError(\"no probe templates were found in the arguments.\")\n if min(len(score_request.face_gallery.face_records),len(score_request.template_gallery.templates)) != 0:\n raise ValueError(\"gallery argument cannot have both face_gallery and template_gallery defined.\")\n if max(len(score_request.face_gallery.face_records),len(score_request.template_gallery.templates)) == 0:\n raise ValueError(\"no gallery templates were found in the arguments.\")\n \n # Generate probe and gallery matrices\n if len(score_request.face_probes.face_records) > len(score_request.template_probes.templates):\n probe_mat = [pt.vector_proto2np(face_rec.template.data) for face_rec in score_request.face_probes.face_records]\n else:\n probe_mat = [pt.vector_proto2np(template.data) for template in score_request.template_probes.templates]\n probe_mat = np.array(probe_mat,dtype=np.float32)\n \n if len(score_request.face_gallery.face_records) > len(score_request.template_gallery.templates):\n gal_mat = [pt.vector_proto2np(face_rec.template.data) for face_rec in score_request.face_gallery.face_records]\n else:\n gal_mat = [pt.vector_proto2np(template.data) for template in score_request.template_gallery.templates]\n gal_mat = np.array(gal_mat,dtype=np.float32)\n \n # Compute the distance\n if score_type == fsd.L1:\n dist_mat = spat.distance_matrix(probe_mat,gal_mat,1)\n elif score_type == fsd.L2:\n dist_mat = spat.distance_matrix(probe_mat,gal_mat,2)\n elif score_type == fsd.NEG_DOT:\n dist_mat = -np.dot(probe_mat,gal_mat.T)\n else:\n NotImplementedError(\"ScoreType %s is not implemented.\"%(score_type,))\n \n # Return the result\n return pt.matrix_np2proto(dist_mat)\n \n def version(self):\n '''Returns a three item tuple of algorithm name, version number, \n configuration notes. '''\n raise NotImplementedError(\"Abstract Method Called.\")\n \n def scoreType(self):\n '''Return the method used to create a score from the template.\n \n By default server computation is required.\n \n SCORE_L1, SCORE_L2, SCORE_DOT, SCORE_SERVER\n '''\n return fsd.L2\n \n \n def status(self):\n '''Return a simple status message.'''\n print(\"Handeling status request.\")\n status_message = fsd.FaceServiceInfo()\n status_message.status = fsd.READY\n \n return status_message\n \n def recommendedThreshold(self,far=-1.0):\n '''Return the method used to create a score from the template.\n \n By default server computation is required.\n \n Should return a recommended score. If a positive false accept rate is\n provided \n '''\n \n raise NotImplementedError(\"Abstract Method Called.\")\n \n \n def cleanexit(self):\n pass \n"
] | [
[
"numpy.array",
"numpy.dot",
"scipy.spatial.distance_matrix"
]
] |
ishank-arora/venmo-emoji | [
"209f53b4f90b9d8737c609e6cd5f16d0f5cf25d4"
] | [
"topicModellingWhite.py"
] | [
"import csv\nfrom collections import Counter\nimport emoji\nfrom emoji import unicode_codes\nimport pickle\nimport re\nimport pandas\nimport string\nfrom num2words import num2words\nfrom nltk.tokenize import word_tokenize\nfrom nltk.corpus import stopwords\nfrom nltk.stem import PorterStemmer\nfrom nltk.stem import WordNetLemmatizer\nimport gensim\nfrom gensim.utils import simple_preprocess\nfrom gensim.parsing.preprocessing import STOPWORDS\nfrom nltk.stem.porter import *\nimport numpy as np\nnp.random.seed(2018)\nimport nltk\nnltk.download('wordnet')\nimport time\n\n#pd = pandas.read_csv(\"/data/06333/aroraish/rest.csv\", encoding='utf-8')\npd = pandas.read_csv(\"/data/06333/aroraish/flat/flat_light_proc_2.csv\", encoding='utf-8', error_bad_lines=False)\n#pd3 = pandas.read_csv(\"/data/06333/aroraish/modifiableN.csv\", encoding='utf-8', error_bad_lines=False)\n\n\nemojicols = [u\"\\U0001f3fb\", u\"\\U0001f3fc\", u\"\\U0001f3fd\", u\"\\U0001f3fe\", u\"\\U0001f3ff\"]\npattern = u'(' + u'|'.join(re.escape(u) for u in emojicols) + u')'\n\nallCols = re.compile(pattern)\n\nemojiss = unicode_codes.EMOJI_ALIAS_UNICODE\ncoloured = set()\n\nfor key in emojiss:\n if(allCols.findall(emojiss[key])):\n coloured.add(emojiss[key])\n coloured.add(allCols.sub('',emojiss[key]))\n\ncoloured.remove(u\"\")\nemojis = sorted(coloured, key=len,\n reverse=True)\npattern2 = u'(' + u'|'.join(re.escape(u) for u in emojis) + u')'\n\ncolouredRE = re.compile(pattern2)\n\n\nemojis = sorted(emojiss.values(), key=len,\n reverse=True)\npattern3 = u'(' + u'|'.join(re.escape(u) for u in emojis) + u')'\n\nree = re.compile(pattern3)\n\n \ndef pipe(message):\n text = preprocess(message)\n n_all(text)\n \ndef num(token):\n try:\n return num2words(token)\n except:\n return token\n\ndef n_all(message):\n #message = message.decode('utf-8')\n tokens = list()\n sp = message.split()\n for i in sp:\n l = ree.findall(i)\n if(l):\n tokens.extend(l)\n else:\n tokens.append(i)\n return sp\n\n\n\n\nprocessed_docs = pd[u'message'].map(n_all)\ndictionary = gensim.corpora.Dictionary(processed_docs)\n\ndictionary.filter_extremes(no_below=15, no_above=0.5, keep_n=100000)\n\nbow_corpus = [dictionary.doc2bow(doc) for doc in processed_docs]\n\nfrom gensim import corpora, models\ntfidf = models.TfidfModel(bow_corpus)\ncorpus_tfidf = tfidf[bow_corpus]\n\nlda_model = gensim.models.LdaMulticore(bow_corpus, num_topics=50, id2word=dictionary, passes=2, workers=1)\n\npickle.dump(lda_model, open(\"/data/06333/aroraish/models/ldaM_light_3.pkl\", \"w\"))\n\nlda_model_tfidf = gensim.models.LdaMulticore(corpus_tfidf, num_topics=50, id2word=dictionary, passes=2, workers=1)\n\npickle.dump(lda_model, open(\"/data/06333/aroraish/models/ldaMtfidf_light_3.pkl\", \"w\"))\n\nwith open(\"/data/06333/aroraish/outputs/lda_bag_of_words_light_3.txt\", 'w') as bw:\n\n for idx, topic in lda_model.print_topics(-1):\n bw.write('Topic: {} \\nWords: {}\\n\\n'.format(idx, topic.encode('utf-8')))\n\n\nwith open(\"/data/06333/aroraish/outputs/lda_tfidf_light_3.txt\", 'w') as tf:\n\n for idx, topic in lda_model_tfidf.print_topics(-1):\n tf.write('Topic: {} \\nWord: {}\\n\\n'.format(idx, topic.encode('utf-8')))\n\n\n\n"
] | [
[
"pandas.read_csv",
"numpy.random.seed"
]
] |
bjlkeng/sandbox | [
"c95653618b7be5022b0a8e217a4e5667badb2449"
] | [
"notebooks/label_refinery/imagenet_utils.py"
] | [
"\"\"\"Utilities for ImageNet data preprocessing & prediction decoding.\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport json\nimport warnings\nimport numpy as np\n\n# from . import get_keras_submodule\n\n# backend = get_keras_submodule('backend')\n# keras_utils = get_keras_submodule('utils')\nimport keras.backend as backend\nimport keras.utils as keras_utils\n\nCLASS_INDEX = None\nCLASS_INDEX_PATH = ('https://s3.amazonaws.com/deep-learning-models/'\n 'image-models/imagenet_class_index.json')\n\n# Global tensor of imagenet mean for preprocessing symbolic inputs\n_IMAGENET_MEAN = None\n\n\ndef _preprocess_numpy_input(x, data_format, mode):\n \"\"\"Preprocesses a Numpy array encoding a batch of images.\n\n # Arguments\n x: Input array, 3D or 4D.\n data_format: Data format of the image array.\n mode: One of \"caffe\", \"tf\" or \"torch\".\n - caffe: will convert the images from RGB to BGR,\n then will zero-center each color channel with\n respect to the ImageNet dataset,\n without scaling.\n - tf: will scale pixels between -1 and 1,\n sample-wise.\n - torch: will scale pixels between 0 and 1 and then\n will normalize each channel with respect to the\n ImageNet dataset.\n\n # Returns\n Preprocessed Numpy array.\n \"\"\"\n if not issubclass(x.dtype.type, np.floating):\n x = x.astype(backend.floatx(), copy=False)\n\n if mode == 'tf':\n x /= 127.5\n x -= 1.\n return x\n\n if mode == 'torch':\n x /= 255.\n mean = [0.485, 0.456, 0.406]\n std = [0.229, 0.224, 0.225]\n else:\n if data_format == 'channels_first':\n # 'RGB'->'BGR'\n if x.ndim == 3:\n x = x[::-1, ...]\n else:\n x = x[:, ::-1, ...]\n else:\n # 'RGB'->'BGR'\n x = x[..., ::-1]\n mean = [103.939, 116.779, 123.68]\n std = None\n\n # Zero-center by mean pixel\n if data_format == 'channels_first':\n if x.ndim == 3:\n x[0, :, :] -= mean[0]\n x[1, :, :] -= mean[1]\n x[2, :, :] -= mean[2]\n if std is not None:\n x[0, :, :] /= std[0]\n x[1, :, :] /= std[1]\n x[2, :, :] /= std[2]\n else:\n x[:, 0, :, :] -= mean[0]\n x[:, 1, :, :] -= mean[1]\n x[:, 2, :, :] -= mean[2]\n if std is not None:\n x[:, 0, :, :] /= std[0]\n x[:, 1, :, :] /= std[1]\n x[:, 2, :, :] /= std[2]\n else:\n x[..., 0] -= mean[0]\n x[..., 1] -= mean[1]\n x[..., 2] -= mean[2]\n if std is not None:\n x[..., 0] /= std[0]\n x[..., 1] /= std[1]\n x[..., 2] /= std[2]\n return x\n\n\ndef _preprocess_symbolic_input(x, data_format, mode):\n \"\"\"Preprocesses a tensor encoding a batch of images.\n\n # Arguments\n x: Input tensor, 3D or 4D.\n data_format: Data format of the image tensor.\n mode: One of \"caffe\", \"tf\" or \"torch\".\n - caffe: will convert the images from RGB to BGR,\n then will zero-center each color channel with\n respect to the ImageNet dataset,\n without scaling.\n - tf: will scale pixels between -1 and 1,\n sample-wise.\n - torch: will scale pixels between 0 and 1 and then\n will normalize each channel with respect to the\n ImageNet dataset.\n\n # Returns\n Preprocessed tensor.\n \"\"\"\n global _IMAGENET_MEAN\n\n if mode == 'tf':\n x /= 127.5\n x -= 1.\n return x\n\n if mode == 'torch':\n x /= 255.\n mean = [0.485, 0.456, 0.406]\n std = [0.229, 0.224, 0.225]\n else:\n if data_format == 'channels_first':\n # 'RGB'->'BGR'\n if backend.ndim(x) == 3:\n x = x[::-1, ...]\n else:\n x = x[:, ::-1, ...]\n else:\n # 'RGB'->'BGR'\n x = x[..., ::-1]\n mean = [103.939, 116.779, 123.68]\n std = None\n\n if _IMAGENET_MEAN is None:\n _IMAGENET_MEAN = backend.constant(-np.array(mean))\n\n # Zero-center by mean pixel\n if backend.dtype(x) != backend.dtype(_IMAGENET_MEAN):\n x = backend.bias_add(\n x, backend.cast(_IMAGENET_MEAN, backend.dtype(x)),\n data_format=data_format)\n else:\n x = backend.bias_add(x, _IMAGENET_MEAN, data_format)\n if std is not None:\n x /= std\n return x\n\n\ndef preprocess_input(x, data_format=None, mode='caffe'):\n \"\"\"Preprocesses a tensor or Numpy array encoding a batch of images.\n\n # Arguments\n x: Input Numpy or symbolic tensor, 3D or 4D.\n The preprocessed data is written over the input data\n if the data types are compatible. To avoid this\n behaviour, `numpy.copy(x)` can be used.\n data_format: Data format of the image tensor/array.\n mode: One of \"caffe\", \"tf\" or \"torch\".\n - caffe: will convert the images from RGB to BGR,\n then will zero-center each color channel with\n respect to the ImageNet dataset,\n without scaling.\n - tf: will scale pixels between -1 and 1,\n sample-wise.\n - torch: will scale pixels between 0 and 1 and then\n will normalize each channel with respect to the\n ImageNet dataset.\n\n # Returns\n Preprocessed tensor or Numpy array.\n\n # Raises\n ValueError: In case of unknown `data_format` argument.\n \"\"\"\n if data_format is None:\n data_format = backend.image_data_format()\n if data_format not in {'channels_first', 'channels_last'}:\n raise ValueError('Unknown data_format ' + str(data_format))\n\n if isinstance(x, np.ndarray):\n return _preprocess_numpy_input(x, data_format=data_format, mode=mode)\n else:\n return _preprocess_symbolic_input(x, data_format=data_format,\n mode=mode)\n\n\ndef decode_predictions(preds, top=5):\n \"\"\"Decodes the prediction of an ImageNet model.\n\n # Arguments\n preds: Numpy tensor encoding a batch of predictions.\n top: Integer, how many top-guesses to return.\n\n # Returns\n A list of lists of top class prediction tuples\n `(class_name, class_description, score)`.\n One list of tuples per sample in batch input.\n\n # Raises\n ValueError: In case of invalid shape of the `pred` array\n (must be 2D).\n \"\"\"\n global CLASS_INDEX\n if len(preds.shape) != 2 or preds.shape[1] != 1000:\n raise ValueError('`decode_predictions` expects '\n 'a batch of predictions '\n '(i.e. a 2D array of shape (samples, 1000)). '\n 'Found array with shape: ' + str(preds.shape))\n if CLASS_INDEX is None:\n fpath = keras_utils.get_file(\n 'imagenet_class_index.json',\n CLASS_INDEX_PATH,\n cache_subdir='models',\n file_hash='c2c37ea517e94d9795004a39431a14cb')\n with open(fpath) as f:\n CLASS_INDEX = json.load(f)\n results = []\n for pred in preds:\n top_indices = pred.argsort()[-top:][::-1]\n result = [tuple(CLASS_INDEX[str(i)]) + (pred[i],) for i in top_indices]\n result.sort(key=lambda x: x[2], reverse=True)\n results.append(result)\n return results\n\n\ndef _obtain_input_shape(input_shape,\n default_size,\n min_size,\n data_format,\n require_flatten,\n weights=None):\n \"\"\"Internal utility to compute/validate a model's input shape.\n\n # Arguments\n input_shape: Either None (will return the default network input shape),\n or a user-provided shape to be validated.\n default_size: Default input width/height for the model.\n min_size: Minimum input width/height accepted by the model.\n data_format: Image data format to use.\n require_flatten: Whether the model is expected to\n be linked to a classifier via a Flatten layer.\n weights: One of `None` (random initialization)\n or 'imagenet' (pre-training on ImageNet).\n If weights='imagenet' input channels must be equal to 3.\n\n # Returns\n An integer shape tuple (may include None entries).\n\n # Raises\n ValueError: In case of invalid argument values.\n \"\"\"\n if weights != 'imagenet' and input_shape and len(input_shape) == 3:\n if data_format == 'channels_first':\n if input_shape[0] not in {1, 3}:\n warnings.warn(\n 'This model usually expects 1 or 3 input channels. '\n 'However, it was passed an input_shape with ' +\n str(input_shape[0]) + ' input channels.')\n default_shape = (input_shape[0], default_size, default_size)\n else:\n if input_shape[-1] not in {1, 3}:\n warnings.warn(\n 'This model usually expects 1 or 3 input channels. '\n 'However, it was passed an input_shape with ' +\n str(input_shape[-1]) + ' input channels.')\n default_shape = (default_size, default_size, input_shape[-1])\n else:\n if data_format == 'channels_first':\n default_shape = (3, default_size, default_size)\n else:\n default_shape = (default_size, default_size, 3)\n if weights == 'imagenet' and require_flatten:\n if input_shape is not None:\n if input_shape != default_shape:\n raise ValueError('When setting`include_top=True` '\n 'and loading `imagenet` weights, '\n '`input_shape` should be ' +\n str(default_shape) + '.')\n return default_shape\n if input_shape:\n if data_format == 'channels_first':\n if input_shape is not None:\n if len(input_shape) != 3:\n raise ValueError(\n '`input_shape` must be a tuple of three integers.')\n if input_shape[0] != 3 and weights == 'imagenet':\n raise ValueError('The input must have 3 channels; got '\n '`input_shape=' + str(input_shape) + '`')\n if ((input_shape[1] is not None and input_shape[1] < min_size) or\n (input_shape[2] is not None and input_shape[2] < min_size)):\n raise ValueError('Input size must be at least ' +\n str(min_size) + 'x' + str(min_size) +\n '; got `input_shape=' +\n str(input_shape) + '`')\n else:\n if input_shape is not None:\n if len(input_shape) != 3:\n raise ValueError(\n '`input_shape` must be a tuple of three integers.')\n if input_shape[-1] != 3 and weights == 'imagenet':\n raise ValueError('The input must have 3 channels; got '\n '`input_shape=' + str(input_shape) + '`')\n if ((input_shape[0] is not None and input_shape[0] < min_size) or\n (input_shape[1] is not None and input_shape[1] < min_size)):\n raise ValueError('Input size must be at least ' +\n str(min_size) + 'x' + str(min_size) +\n '; got `input_shape=' +\n str(input_shape) + '`')\n else:\n if require_flatten:\n input_shape = default_shape\n else:\n if data_format == 'channels_first':\n input_shape = (3, None, None)\n else:\n input_shape = (None, None, 3)\n if require_flatten:\n if None in input_shape:\n raise ValueError('If `include_top` is True, '\n 'you should specify a static `input_shape`. '\n 'Got `input_shape=' + str(input_shape) + '`')\n return input_shape\n"
] | [
[
"numpy.array"
]
] |
reagames/ipcamstreamer | [
"a0b6782e228659d526c91e12255c9fd62c694471"
] | [
"ipcamstreamer.py"
] | [
"#ip camera openCV streamer for DLink DCS-932L\n\n\n\n\nimport cv2\nimport urllib \nimport numpy as np\nimport sys\n\n#stream=urllib.urlopen('http://admin:[email protected]:8088/mjpeg.cgi?user=admin&password=CmasQp123&channel=0&.mjpg')\n\nstream=urllib.urlopen('http://admin:[email protected]/mjpeg.cgi?user=admin&password=CmasQp123&channel=0&.mjpg')\n\nprint(sys.argv)\n\ncascPath = sys.argv[1]\nfaceCascade = cv2.CascadeClassifier(cascPath)\n\nbytes=''\nwhile True:\n bytes+=stream.read(1024)\n a = bytes.find('\\xff\\xd8')\n b = bytes.find('\\xff\\xd9')\n if a!=-1 and b!=-1:\n jpg = bytes[a:b+2]\n bytes= bytes[b+2:]\n frame = cv2.imdecode(np.fromstring(jpg, dtype=np.uint8),cv2.CV_LOAD_IMAGE_COLOR)\n \n\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n \n faces = faceCascade.detectMultiScale(\n frame,\n scaleFactor=1.1,\n minNeighbors=5,\n minSize=(30, 30),\n flags=cv2.cv.CV_HAAR_SCALE_IMAGE\n )\n \n # Draw a rectangle around the faces\n for (x, y, w, h) in faces:\n cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 255, 0), 2)\n \n cv2.imshow('stream',frame)\n \n if cv2.waitKey(1) ==27:\n exit(0) \n\n\ncv2.destroyAllWindows()\n"
] | [
[
"numpy.fromstring"
]
] |
Thinklab-SJTU/DCL_RetinaNet_Tensorflow | [
"1d14c9800c3eb1975e8832978f7a263783d171ec",
"1d14c9800c3eb1975e8832978f7a263783d171ec"
] | [
"libs/detection_oprations/proposal_opr_csl_tsne.py",
"libs/configs/DOTA1.0/dcl/cfgs_res101_dota_dcl_v1.py"
] | [
"# encoding: utf-8\nfrom libs.configs import cfgs\nfrom libs.box_utils import bbox_transform\nfrom libs.box_utils import nms_rotate\nimport tensorflow as tf\nimport numpy as np\n\nfrom libs.box_utils.coordinate_convert import coordinate_present_convert, coords_regular\n\n\ndef postprocess_detctions(rpn_bbox_pred, rpn_cls_prob, rpn_angle_prob, rpn_angle_logits, anchors, is_training, gpu_id):\n\n return_boxes_pred = []\n return_boxes_pred_angle = []\n return_angle_logits = []\n return_scores = []\n return_labels = []\n for j in range(0, cfgs.CLASS_NUM):\n scores = rpn_cls_prob[:, j]\n if is_training:\n indices = tf.reshape(tf.where(tf.greater(scores, cfgs.VIS_SCORE)), [-1, ])\n else:\n indices = tf.reshape(tf.where(tf.greater(scores, cfgs.FILTERED_SCORE)), [-1, ])\n\n anchors_ = tf.gather(anchors, indices)\n rpn_bbox_pred_ = tf.gather(rpn_bbox_pred, indices)\n scores = tf.gather(scores, indices)\n rpn_angle_prob_ = tf.gather(rpn_angle_prob, indices)\n rpn_angle_logits_ = tf.gather(rpn_angle_logits, indices)\n\n angle_cls = tf.cast(tf.argmax(rpn_angle_prob_, axis=1), tf.float32)\n\n if cfgs.METHOD == 'H':\n x_c = (anchors_[:, 2] + anchors_[:, 0]) / 2\n y_c = (anchors_[:, 3] + anchors_[:, 1]) / 2\n h = anchors_[:, 2] - anchors_[:, 0] + 1\n w = anchors_[:, 3] - anchors_[:, 1] + 1\n theta = -90 * tf.ones_like(x_c)\n anchors_ = tf.transpose(tf.stack([x_c, y_c, w, h, theta]))\n\n if cfgs.ANGLE_RANGE == 180:\n anchors_ = tf.py_func(coordinate_present_convert,\n inp=[anchors_, -1],\n Tout=[tf.float32])\n anchors_ = tf.reshape(anchors_, [-1, 5])\n\n boxes_pred = bbox_transform.rbbox_transform_inv(boxes=anchors_, deltas=rpn_bbox_pred_)\n\n boxes_pred = tf.reshape(boxes_pred, [-1, 5])\n angle_cls = (tf.reshape(angle_cls, [-1, ]) * -1 - 0.5) * cfgs.OMEGA\n\n x, y, w, h, theta = tf.unstack(boxes_pred, axis=1)\n boxes_pred_angle = tf.transpose(tf.stack([x, y, w, h, angle_cls]))\n\n if cfgs.ANGLE_RANGE == 180:\n\n # _, _, _, _, theta = tf.unstack(boxes_pred, axis=1)\n # indx = tf.reshape(tf.where(tf.logical_and(tf.less(theta, 0), tf.greater_equal(theta, -180))), [-1, ])\n # boxes_pred = tf.gather(boxes_pred, indx)\n # scores = tf.gather(scores, indx)\n\n boxes_pred = tf.py_func(coordinate_present_convert,\n inp=[boxes_pred, 1],\n Tout=[tf.float32])\n boxes_pred = tf.reshape(boxes_pred, [-1, 5])\n\n boxes_pred_angle = tf.py_func(coordinate_present_convert,\n inp=[boxes_pred_angle, 1],\n Tout=[tf.float32])\n boxes_pred_angle = tf.reshape(boxes_pred_angle, [-1, 5])\n\n max_output_size = 4000 if 'DOTA' in cfgs.NET_NAME else 200\n nms_indices = nms_rotate.nms_rotate(decode_boxes=boxes_pred_angle,\n scores=scores,\n iou_threshold=cfgs.NMS_IOU_THRESHOLD,\n max_output_size=100 if is_training else max_output_size,\n use_angle_condition=False,\n angle_threshold=15,\n use_gpu=True,\n gpu_id=gpu_id)\n\n tmp_boxes_pred = tf.reshape(tf.gather(boxes_pred, nms_indices), [-1, 5])\n tmp_boxes_pred_angle = tf.reshape(tf.gather(boxes_pred_angle, nms_indices), [-1, 5])\n tmp_scores = tf.reshape(tf.gather(scores, nms_indices), [-1, ])\n tmp_rpn_angle_logits = tf.gather(rpn_angle_logits_, nms_indices)\n\n return_boxes_pred.append(tmp_boxes_pred)\n return_boxes_pred_angle.append(tmp_boxes_pred_angle)\n return_scores.append(tmp_scores)\n return_labels.append(tf.ones_like(tmp_scores)*(j+1))\n return_angle_logits.append(tmp_rpn_angle_logits)\n\n return_boxes_pred = tf.concat(return_boxes_pred, axis=0)\n return_boxes_pred_angle = tf.concat(return_boxes_pred_angle, axis=0)\n return_scores = tf.concat(return_scores, axis=0)\n return_labels = tf.concat(return_labels, axis=0)\n return_angle_logits = tf.concat(return_angle_logits, axis=0)\n\n return return_boxes_pred, return_scores, return_labels, return_boxes_pred_angle, return_angle_logits\n",
"# -*- coding: utf-8 -*-\nfrom __future__ import division, print_function, absolute_import\nimport os\nimport tensorflow as tf\nimport math\n\n\"\"\"\nBCL + OMEGA = 180 / 32. + data aug + ms\nFLOPs: 1321979063; Trainable params: 52136440\n\nThis is your result for task 1:\n\n mAP: 0.7197849386403127\n ap of each class:\n plane:0.888767706661227,\n baseball-diamond:0.828813250009659,\n bridge:0.4680099872101205,\n ground-track-field:0.6901660404277621,\n small-vehicle:0.7395262726408154,\n large-vehicle:0.5667009043812319,\n ship:0.7347841545028257,\n tennis-court:0.9071577005837769,\n basketball-court:0.8229722946512178,\n storage-tank:0.8448119293093586,\n soccer-ball-field:0.6186025857112213,\n roundabout:0.6441106031308795,\n harbor:0.628617739475033,\n swimming-pool:0.7122314212831211,\n helicopter:0.7015014896264388\n\nThe submitted information is :\n\nDescription: RetinaNet_DOTA_DCL_B_3x_20200923_145.8w\n\n\nThis is your result for task 1:\n\n mAP: 0.7301021435398962\n ap of each class:\n plane:0.8770187842801944,\n baseball-diamond:0.8267941412496465,\n bridge:0.5127762497195772,\n ground-track-field:0.7429087472658292,\n small-vehicle:0.7430367724213736,\n large-vehicle:0.5717593529976157,\n ship:0.7535736625119606,\n tennis-court:0.9066598303041958,\n basketball-court:0.8420467411496289,\n storage-tank:0.85672175425764,\n soccer-ball-field:0.6380583684613818,\n roundabout:0.653533415863242,\n harbor:0.6392204165860068,\n swimming-pool:0.7104658633500178,\n helicopter:0.676958052680133\n\nThe submitted information is :\n\nDescription: RetinaNet_DOTA_DCL_B_3x_20200923_ms_145.8w\n\n\"\"\"\n\n# ------------------------------------------------\nVERSION = 'RetinaNet_DOTA_DCL_B_3x_20200923'\nNET_NAME = 'resnet101_v1d' # 'MobilenetV2'\nADD_BOX_IN_TENSORBOARD = True\n\n# ---------------------------------------- System_config\nROOT_PATH = os.path.abspath('../')\nprint(20*\"++--\")\nprint(ROOT_PATH)\nGPU_GROUP = \"0,1,2\"\nNUM_GPU = len(GPU_GROUP.strip().split(','))\nSHOW_TRAIN_INFO_INTE = 20\nSMRY_ITER = 2000\nSAVE_WEIGHTS_INTE = 27000 * 3\n\nSUMMARY_PATH = ROOT_PATH + '/output/summary'\nTEST_SAVE_PATH = ROOT_PATH + '/tools/test_result'\n\nif NET_NAME.startswith(\"resnet\"):\n weights_name = NET_NAME\nelif NET_NAME.startswith(\"MobilenetV2\"):\n weights_name = \"mobilenet/mobilenet_v2_1.0_224\"\nelse:\n raise Exception('net name must in [resnet_v1_101, resnet_v1_50, MobilenetV2]')\n\nPRETRAINED_CKPT = ROOT_PATH + '/data/pretrained_weights/' + weights_name + '.ckpt'\nTRAINED_CKPT = os.path.join(ROOT_PATH, 'output/trained_weights')\nEVALUATE_DIR = ROOT_PATH + '/output/evaluate_result_pickle/'\n\n# ------------------------------------------ Train config\nRESTORE_FROM_RPN = False\nFIXED_BLOCKS = 1 # allow 0~3\nFREEZE_BLOCKS = [True, False, False, False, False] # for gluoncv backbone\nUSE_07_METRIC = True\n\nMUTILPY_BIAS_GRADIENT = 2.0 # if None, will not multipy\nGRADIENT_CLIPPING_BY_NORM = 10.0 # if None, will not clip\n\nCLS_WEIGHT = 1.0\nREG_WEIGHT = 1.0\nANGLE_WEIGHT = 0.5\nREG_LOSS_MODE = None\nALPHA = 1.0\nBETA = 1.0\n\nBATCH_SIZE = 1\nEPSILON = 1e-5\nMOMENTUM = 0.9\nLR = 5e-4\nDECAY_STEP = [SAVE_WEIGHTS_INTE*12, SAVE_WEIGHTS_INTE*16, SAVE_WEIGHTS_INTE*20]\nMAX_ITERATION = SAVE_WEIGHTS_INTE*20\nWARM_SETP = int(1.0 / 4.0 * SAVE_WEIGHTS_INTE)\n\n# -------------------------------------------- Data_preprocess_config\nDATASET_NAME = 'DOTA' # 'pascal', 'coco'\nPIXEL_MEAN = [123.68, 116.779, 103.939] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR\nPIXEL_MEAN_ = [0.485, 0.456, 0.406]\nPIXEL_STD = [0.229, 0.224, 0.225] # R, G, B. In tf, channel is RGB. In openCV, channel is BGR\nIMG_SHORT_SIDE_LEN = [800, 400, 600, 1000, 1200]\nIMG_MAX_LENGTH = 1200\nCLASS_NUM = 15\nOMEGA = 180 / 32.\nANGLE_MODE = 0\n\nIMG_ROTATE = True\nRGB2GRAY = True\nVERTICAL_FLIP = True\nHORIZONTAL_FLIP = True\nIMAGE_PYRAMID = True\n\n# --------------------------------------------- Network_config\nSUBNETS_WEIGHTS_INITIALIZER = tf.random_normal_initializer(mean=0.0, stddev=0.01, seed=None)\nSUBNETS_BIAS_INITIALIZER = tf.constant_initializer(value=0.0)\nPROBABILITY = 0.01\nFINAL_CONV_BIAS_INITIALIZER = tf.constant_initializer(value=-math.log((1.0 - PROBABILITY) / PROBABILITY))\nWEIGHT_DECAY = 1e-4\nUSE_GN = False\nFPN_CHANNEL = 256\n\n# ---------------------------------------------Anchor config\nLEVEL = ['P3', 'P4', 'P5', 'P6', 'P7']\nBASE_ANCHOR_SIZE_LIST = [32, 64, 128, 256, 512]\nANCHOR_STRIDE = [8, 16, 32, 64, 128]\nANCHOR_SCALES = [2 ** 0, 2 ** (1.0 / 3.0), 2 ** (2.0 / 3.0)]\nANCHOR_RATIOS = [1, 1 / 2, 2., 1 / 3., 3., 5., 1 / 5.]\nANCHOR_ANGLES = [-90, -75, -60, -45, -30, -15]\nANCHOR_SCALE_FACTORS = None\nUSE_CENTER_OFFSET = True\nMETHOD = 'H'\nUSE_ANGLE_COND = False\nANGLE_RANGE = 180 # 90 or 180\n\n# --------------------------------------------RPN config\nSHARE_NET = True\nUSE_P5 = True\nIOU_POSITIVE_THRESHOLD = 0.5\nIOU_NEGATIVE_THRESHOLD = 0.4\n\nNMS = True\nNMS_IOU_THRESHOLD = 0.1\nMAXIMUM_DETECTIONS = 100\nFILTERED_SCORE = 0.05\nVIS_SCORE = 0.4\n\n\n"
] | [
[
"tensorflow.stack",
"tensorflow.reshape",
"tensorflow.unstack",
"tensorflow.ones_like",
"tensorflow.greater",
"tensorflow.argmax",
"tensorflow.concat",
"tensorflow.gather",
"tensorflow.py_func"
],
[
"tensorflow.random_normal_initializer",
"tensorflow.constant_initializer"
]
] |
mikofski/sktime | [
"87bdf36dbc0990f29942eb6f7fa56a8e6c5fa7b7"
] | [
"sktime/forecasting/base/adapters/_pmdarima.py"
] | [
"# -*- coding: utf-8 -*-\n# !/usr/bin/env python3 -u\n# copyright: sktime developers, BSD-3-Clause License (see LICENSE file)\n\"\"\"Implements adapter for pmdarima forecasters to be used in sktime framework.\"\"\"\n\n__author__ = [\"mloning\", \"hyang1996\", \"kejsitake\", \"fkiraly\"]\n__all__ = [\"_PmdArimaAdapter\"]\n\nimport pandas as pd\n\nfrom sktime.forecasting.base import BaseForecaster\nfrom sktime.forecasting.base._base import DEFAULT_ALPHA\n\n\nclass _PmdArimaAdapter(BaseForecaster):\n \"\"\"Base class for interfacing pmdarima.\"\"\"\n\n _tags = {\n \"ignores-exogeneous-X\": False,\n \"capability:pred_int\": True,\n \"requires-fh-in-fit\": False,\n \"handles-missing-data\": False,\n }\n\n def __init__(self):\n self._forecaster = None\n super(_PmdArimaAdapter, self).__init__()\n\n def _instantiate_model(self):\n raise NotImplementedError(\"abstract method\")\n\n def _fit(self, y, X=None, fh=None, **fit_params):\n \"\"\"Fit to training data.\n\n Parameters\n ----------\n y : pd.Series\n Target time series to which to fit the forecaster.\n fh : int, list, np.array or ForecastingHorizon, optional (default=None)\n The forecasters horizon with the steps ahead to to predict.\n X : pd.DataFrame, optional (default=None)\n Exogenous variables are ignored\n\n Returns\n -------\n self : returns an instance of self.\n \"\"\"\n self._forecaster = self._instantiate_model()\n self._forecaster.fit(y, X=X, **fit_params)\n return self\n\n def _predict(self, fh, X=None):\n \"\"\"Make forecasts.\n\n Parameters\n ----------\n fh : array-like\n The forecasters horizon with the steps ahead to to predict.\n Default is\n one-step ahead forecast, i.e. np.array([1]).\n\n Returns\n -------\n y_pred : pandas.Series\n Returns series of predicted values.\n \"\"\"\n # distinguish between in-sample and out-of-sample prediction\n fh_oos = fh.to_out_of_sample(self.cutoff)\n fh_ins = fh.to_in_sample(self.cutoff)\n\n # all values are out-of-sample\n if fh.is_all_out_of_sample(self.cutoff):\n return self._predict_fixed_cutoff(fh_oos, X=X)\n\n # all values are in-sample\n elif fh.is_all_in_sample(self.cutoff):\n return self._predict_in_sample(fh_ins, X=X)\n\n # both in-sample and out-of-sample values\n else:\n y_ins = self._predict_in_sample(fh_ins, X=X)\n y_oos = self._predict_fixed_cutoff(fh_oos, X=X)\n return y_ins.append(y_oos)\n\n def _predict_in_sample(\n self, fh, X=None, return_pred_int=False, alpha=DEFAULT_ALPHA\n ):\n \"\"\"Generate in sample predictions.\n\n Parameters\n ----------\n fh : array-like\n The forecasters horizon with the steps ahead to to predict.\n Default is\n one-step ahead forecast, i.e. np.array([1]).\n\n Returns\n -------\n y_pred : pandas.Series\n Returns series of predicted values.\n \"\"\"\n if hasattr(self, \"order\"):\n diff_order = self.order[1]\n else:\n diff_order = self._forecaster.model_.order[1]\n\n # Initialize return objects\n fh_abs = fh.to_absolute(self.cutoff).to_numpy()\n fh_idx = fh.to_indexer(self.cutoff, from_cutoff=False)\n y_pred = pd.Series(index=fh_abs)\n\n # for in-sample predictions, pmdarima requires zero-based integer indicies\n start, end = fh.to_absolute_int(self._y.index[0], self.cutoff)[[0, -1]]\n if start < 0:\n # Can't forecasts earlier to train starting point\n raise ValueError(\"Can't make predictions earlier to train starting point\")\n elif start < diff_order:\n # Can't forecasts earlier to arima's differencing order\n # But we return NaN for these supposedly forecastable points\n start = diff_order\n if end < start:\n # since we might have forced `start` to surpass `end`\n end = diff_order\n # get rid of unforcastable points\n fh_abs = fh_abs[fh_idx >= diff_order]\n # reindex accordingly\n fh_idx = fh_idx[fh_idx >= diff_order] - diff_order\n\n result = self._forecaster.predict_in_sample(\n start=start,\n end=end,\n X=X,\n return_conf_int=False,\n alpha=DEFAULT_ALPHA,\n )\n\n if return_pred_int:\n pred_ints = []\n for a in alpha:\n pred_int = pd.DataFrame(index=fh_abs, columns=[\"lower\", \"upper\"])\n result = self._forecaster.predict_in_sample(\n start=start,\n end=end,\n X=X,\n return_conf_int=return_pred_int,\n alpha=a,\n )\n pred_int.loc[fh_abs] = result[1][fh_idx, :]\n pred_ints.append(pred_int)\n # unpack results\n y_pred.loc[fh_abs] = result[0][fh_idx]\n return y_pred, pred_ints\n else:\n y_pred.loc[fh_abs] = result[fh_idx]\n return y_pred\n\n def _predict_fixed_cutoff(\n self, fh, X=None, return_pred_int=False, alpha=DEFAULT_ALPHA\n ):\n \"\"\"Make predictions out of sample.\n\n Parameters\n ----------\n fh : array-like\n The forecasters horizon with the steps ahead to to predict.\n Default is\n one-step ahead forecast, i.e. np.array([1]).\n\n Returns\n -------\n y_pred : pandas.Series\n Returns series of predicted values.\n \"\"\"\n n_periods = int(fh.to_relative(self.cutoff)[-1])\n result = self._forecaster.predict(\n n_periods=n_periods,\n X=X,\n return_conf_int=False,\n alpha=DEFAULT_ALPHA,\n )\n\n fh_abs = fh.to_absolute(self.cutoff)\n fh_idx = fh.to_indexer(self.cutoff)\n if return_pred_int:\n pred_ints = []\n for a in alpha:\n result = self._forecaster.predict(\n n_periods=n_periods,\n X=X,\n return_conf_int=True,\n alpha=a,\n )\n pred_int = result[1]\n pred_int = pd.DataFrame(\n pred_int[fh_idx, :], index=fh_abs, columns=[\"lower\", \"upper\"]\n )\n pred_ints.append(pred_int)\n return result[0], pred_ints\n else:\n return pd.Series(result[fh_idx], index=fh_abs)\n\n def _predict_interval(self, fh, X=None, coverage=0.90):\n \"\"\"Compute/return prediction quantiles for a forecast.\n\n private _predict_interval containing the core logic,\n called from predict_interval and possibly predict_quantiles\n\n State required:\n Requires state to be \"fitted\".\n\n Accesses in self:\n Fitted model attributes ending in \"_\"\n self.cutoff\n\n Parameters\n ----------\n fh : int, list, np.array or ForecastingHorizon\n Forecasting horizon, default = y.index (in-sample forecast)\n X : pd.DataFrame, optional (default=None)\n Exogenous time series\n coverage : list of float (guaranteed not None and floats in [0,1] interval)\n nominal coverage(s) of predictive interval(s)\n\n Returns\n -------\n pred_int : pd.DataFrame\n Column has multi-index: first level is variable name from y in fit,\n second level coverage fractions for which intervals were computed.\n in the same order as in input `coverage`.\n Third level is string \"lower\" or \"upper\", for lower/upper interval end.\n Row index is fh. Entries are forecasts of lower/upper interval end,\n for var in col index, at nominal coverage in second col index,\n lower/upper depending on third col index, for the row index.\n Upper/lower interval end forecasts are equivalent to\n quantile forecasts at alpha = 0.5 - c/2, 0.5 + c/2 for c in coverage.\n \"\"\"\n # initializaing cutoff and fh related info\n cutoff = self.cutoff\n fh_oos = fh.to_out_of_sample(cutoff)\n fh_ins = fh.to_in_sample(cutoff)\n fh_is_in_sample = fh.is_all_in_sample(cutoff)\n fh_is_oosample = fh.is_all_out_of_sample(cutoff)\n\n # prepare the return DataFrame - empty with correct cols\n var_names = [\"Coverage\"]\n int_idx = pd.MultiIndex.from_product([var_names, coverage, [\"lower\", \"upper\"]])\n pred_int = pd.DataFrame(columns=int_idx)\n\n kwargs = {\"X\": X, \"return_pred_int\": True, \"alpha\": coverage}\n # all values are out-of-sample\n if fh_is_oosample:\n _, y_pred_int = self._predict_fixed_cutoff(fh_oos, **kwargs)\n\n # all values are in-sample\n elif fh_is_in_sample:\n _, y_pred_int = self._predict_in_sample(fh_ins, **kwargs)\n\n # if all in-sample/out-of-sample, we put y_pred_int in the required format\n if fh_is_in_sample or fh_is_oosample:\n # needs to be replaced, also seems duplicative, identical to part A\n for intervals, a in zip(y_pred_int, coverage):\n pred_int[(\"Coverage\", a, \"lower\")] = intervals[\"lower\"]\n pred_int[(\"Coverage\", a, \"upper\")] = intervals[\"upper\"]\n return pred_int\n\n # both in-sample and out-of-sample values (we reach this line only then)\n # in this case, we additionally need to concat in and out-of-sample returns\n _, y_ins_pred_int = self._predict_in_sample(fh_ins, **kwargs)\n _, y_oos_pred_int = self._predict_fixed_cutoff(fh_oos, **kwargs)\n for ins_int, oos_int, a in zip(y_ins_pred_int, y_oos_pred_int, coverage):\n pred_int[(\"Coverage\", a, \"lower\")] = ins_int.append(oos_int)[\"lower\"]\n pred_int[(\"Coverage\", a, \"upper\")] = ins_int.append(oos_int)[\"upper\"]\n\n return pred_int\n\n def get_fitted_params(self):\n \"\"\"Get fitted parameters.\n\n Returns\n -------\n fitted_params : dict\n \"\"\"\n self.check_is_fitted()\n names = self._get_fitted_param_names()\n params = self._get_fitted_params()\n fitted_params = {name: param for name, param in zip(names, params)}\n\n if hasattr(self._forecaster, \"model_\"): # AutoARIMA\n fitted_params[\"order\"] = self._forecaster.model_.order\n fitted_params[\"seasonal_order\"] = self._forecaster.model_.seasonal_order\n res = self._forecaster.model_.arima_res_\n elif hasattr(self._forecaster, \"arima_res_\"): # ARIMA\n res = self._forecaster.arima_res_\n else:\n res = None\n\n for name in [\"aic\", \"aicc\", \"bic\", \"hqic\"]:\n fitted_params[name] = getattr(res, name, None)\n\n return fitted_params\n\n def _get_fitted_params(self):\n # Return parameter values under `arima_res_`\n if hasattr(self._forecaster, \"model_\"): # AutoARIMA\n return self._forecaster.model_.arima_res_._results.params\n elif hasattr(self._forecaster, \"arima_res_\"): # ARIMA\n return self._forecaster.arima_res_._results.params\n else:\n raise NotImplementedError()\n\n def _get_fitted_param_names(self):\n # Return parameter names under `arima_res_`\n if hasattr(self._forecaster, \"model_\"): # AutoARIMA\n return self._forecaster.model_.arima_res_._results.param_names\n elif hasattr(self._forecaster, \"arima_res_\"): # ARIMA\n return self._forecaster.arima_res_._results.param_names\n else:\n raise NotImplementedError()\n\n def summary(self):\n \"\"\"Summary of the fitted model.\"\"\"\n return self._forecaster.summary()\n"
] | [
[
"pandas.MultiIndex.from_product",
"pandas.Series",
"pandas.DataFrame"
]
] |
nalderto/otter-grader | [
"a4714bf48df07b7eb8b3c41530ce7a778fd42c98"
] | [
"test/test_grade.py"
] | [
"#################################\n##### Tests for otter grade #####\n#################################\n\nimport os\nimport unittest\nimport subprocess\nimport json\nimport re\nimport pandas as pd\n\nfrom unittest import mock\nfrom subprocess import PIPE\nfrom glob import glob\n\nfrom otter.argparser import get_parser\nfrom otter.grade import main as grade\nfrom otter.grade.metadata import GradescopeParser, CanvasParser, JSONParser, YAMLParser\n\nfrom . import TestCase\n\nparser = get_parser()\n\nTEST_FILES_PATH = \"test/test-grade/\"\n\nclass TestGrade(TestCase):\n \n @classmethod\n def setUpClass(cls):\n super().setUpClass()\n \n create_image_cmd = [\"make\", \"docker-test\"]\n subprocess.run(create_image_cmd, check=True)\n # create_image = subprocess.run(create_image_cmd, check=True)\n # assert not create_image.stderr, create_image.stderr.decode(\"utf-8\")\n \n def setUp(self):\n \"\"\"\n Load in point values\n \"\"\"\n self.test_points = {}\n for test_file in glob(TEST_FILES_PATH + \"tests/*.py\"):\n env = {}\n with open(test_file) as f:\n exec(f.read(), env)\n self.test_points[env['test']['name']] = env['test']['points']\n return super().setUp()\n\n\n def test_docker(self):\n \"\"\"\n Check that we have the right container installed and that docker is running\n \"\"\"\n # use docker image inspect to see that the image is installed and tagged as otter-grader\n inspect = subprocess.run([\"docker\", \"image\", \"inspect\", \"otter-test\"], stdout=PIPE, stderr=PIPE)\n\n # assert that it didn't fail, it will fail if it is not installed\n self.assertEqual(len(inspect.stderr), 0, inspect.stderr.decode(\"utf-8\"))\n\n\n def test_metadata_parsers(self):\n \"\"\"\n Check that metadata parsers work correctly\n \"\"\"\n correct_metadata = [\n {\n \"identifier\": \"12345\",\n \"filename\": \"12345_empty_file.ipynb\"\n }, {\n \"identifier\": \"23456\",\n \"filename\": \"23456_empty_file.ipynb\"\n }, {\n \"identifier\": \"34567\",\n \"filename\": \"34567_empty_file.ipynb\"\n }, {\n \"identifier\": \"45678\",\n \"filename\": \"45678_empty_file.ipynb\"\n }, {\n \"identifier\": \"56789\",\n \"filename\": \"56789_empty_file.ipynb\"\n }\n ]\n\n correct_file_to_id = {\n \"12345_empty_file.ipynb\": \"12345\",\n \"23456_empty_file.ipynb\": \"23456\",\n \"34567_empty_file.ipynb\": \"34567\",\n \"45678_empty_file.ipynb\": \"45678\",\n \"56789_empty_file.ipynb\": \"56789\",\n }\n\n correct_id_to_file = {\n \"12345\": \"12345_empty_file.ipynb\",\n \"23456\": \"23456_empty_file.ipynb\",\n \"34567\": \"34567_empty_file.ipynb\",\n \"45678\": \"45678_empty_file.ipynb\",\n \"56789\": \"56789_empty_file.ipynb\",\n }\n\n correct_filenames = [\n \"12345_empty_file.ipynb\",\n \"23456_empty_file.ipynb\",\n \"34567_empty_file.ipynb\",\n \"45678_empty_file.ipynb\",\n \"56789_empty_file.ipynb\",\n ]\n\n correct_identifiers = [\n \"12345\",\n \"23456\",\n \"34567\",\n \"45678\",\n \"56789\",\n ]\n\n try:\n # gradescope parser\n gs_parser = GradescopeParser(TEST_FILES_PATH + \"gradescope-export\")\n self.assertCountEqual(gs_parser.get_metadata(), correct_metadata)\n self.assertCountEqual(gs_parser.get_filenames(), correct_filenames)\n self.assertCountEqual(gs_parser.get_identifiers(), correct_identifiers)\n for file, identifier in zip(correct_file_to_id, correct_id_to_file):\n self.assertEqual(correct_file_to_id[file], gs_parser.file_to_id(file))\n self.assertEqual(correct_id_to_file[identifier], gs_parser.id_to_file(identifier))\n\n # canvas parser\n canvas_parser = CanvasParser(TEST_FILES_PATH + \"canvas-export\")\n self.assertCountEqual(canvas_parser.get_metadata(), correct_metadata)\n self.assertCountEqual(canvas_parser.get_filenames(), correct_filenames)\n self.assertCountEqual(canvas_parser.get_identifiers(), correct_identifiers)\n for file, identifier in zip(correct_file_to_id, correct_id_to_file):\n self.assertEqual(correct_file_to_id[file], canvas_parser.file_to_id(file))\n self.assertEqual(correct_id_to_file[identifier], canvas_parser.id_to_file(identifier))\n\n # JSON parser\n json_parser = JSONParser(TEST_FILES_PATH + \"meta.json\")\n self.assertCountEqual(json_parser.get_metadata(), correct_metadata)\n self.assertCountEqual(json_parser.get_filenames(), correct_filenames)\n self.assertCountEqual(json_parser.get_identifiers(), correct_identifiers)\n for file, identifier in zip(correct_file_to_id, correct_id_to_file):\n self.assertEqual(correct_file_to_id[file], json_parser.file_to_id(file))\n self.assertEqual(correct_id_to_file[identifier], json_parser.id_to_file(identifier))\n\n # YAML parser\n yaml_parser = YAMLParser(TEST_FILES_PATH + \"meta.yml\")\n self.assertCountEqual(yaml_parser.get_metadata(), correct_metadata)\n self.assertCountEqual(yaml_parser.get_filenames(), correct_filenames)\n self.assertCountEqual(yaml_parser.get_identifiers(), correct_identifiers)\n for file, identifier in zip(correct_file_to_id, correct_id_to_file):\n self.assertEqual(correct_file_to_id[file], yaml_parser.file_to_id(file))\n self.assertEqual(correct_id_to_file[identifier], yaml_parser.id_to_file(identifier))\n\n # cleanup\n gs_rm = subprocess.run([\"rm\", \"-rf\"] + glob(TEST_FILES_PATH + \"gradescope-export/*.ipynb\"), stdout=PIPE, stderr=PIPE)\n self.assertEqual(len(gs_rm.stderr), 0, gs_rm.stderr.decode(\"utf-8\"))\n\n except:\n # cleanup\n gs_rm = subprocess.run([\"rm\", \"-rf\"] + glob(TEST_FILES_PATH + \"gradescope-export/*.ipynb\"), stdout=PIPE, stderr=PIPE)\n self.assertEqual(len(gs_rm.stderr), 0, gs_rm.stderr.decode(\"utf-8\"))\n raise\n\n\n def test_notebooks(self):\n \"\"\"\n Check that the example of 100 notebooks runs correctely locally.\n \"\"\"\n # grade the 100 notebooks\n grade_command = [\"grade\",\n # NO METADATA PASSED, test case when no metadata provided\n # \"-y\", TEST_FILES_PATH + \"notebooks/meta.yml\", \n \"-p\", TEST_FILES_PATH + \"notebooks/\", \n \"-t\", TEST_FILES_PATH + \"tests/\", \n \"-r\", TEST_FILES_PATH + \"requirements.txt\",\n \"-o\", \"test/\",\n \"--image\", \"otter-test\",\n \"-v\"\n ]\n args = parser.parse_args(grade_command)\n args.func = grade\n args.func(args)\n\n # read the output and expected output\n df_test = pd.read_csv(\"test/final_grades.csv\")\n self.assertTrue(\"identifier\" not in df_test.columns, \"did not drop identifier column when no metadata passed\")\n\n # sort by filename\n df_test = df_test.sort_values(\"file\").reset_index(drop=True)\n df_test[\"failures\"] = df_test[\"file\"].apply(lambda x: [int(n) for n in re.split(r\"\\D+\", x) if len(n) > 0])\n\n # check point values\n for _, row in df_test.iterrows():\n for test in self.test_points:\n if int(re.sub(r\"\\D\", \"\", test)) in row[\"failures\"]:\n self.assertEqual(row[test], 0, \"{} supposed to fail {} but passed\".format(row[\"file\"], test))\n else:\n self.assertEqual(row[test], self.test_points[test], \"{} supposed to pass {} but failed\".format(row[\"file\"], test))\n\n # df_correct = pd.read_csv(TEST_FILES_PATH + \"final_grades_correct_notebooks.csv\").sort_values(\"identifier\").reset_index(drop=True)\n\n # # assert the dataframes are as expected\n # self.assertTrue(df_test.equals(df_correct), \"Dataframes not equal\")\n\n # remove the extra output\n cleanup_command = [\"rm\", \"test/final_grades.csv\"]\n cleanup = subprocess.run(cleanup_command, stdout=PIPE, stderr=PIPE)\n\n # assert cleanup worked\n self.assertEqual(len(cleanup.stderr), 0, \"Error in cleanup\")\n\n\n def test_notebooks_with_pdfs(self):\n \"\"\"\n Check that the example of 100 notebooks runs correctely locally.\n \"\"\"\n # grade the 100 notebooks\n grade_command = [\"grade\",\n \"-y\", TEST_FILES_PATH + \"notebooks/meta.yml\", \n \"-p\", TEST_FILES_PATH + \"notebooks/\", \n \"-t\", TEST_FILES_PATH + \"tests/\", \n \"-r\", TEST_FILES_PATH + \"requirements.txt\",\n \"-o\", \"test/\",\n \"--pdfs\",\n \"--containers\", \"5\",\n \"--image\", \"otter-test\"\n ]\n args = parser.parse_args(grade_command)\n args.func = grade\n args.func(args)\n\n # check that we have PDFs\n self.assertTrue(os.path.isdir(\"test/submission_pdfs\"))\n for file in glob(TEST_FILES_PATH + \"notebooks/*.ipynb\"):\n pdf = \"test/submission_pdfs/\" + os.path.split(file)[1][:-5] + \"pdf\"\n self.assertTrue(os.path.isfile(pdf))\n\n # remove the extra output\n cleanup_command = [\"rm\", \"-rf\", \"test/final_grades.csv\", \"test/submission_pdfs\"]\n cleanup = subprocess.run(cleanup_command, stdout=PIPE, stderr=PIPE)\n self.assertEqual(len(cleanup.stderr), 0, cleanup.stderr.decode(\"utf-8\"))\n\n\n def test_scripts(self):\n \"\"\"\n Check that the example of 100 scripts runs correctely locally.\n \"\"\"\n grade_command = [\"grade\",\n \"-sy\", TEST_FILES_PATH + \"scripts/meta.yml\", \n \"-p\", TEST_FILES_PATH + \"scripts/\", \n \"-t\", TEST_FILES_PATH + \"tests/\", \n \"-r\", TEST_FILES_PATH + \"requirements.txt\",\n \"-o\", \"test/\",\n \"--image\", \"otter-test\"\n ]\n args = parser.parse_args(grade_command)\n args.func = grade\n args.func(args)\n\n # read the output and expected output\n df_test = pd.read_csv(\"test/final_grades.csv\").sort_values(\"identifier\").reset_index(drop=True)\n df_test[\"failures\"] = df_test[\"identifier\"].apply(lambda x: [int(n) for n in re.split(r\"\\D+\", x) if len(n) > 0])\n\n # check point values\n for _, row in df_test.iterrows():\n for test in self.test_points:\n if int(re.sub(r\"\\D\", \"\", test)) in row[\"failures\"]:\n self.assertEqual(row[test], 0, \"{} supposed to fail {} but passed\".format(row[\"identifier\"], test))\n else:\n self.assertEqual(row[test], self.test_points[test], \"{} supposed to pass {} but failed\".format(row[\"identifier\"], test))\n \n # grade the 100 scripts\n \n # args = parser.parse_args(grade_command)\n # args.func = grade\n # args.func(args)\n\n # # read the output and expected output\n # df_test = pd.read_csv(\"test/final_grades.csv\").sort_values(\"identifier\").reset_index(drop=True)\n # df_correct = pd.read_csv(TEST_FILES_PATH + \"final_grades_correct_script.csv\").sort_values(\"identifier\").reset_index(drop=True)\n\n # # assert the dataframes are as expected\n # self.assertTrue(df_test.equals(df_correct), \"Dataframes not equal\")\n\n # remove the extra output\n cleanup_command = [\"rm\", \"test/final_grades.csv\"]\n cleanup = subprocess.run(cleanup_command, stdout=PIPE, stderr=PIPE)\n\n # assert cleanup worked\n self.assertEqual(len(cleanup.stderr), 0, \"Error in cleanup\")\n"
] | [
[
"pandas.read_csv"
]
] |
cjhsieh/pecos | [
"6d5a657945f0a70f13dcf3afec224713cd2deb4d"
] | [
"pecos/core/base.py"
] | [
"# Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\"). You may not use this file except in compliance\n# with the License. A copy of the License is located at\n#\n# http://aws.amazon.com/apache2.0/\n#\n# or in the \"license\" file accompanying this file. This file is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES\n# OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions\n# and limitations under the License.\nimport copy\nimport ctypes\nimport logging\nimport os\nfrom ctypes import (\n CDLL,\n CFUNCTYPE,\n POINTER,\n byref,\n c_bool,\n c_char_p,\n c_double,\n c_float,\n c_int,\n c_int32,\n c_uint32,\n c_uint64,\n c_void_p,\n cast,\n)\nfrom glob import glob\nfrom subprocess import check_output\n\nimport numpy as np\nimport pecos\nimport scipy.sparse as smat\nfrom pecos.utils import smat_util\n\nLOGGER = logging.getLogger(\"__name__\")\n\nXLINEAR_SOLVERS = {\"L2R_L2LOSS_SVC_DUAL\": 1, \"L2R_L1LOSS_SVC_DUAL\": 3, \"L2R_LR_DUAL\": 7}\nXLINEAR_INFERENCE_MODEL_TYPES = {\"CSC\": 0, \"HASH_CHUNKED\": 1, \"BINARY_SEARCH_CHUNKED\": 2}\nTFIDF_TOKENIZER_CODES = {\"word\": 10, \"char\": 20, \"char_wb\": 30}\n\n\nclass TfidfBaseVectorizerParam(ctypes.Structure):\n \"\"\"\n python class for handling struct TfidfBaseVectorizerParam in tfidf.hpp\n \"\"\"\n\n _fields_ = [\n (\"min_ngram\", c_int32),\n (\"max_ngram\", c_int32),\n (\"max_length\", c_int32),\n (\"max_feature\", c_int32),\n (\"min_df_ratio\", c_float),\n (\"max_df_ratio\", c_float),\n (\"min_df_cnt\", c_int32),\n (\"max_df_cnt\", c_int32),\n (\"binary\", c_bool),\n (\"use_idf\", c_bool),\n (\"smooth_idf\", c_bool),\n (\"sublinear_tf\", c_bool),\n (\"keep_frequent_feature\", c_bool),\n (\"norm_p\", c_int32),\n (\"tok_type\", c_int32),\n ]\n\n DEFAULTS = {\n \"min_ngram\": 1,\n \"max_ngram\": 1,\n \"max_length\": -1,\n \"max_feature\": 0,\n \"min_df_ratio\": 0.0,\n \"max_df_ratio\": 1.0,\n \"min_df_cnt\": 0,\n \"max_df_cnt\": -1,\n \"binary\": False,\n \"use_idf\": True,\n \"smooth_idf\": True,\n \"sublinear_tf\": False,\n \"keep_frequent_feature\": True,\n \"norm_p\": 2,\n \"tok_type\": TFIDF_TOKENIZER_CODES[\"word\"],\n }\n\n @classmethod\n def get_default(cls, name):\n return copy.deepcopy(cls.DEFAULTS[name])\n\n def __init__(self, config_dict=None):\n if config_dict is None:\n config_dict = {}\n\n def extract_dict_key(config_dict, key, alias):\n return config_dict.get(key, config_dict.get(alias, self.get_default(key)))\n\n config_dict[\"norm_p\"] = extract_dict_key(config_dict, \"norm_p\", \"norm\")\n # to support norm_p being \"l1\" or \"l2\"\n if isinstance(config_dict[\"norm_p\"], str):\n config_dict[\"norm_p\"] = int(config_dict[\"norm_p\"][1:])\n if not (config_dict[\"norm_p\"] == 1 or config_dict[\"norm_p\"] == 2):\n raise NotImplementedError(\"norm_p only support 1 or 2\")\n\n config_dict[\"tok_type\"] = extract_dict_key(config_dict, \"tok_type\", \"analyzer\")\n if isinstance(config_dict[\"tok_type\"], str):\n config_dict[\"tok_type\"] = TFIDF_TOKENIZER_CODES[config_dict[\"tok_type\"]]\n\n config_dict[\"max_length\"] = extract_dict_key(config_dict, \"max_length\", \"truncate_length\")\n\n if \"ngram_range\" in config_dict:\n config_dict[\"min_ngram\"] = config_dict[\"ngram_range\"][0]\n config_dict[\"max_ngram\"] = config_dict[\"ngram_range\"][1]\n\n name2type = dict(TfidfBaseVectorizerParam._fields_)\n for name in name2type:\n setattr(self, name, name2type[name](config_dict.get(name, self.get_default(name))))\n\n\nclass TfidfVectorizerParam(ctypes.Structure):\n \"\"\"\n python class for handling struct TfidfVectorizerParam in tfidf.hpp\n \"\"\"\n\n _fields_ = [\n (\"base_param_ptr\", POINTER(TfidfBaseVectorizerParam)),\n (\"num_base_vect\", c_int32),\n (\"norm_p\", c_int32),\n ]\n\n def __init__(self, base_vect_param_list, norm_p):\n\n self.num_base_vect = len(base_vect_param_list)\n self.c_base_params = (TfidfBaseVectorizerParam * self.num_base_vect)()\n for i, base_vect_param in enumerate(base_vect_param_list):\n self.c_base_params[i] = base_vect_param\n\n self.base_param_ptr = cast(self.c_base_params, POINTER(TfidfBaseVectorizerParam))\n self.num_base_vect = c_int32(self.num_base_vect)\n self.norm_p = c_int32(norm_p)\n\n\nclass ScipyCscF32(ctypes.Structure):\n \"\"\"\n PyMatrix for scipy.sparse.csc_matrix\n \"\"\"\n\n _fields_ = [\n (\"rows\", c_uint32),\n (\"cols\", c_uint32),\n (\"col_ptr\", POINTER(c_uint64)),\n (\"row_idx\", POINTER(c_uint32)),\n (\"val\", POINTER(c_float)),\n ]\n\n def __init__(self, A):\n assert isinstance(A, smat.csc_matrix)\n assert A.dtype == np.float32\n self.py_buf = {\n \"col_ptr\": A.indptr.astype(np.uint64, copy=False),\n \"row_idx\": A.indices.astype(np.uint32, copy=False),\n \"val\": A.data.astype(np.float32, copy=False),\n }\n\n self.rows = c_uint32(A.shape[0])\n self.cols = c_uint32(A.shape[1])\n name2type = dict(ScipyCscF32._fields_)\n for name in self.py_buf:\n setattr(self, name, self.py_buf[name].ctypes.data_as(name2type[name]))\n self.buf = A\n\n @property\n def dtype(self):\n return self.buf.dtype\n\n @property\n def shape(self):\n return self.buf.shape\n\n @classmethod\n def init_from(cls, A):\n if A is None:\n return None\n elif isinstance(A, cls):\n return A\n else:\n return cls(A)\n\n\nclass ScipyCsrF32(ctypes.Structure):\n \"\"\"\n PyMatrix for scipy.sparse.csr_matrix\n \"\"\"\n\n _fields_ = [\n (\"rows\", c_uint32),\n (\"cols\", c_uint32),\n (\"row_ptr\", POINTER(c_uint64)),\n (\"col_idx\", POINTER(c_uint32)),\n (\"val\", POINTER(c_float)),\n ]\n\n def __init__(self, A):\n assert isinstance(A, smat.csr_matrix)\n assert A.dtype == np.float32\n self.py_buf = {\n \"row_ptr\": A.indptr.astype(np.uint64, copy=False),\n \"col_idx\": A.indices.astype(np.uint32, copy=False),\n \"val\": A.data.astype(np.float32, copy=False),\n }\n\n self.rows = c_uint32(A.shape[0])\n self.cols = c_uint32(A.shape[1])\n name2type = dict(ScipyCsrF32._fields_)\n for name in self.py_buf:\n setattr(self, name, self.py_buf[name].ctypes.data_as(name2type[name]))\n self.buf = A\n\n @classmethod\n def init_from(cls, A):\n if A is None:\n return None\n elif isinstance(A, cls):\n return A\n else:\n return cls(A)\n\n @property\n def dtype(self):\n return self.buf.dtype\n\n @property\n def shape(self):\n return self.buf.shape\n\n def dot(self, other):\n return self.buf.dot(other)\n\n\nclass ScipyDrmF32(ctypes.Structure):\n \"\"\"\n PyMatrix for row-major scipy.ndarray\n \"\"\"\n\n _fields_ = [(\"rows\", c_uint32), (\"cols\", c_uint32), (\"val\", POINTER(c_float))]\n\n def __init__(self, A):\n assert isinstance(A, np.ndarray)\n assert A.dtype == np.float32\n assert A.flags.c_contiguous is True\n self.py_buf = {\"val\": A}\n\n self.rows = c_uint32(A.shape[0])\n self.cols = c_uint32(A.shape[1])\n name2type = dict(ScipyDrmF32._fields_)\n for name in self.py_buf:\n setattr(self, name, self.py_buf[name].ctypes.data_as(name2type[name]))\n self.buf = A\n\n @classmethod\n def init_from(cls, A):\n if A is None:\n return None\n elif isinstance(A, cls):\n return A\n else:\n return cls(A)\n\n @property\n def dtype(self):\n return self.buf.dtype\n\n @property\n def shape(self):\n return self.buf.shape\n\n def dot(self, other):\n if isinstance(other, smat.spmatrix):\n return other.T.dot(self.buf.T).T\n else:\n return self.buf.dot(other)\n\n\nclass ScipyDcmF32(ctypes.Structure):\n \"\"\"\n PyMatrix for col-major scipy.ndarray\n \"\"\"\n\n _fields_ = [(\"rows\", c_uint32), (\"cols\", c_uint32), (\"val\", POINTER(c_float))]\n\n def __init__(self, A):\n assert isinstance(A, np.ndarray)\n assert A.dtype == np.float32\n assert A.flags.f_contiguous is True\n self.py_buf = {\"val\": A}\n\n self.rows = c_uint32(A.shape[0])\n self.cols = c_uint32(A.shape[1])\n name2type = dict(ScipyDcmF32._fields_)\n for name in self.py_buf:\n setattr(self, name, self.py_buf[name].ctypes.data_as(name2type[name]))\n self.buf = A\n\n @classmethod\n def init_from(cls, A):\n if A is None:\n return None\n elif isinstance(A, cls):\n return A\n else:\n return cls(A)\n\n @property\n def dtype(self):\n return self.buf.dtype\n\n @property\n def shape(self):\n return self.buf.shape\n\n def dot(self, other):\n if isinstance(other, smat.spmatrix):\n return other.T.dot(self.buf.T).T\n else:\n return self.buf.dot(other)\n\n\nclass ScipyCoordinateSparseAllocator(object):\n \"\"\"\n Scipy Coordinate Sparse Matrix Allocator for C++/C code\n \"\"\"\n\n CFUNCTYPE = CFUNCTYPE(None, c_uint32, c_uint32, c_uint64, c_void_p, c_void_p, c_void_p)\n\n def __init__(self, rows=0, cols=0, dtype=np.float64):\n self.rows = rows\n self.cols = cols\n self.row_idx = None\n self.col_idx = None\n self.data = None\n self.dtype = dtype\n assert dtype == np.float32 or dtype == np.float64\n\n def __call__(self, rows, cols, nnz, row_ptr, col_ptr, val_ptr):\n self.rows = rows\n self.cols = cols\n self.row_idx = np.zeros(nnz, dtype=np.uint64)\n self.col_idx = np.zeros(nnz, dtype=np.uint64)\n self.data = np.zeros(nnz, dtype=self.dtype)\n cast(row_ptr, POINTER(c_uint64)).contents.value = self.row_idx.ctypes.data_as(\n c_void_p\n ).value\n cast(col_ptr, POINTER(c_uint64)).contents.value = self.col_idx.ctypes.data_as(\n c_void_p\n ).value\n cast(val_ptr, POINTER(c_uint64)).contents.value = self.data.ctypes.data_as(c_void_p).value\n\n def tocoo(self):\n return smat.coo_matrix(\n (self.data, (self.row_idx, self.col_idx)), shape=(self.rows, self.cols)\n )\n\n def tocsr(self):\n return smat.csr_matrix(\n (self.data, (self.row_idx, self.col_idx)), shape=(self.rows, self.cols)\n )\n\n def tocsc(self):\n return smat.csc_matrix(\n (self.data, (self.row_idx, self.col_idx)), shape=(self.rows, self.cols)\n )\n\n @property\n def cfunc(self):\n return self.CFUNCTYPE(self)\n\n\nclass ScipyCompressedSparseAllocator(object):\n \"\"\"\n Scipy Compressed Sparse Matrix Allocator for C++/C code,\n which supports both smat.csr_matrix and smat.csc_matrix.\n\n Whether it is row or column major is controlled by self.is_col_major,\n which is passed in by the first argument in the __call__().\n\n Attributes:\n CFUNCTYPE (ctypes.CFUNCTYPE): a function prototype creates functions that uses the standard C calling convention\n \"\"\"\n\n CFUNCTYPE = CFUNCTYPE(None, c_bool, c_uint64, c_uint64, c_uint64, c_void_p, c_void_p, c_void_p)\n\n def __init__(self, rows=0, cols=0, dtype=np.float32):\n self.cols = cols\n self.rows = rows\n self.indices = None\n self.indptr = None\n self.data = None\n self.dtype = dtype\n self.is_col_major = None\n assert dtype == np.float32\n\n def __call__(self, is_col_major, rows, cols, nnz, indices_ptr, indptr_ptr, data_ptr):\n \"\"\"\n Allocate memory for the members\n\n Parameters:\n is_col_major (bool): specifying whether the to-be allocated matrix is row-majored or col-majored.\n rows (int): the number of rows of the sparse matrix.\n cols (int): the number of cols of the sparse matrix.\n nnz (int): the number of non-zeros of the sparse matrix.\n indptr_ptr (pointer): the pointer to the nnz array, of length (rows+1) or (cols+1).\n indices_ptr (pointer): the pointer to the row/col indices array, of length nnz.\n data_ptr (pointer): the pointer to the non-zero values array, of length nnz.\n\n Returns:\n None\n \"\"\"\n\n self.cols = cols\n self.rows = rows\n self.is_col_major = is_col_major\n if is_col_major:\n self.indptr = np.zeros(cols + 1, dtype=np.uint64)\n else:\n self.indptr = np.zeros(rows + 1, dtype=np.uint64)\n self.indices = np.zeros(nnz, dtype=np.uint32)\n self.data = np.zeros(nnz, dtype=self.dtype)\n\n cast(indices_ptr, POINTER(c_uint64)).contents.value = self.indices.ctypes.data_as(\n c_void_p\n ).value\n cast(indptr_ptr, POINTER(c_uint64)).contents.value = self.indptr.ctypes.data_as(\n c_void_p\n ).value\n cast(data_ptr, POINTER(c_uint64)).contents.value = self.data.ctypes.data_as(c_void_p).value\n\n def get(self):\n if self.is_col_major:\n return smat_util.csc_matrix(\n (self.data, self.indices, self.indptr), shape=(self.rows, self.cols)\n )\n else:\n return smat_util.csr_matrix(\n (self.data, self.indices, self.indptr), shape=(self.rows, self.cols)\n )\n\n @property\n def cfunc(self):\n return self.CFUNCTYPE(self)\n\n\nclass corelib(object):\n \"\"\"\n The core functions for linear problems\n \"\"\"\n\n @staticmethod\n def fillprototype(f, restype, argtypes):\n \"\"\"\n Specify corelib function's return type and argument types.\n\n Args:\n restype (single or list of ctypes): The return type.\n argtypes (list of ctypes): The argument types.\n \"\"\"\n f.restype = restype\n f.argtypes = argtypes\n\n @staticmethod\n def load_dynamic_library(dirname, soname, forced_rebuild=False):\n \"\"\"\n Load compiled C library into Python.\n If not found, will build upon loading.\n\n Args:\n dirname (str): The directory of C library.\n soname (str): The name of C library.\n force_rebuild (bool, optional): Whether to force rebuild C library upon calling.\n\n Return:\n c_lib (CDLL): Ctypes CDLL library.\n \"\"\"\n try:\n if forced_rebuild:\n check_output(\"make -C {} clean lib\".format(dirname), shell=True)\n path_to_so = glob(os.path.join(dirname, soname) + \"*.so\")[0]\n _c_lib = CDLL(path_to_so)\n except BaseException:\n try:\n check_output(\"make -C {} clean lib\".format(dirname), shell=True)\n path_to_so = glob(os.path.join(dirname, soname) + \"*.so\")[0]\n _c_lib = CDLL(path_to_so)\n except BaseException:\n raise Exception(\"{soname} library cannot be found and built.\".format(soname=soname))\n return _c_lib\n\n def __init__(self, dirname, soname, forced_rebuild=False):\n self.clib_float32 = corelib.load_dynamic_library(\n dirname, soname + \"_float32\", forced_rebuild=forced_rebuild\n )\n self.link_xlinear_methods()\n self.link_sparse_operations()\n self.link_clustering()\n self.link_tfidf_vectorizer()\n\n def link_xlinear_methods(self):\n \"\"\"\n Specify C-lib's Xlinear methods argument and return type.\n \"\"\"\n arg_list = [\n POINTER(ScipyCsrF32), # CSR X\n POINTER(ScipyCscF32), # CSC Y\n POINTER(ScipyCscF32), # CSC C\n POINTER(ScipyCscF32), # CSC M\n POINTER(ScipyCscF32), # CSC R\n ScipyCoordinateSparseAllocator.CFUNCTYPE, # py_coo_allocator\n c_double, # threshold\n c_uint32, # max_nonzeros_per_label\n c_int, # solver_type\n c_double, # Cp\n c_double, # Cn\n c_uint64, # max_iter\n c_double, # eps\n c_double, # bias\n c_int, # threads\n ]\n corelib.fillprototype(\n self.clib_float32.c_xlinear_single_layer_train_csr_f32,\n None,\n [POINTER(ScipyCsrF32)] + arg_list[1:],\n )\n corelib.fillprototype(\n self.clib_float32.c_xlinear_single_layer_train_drm_f32,\n None,\n [POINTER(ScipyDrmF32)] + arg_list[1:],\n )\n\n arg_list = [c_void_p]\n corelib.fillprototype(self.clib_float32.c_xlinear_destruct_model, None, arg_list)\n\n # Interface for sparse prediction\n arg_list = [\n c_void_p,\n POINTER(ScipyCsrF32),\n c_uint32,\n c_char_p,\n c_uint32,\n c_int,\n ScipyCompressedSparseAllocator.CFUNCTYPE,\n ]\n corelib.fillprototype(self.clib_float32.c_xlinear_predict_csr_f32, None, arg_list)\n\n # Interface for dense prediction\n arg_list = [\n c_void_p,\n POINTER(ScipyDrmF32),\n c_uint32,\n c_char_p,\n c_uint32,\n c_int,\n ScipyCompressedSparseAllocator.CFUNCTYPE,\n ]\n corelib.fillprototype(self.clib_float32.c_xlinear_predict_drm_f32, None, arg_list)\n\n # c interface for loading just model tree directly (no tfidf)\n res_list = c_void_p\n arg_list = [c_char_p]\n corelib.fillprototype(self.clib_float32.c_xlinear_load_model_from_disk, res_list, arg_list)\n\n res_list = c_void_p\n arg_list = [c_char_p, c_int]\n corelib.fillprototype(\n self.clib_float32.c_xlinear_load_model_from_disk_ext, res_list, arg_list\n )\n\n # c interface for per-layer prediction\n arg_list = [\n POINTER(ScipyCsrF32),\n POINTER(ScipyCsrF32),\n POINTER(ScipyCscF32),\n POINTER(ScipyCscF32),\n c_char_p,\n c_uint32,\n c_int,\n c_float,\n ScipyCompressedSparseAllocator.CFUNCTYPE,\n ]\n corelib.fillprototype(\n self.clib_float32.c_xlinear_single_layer_predict_csr_f32, None, arg_list\n )\n\n arg_list = [\n POINTER(ScipyDrmF32),\n POINTER(ScipyCsrF32),\n POINTER(ScipyCscF32),\n POINTER(ScipyCscF32),\n c_char_p,\n c_uint32,\n c_int,\n c_float,\n ScipyCompressedSparseAllocator.CFUNCTYPE,\n ]\n corelib.fillprototype(\n self.clib_float32.c_xlinear_single_layer_predict_drm_f32, None, arg_list\n )\n\n res_list = c_uint32\n arg_list = [c_void_p, c_char_p]\n corelib.fillprototype(self.clib_float32.c_xlinear_get_int_attr, res_list, arg_list)\n\n def xlinear_load_predict_only(\n self,\n folder,\n weight_matrix_type=\"BINARY_SEARCH_CHUNKED\",\n ):\n \"\"\"\n Load xlinear model in predict only mode.\n\n Args:\n folder (str): The folder path for xlinear model.\n weight_matrix_type (str, optional): The xlinear inference model types.\n\n Return:\n cmodel (ptr): The pointer to xlinear model.\n \"\"\"\n weight_matrix_type_id = XLINEAR_INFERENCE_MODEL_TYPES[weight_matrix_type]\n cmodel = self.clib_float32.c_xlinear_load_model_from_disk_ext(\n c_char_p(folder.encode(\"utf-8\")), c_int(int(weight_matrix_type_id))\n )\n return cmodel\n\n def xlinear_destruct_model(self, c_model):\n \"\"\"\n Destruct xlinear model.\n\n Args:\n cmodel (ptr): The pointer to xlinear model.\n \"\"\"\n self.clib_float32.c_xlinear_destruct_model(c_model)\n\n def xlinear_predict(\n self,\n c_model,\n X,\n overriden_beam_size,\n overriden_post_processor_str,\n overriden_only_topk,\n threads,\n pred_alloc,\n ):\n \"\"\"\n Performs a full prediction using the given model and queries.\n\n Args:\n c_model (c_pointer): A C pointer to the model to use for prediction. This pointer\n is returned by the c_load_xlinear_model_from_disk and\n c_load_xlinear_model_from_disk_ext functions in corelib.clib_float32.\n X: The query matrix (admissible formats are smat.csr_matrix,\n np.ndarray, ScipyCsrF32, or ScipyDrmF32). Note that if this is smat.csr_matrix,\n the matrix must have sorted indices. You can call sort_indices() to ensure this.\n overriden_beam_size (uint): Overrides the beam size to use for prediction. Use None for\n model defaults.\n overriden_post_processor_str (string): Overrides the post processor to use by name. Use\n None for model defaults.\n overriden_only_topk (uint): Overrides the number of results to return for each query. Use\n None for model defaults.\n threads (int): Sets the number of threads to use in computation. Use\n -1 to use the maximum amount of available threads.\n pred_alloc (ScipyCompressedSparseAllocator): The allocator to store the result in.\n \"\"\"\n clib = self.clib_float32\n\n if isinstance(X, smat.csr_matrix):\n if not X.has_sorted_indices:\n raise ValueError(\"Query matrix does not have sorted indices!\")\n X = ScipyCsrF32.init_from(X)\n elif isinstance(X, np.ndarray):\n X = ScipyDrmF32.init_from(X)\n\n if isinstance(X, ScipyCsrF32):\n c_predict = clib.c_xlinear_predict_csr_f32\n elif isinstance(X, ScipyDrmF32):\n c_predict = clib.c_xlinear_predict_drm_f32\n else:\n raise NotImplementedError(\"type(X) = {} not implemented\".format(type(X)))\n\n c_predict(\n c_model,\n byref(X),\n overriden_beam_size if overriden_beam_size else 0,\n overriden_post_processor_str.encode(\"utf-8\") if overriden_post_processor_str else None,\n overriden_only_topk if overriden_only_topk else 0,\n threads,\n pred_alloc.cfunc,\n )\n\n def xlinear_single_layer_predict(\n self,\n X,\n csr_codes,\n W,\n C,\n post_processor_str,\n only_topk,\n num_threads,\n bias,\n pred_alloc,\n ):\n \"\"\"\n Performs a single layer prediction in C++ using matrices owned by Python.\n\n Args:\n X (csr_matrix): The query matrix.\n Note that if this is smat.csr_matrix, the matrix must have sorted indices.\n You can call sort_indices() to ensure this.\n csr_codes (smat.csr_matrix or ScipyCsrF32): The prediction for the previous layer, None if this is the first layer.\n W (smat.csc_matrix, ScipyCscF32): The weight matrix for this layer.\n C (smat.csc_matrix, ScipyCscF32): The child/parent map for this layer.\n post_processor_str (str): A string specifying which post processor to use.\n only_topk (uint): How many results to return for each query.\n num_threads (uint): How many threads to use in this computation. Set to -1 to use defaults.\n bias (float): The bias of the model.\n pred_alloc (ScipyCompressedSparseAllocator): The allocator to store the result in.\n \"\"\"\n clib = self.clib_float32\n\n post_processor_str = post_processor_str.encode(\"utf-8\")\n\n W = ScipyCscF32.init_from(W)\n\n if isinstance(X, smat.csr_matrix):\n if not X.has_sorted_indices:\n raise ValueError(\"Query matrix does not have sorted indices!\")\n X = ScipyCsrF32.init_from(X)\n elif isinstance(X, np.ndarray):\n X = ScipyDrmF32.init_from(X)\n\n if isinstance(X, ScipyCsrF32):\n c_single_layer_predict = clib.c_xlinear_single_layer_predict_csr_f32\n elif isinstance(X, ScipyDrmF32):\n c_single_layer_predict = clib.c_xlinear_single_layer_predict_drm_f32\n else:\n raise NotImplementedError(\"type(X) = {} not implemented\".format(type(X)))\n\n # csr_codes and pC might be null\n if csr_codes is not None:\n csr_codes = ScipyCsrF32.init_from(csr_codes)\n\n if C is None:\n C = smat.csc_matrix(np.ones((W.shape[1], 1), dtype=W.dtype))\n C = ScipyCscF32.init_from(C)\n\n c_single_layer_predict(\n byref(X),\n byref(csr_codes) if csr_codes is not None else None,\n byref(W),\n byref(C),\n post_processor_str,\n only_topk,\n num_threads,\n bias,\n pred_alloc.cfunc,\n )\n\n def xlinear_single_layer_train(\n self,\n pX,\n pY,\n pC,\n pM,\n pR,\n threshold=0.1,\n max_nonzeros_per_label=None,\n solver_type=\"L2R_L2LOSS_SVC_DUAL\",\n Cp=1.0,\n Cn=1.0,\n max_iter=1000,\n eps=0.1,\n bias=1.0,\n threads=-1,\n verbose=0,\n **kwargs,\n ):\n \"\"\"\n Performs a single layer training in C++ using matrices owned by Python.\n\n Args:\n pX (ScipyCsrF32 or ScipyDrmF32): Instance feature matrix of shape (nr_inst, nr_feat).\n pY (ScipyCscF32): Label matrix of shape (nr_inst, nr_labels).\n pC (ScipyCscF32): Single matrix from clustering chain, representing a hierarchical clustering.\n pM (ScipyCsrF32): Single matrix from matching chain.\n pR (ScipyCscF32): Relevance matrix for cost-sensitive learning, of shape (nr_inst, nr_labels).\n threshold (float, optional): sparsify the final model by eliminating all entrees with abs value less than threshold.\n Default to 0.1.\n max_nonzeros_per_label (int, optional): keep at most NONZEROS weight parameters per label in model.\n Default None to set to (nr_feat + 1)\n solver_type (string, optional): backend linear solver type.\n Options: L2R_L2LOSS_SVC_DUAL(default), L2R_L1LOSS_SVC_DUAL.\n Cp (float, optional): positive penalty parameter. Defaults to 1.0\n Cn (float, optional): negative penalty parameter. Defaults to 1.0\n max_iter (int, optional): maximum iterations. Defaults to 100\n eps (float, optional): epsilon. Defaults to 0.1\n bias (float, optional): if >0, append the bias value to each instance feature. Defaults to 1.0\n threads (int, optional): the number of threads to use for training. Defaults to -1 to use all\n verbose (int, optional): verbose level. Defaults to 0\n\n Return:\n layer_train_res (smat.csc_matrix): The layer training result.\n \"\"\"\n clib = self.clib_float32\n coo_alloc = ScipyCoordinateSparseAllocator(dtype=np.float32)\n if isinstance(pX, ScipyCsrF32):\n c_xlinear_single_layer_train = clib.c_xlinear_single_layer_train_csr_f32\n elif isinstance(pX, ScipyDrmF32):\n c_xlinear_single_layer_train = clib.c_xlinear_single_layer_train_drm_f32\n else:\n raise NotImplementedError(\"type(pX) = {} not implemented\".format(type(pX)))\n\n c_xlinear_single_layer_train(\n byref(pX),\n byref(pY),\n byref(pC) if pC is not None else None,\n byref(pM) if pM is not None else None,\n byref(pR) if pR is not None else None,\n coo_alloc.cfunc,\n threshold,\n 0 if max_nonzeros_per_label is None else max_nonzeros_per_label,\n XLINEAR_SOLVERS[solver_type],\n Cp,\n Cn,\n max_iter,\n eps,\n bias,\n threads,\n )\n return coo_alloc.tocsc().astype(np.float32)\n\n def xlinear_get_int_attr(self, c_model, attr):\n \"\"\"\n Get int attribute from C xlinear model.\n\n Args:\n c_model (ptr): The C xlinear model pointer.\n attr (str): The attribute name to get.\n\n Return:\n int_attr (int): The int attribute under given name.\n \"\"\"\n assert attr in {\n \"depth\",\n \"nr_features\",\n \"nr_labels\",\n \"nr_codes\",\n }, f\"attr {attr} not implemented\"\n return self.clib_float32.c_xlinear_get_int_attr(c_model, c_char_p(attr.encode(\"utf-8\")))\n\n def link_sparse_operations(self):\n \"\"\"\n Specify C-lib's sparse matrix operation methods argument and return type.\n \"\"\"\n arg_list = [\n POINTER(ScipyCscF32), # pX (should support both CSC and CSR)\n POINTER(ScipyCscF32), # pY (should support both CSC and CSR)\n ScipyCompressedSparseAllocator.CFUNCTYPE, # allocator for pZ\n c_bool, # eliminate_zeros\n c_bool, # sorted_indices\n c_int, # threads\n ]\n corelib.fillprototype(\n self.clib_float32.c_sparse_matmul_csc_f32,\n None,\n [POINTER(ScipyCscF32), POINTER(ScipyCscF32)] + arg_list[2:],\n )\n corelib.fillprototype(\n self.clib_float32.c_sparse_matmul_csr_f32,\n None,\n [POINTER(ScipyCsrF32), POINTER(ScipyCsrF32)] + arg_list[2:],\n )\n\n arg_list = [\n POINTER(ScipyCsrF32), # pX\n POINTER(ScipyCscF32), # pW\n c_uint64, # len\n POINTER(c_uint32), # X_row_idx\n POINTER(c_uint32), # W_col_idx\n POINTER(c_float), # val\n c_int, # threads\n ]\n corelib.fillprototype(\n self.clib_float32.c_sparse_inner_products_csr_f32,\n None,\n [POINTER(ScipyCsrF32)] + arg_list[1:],\n )\n corelib.fillprototype(\n self.clib_float32.c_sparse_inner_products_drm_f32,\n None,\n [POINTER(ScipyDrmF32)] + arg_list[1:],\n )\n\n def sparse_matmul(self, X, Y, eliminate_zeros=False, sorted_indices=True, threads=-1):\n \"\"\"\n Sparse-Sparse matrix multiplication with multithreading (shared-memory).\n\n Args:\n X (smat.csc_matrix, smat.csr_matrix, ScipyCscF32, ScipyCsrF32): The first sparse matrix.\n Y (smat.csc_matrix, smat.csr_matrix, ScipyCscF32, ScipyCsrF32): The second sparse matrix.\n eliminate_zeros (bool, optional): if true, then eliminate (potential) zeros created by maxnnz in output matrix Z. Default is false.\n sorted_indices (bool, optional): if true, then sort the Z.indices for the output matrix Z. Default is true.\n threads (int, optional): The number of threads. Default -1 to use all cores.\n\n Return:\n matmul_res (smat.csc_matrix or smat.csr_matrix): The matrix multiplication results of X and Y\n \"\"\"\n\n if X.shape[1] != Y.shape[0]:\n raise ValueError(\"X.shape[1]={} != Y.shape[0]={}\".format(X.shape[1], Y.shape[0]))\n\n clib = self.clib_float32\n pred_alloc = ScipyCompressedSparseAllocator()\n\n def is_col_major(X):\n return isinstance(X, smat.csc_matrix) or isinstance(X, ScipyCscF32)\n\n def is_row_major(X):\n return isinstance(X, smat.csr_matrix) or isinstance(X, ScipyCsrF32)\n\n if is_col_major(X) and is_col_major(Y):\n pX = ScipyCscF32.init_from(X)\n pY = ScipyCscF32.init_from(Y)\n clib.c_sparse_matmul_csc_f32(\n pX, pY, pred_alloc.cfunc, eliminate_zeros, sorted_indices, threads\n )\n elif is_row_major(X) and is_row_major(Y):\n pX = ScipyCsrF32.init_from(X)\n pY = ScipyCsrF32.init_from(Y)\n clib.c_sparse_matmul_csr_f32(\n pX, pY, pred_alloc.cfunc, eliminate_zeros, sorted_indices, threads\n )\n elif is_col_major(X) and is_row_major(Y):\n if X.nnz > Y.nnz:\n Y = Y.tocsc()\n pX = ScipyCscF32.init_from(X)\n pY = ScipyCscF32.init_from(Y)\n clib.c_sparse_matmul_csc_f32(\n pX, pY, pred_alloc.cfunc, eliminate_zeros, sorted_indices, threads\n )\n else:\n X = X.tocsr()\n pX = ScipyCsrF32.init_from(X)\n pY = ScipyCsrF32.init_from(Y)\n clib.c_sparse_matmul_csr_f32(\n pX, pY, pred_alloc.cfunc, eliminate_zeros, sorted_indices, threads\n )\n elif is_row_major(X) and is_col_major(Y):\n if X.nnz > Y.nnz:\n Y = Y.tocsr()\n pX = ScipyCsrF32.init_from(X)\n pY = ScipyCsrF32.init_from(Y)\n clib.c_sparse_matmul_csr_f32(\n pX, pY, pred_alloc.cfunc, eliminate_zeros, sorted_indices, threads\n )\n else:\n X = X.tocsc()\n pX = ScipyCscF32.init_from(X)\n pY = ScipyCscF32.init_from(Y)\n clib.c_sparse_matmul_csc_f32(\n pX, pY, pred_alloc.cfunc, eliminate_zeros, sorted_indices, threads\n )\n else:\n raise ValueError(\n \"X and Y should be either csr_matrix/csc_matrix/ScipyCscF32/ScipyCsrF32 !\"\n )\n\n return pred_alloc.get()\n\n def sparse_inner_products(self, pX, pW, X_row_idx, W_col_idx, pred_values=None, threads=-1):\n \"\"\"\n Sparse-Sparse matrix batch inner product with multithreading (shared-memory).\n Do inner product for rows from `pX` indicated by `X_row_idx`, and columns from `pW` indicated by `W_col_idx`.\n Results will be written in `pred_values` if provided; Otherwise, create a new array for results.\n\n Args:\n pX (ScipyCsrF32, ScipyDrmF32): The first sparse matrix.\n pW (ScipyCscF32, ScipyDcmF32): The second sparse matrix.\n X_row_idx (ndarray): Row indexes for `pX`.\n W_col_idx (ndarray): Column indexes for `pW`.\n pred_values (ndarray, optional): The inner product result array.\n threads (int, optional): The number of threads. Default -1 to use all cores.\n\n Return:\n pred_values (ndarray): The matrix batch inner product results.\n If `pred_values` not given, return a new allocated ndarray, dtype same as `pW`.\n \"\"\"\n clib = self.clib_float32\n\n nnz = len(X_row_idx)\n assert nnz == len(W_col_idx)\n\n if not isinstance(pW, ScipyCscF32):\n raise NotImplementedError(\"type(pW) = {} no implemented\".format(type(pW)))\n\n if isinstance(pX, ScipyCsrF32):\n c_sparse_inner_products = clib.c_sparse_inner_products_csr_f32\n elif isinstance(pX, ScipyDrmF32):\n c_sparse_inner_products = clib.c_sparse_inner_products_drm_f32\n else:\n raise NotImplementedError(\"type(pX) = {} no implemented\".format(type(pX)))\n\n if pred_values is None or len(pred_values) != nnz or pred_values.dtype != np.float32:\n pred_values = np.zeros(nnz, pW.dtype)\n\n c_sparse_inner_products(\n byref(pX),\n byref(pW),\n nnz,\n X_row_idx.ctypes.data_as(POINTER(c_uint32)),\n W_col_idx.ctypes.data_as(POINTER(c_uint32)),\n pred_values.ctypes.data_as(POINTER(c_float)),\n threads,\n )\n return pred_values\n\n def link_clustering(self):\n \"\"\"\n Specify C-lib's clustering method argument and return type.\n \"\"\"\n arg_list = [\n POINTER(ScipyCsrF32),\n c_uint32,\n c_uint32,\n c_int,\n c_uint32,\n c_int,\n POINTER(c_uint32),\n ]\n corelib.fillprototype(\n self.clib_float32.c_run_clustering_csr_f32, None, [POINTER(ScipyCsrF32)] + arg_list[1:]\n )\n corelib.fillprototype(\n self.clib_float32.c_run_clustering_drm_f32, None, [POINTER(ScipyDrmF32)] + arg_list[1:]\n )\n\n def run_clustering(self, py_feat_mat, depth, algo, seed, codes=None, max_iter=10, threads=-1):\n \"\"\"\n Run clustering with given label embedding matrix and parameters in C++.\n\n Args:\n py_feat_mat (ScipyCsrF32, ScipyDrmF32): label embedding matrix. (num_labels x num_features).\n depth (int): Depth of K-means clustering N-nary tree.\n algo (str): The algorithm for clustering, either `KMEANS` or `SKMEANS`.\n seed (int): Randoms seed.\n codes (ndarray, optional): Label clustering results.\n max_iter (int, optional): Maximum number of iter for reordering each node based on score.\n threads (int, optional): The number of threads. Default -1 to use all cores.\n\n Return:\n codes (ndarray): The clustering result.\n If `codes` not given, return a new allocated ndarray, dtype `np.uint32`.\n \"\"\"\n clib = self.clib_float32\n if isinstance(py_feat_mat, ScipyCsrF32):\n run_clustering = clib.c_run_clustering_csr_f32\n elif isinstance(py_feat_mat, ScipyDrmF32):\n run_clustering = clib.c_run_clustering_drm_f32\n else:\n raise NotImplementedError(\n \"type(py_feat_mat) = {} no implemented\".format(type(py_feat_mat))\n )\n\n if codes is None or len(codes) != py_feat_mat.shape[0] or codes.dtype != np.uint32:\n codes = np.zeros(py_feat_mat.rows, dtype=np.uint32)\n run_clustering(\n byref(py_feat_mat),\n depth,\n algo,\n seed,\n max_iter,\n threads,\n codes.ctypes.data_as(POINTER(c_uint32)),\n )\n return codes\n\n def link_tfidf_vectorizer(self):\n \"\"\"\n Specify C-lib's Tfidf vectorizer method argument and return type.\n \"\"\"\n res_list = c_void_p\n arg_list = [c_char_p]\n corelib.fillprototype(self.clib_float32.c_tfidf_load, res_list, arg_list)\n\n arg_list = [c_void_p, c_char_p]\n corelib.fillprototype(self.clib_float32.c_tfidf_save, None, arg_list)\n\n arg_list = [c_void_p]\n corelib.fillprototype(self.clib_float32.c_tfidf_destruct, None, arg_list)\n\n arg_list = [\n c_int, # threads\n ScipyCompressedSparseAllocator.CFUNCTYPE, # pred_alloc for result\n ]\n\n # model, fname, fname_len, buffer_size\n corelib.fillprototype(\n self.clib_float32.c_tfidf_predict_from_file,\n None,\n [c_void_p, c_void_p, c_uint64, c_uint64] + arg_list,\n )\n\n # model, corpus, doc_lens, nr_docs\n corelib.fillprototype(\n self.clib_float32.c_tfidf_predict,\n None,\n [c_void_p, c_void_p, POINTER(c_uint64), c_uint64] + arg_list,\n )\n\n res_list = c_void_p\n\n # file-list, fname_lens, nr_files, param, buffer_size, threads\n corelib.fillprototype(\n self.clib_float32.c_tfidf_train_from_file,\n res_list,\n [c_void_p, POINTER(c_uint64), c_uint64, POINTER(TfidfVectorizerParam), c_uint64, c_int],\n )\n # corpus, doc_lens, nr_docs, params, threads\n corelib.fillprototype(\n self.clib_float32.c_tfidf_train,\n res_list,\n [c_void_p, POINTER(c_uint64), c_uint64, POINTER(TfidfVectorizerParam), c_int],\n )\n\n def tfidf_destruct(self, model):\n \"\"\"\n Destruct Tfdif model.\n\n Args:\n model (ptr): Pointer to C Tfdif model.\n \"\"\"\n if type(model) == c_void_p:\n self.clib_float32.c_tfidf_destruct(model)\n\n def tfidf_save(self, model, save_dir):\n \"\"\"\n Save trained tfidf vectorizer to disk.\n\n Args:\n save_dir (str): Folder to save the model.\n \"\"\"\n self.clib_float32.c_tfidf_save(model, c_char_p(save_dir.encode(\"utf-8\")))\n\n def tfidf_load(self, load_dir):\n \"\"\"\n Load a CppTfidf vectorizer from disk.\n\n Args:\n load_dir (str): Folder inside which the model is loaded.\n\n Returns:\n pointer to C instance tfidf::Vectorizer\n \"\"\"\n return self.clib_float32.c_tfidf_load(c_char_p(load_dir.encode(\"utf-8\")))\n\n def tfidf_train(self, trn_corpus, config=None):\n \"\"\"\n Train on a corpus.\n\n Args:\n trn_corpus (list of str or str): Training corpus in the form of a list of strings or path to corpus file/folder.\n config (dict): Dict with keyword arguments to pass to C++ class tfidf::Vectorizer. None to use default in TfidfVectorizerParam.\n For TfidfVectorizerParam, the config should contain\n base_vect_configs (List(Dict)): list of config (list[TfidfBaseVectorizerParam]) to be used for TfidfBaseVectorizerParam.\n norm_p (int): after ensembling feature sub matrices, do row-wise normalization with norm_p.\n buffer_size (int): if train from file, number of bytes allocated for file I/O. Set to 0 to use default value.\n threads (int): number of threads to use, set to negative to use all\n For TfidfBaseVectorizerParam, the config should contain\n ngram_range (tuple of int): (min_ngram, max_ngram)\n truncate_length (int): sequence truncation length, set to negative to disable\n max_feature (int): maximum number of features allowed, set to 0 to disable\n min_df_ratio (float, [0, max_df_ratio)): min ratio for document frequency truncation\n max_df_ratio (float, (min_df_ratio, 1]): max ratio for document frequency truncation\n min_df_cnt (int, [0, max_df_cnt)): min count for document frequency truncation\n max_df_cnt (float, (min_df_cnt, Inf)): max count for document frequency truncation. Default -1 to disable.\n binary (bool): whether to binarize term frequency, default False\n use_idf (bool): whether to use inverse document frequency, default True\n smooth_idf (bool): whether to smooth IDF by adding 1 to all DF counts, default True\n sublinear_tf (bool): whether to use sublinear mapping (log) on term frequency, default False\n keep_frequent_feature (bool): if max_feature > 0, will only keep max_feature features by\n ignoring features with low document frequency (if True, default),\n ignoring features with high document frequency (if False)\n norm (str, 'l1' or 'l2'): feature vector will have unit l1 or l2 norm\n analyzer (str, 'word', 'char' or 'char_wb'): Whether to use word or character n-grams.\n Option ‘char_wb’ creates character n-grams only from text inside word boundaries,\n n-grams at the edges of words are padded with space.\n buffer_size (int): if train from file, number of bytes allocated for file I/O. Set to 0 to use default value.\n threads (int): number of threads to use, set to negative to use all\n\n Returns:\n pointer to C instance tfidf::Vectorizer\n \"\"\"\n\n # Check whether \"base_vect_configs\" is in config.keys()\n # If not, this config is for TfidfBaseVectorizerParam.\n # Otherwise, this config is for TfidfVectorizerParam.\n if \"base_vect_configs\" not in config:\n base_vect_param_list = [TfidfBaseVectorizerParam(config)]\n norm_p = base_vect_param_list[0].norm_p\n else:\n base_vect_param_list = [\n TfidfBaseVectorizerParam(base_vect_config)\n for base_vect_config in config[\"base_vect_configs\"]\n ]\n norm_p = config[\"norm_p\"]\n params = TfidfVectorizerParam(base_vect_param_list, norm_p)\n\n if isinstance(trn_corpus, str):\n if os.path.isfile(trn_corpus): # train from a single corpus file\n corpus_files = [trn_corpus]\n elif os.path.isdir(trn_corpus): # train from a folder of corpus files\n corpus_files = [\n os.path.join(trn_corpus, f)\n for f in sorted(os.listdir(trn_corpus))\n if os.path.isfile(os.path.join(trn_corpus, f))\n ]\n else:\n raise Exception(\"Failed to load training corpus from {}\".format(trn_corpus))\n nr_files = len(corpus_files)\n c_corpusf_arr = (c_char_p * nr_files)()\n c_corpusf_arr[:] = [line.encode(\"utf-8\") for line in corpus_files]\n fname_lens = np.array([len(line) for line in c_corpusf_arr], dtype=np.uint64)\n\n model = self.clib_float32.c_tfidf_train_from_file(\n c_corpusf_arr,\n fname_lens.ctypes.data_as(POINTER(c_uint64)),\n nr_files,\n params,\n config[\"buffer_size\"],\n config[\"threads\"],\n )\n else:\n nr_doc = len(trn_corpus)\n c_corpus_arr = (c_char_p * nr_doc)()\n c_corpus_arr[:] = [line.encode(\"utf-8\") for line in trn_corpus]\n doc_lens = np.array([len(line) for line in c_corpus_arr], dtype=np.uint64)\n\n model = self.clib_float32.c_tfidf_train(\n c_corpus_arr,\n doc_lens.ctypes.data_as(POINTER(c_uint64)),\n nr_doc,\n params,\n config[\"threads\"],\n )\n\n return model\n\n def tfidf_predict(self, model, corpus, buffer_size=0, threads=-1):\n \"\"\"\n Vectorize a corpus.\n\n Args:\n model (ctypes.c_void_p): pointer to tfidf::Vectorizer model\n corpus (list): List of strings to vectorize.\n buffer_size (int, default 0): number of bytes used for file I/O while train from file, set to 0 to use default value\n threads (int, default -1): number of threads to use for predict, set to negative to use all\n\n Returns:\n scipy.sparse.csr.csr_matrix: Matrix of features.\n \"\"\"\n pred_alloc = ScipyCompressedSparseAllocator()\n if isinstance(corpus, str):\n # train from file\n assert os.path.isfile(corpus), \"Cannot predict from {}!\".format(corpus)\n corpus_utf8 = corpus.encode(\"utf-8\")\n\n self.clib_float32.c_tfidf_predict_from_file(\n model,\n c_char_p(corpus_utf8),\n len(corpus_utf8),\n buffer_size,\n threads,\n pred_alloc.cfunc,\n )\n\n else:\n # in memory predict\n nr_doc = len(corpus)\n c_corpus_arr = (c_char_p * nr_doc)()\n c_corpus_arr[:] = [line.encode(\"utf-8\") for line in corpus]\n doc_lens = np.array([len(line) for line in c_corpus_arr], dtype=np.uint64)\n\n self.clib_float32.c_tfidf_predict(\n model,\n c_corpus_arr,\n doc_lens.ctypes.data_as(POINTER(c_uint64)),\n nr_doc,\n threads,\n pred_alloc.cfunc,\n )\n return pred_alloc.get()\n\n\nclib = corelib(os.path.join(os.path.dirname(os.path.abspath(pecos.__file__)), \"core\"), \"libpecos\")\n"
] | [
[
"numpy.ones",
"numpy.zeros",
"scipy.sparse.csc_matrix",
"scipy.sparse.csr_matrix",
"scipy.sparse.coo_matrix"
]
] |
breandan/tensorflow | [
"7509bad95200e1baed4eb488dbeaaa2c505a2824",
"7509bad95200e1baed4eb488dbeaaa2c505a2824"
] | [
"tensorflow/contrib/learn/python/learn/dataframe/transforms/batch.py",
"tensorflow/python/lib/io/tf_record.py"
] | [
"# Copyright 2015 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\n\"\"\"Batches `Series` objects. For internal use, not part of the public API.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom tensorflow.contrib.learn.python.learn.dataframe import transform\nfrom tensorflow.python.training import input as input_ops\n\n\nclass AbstractBatchTransform(transform.Transform):\n \"\"\"Abstract parent class for batching Transforms.\"\"\"\n\n def __init__(self,\n batch_size,\n output_names,\n num_threads=1,\n queue_capacity=None):\n super(AbstractBatchTransform, self).__init__()\n self._batch_size = batch_size\n self._output_name_list = output_names\n self._num_threads = num_threads\n self._queue_capacity = (self.batch_size * 10 if queue_capacity is None\n else queue_capacity)\n\n @transform.parameter\n def batch_size(self):\n return self._batch_size\n\n @transform.parameter\n def num_threads(self):\n return self._num_threads\n\n @transform.parameter\n def queue_capacity(self):\n return self._queue_capacity\n\n @property\n def input_valency(self):\n return len(self.output_names)\n\n @property\n def _output_names(self):\n return self._output_name_list\n\n\nclass Batch(AbstractBatchTransform):\n \"\"\"Batches Columns to specified size.\n\n Note that dimension 0 is assumed to correspond to \"example number\" so\n `Batch` does not prepend an additional dimension to incoming `Series`.\n For example, if a `Tensor` in `transform_input` has shape [x, y], the\n corresponding output will have shape [batch_size, y].\n \"\"\"\n\n @property\n def name(self):\n return \"Batch\"\n\n def _apply_transform(self, transform_input):\n batched = input_ops.batch(transform_input,\n batch_size=self.batch_size,\n num_threads=self.num_threads,\n capacity=self.queue_capacity,\n enqueue_many=True)\n # TODO(jamieas): batch will soon return a list regardless of the number of\n # enqueued tensors. Remove the following once that change is in place.\n if not isinstance(batched, (tuple, list)):\n batched = (batched,)\n # pylint: disable=not-callable\n return self.return_type(*batched)\n\n\nclass ShuffleBatch(AbstractBatchTransform):\n \"\"\"Creates shuffled batches from `Series` containing a single row.\n\n Note that dimension 0 is assumed to correspond to \"example number\" so\n `ShuffleBatch` does not prepend an additional dimension to incoming `Series`.\n For example, if a `Tensor` in `transform_input` has shape [x, y], the\n corresponding output will have shape [batch_size, y].\n \"\"\"\n\n @property\n def name(self):\n return \"ShuffleBatch\"\n\n def __init__(self,\n batch_size,\n output_names,\n num_threads=1,\n queue_capacity=None,\n min_after_dequeue=None,\n seed=None):\n super(ShuffleBatch, self).__init__(batch_size, output_names, num_threads,\n queue_capacity)\n self._min_after_dequeue = (self.queue_capacity / 4 if\n min_after_dequeue is None else min_after_dequeue)\n self._seed = seed\n\n @transform.parameter\n def min_after_dequeue(self):\n return self._min_after_dequeue\n\n @transform.parameter\n def seed(self):\n return self._seed\n\n def _apply_transform(self, transform_input):\n batched = input_ops.shuffle_batch(transform_input,\n batch_size=self.batch_size,\n capacity=self.queue_capacity,\n min_after_dequeue=self.min_after_dequeue,\n num_threads=self.num_threads,\n seed=self.seed,\n enqueue_many=True)\n # TODO(jamieas): batch will soon return a list regardless of the number of\n # enqueued tensors. Remove the following once that change is in place.\n if not isinstance(batched, (tuple, list)):\n batched = (batched,)\n # pylint: disable=not-callable\n return self.return_type(*batched)\n",
"# Copyright 2015 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\n\"\"\"For reading and writing TFRecords files.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom tensorflow.python import pywrap_tensorflow\nfrom tensorflow.python.util import compat\n\n\ndef tf_record_iterator(path):\n \"\"\"An iterator that read the records from a TFRecords file.\n\n Args:\n path: The path to the TFRecords file.\n\n Yields:\n Strings.\n\n Raises:\n IOError: If `path` cannot be opened for reading.\n \"\"\"\n reader = pywrap_tensorflow.PyRecordReader_New(compat.as_bytes(path), 0)\n if reader is None:\n raise IOError(\"Could not open %s.\" % path)\n while reader.GetNext():\n yield reader.record()\n reader.Close()\n\n\nclass TFRecordWriter(object):\n \"\"\"A class to write records to a TFRecords file.\n\n This class implements `__enter__` and `__exit__`, and can be used\n in `with` blocks like a normal file.\n\n @@__init__\n @@write\n @@close\n \"\"\"\n # TODO(josh11b): Support appending?\n def __init__(self, path):\n \"\"\"Opens file `path` and creates a `TFRecordWriter` writing to it.\n\n Args:\n path: The path to the TFRecords file.\n\n Raises:\n IOError: If `path` cannot be opened for writing.\n \"\"\"\n self._writer = pywrap_tensorflow.PyRecordWriter_New(compat.as_bytes(path))\n if self._writer is None:\n raise IOError(\"Could not write to %s.\" % path)\n\n def __enter__(self):\n \"\"\"Enter a `with` block.\"\"\"\n return self\n\n def __exit__(self, unused_type, unused_value, unused_traceback):\n \"\"\"Exit a `with` block, closing the file.\"\"\"\n self.close()\n\n def write(self, record):\n \"\"\"Write a string record to the file.\n\n Args:\n record: str\n \"\"\"\n self._writer.WriteRecord(record)\n\n def close(self):\n \"\"\"Close the file.\"\"\"\n self._writer.Close()\n"
] | [
[
"tensorflow.python.training.input.shuffle_batch",
"tensorflow.python.training.input.batch"
],
[
"tensorflow.python.util.compat.as_bytes"
]
] |
thegodone/gcnn_keras | [
"2009b9ab9a07c1a369849478812fcc2cb9799945"
] | [
"kgcnn/literature/GAT.py"
] | [
"import tensorflow as tf\nimport tensorflow.keras as ks\n\nfrom kgcnn.layers.casting import ChangeTensorType\nfrom kgcnn.layers.conv.attention import AttentionHeadGAT\nfrom kgcnn.layers.keras import Concatenate, Dense, Average, Activation\nfrom kgcnn.layers.mlp import MLP\nfrom kgcnn.layers.pool.pooling import PoolingNodes\nfrom kgcnn.utils.models import generate_embedding, update_model_kwargs\n\n# Graph Attention Networks\n# by Veličković et al. (2018)\n# https://arxiv.org/abs/1710.10903\n\nmodel_default = {'name': \"GAT\",\n 'inputs': [{'shape': (None,), 'name': \"node_attributes\", 'dtype': 'float32', 'ragged': True},\n {'shape': (None,), 'name': \"edge_attributes\", 'dtype': 'float32', 'ragged': True},\n {'shape': (None, 2), 'name': \"edge_indices\", 'dtype': 'int64', 'ragged': True}],\n 'input_embedding': {\"node\": {\"input_dim\": 95, \"output_dim\": 64},\n \"edge\": {\"input_dim\": 5, \"output_dim\": 64}},\n 'output_embedding': 'graph',\n 'output_mlp': {\"use_bias\": [True, True, False], \"units\": [25, 10, 1],\n \"activation\": ['relu', 'relu', 'sigmoid']},\n 'attention_args': {\"units\": 32, \"use_final_activation\": False, \"use_edge_features\": True,\n \"has_self_loops\": True, \"activation\": \"kgcnn>leaky_relu\", 'use_bias': True},\n 'pooling_nodes_args': {'pooling_method': 'mean'},\n 'depth': 3, 'attention_heads_num': 5,\n 'attention_heads_concat': False, 'verbose': 1\n }\n\n\n@update_model_kwargs(model_default)\ndef make_model(inputs=None,\n input_embedding=None,\n output_embedding=None,\n output_mlp=None,\n attention_args=None,\n pooling_nodes_args=None,\n depth=None,\n attention_heads_num=None,\n attention_heads_concat=None,\n **kwargs):\n \"\"\"Make GAT graph network via functional API. Default parameters can be found in :obj:`model_default`.\n\n Args:\n inputs (list): List of dictionaries unpacked in :obj:`tf.keras.layers.Input`. Order must match model definition.\n input_embedding (dict): Dictionary of embedding arguments for nodes etc. unpacked in `Embedding` layers.\n output_embedding (str): Main embedding task for graph network. Either \"node\", (\"edge\") or \"graph\".\n output_mlp (dict): Dictionary of layer arguments unpacked in the final classification `MLP` layer block.\n Defines number of model outputs and activation.\n attention_args (dict): Dictionary of layer arguments unpacked in `AttentionHeadGAT` layer.\n pooling_nodes_args (dict): Dictionary of layer arguments unpacked in `PoolingNodes` layer.\n depth (int): Number of graph embedding units or depth of the network.\n attention_heads_num (int): Number of attention heads to use.\n attention_heads_concat (bool): Whether to concat attention heads. Otherwise average heads.\n\n Returns:\n tf.keras.models.Model\n \"\"\"\n\n # Make input\n node_input = ks.layers.Input(**inputs[0])\n edge_input = ks.layers.Input(**inputs[1])\n edge_index_input = ks.layers.Input(**inputs[2])\n # Embedding, if no feature dimension\n n = generate_embedding(node_input, inputs[0]['shape'], input_embedding['node'])\n ed = generate_embedding(edge_input, inputs[1]['shape'], input_embedding['edge'])\n edi = edge_index_input\n\n # Model\n nk = Dense(units=attention_args[\"units\"], activation=\"linear\")(n)\n for i in range(0, depth):\n heads = [AttentionHeadGAT(**attention_args)([n, ed, edi]) for _ in range(attention_heads_num)]\n if attention_heads_concat:\n nk = Concatenate(axis=-1)(heads)\n else:\n nk = Average()(heads)\n nk = Activation(activation=attention_args[\"activation\"])(nk)\n n = nk\n\n # Output embedding choice\n if output_embedding == 'graph':\n out = PoolingNodes(**pooling_nodes_args)(n)\n out = MLP(**output_mlp)(out)\n main_output = ks.layers.Flatten()(out) # will be dense\n elif output_embedding == 'node':\n out = MLP(**output_mlp)(n)\n main_output = ChangeTensorType(input_tensor_type=\"ragged\", output_tensor_type=\"tensor\")(out)\n else:\n raise ValueError(\"Unsupported graph embedding for `GAT`\")\n\n model = tf.keras.models.Model(inputs=[node_input, edge_input, edge_index_input], outputs=main_output)\n return model\n"
] | [
[
"tensorflow.keras.models.Model",
"tensorflow.keras.layers.Flatten",
"tensorflow.keras.layers.Input"
]
] |
kne42/napari | [
"d61d0be0ef8ea622dd3d6acd270c0529816c11ec"
] | [
"napari/layers/points/_tests/test_points.py"
] | [
"from copy import copy\nfrom itertools import cycle, islice\n\nimport numpy as np\nimport pandas as pd\nimport pytest\nfrom vispy.color import get_colormap\n\nfrom napari._tests.utils import check_layer_world_data_extent\nfrom napari.layers import Points\nfrom napari.layers.points._points_utils import points_to_squares\nfrom napari.layers.utils.color_manager import ColorProperties\nfrom napari.utils.colormaps.standardize_color import transform_color\n\n\ndef _make_cycled_properties(values, length):\n \"\"\"Helper function to make property values\n\n Parameters\n ----------\n values\n The values to be cycled.\n length : int\n The length of the resulting property array\n\n Returns\n -------\n cycled_properties : np.ndarray\n The property array comprising the cycled values.\n \"\"\"\n cycled_properties = np.array(list(islice(cycle(values), 0, length)))\n return cycled_properties\n\n\ndef test_empty_points():\n pts = Points()\n assert pts.data.shape == (0, 2)\n\n\ndef test_empty_points_with_properties():\n \"\"\"Test instantiating an empty Points layer with properties\n\n See: https://github.com/napari/napari/pull/1069\n \"\"\"\n properties = {\n 'label': np.array(['label1', 'label2']),\n 'cont_prop': np.array([0], dtype=float),\n }\n pts = Points(property_choices=properties)\n current_props = {k: v[0] for k, v in properties.items()}\n np.testing.assert_equal(pts.current_properties, current_props)\n\n # verify the property datatype is correct\n assert pts.properties['cont_prop'].dtype == float\n\n # add two points and verify the default property was applied\n pts.add([10, 10])\n pts.add([20, 20])\n props = {\n 'label': np.array(['label1', 'label1']),\n 'cont_prop': np.array([0, 0], dtype=float),\n }\n np.testing.assert_equal(pts.properties, props)\n\n\ndef test_empty_points_with_properties_list():\n \"\"\"Test instantiating an empty Points layer with properties\n stored in a list\n\n See: https://github.com/napari/napari/pull/1069\n \"\"\"\n properties = {'label': ['label1', 'label2'], 'cont_prop': [0]}\n pts = Points(property_choices=properties)\n current_props = {k: np.asarray(v[0]) for k, v in properties.items()}\n np.testing.assert_equal(pts.current_properties, current_props)\n\n # add two points and verify the default property was applied\n pts.add([10, 10])\n pts.add([20, 20])\n props = {\n 'label': np.array(['label1', 'label1']),\n 'cont_prop': np.array([0, 0], dtype=float),\n }\n np.testing.assert_equal(pts.properties, props)\n\n\ndef test_empty_layer_with_face_colormap():\n \"\"\"Test creating an empty layer where the face color is a colormap\n See: https://github.com/napari/napari/pull/1069\n \"\"\"\n default_properties = {'point_type': np.array([1.5], dtype=float)}\n layer = Points(\n property_choices=default_properties,\n face_color='point_type',\n face_colormap='gray',\n )\n\n assert layer.face_color_mode == 'colormap'\n\n # verify the current_face_color is correct\n face_color = np.array([1, 1, 1, 1])\n np.testing.assert_allclose(layer._face.current_color, face_color)\n\n\ndef test_empty_layer_with_edge_colormap():\n \"\"\"Test creating an empty layer where the face color is a colormap\n See: https://github.com/napari/napari/pull/1069\n \"\"\"\n default_properties = {'point_type': np.array([1.5], dtype=float)}\n layer = Points(\n property_choices=default_properties,\n edge_color='point_type',\n edge_colormap='gray',\n )\n\n assert layer.edge_color_mode == 'colormap'\n\n # verify the current_face_color is correct\n edge_color = np.array([1, 1, 1, 1])\n np.testing.assert_allclose(layer._edge.current_color, edge_color)\n\n\ndef test_empty_layer_with_text_properties():\n \"\"\"Test initializing an empty layer with text defined\"\"\"\n default_properties = {'point_type': np.array([1.5], dtype=float)}\n text_kwargs = {'text': 'point_type', 'color': 'red'}\n layer = Points(\n property_choices=default_properties,\n text=text_kwargs,\n )\n assert layer.text.values.size == 0\n np.testing.assert_allclose(layer.text.color, [1, 0, 0, 1])\n\n # add a point and check that the appropriate text value was added\n layer.add([1, 1])\n np.testing.assert_equal(layer.text.values, ['1.5'])\n np.testing.assert_allclose(layer.text.color, [1, 0, 0, 1])\n\n\ndef test_empty_layer_with_text_formatted():\n \"\"\"Test initializing an empty layer with text defined\"\"\"\n default_properties = {'point_type': np.array([1.5], dtype=float)}\n layer = Points(\n property_choices=default_properties,\n text='point_type: {point_type:.2f}',\n )\n assert layer.text.values.size == 0\n\n # add a point and check that the appropriate text value was added\n layer.add([1, 1])\n np.testing.assert_equal(layer.text.values, ['point_type: 1.50'])\n\n\ndef test_random_points():\n \"\"\"Test instantiating Points layer with random 2D data.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n assert np.all(layer.data == data)\n assert layer.ndim == shape[1]\n assert layer._view_data.ndim == 2\n assert len(layer.data) == 10\n assert len(layer.selected_data) == 0\n\n\ndef test_integer_points():\n \"\"\"Test instantiating Points layer with integer data.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = np.random.randint(20, size=(10, 2))\n layer = Points(data)\n assert np.all(layer.data == data)\n assert layer.ndim == shape[1]\n assert layer._view_data.ndim == 2\n assert len(layer.data) == 10\n\n\ndef test_negative_points():\n \"\"\"Test instantiating Points layer with negative data.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape) - 10\n layer = Points(data)\n assert np.all(layer.data == data)\n assert layer.ndim == shape[1]\n assert layer._view_data.ndim == 2\n assert len(layer.data) == 10\n\n\ndef test_empty_points_array():\n \"\"\"Test instantiating Points layer with empty array.\"\"\"\n shape = (0, 2)\n data = np.empty(shape)\n layer = Points(data)\n assert np.all(layer.data == data)\n assert layer.ndim == shape[1]\n assert layer._view_data.ndim == 2\n assert len(layer.data) == 0\n\n\ndef test_3D_points():\n \"\"\"Test instantiating Points layer with random 3D data.\"\"\"\n shape = (10, 3)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n assert np.all(layer.data == data)\n assert layer.ndim == shape[1]\n assert layer._view_data.ndim == 2\n assert len(layer.data) == 10\n\n\ndef test_4D_points():\n \"\"\"Test instantiating Points layer with random 4D data.\"\"\"\n shape = (10, 4)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n assert np.all(layer.data == data)\n assert layer.ndim == shape[1]\n assert layer._view_data.ndim == 2\n assert len(layer.data) == 10\n\n\ndef test_changing_points():\n \"\"\"Test changing Points data.\"\"\"\n shape_a = (10, 2)\n shape_b = (20, 2)\n np.random.seed(0)\n data_a = 20 * np.random.random(shape_a)\n data_b = 20 * np.random.random(shape_b)\n layer = Points(data_a)\n layer.data = data_b\n assert np.all(layer.data == data_b)\n assert layer.ndim == shape_b[1]\n assert layer._view_data.ndim == 2\n assert len(layer.data) == 20\n\n\ndef test_selecting_points():\n \"\"\"Test selecting points.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n layer.mode = 'select'\n data_to_select = {1, 2}\n layer.selected_data = data_to_select\n assert layer.selected_data == data_to_select\n\n # test switching to 3D\n layer._slice_dims(ndisplay=3)\n assert layer.selected_data == data_to_select\n\n # select different points while in 3D mode\n other_data_to_select = {0}\n layer.selected_data = other_data_to_select\n assert layer.selected_data == other_data_to_select\n\n # selection should persist when going back to 2D mode\n layer._slice_dims(ndisplay=2)\n assert layer.selected_data == other_data_to_select\n\n # selection should persist when switching between between select and pan_zoom\n layer.mode = 'pan_zoom'\n assert layer.selected_data == other_data_to_select\n layer.mode = 'select'\n assert layer.selected_data == other_data_to_select\n\n # add mode should clear the selection\n layer.mode = 'add'\n assert layer.selected_data == set()\n\n\ndef test_adding_points():\n \"\"\"Test adding Points data.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n assert len(layer.data) == 10\n\n coord = [20, 20]\n layer.add(coord)\n assert len(layer.data) == 11\n assert np.all(layer.data[10] == coord)\n # the added point should be selected\n assert layer.selected_data == {10}\n\n # test adding multiple points\n coords = [[10, 10], [15, 15]]\n layer.add(coords)\n assert len(layer.data) == 13\n assert np.all(layer.data[11:, :] == coords)\n\n # test that the last added points can be deleted\n layer.remove_selected()\n np.testing.assert_equal(layer.data, np.vstack((data, coord)))\n\n\ndef test_adding_points_to_empty():\n \"\"\"Test adding Points data to empty.\"\"\"\n shape = (0, 2)\n data = np.empty(shape)\n layer = Points(data)\n assert len(layer.data) == 0\n\n coord = [20, 20]\n layer.add(coord)\n assert len(layer.data) == 1\n assert np.all(layer.data[0] == coord)\n\n\ndef test_removing_selected_points():\n \"\"\"Test selecting points.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n\n # With nothing selected no points should be removed\n layer.remove_selected()\n assert len(layer.data) == shape[0]\n\n # Select two points and remove them\n layer.selected_data = {0, 3}\n layer.remove_selected()\n assert len(layer.data) == shape[0] - 2\n assert len(layer.selected_data) == 0\n keep = [1, 2] + list(range(4, 10))\n assert np.all(layer.data == data[keep])\n\n # Select another point and remove it\n layer.selected_data = {4}\n layer.remove_selected()\n assert len(layer.data) == shape[0] - 3\n\n\ndef test_move():\n \"\"\"Test moving points.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n unmoved = copy(data)\n layer = Points(data)\n\n # Move one point relative to an initial drag start location\n layer._move([0], [0, 0])\n layer._move([0], [10, 10])\n layer._drag_start = None\n assert np.all(layer.data[0] == unmoved[0] + [10, 10])\n assert np.all(layer.data[1:] == unmoved[1:])\n\n # Move two points relative to an initial drag start location\n layer._move([1, 2], [2, 2])\n layer._move([1, 2], np.add([2, 2], [-3, 4]))\n assert np.all(layer.data[1:2] == unmoved[1:2] + [-3, 4])\n\n\ndef test_changing_modes():\n \"\"\"Test changing modes.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n assert layer.mode == 'pan_zoom'\n assert layer.interactive is True\n\n layer.mode = 'add'\n assert layer.mode == 'add'\n\n layer.mode = 'select'\n assert layer.mode == 'select'\n assert layer.interactive is False\n\n layer.mode = 'pan_zoom'\n assert layer.mode == 'pan_zoom'\n assert layer.interactive is True\n\n with pytest.raises(ValueError):\n layer.mode = 'not_a_mode'\n\n\ndef test_name():\n \"\"\"Test setting layer name.\"\"\"\n np.random.seed(0)\n data = 20 * np.random.random((10, 2))\n layer = Points(data)\n assert layer.name == 'Points'\n\n layer = Points(data, name='random')\n assert layer.name == 'random'\n\n layer.name = 'pts'\n assert layer.name == 'pts'\n\n\ndef test_visiblity():\n \"\"\"Test setting layer visibility.\"\"\"\n np.random.seed(0)\n data = 20 * np.random.random((10, 2))\n layer = Points(data)\n assert layer.visible is True\n\n layer.visible = False\n assert layer.visible is False\n\n layer = Points(data, visible=False)\n assert layer.visible is False\n\n layer.visible = True\n assert layer.visible is True\n\n\ndef test_opacity():\n \"\"\"Test setting layer opacity.\"\"\"\n np.random.seed(0)\n data = 20 * np.random.random((10, 2))\n layer = Points(data)\n assert layer.opacity == 1.0\n\n layer.opacity = 0.5\n assert layer.opacity == 0.5\n\n layer = Points(data, opacity=0.6)\n assert layer.opacity == 0.6\n\n layer.opacity = 0.3\n assert layer.opacity == 0.3\n\n\ndef test_blending():\n \"\"\"Test setting layer blending.\"\"\"\n np.random.seed(0)\n data = 20 * np.random.random((10, 2))\n layer = Points(data)\n assert layer.blending == 'translucent'\n\n layer.blending = 'additive'\n assert layer.blending == 'additive'\n\n layer = Points(data, blending='additive')\n assert layer.blending == 'additive'\n\n layer.blending = 'opaque'\n assert layer.blending == 'opaque'\n\n\ndef test_symbol():\n \"\"\"Test setting symbol.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n assert layer.symbol == 'disc'\n\n layer.symbol = 'cross'\n assert layer.symbol == 'cross'\n\n layer = Points(data, symbol='star')\n assert layer.symbol == 'star'\n\n\nproperties_array = {'point_type': _make_cycled_properties(['A', 'B'], 10)}\nproperties_list = {'point_type': list(_make_cycled_properties(['A', 'B'], 10))}\n\n\[email protected](\"properties\", [properties_array, properties_list])\ndef test_properties(properties):\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data, properties=copy(properties))\n np.testing.assert_equal(layer.properties, properties)\n\n current_prop = {'point_type': np.array(['B'])}\n assert layer.current_properties == current_prop\n\n # test removing points\n layer.selected_data = {0, 1}\n layer.remove_selected()\n remove_properties = properties['point_type'][2::]\n assert len(layer.properties['point_type']) == (shape[0] - 2)\n assert np.all(layer.properties['point_type'] == remove_properties)\n\n # test selection of properties\n layer.selected_data = {0}\n selected_annotation = layer.current_properties['point_type']\n assert len(selected_annotation) == 1\n assert selected_annotation[0] == 'A'\n\n # test adding points with properties\n layer.add([10, 10])\n add_annotations = np.concatenate((remove_properties, ['A']), axis=0)\n assert np.all(layer.properties['point_type'] == add_annotations)\n\n # test copy/paste\n layer.selected_data = {0, 1}\n layer._copy_data()\n assert np.all(layer._clipboard['properties']['point_type'] == ['A', 'B'])\n\n layer._paste_data()\n paste_annotations = np.concatenate((add_annotations, ['A', 'B']), axis=0)\n assert np.all(layer.properties['point_type'] == paste_annotations)\n\n\[email protected](\"attribute\", ['edge', 'face'])\ndef test_adding_properties(attribute):\n \"\"\"Test adding properties to an existing layer\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n\n # add properties\n properties = {'point_type': _make_cycled_properties(['A', 'B'], shape[0])}\n layer.properties = properties\n np.testing.assert_equal(layer.properties, properties)\n\n # add properties as a dataframe\n properties_df = pd.DataFrame(properties)\n layer.properties = properties_df\n np.testing.assert_equal(layer.properties, properties)\n\n # add properties as a dictionary with list values\n properties_list = {\n 'point_type': list(_make_cycled_properties(['A', 'B'], shape[0]))\n }\n layer.properties = properties_list\n assert isinstance(layer.properties['point_type'], np.ndarray)\n\n # removing a property that was the _*_color_property should give a warning\n color_manager = getattr(layer, f'_{attribute}')\n color_manager.color_properties = {\n 'name': 'point_type',\n 'values': np.empty(0),\n 'current_value': 'A',\n }\n properties_2 = {\n 'not_point_type': _make_cycled_properties(['A', 'B'], shape[0])\n }\n with pytest.warns(RuntimeWarning):\n layer.properties = properties_2\n\n\ndef test_properties_dataframe():\n \"\"\"Test if properties can be provided as a DataFrame\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n properties = {'point_type': _make_cycled_properties(['A', 'B'], shape[0])}\n properties_df = pd.DataFrame(properties)\n properties_df = properties_df.astype(properties['point_type'].dtype)\n layer = Points(data, properties=properties_df)\n np.testing.assert_equal(layer.properties, properties)\n\n\ndef test_add_points_with_properties_as_list():\n # test adding points initialized with properties as list\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n properties = {\n 'point_type': list(_make_cycled_properties(['A', 'B'], shape[0]))\n }\n layer = Points(data, properties=copy(properties))\n\n coord = [18, 18]\n layer.add(coord)\n new_prop = {'point_type': np.append(properties['point_type'], 'B')}\n np.testing.assert_equal(layer.properties, new_prop)\n\n\ndef test_updating_points_properties():\n # test adding points initialized with properties\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n properties = {'point_type': _make_cycled_properties(['A', 'B'], shape[0])}\n layer = Points(data, properties=copy(properties))\n\n layer.mode = 'select'\n layer.selected_data = [len(data) - 1]\n layer.current_properties = {'point_type': np.array(['A'])}\n\n updated_properties = properties\n updated_properties['point_type'][-1] = 'A'\n np.testing.assert_equal(layer.properties, updated_properties)\n\n\nproperties_array = {'point_type': _make_cycled_properties(['A', 'B'], 10)}\nproperties_list = {'point_type': list(_make_cycled_properties(['A', 'B'], 10))}\n\n\[email protected](\"properties\", [properties_array, properties_list])\ndef test_text_from_property_value(properties):\n \"\"\"Test setting text from a property value\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data, properties=copy(properties), text='point_type')\n\n np.testing.assert_equal(layer.text.values, properties['point_type'])\n\n\[email protected](\"properties\", [properties_array, properties_list])\ndef test_text_from_property_fstring(properties):\n \"\"\"Test setting text with an f-string from the property value\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(\n data, properties=copy(properties), text='type: {point_type}'\n )\n\n expected_text = ['type: ' + v for v in properties['point_type']]\n np.testing.assert_equal(layer.text.values, expected_text)\n\n # test updating the text\n layer.text = 'type-ish: {point_type}'\n expected_text_2 = ['type-ish: ' + v for v in properties['point_type']]\n np.testing.assert_equal(layer.text.values, expected_text_2)\n\n # copy/paste\n layer.selected_data = {0}\n layer._copy_data()\n layer._paste_data()\n expected_text_3 = expected_text_2 + ['type-ish: A']\n np.testing.assert_equal(layer.text.values, expected_text_3)\n\n # add point\n layer.selected_data = {0}\n new_shape = np.random.random((1, 2))\n layer.add(new_shape)\n expected_text_4 = expected_text_3 + ['type-ish: A']\n np.testing.assert_equal(layer.text.values, expected_text_4)\n\n\[email protected](\"properties\", [properties_array, properties_list])\ndef test_set_text_with_kwarg_dict(properties):\n text_kwargs = {\n 'text': 'type: {point_type}',\n 'color': [0, 0, 0, 1],\n 'rotation': 10,\n 'translation': [5, 5],\n 'anchor': 'upper_left',\n 'size': 10,\n 'visible': True,\n }\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data, properties=copy(properties), text=text_kwargs)\n\n expected_text = ['type: ' + v for v in properties['point_type']]\n np.testing.assert_equal(layer.text.values, expected_text)\n\n for property, value in text_kwargs.items():\n if property == 'text':\n continue\n layer_value = getattr(layer._text, property)\n np.testing.assert_equal(layer_value, value)\n\n\[email protected](\"properties\", [properties_array, properties_list])\ndef test_text_error(properties):\n \"\"\"creating a layer with text as the wrong type should raise an error\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n # try adding text as the wrong type\n with pytest.raises(TypeError):\n Points(data, properties=copy(properties), text=123)\n\n\ndef test_refresh_text():\n \"\"\"Test refreshing the text after setting new properties\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n properties = {'point_type': ['A'] * shape[0]}\n layer = Points(data, properties=copy(properties), text='point_type')\n\n new_properties = {'point_type': ['B'] * shape[0]}\n layer.properties = new_properties\n np.testing.assert_equal(layer.text.values, new_properties['point_type'])\n\n\ndef test_points_errors():\n shape = (3, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n\n # try adding properties with the wrong number of properties\n with pytest.raises(ValueError):\n annotations = {'point_type': np.array(['A', 'B'])}\n Points(data, properties=copy(annotations))\n\n\ndef test_edge_width():\n \"\"\"Test setting edge width.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n assert layer.edge_width == 1\n\n layer.edge_width = 2\n assert layer.edge_width == 2\n\n layer = Points(data, edge_width=3)\n assert layer.edge_width == 3\n\n\ndef test_n_dimensional():\n \"\"\"Test setting n_dimensional flag for 2D and 4D data.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n assert layer.n_dimensional is False\n\n layer.n_dimensional = True\n assert layer.n_dimensional is True\n\n layer = Points(data, n_dimensional=True)\n assert layer.n_dimensional is True\n\n shape = (10, 4)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n assert layer.n_dimensional is False\n\n layer.n_dimensional = True\n assert layer.n_dimensional is True\n\n layer = Points(data, n_dimensional=True)\n assert layer.n_dimensional is True\n\n\[email protected](\"ignore:elementwise comparison fail:FutureWarning\")\[email protected](\"attribute\", ['edge', 'face'])\ndef test_switch_color_mode(attribute):\n \"\"\"Test switching between color modes\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n # create a continuous property with a known value in the last element\n continuous_prop = np.random.random((shape[0],))\n continuous_prop[-1] = 1\n properties = {\n 'point_truthiness': continuous_prop,\n 'point_type': _make_cycled_properties(['A', 'B'], shape[0]),\n }\n initial_color = [1, 0, 0, 1]\n color_cycle = ['red', 'blue']\n color_kwarg = f'{attribute}_color'\n colormap_kwarg = f'{attribute}_colormap'\n color_cycle_kwarg = f'{attribute}_color_cycle'\n args = {\n color_kwarg: initial_color,\n colormap_kwarg: 'gray',\n color_cycle_kwarg: color_cycle,\n }\n layer = Points(data, properties=properties, **args)\n\n layer_color_mode = getattr(layer, f'{attribute}_color_mode')\n layer_color = getattr(layer, f'{attribute}_color')\n assert layer_color_mode == 'direct'\n np.testing.assert_allclose(\n layer_color, np.repeat([initial_color], shape[0], axis=0)\n )\n\n # there should not be an edge_color_property\n color_manager = getattr(layer, f'_{attribute}')\n color_property = color_manager.color_properties\n assert color_property is None\n\n # transitioning to colormap should raise a warning\n # because there isn't an edge color property yet and\n # the first property in points.properties is being automatically selected\n with pytest.warns(UserWarning):\n setattr(layer, f'{attribute}_color_mode', 'colormap')\n color_manager = getattr(layer, f'_{attribute}')\n color_property_name = color_manager.color_properties.name\n assert color_property_name == next(iter(properties))\n layer_color = getattr(layer, f'{attribute}_color')\n np.testing.assert_allclose(layer_color[-1], [1, 1, 1, 1])\n\n # switch to color cycle\n setattr(layer, f'{attribute}_color_mode', 'cycle')\n setattr(layer, f'{attribute}_color', 'point_type')\n color = getattr(layer, f'{attribute}_color')\n layer_color = transform_color(color_cycle * int(shape[0] / 2))\n np.testing.assert_allclose(color, layer_color)\n\n # switch back to direct, edge_colors shouldn't change\n setattr(layer, f'{attribute}_color_mode', 'direct')\n new_edge_color = getattr(layer, f'{attribute}_color')\n np.testing.assert_allclose(new_edge_color, color)\n\n\[email protected](\"attribute\", ['edge', 'face'])\ndef test_colormap_without_properties(attribute):\n \"\"\"Setting the colormode to colormap should raise an exception\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n\n with pytest.raises(ValueError):\n setattr(layer, f'{attribute}_color_mode', 'colormap')\n\n\[email protected](\"attribute\", ['edge', 'face'])\ndef test_colormap_with_categorical_properties(attribute):\n \"\"\"Setting the colormode to colormap should raise an exception\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n properties = {'point_type': _make_cycled_properties(['A', 'B'], shape[0])}\n layer = Points(data, properties=properties)\n\n with pytest.raises(TypeError):\n with pytest.warns(UserWarning):\n setattr(layer, f'{attribute}_color_mode', 'colormap')\n\n\[email protected](\"attribute\", ['edge', 'face'])\ndef test_add_colormap(attribute):\n \"\"\"Test directly adding a vispy Colormap object\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n annotations = {'point_type': _make_cycled_properties([0, 1.5], shape[0])}\n color_kwarg = f'{attribute}_color'\n colormap_kwarg = f'{attribute}_colormap'\n args = {color_kwarg: 'point_type', colormap_kwarg: 'viridis'}\n layer = Points(data, properties=annotations, **args)\n\n setattr(layer, f'{attribute}_colormap', get_colormap('gray'))\n layer_colormap = getattr(layer, f'{attribute}_colormap')\n assert 'unnamed colormap' in layer_colormap.name\n\n\[email protected](\"attribute\", ['edge', 'face'])\ndef test_add_point_direct(attribute: str):\n \"\"\"Test adding points to layer directly\"\"\"\n layer = Points()\n assert len(getattr(layer, f'{attribute}_color')) == 0\n setattr(layer, f'current_{attribute}_color', 'red')\n coord = [18, 18]\n layer.add(coord)\n np.testing.assert_allclose(\n [[1, 0, 0, 1]], getattr(layer, f'{attribute}_color')\n )\n\n\[email protected](\"attribute\", ['edge', 'face'])\ndef test_color_direct(attribute: str):\n \"\"\"Test setting colors directly\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer_kwargs = {f'{attribute}_color': 'black'}\n layer = Points(data, **layer_kwargs)\n color_array = transform_color(['black'] * shape[0])\n current_color = getattr(layer, f'current_{attribute}_color')\n layer_color = getattr(layer, f'{attribute}_color')\n assert current_color == 'black'\n assert len(layer.edge_color) == shape[0]\n np.testing.assert_allclose(color_array, layer_color)\n\n # With no data selected changing color has no effect\n setattr(layer, f'current_{attribute}_color', 'blue')\n current_color = getattr(layer, f'current_{attribute}_color')\n assert current_color == 'blue'\n np.testing.assert_allclose(color_array, layer_color)\n\n # Select data and change edge color of selection\n selected_data = {0, 1}\n layer.selected_data = {0, 1}\n current_color = getattr(layer, f'current_{attribute}_color')\n assert current_color == 'black'\n setattr(layer, f'current_{attribute}_color', 'green')\n colorarray_green = transform_color(['green'] * len(layer.selected_data))\n color_array[list(selected_data)] = colorarray_green\n layer_color = getattr(layer, f'{attribute}_color')\n np.testing.assert_allclose(color_array, layer_color)\n\n # Add new point and test its color\n coord = [18, 18]\n layer.selected_data = {}\n setattr(layer, f'current_{attribute}_color', 'blue')\n layer.add(coord)\n color_array = np.vstack([color_array, transform_color('blue')])\n layer_color = getattr(layer, f'{attribute}_color')\n assert len(layer_color) == shape[0] + 1\n np.testing.assert_allclose(color_array, layer_color)\n\n # Check removing data adjusts colors correctly\n layer.selected_data = {0, 2}\n layer.remove_selected()\n assert len(layer.data) == shape[0] - 1\n\n layer_color = getattr(layer, f'{attribute}_color')\n assert len(layer_color) == shape[0] - 1\n np.testing.assert_allclose(\n layer_color,\n np.vstack((color_array[1], color_array[3:])),\n )\n\n\ncolor_cycle_str = ['red', 'blue']\ncolor_cycle_rgb = [[1, 0, 0], [0, 0, 1]]\ncolor_cycle_rgba = [[1, 0, 0, 1], [0, 0, 1, 1]]\n\n\[email protected](\"attribute\", ['edge', 'face'])\[email protected](\n \"color_cycle\",\n [color_cycle_str, color_cycle_rgb, color_cycle_rgba],\n)\ndef test_color_cycle(attribute, color_cycle):\n \"\"\"Test setting edge/face color with a color cycle list\"\"\"\n # create Points using list color cycle\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n properties = {'point_type': _make_cycled_properties(['A', 'B'], shape[0])}\n points_kwargs = {\n 'properties': properties,\n f'{attribute}_color': 'point_type',\n f'{attribute}_color_cycle': color_cycle,\n }\n layer = Points(data, **points_kwargs)\n\n assert layer.properties == properties\n color_array = transform_color(\n list(islice(cycle(color_cycle), 0, shape[0]))\n )\n layer_color = getattr(layer, f'{attribute}_color')\n np.testing.assert_allclose(layer_color, color_array)\n\n # Add new point and test its color\n coord = [18, 18]\n layer.selected_data = {0}\n layer.add(coord)\n layer_color = getattr(layer, f'{attribute}_color')\n assert len(layer_color) == shape[0] + 1\n np.testing.assert_allclose(\n layer_color,\n np.vstack((color_array, transform_color('red'))),\n )\n\n # Check removing data adjusts colors correctly\n layer.selected_data = {0, 2}\n layer.remove_selected()\n assert len(layer.data) == shape[0] - 1\n\n layer_color = getattr(layer, f'{attribute}_color')\n assert len(layer_color) == shape[0] - 1\n np.testing.assert_allclose(\n layer_color,\n np.vstack((color_array[1], color_array[3:], transform_color('red'))),\n )\n\n # test adding a point with a new property value\n layer.selected_data = {}\n current_properties = layer.current_properties\n current_properties['point_type'] = np.array(['new'])\n layer.current_properties = current_properties\n layer.add([10, 10])\n color_manager = getattr(layer, f'_{attribute}')\n color_cycle_map = color_manager.categorical_colormap.colormap\n\n assert 'new' in color_cycle_map\n np.testing.assert_allclose(\n color_cycle_map['new'], np.squeeze(transform_color(color_cycle[0]))\n )\n\n\[email protected](\"attribute\", ['edge', 'face'])\ndef test_color_cycle_dict(attribute):\n \"\"\"Test setting edge/face color with a color cycle dict\"\"\"\n data = np.array([[0, 0], [100, 0], [0, 100]])\n properties = {'my_colors': [2, 6, 3]}\n points_kwargs = {\n 'properties': properties,\n f'{attribute}_color': 'my_colors',\n f'{attribute}_color_cycle': {1: 'green', 2: 'red', 3: 'blue'},\n }\n layer = Points(data, **points_kwargs)\n\n color_manager = getattr(layer, f'_{attribute}')\n color_cycle_map = color_manager.categorical_colormap.colormap\n np.testing.assert_allclose(color_cycle_map[2], [1, 0, 0, 1]) # 2 is red\n np.testing.assert_allclose(color_cycle_map[3], [0, 0, 1, 1]) # 3 is blue\n np.testing.assert_allclose(color_cycle_map[6], [1, 1, 1, 1]) # 6 is white\n\n\[email protected](\"attribute\", ['edge', 'face'])\ndef test_add_color_cycle_to_empty_layer(attribute):\n \"\"\"Test adding a point to an empty layer when edge/face color is a color cycle\n\n See: https://github.com/napari/napari/pull/1069\n \"\"\"\n default_properties = {'point_type': np.array(['A'])}\n color_cycle = ['red', 'blue']\n points_kwargs = {\n 'property_choices': default_properties,\n f'{attribute}_color': 'point_type',\n f'{attribute}_color_cycle': color_cycle,\n }\n layer = Points(**points_kwargs)\n\n # verify the current_edge_color is correct\n expected_color = transform_color(color_cycle[0])[0]\n color_manager = getattr(layer, f'_{attribute}')\n current_color = color_manager.current_color\n np.testing.assert_allclose(current_color, expected_color)\n\n # add a point\n layer.add([10, 10])\n props = {'point_type': np.array(['A'])}\n expected_color = np.array([[1, 0, 0, 1]])\n np.testing.assert_equal(layer.properties, props)\n attribute_color = getattr(layer, f'{attribute}_color')\n np.testing.assert_allclose(attribute_color, expected_color)\n\n # add a point with a new property\n layer.selected_data = []\n layer.current_properties = {'point_type': np.array(['B'])}\n layer.add([12, 12])\n new_color = np.array([0, 0, 1, 1])\n expected_color = np.vstack((expected_color, new_color))\n new_properties = {'point_type': np.array(['A', 'B'])}\n attribute_color = getattr(layer, f'{attribute}_color')\n np.testing.assert_allclose(attribute_color, expected_color)\n np.testing.assert_equal(layer.properties, new_properties)\n\n\[email protected](\"attribute\", ['edge', 'face'])\ndef test_adding_value_color_cycle(attribute):\n \"\"\"Test that adding values to properties used to set a color cycle\n and then calling Points.refresh_colors() performs the update and adds the\n new value to the face/edge_color_cycle_map.\n\n See: https://github.com/napari/napari/issues/988\n \"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n properties = {'point_type': _make_cycled_properties(['A', 'B'], shape[0])}\n color_cycle = ['red', 'blue']\n points_kwargs = {\n 'properties': properties,\n f'{attribute}_color': 'point_type',\n f'{attribute}_color_cycle': color_cycle,\n }\n layer = Points(data, **points_kwargs)\n\n # make point 0 point_type C\n props = layer.properties\n point_types = props['point_type']\n point_types[0] = 'C'\n props['point_type'] = point_types\n layer.properties = props\n\n color_manager = getattr(layer, f'_{attribute}')\n color_cycle_map = color_manager.categorical_colormap.colormap\n color_map_keys = [*color_cycle_map]\n assert 'C' in color_map_keys\n\n\[email protected](\"attribute\", ['edge', 'face'])\ndef test_color_colormap(attribute):\n \"\"\"Test setting edge/face color with a colormap\"\"\"\n # create Points using with a colormap\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n properties = {'point_type': _make_cycled_properties([0, 1.5], shape[0])}\n points_kwargs = {\n 'properties': properties,\n f'{attribute}_color': 'point_type',\n f'{attribute}_colormap': 'gray',\n }\n layer = Points(data, **points_kwargs)\n assert layer.properties == properties\n color_mode = getattr(layer, f'{attribute}_color_mode')\n assert color_mode == 'colormap'\n color_array = transform_color(['black', 'white'] * int(shape[0] / 2))\n attribute_color = getattr(layer, f'{attribute}_color')\n assert np.all(attribute_color == color_array)\n\n # change the color cycle - face_color should not change\n setattr(layer, f'{attribute}_color_cycle', ['red', 'blue'])\n attribute_color = getattr(layer, f'{attribute}_color')\n assert np.all(attribute_color == color_array)\n\n # Add new point and test its color\n coord = [18, 18]\n layer.selected_data = {0}\n layer.add(coord)\n attribute_color = getattr(layer, f'{attribute}_color')\n assert len(attribute_color) == shape[0] + 1\n np.testing.assert_allclose(\n attribute_color,\n np.vstack((color_array, transform_color('black'))),\n )\n\n # Check removing data adjusts colors correctly\n layer.selected_data = {0, 2}\n layer.remove_selected()\n assert len(layer.data) == shape[0] - 1\n attribute_color = getattr(layer, f'{attribute}_color')\n assert len(attribute_color) == shape[0] - 1\n np.testing.assert_allclose(\n attribute_color,\n np.vstack(\n (\n color_array[1],\n color_array[3:],\n transform_color('black'),\n )\n ),\n )\n\n # adjust the clims\n setattr(layer, f'{attribute}_contrast_limits', (0, 3))\n attribute_color = getattr(layer, f'{attribute}_color')\n np.testing.assert_allclose(attribute_color[-2], [0.5, 0.5, 0.5, 1])\n\n # change the colormap\n new_colormap = 'viridis'\n setattr(layer, f'{attribute}_colormap', new_colormap)\n attribute_colormap = getattr(layer, f'{attribute}_colormap')\n assert attribute_colormap.name == new_colormap\n\n\ndef test_size():\n \"\"\"Test setting size with scalar.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n assert layer.current_size == 10\n assert layer.size.shape == shape\n assert np.unique(layer.size)[0] == 10\n\n # Add a new point, it should get current size\n coord = [17, 17]\n layer.add(coord)\n assert layer.size.shape == (11, 2)\n assert np.unique(layer.size)[0] == 10\n\n # Setting size affects newly added points not current points\n layer.current_size = 20\n assert layer.current_size == 20\n assert layer.size.shape == (11, 2)\n assert np.unique(layer.size)[0] == 10\n\n # Add new point, should have new size\n coord = [18, 18]\n layer.add(coord)\n assert layer.size.shape == (12, 2)\n assert np.unique(layer.size[:11])[0] == 10\n assert np.all(layer.size[11] == [20, 20])\n\n # Select data and change size\n layer.selected_data = {0, 1}\n assert layer.current_size == 10\n layer.current_size = 16\n assert layer.size.shape == (12, 2)\n assert np.unique(layer.size[2:11])[0] == 10\n assert np.unique(layer.size[:2])[0] == 16\n\n # Select data and size changes\n layer.selected_data = {11}\n assert layer.current_size == 20\n\n\ndef test_size_with_arrays():\n \"\"\"Test setting size with arrays.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n sizes = 5 * np.random.random(shape)\n layer.size = sizes\n assert np.all(layer.size == sizes)\n\n # Test broadcasting of sizes\n sizes = [5, 5]\n layer.size = sizes\n assert np.all(layer.size[0] == sizes)\n\n # Test broadcasting of transposed sizes\n sizes = np.random.randint(low=1, high=5, size=shape[::-1])\n layer.size = sizes\n np.testing.assert_equal(layer.size, sizes.T)\n\n # Un-broadcastable array should raise an exception\n bad_sizes = np.random.randint(low=1, high=5, size=(3, 8))\n with pytest.raises(ValueError):\n layer.size = bad_sizes\n\n # Create new layer with new size array data\n sizes = 5 * np.random.random(shape)\n layer = Points(data, size=sizes)\n assert layer.current_size == 10\n assert layer.size.shape == shape\n assert np.all(layer.size == sizes)\n\n # Create new layer with new size array data\n sizes = [5, 5]\n layer = Points(data, size=sizes)\n assert layer.current_size == 10\n assert layer.size.shape == shape\n assert np.all(layer.size[0] == sizes)\n\n # Add new point, should have new size\n coord = [18, 18]\n layer.current_size = 13\n layer.add(coord)\n assert layer.size.shape == (11, 2)\n assert np.unique(layer.size[:10])[0] == 5\n assert np.all(layer.size[10] == [13, 13])\n\n # Select data and change size\n layer.selected_data = {0, 1}\n assert layer.current_size == 5\n layer.current_size = 16\n assert layer.size.shape == (11, 2)\n assert np.unique(layer.size[2:10])[0] == 5\n assert np.unique(layer.size[:2])[0] == 16\n\n # Check removing data adjusts colors correctly\n layer.selected_data = {0, 2}\n layer.remove_selected()\n assert len(layer.data) == 9\n assert len(layer.size) == 9\n assert np.all(layer.size[0] == [16, 16])\n assert np.all(layer.size[1] == [5, 5])\n\n\ndef test_size_with_3D_arrays():\n \"\"\"Test setting size with 3D arrays.\"\"\"\n shape = (10, 3)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n data[:2, 0] = 0\n layer = Points(data)\n assert layer.current_size == 10\n assert layer.size.shape == shape\n assert np.unique(layer.size)[0] == 10\n\n sizes = 5 * np.random.random(shape)\n layer.size = sizes\n assert np.all(layer.size == sizes)\n\n # Test broadcasting of sizes\n sizes = [1, 5, 5]\n layer.size = sizes\n assert np.all(layer.size[0] == sizes)\n\n # Create new layer with new size array data\n sizes = 5 * np.random.random(shape)\n layer = Points(data, size=sizes)\n assert layer.current_size == 10\n assert layer.size.shape == shape\n assert np.all(layer.size == sizes)\n\n # Create new layer with new size array data\n sizes = [1, 5, 5]\n layer = Points(data, size=sizes)\n assert layer.current_size == 10\n assert layer.size.shape == shape\n assert np.all(layer.size[0] == sizes)\n\n # Add new point, should have new size in last dim only\n coord = [4, 18, 18]\n layer.current_size = 13\n layer.add(coord)\n assert layer.size.shape == (11, 3)\n assert np.unique(layer.size[:10, 1:])[0] == 5\n assert np.all(layer.size[10] == [1, 13, 13])\n\n # Select data and change size\n layer.selected_data = {0, 1}\n assert layer.current_size == 5\n layer.current_size = 16\n assert layer.size.shape == (11, 3)\n assert np.unique(layer.size[2:10, 1:])[0] == 5\n assert np.all(layer.size[0] == [16, 16, 16])\n\n # Create new 3D layer with new 2D points size data\n sizes = [0, 5, 5]\n layer = Points(data, size=sizes)\n assert layer.current_size == 10\n assert layer.size.shape == shape\n assert np.all(layer.size[0] == sizes)\n\n # Add new point, should have new size only in last 2 dimensions\n coord = [4, 18, 18]\n layer.current_size = 13\n layer.add(coord)\n assert layer.size.shape == (11, 3)\n assert np.all(layer.size[10] == [0, 13, 13])\n\n # Select data and change size\n layer.selected_data = {0, 1}\n assert layer.current_size == 5\n layer.current_size = 16\n assert layer.size.shape == (11, 3)\n assert np.unique(layer.size[2:10, 1:])[0] == 5\n assert np.all(layer.size[0] == [0, 16, 16])\n\n\ndef test_copy_and_paste():\n \"\"\"Test copying and pasting selected points.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n layer = Points(data)\n # Clipboard starts empty\n assert layer._clipboard == {}\n\n # Pasting empty clipboard doesn't change data\n layer._paste_data()\n assert len(layer.data) == 10\n\n # Copying with nothing selected leave clipboard empty\n layer._copy_data()\n assert layer._clipboard == {}\n\n # Copying and pasting with two points selected adds to clipboard and data\n layer.selected_data = {0, 1}\n layer._copy_data()\n layer._paste_data()\n assert len(layer._clipboard.keys()) > 0\n assert len(layer.data) == shape[0] + 2\n assert np.all(layer.data[:2] == layer.data[-2:])\n\n # Pasting again adds two more points to data\n layer._paste_data()\n assert len(layer.data) == shape[0] + 4\n assert np.all(layer.data[:2] == layer.data[-2:])\n\n # Unselecting everything and copying and pasting will empty the clipboard\n # and add no new data\n layer.selected_data = {}\n layer._copy_data()\n layer._paste_data()\n assert layer._clipboard == {}\n assert len(layer.data) == shape[0] + 4\n\n\ndef test_value():\n \"\"\"Test getting the value of the data at the current coordinates.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n data[-1] = [0, 0]\n layer = Points(data)\n value = layer.get_value((0, 0))\n assert value == 9\n\n layer.data = layer.data + 20\n value = layer.get_value((0, 0))\n assert value is None\n\n\ndef test_message():\n \"\"\"Test converting value and coords to message.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n data[-1] = [0, 0]\n layer = Points(data)\n msg = layer.get_status((0,) * 2)\n assert type(msg) == str\n\n\ndef test_thumbnail():\n \"\"\"Test the image thumbnail for square data.\"\"\"\n shape = (10, 2)\n np.random.seed(0)\n data = 20 * np.random.random(shape)\n data[0] = [0, 0]\n data[-1] = [20, 20]\n layer = Points(data)\n layer._update_thumbnail()\n assert layer.thumbnail.shape == layer._thumbnail_shape\n\n\ndef test_thumbnail_with_n_points_greater_than_max():\n \"\"\"Test thumbnail generation with n_points > _max_points_thumbnail\n\n see: https://github.com/napari/napari/pull/934\n \"\"\"\n # 2D\n max_points = Points._max_points_thumbnail * 2\n bigger_data = np.random.randint(10, 100, (max_points, 2))\n big_layer = Points(bigger_data)\n big_layer._update_thumbnail()\n assert big_layer.thumbnail.shape == big_layer._thumbnail_shape\n\n # #3D\n bigger_data_3d = np.random.randint(10, 100, (max_points, 3))\n bigger_layer_3d = Points(bigger_data_3d)\n bigger_layer_3d._slice_dims(ndisplay=3)\n bigger_layer_3d._update_thumbnail()\n assert bigger_layer_3d.thumbnail.shape == bigger_layer_3d._thumbnail_shape\n\n\ndef test_view_data():\n coords = np.array([[0, 1, 1], [0, 2, 2], [1, 3, 3], [3, 3, 3]])\n layer = Points(coords)\n\n layer._slice_dims([0, slice(None), slice(None)])\n assert np.all(\n layer._view_data == coords[np.ix_([0, 1], layer._dims_displayed)]\n )\n\n layer._slice_dims([1, slice(None), slice(None)])\n assert np.all(\n layer._view_data == coords[np.ix_([2], layer._dims_displayed)]\n )\n\n layer._slice_dims([1, slice(None), slice(None)], ndisplay=3)\n assert np.all(layer._view_data == coords)\n\n\ndef test_view_size():\n coords = np.array([[0, 1, 1], [0, 2, 2], [1, 3, 3], [3, 3, 3]])\n sizes = np.array([[3, 5, 5], [3, 5, 5], [3, 3, 3], [2, 2, 3]])\n layer = Points(coords, size=sizes, n_dimensional=False)\n\n layer._slice_dims([0, slice(None), slice(None)])\n assert np.all(\n layer._view_size == sizes[np.ix_([0, 1], layer._dims_displayed)]\n )\n\n layer._slice_dims([1, slice(None), slice(None)])\n assert np.all(\n layer._view_size == sizes[np.ix_([2], layer._dims_displayed)]\n )\n\n layer.n_dimensional = True\n assert len(layer._view_size) == 3\n\n # test a slice with no points\n layer.n_dimensional = False\n layer._slice_dims([2, slice(None), slice(None)])\n assert np.all(layer._view_size == [])\n\n\ndef test_view_colors():\n coords = [[0, 1, 1], [0, 2, 2], [1, 3, 3], [3, 3, 3]]\n face_color = np.array(\n [[1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1, 1], [0, 0, 1, 1]]\n )\n edge_color = np.array(\n [[0, 0, 1, 1], [1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1, 1]]\n )\n\n layer = Points(coords, face_color=face_color, edge_color=edge_color)\n layer._slice_dims([0, slice(None), slice(None)])\n assert np.all(layer._view_face_color == face_color[[0, 1]])\n assert np.all(layer._view_edge_color == edge_color[[0, 1]])\n\n layer._slice_dims([1, slice(None), slice(None)])\n assert np.all(layer._view_face_color == face_color[[2]])\n assert np.all(layer._view_edge_color == edge_color[[2]])\n\n # view colors should return empty array if there are no points\n layer._slice_dims([2, slice(None), slice(None)])\n assert len(layer._view_face_color) == 0\n assert len(layer._view_edge_color) == 0\n\n\ndef test_interaction_box():\n \"\"\"Test the boxes calculated for selected points\"\"\"\n data = [[3, 3]]\n size = 2\n layer = Points(data, size=size)\n\n # get a box with no points selected\n index = []\n box = layer.interaction_box(index)\n assert box is None\n\n # get a box with a point selected\n index = [0]\n expected_box = points_to_squares(data, size)\n box = layer.interaction_box(index)\n np.all([np.isin(p, expected_box) for p in box])\n\n\ndef test_world_data_extent():\n \"\"\"Test extent after applying transforms.\"\"\"\n data = [(7, -5, 0), (-2, 0, 15), (4, 30, 12)]\n min_val = (-2, -5, 0)\n max_val = (7, 30, 15)\n layer = Points(data)\n extent = np.array((min_val, max_val))\n check_layer_world_data_extent(layer, extent, (3, 1, 1), (10, 20, 5))\n\n\ndef test_slice_data():\n data = [\n (10, 2, 4),\n (10 + 2 * 1e-7, 4, 6),\n (8, 1, 7),\n (10.1, 7, 2),\n (10 - 2 * 1e-7, 1, 6),\n ]\n layer = Points(data)\n assert len(layer._slice_data((8, slice(None), slice(None)))[0]) == 1\n assert len(layer._slice_data((10, slice(None), slice(None)))[0]) == 3\n assert (\n len(layer._slice_data((10 + 2 * 1e-12, slice(None), slice(None)))[0])\n == 3\n )\n assert len(layer._slice_data((10.1, slice(None), slice(None)))[0]) == 1\n\n\ndef test_scale_init():\n layer = Points(None, scale=(1, 1, 1, 1))\n assert layer.ndim == 4\n layer1 = Points([], scale=(1, 1, 1, 1))\n assert layer1.ndim == 4\n layer2 = Points([])\n assert layer2.ndim == 2\n\n with pytest.raises(ValueError):\n Points([[1, 1, 1]], scale=(1, 1, 1, 1))\n\n\ndef test_update_none():\n layer = Points([(1, 2, 3), (1, 3, 2)])\n assert layer.ndim == 3\n assert layer.data.size == 6\n layer.data = None\n assert layer.ndim == 3\n assert layer.data.size == 0\n layer.data = [(1, 2, 3), (1, 3, 2)]\n assert layer.ndim == 3\n assert layer.data.size == 6\n\n\ndef test_prepare_properties():\n layer = Points([(1, 2, 3), (1, 3, 2)])\n properties, choices = layer._prepare_properties({\"aa\": [1, 2]})\n assert list(properties.keys()) == [\"aa\"]\n assert np.array_equal(properties[\"aa\"], [1, 2])\n assert list(choices.keys()) == [\"aa\"]\n assert np.array_equal(choices[\"aa\"], [1, 2])\n assert layer._prepare_properties({}) == ({}, {})\n assert layer._prepare_properties({}, {}) == ({}, {})\n properties, choices = layer._prepare_properties({}, {\"aa\": [1, 2]})\n assert list(properties.keys()) == [\"aa\"]\n assert np.array_equal(properties[\"aa\"], [None, None])\n assert list(choices.keys()) == [\"aa\"]\n assert np.array_equal(choices[\"aa\"], [1, 2])\n properties, choices = layer._prepare_properties(\n {\"aa\": [1, 3]}, {\"aa\": [1, 2]}\n )\n assert list(properties.keys()) == [\"aa\"]\n assert np.array_equal(properties[\"aa\"], [1, 3])\n assert list(choices.keys()) == [\"aa\"]\n assert np.array_equal(choices[\"aa\"], [1, 2, 3])\n properties, choices = layer._prepare_properties(\n {\"aa\": [1, 3]}, {\"aa\": [1, 2], \"bb\": [7, 6]}\n )\n assert list(properties.keys()) == [\"aa\"]\n assert np.array_equal(properties[\"aa\"], [1, 3])\n assert list(choices.keys()) == [\"aa\"]\n assert np.array_equal(choices[\"aa\"], [1, 2, 3])\n properties, choices = layer._prepare_properties(\n {\"aa\": [1, 3]}, {\"aa\": [1, 2], \"bb\": [7, 6]}, save_choices=True\n )\n assert list(properties.keys()) == [\"aa\", \"bb\"]\n assert np.array_equal(properties[\"aa\"], [1, 3])\n assert np.array_equal(properties[\"bb\"], [None, None])\n assert list(choices.keys()) == [\"aa\", \"bb\"]\n assert np.array_equal(choices[\"aa\"], [1, 2, 3])\n assert np.array_equal(choices[\"bb\"], [6, 7])\n\n layer = Points([(1, 2, 3), (1, 3, 2), (1, 3, 3)])\n properties, choices = layer._prepare_properties({\"aa\": [1, 2, 1]})\n assert np.array_equal(properties[\"aa\"], [1, 2, 1])\n assert np.array_equal(choices[\"aa\"], [1, 2])\n\n\ndef test_set_face_color_mode_after_set_properties():\n # See GitHub issue for more details:\n # https://github.com/napari/napari/issues/2755\n np.random.seed(0)\n num_points = 3\n points = Points(np.random.random((num_points, 2)))\n\n points.properties = {\n 'cat': np.random.randint(low=0, high=num_points, size=num_points),\n 'cont': np.random.random(num_points),\n }\n\n # Initially the color_mode is DIRECT, which means that the face ColorManager\n # has no color_properties, so the first property is used with a warning.\n with pytest.warns(UserWarning):\n points.face_color_mode = 'cycle'\n\n first_property_key, first_property_values = next(\n iter(points.properties.items())\n )\n expected_properties = ColorProperties(\n name=first_property_key,\n values=first_property_values,\n current_value=first_property_values[-1],\n )\n assert points._face.color_properties == expected_properties\n"
] | [
[
"numpy.testing.assert_equal",
"numpy.random.seed",
"numpy.asarray",
"numpy.add",
"numpy.testing.assert_allclose",
"numpy.vstack",
"numpy.append",
"numpy.isin",
"numpy.unique",
"numpy.repeat",
"numpy.all",
"numpy.ix_",
"numpy.empty",
"pandas.DataFrame",
"numpy.random.random",
"numpy.array_equal",
"numpy.array",
"numpy.concatenate",
"numpy.random.randint"
]
] |
hpgit/HumanFoot | [
"f9a1a341b7c43747bddcd5584b8c98a0d1ac2973"
] | [
"DartWalkingFoot/main_DartTrackingFoot1.py"
] | [
"from fltk import *\nimport copy\nimport os.path\nfrom cPickle import load\n# import time\nimport numpy as np\n\nimport sys\nif \"..\" not in sys.path:\n sys.path.append(\"..\")\n\nfrom PyCommon.modules.ArticulatedBody import hpBipedFeedback as hbf\n\nfrom PyCommon.modules.Math import mmMath as mm\nfrom PyCommon.modules.Math import ysFunctionGraph as yfg\nfrom PyCommon.modules.Renderer import ysRenderer as yr\n# from PyCommon.modules.Simulator import ysVpUtil as yvu\nfrom PyCommon.modules.GUI import ysSimpleViewer_ori as ysv\nfrom PyCommon.modules.GUI import ysMultiViewer as ymv\n# from PyCommon.modules.ArticulatedBody import ysControl as yct\n# from PyCommon.modules.ArticulatedBody import ysReferencePoints as yrp\nfrom PyCommon.modules.Motion import ysMotionAnalysis as yma\nfrom PyCommon.modules.Motion import ysBipedAnalysis as yba\nfrom PyCommon.modules.Motion import ysMotion as ym\nfrom PyCommon.modules.Motion import ysMotionBlend as ymb\nfrom PyCommon.modules.Motion import ysMotionExtend as ymt\n# from PyCommon.modules.Motion import ysSkeletonEdit as yhe\nfrom PyCommon.modules.Motion import mmAnalyticIK as aik\nfrom PyCommon.modules.Util import ysMatplotEx as ymp\nfrom PyCommon.modules.Resource import ysMotionLoader as yf\nfrom PyCommon.modules.Simulator import ysPhysConfig as ypc\n\nfrom PyCommon.modules.Simulator import hpDartLCPSimulator as hdls\nfrom PyCommon.modules.GUI import hpSimpleViewer as hsv\nfrom PyCommon.modules.Util import ysPythonEx as ype\n\nfrom PyCommon.modules import pydart2 as pydart\nfrom PyCommon.modules.Simulator import csDartModel as cpm\nfrom pdcontroller import PDController\n\nfrom PyCommon.modules.ArticulatedBody import hpFootIK as hfi\n\nimport math\n# from matplotlib import collections\n\nimport multiprocessing as mp\nimport cma\n\ncurrent_path = os.path.dirname(os.path.abspath(__file__))\n\n# MOTION_COLOR = (128,128,128)\n# CHARACTER_COLOR = (102,102,153)\nMOTION_COLOR = (213, 111, 162)\nCHARACTER_COLOR = (20, 166, 188)\n\nMAX_FRAME = 1500\n\nSEGMENT_FOOT = True\nSEGMENT_FOOT_MAG = .03\nSEGMENT_FOOT_RAD = SEGMENT_FOOT_MAG * .5\n\ndef buildMassMap():\n massMap = {}\n massMap = massMap.fromkeys(['Head', 'Head_Effector', 'Hips',\n 'LeftArm', 'LeftFoot', 'LeftForeArm', 'LeftHand', 'LeftHand_Effector',\n 'LeftLeg', 'LeftShoulder1', 'LeftUpLeg',\n 'RightArm', 'RightFoot', 'RightForeArm', 'RightHand', 'RightHand_Effector',\n 'RightLeg', 'RightShoulder', 'RightUpLeg',\n 'Spine', 'Spine1',\n 'RightFoot_foot_0_0', 'RightFoot_foot_0_1', 'RightFoot_foot_0_1_Effector',\n 'RightFoot_foot_1_0', 'RightFoot_foot_1_1', 'RightFoot_foot_1_1_Effector',\n 'RightFoot_foot_2_0', 'RightFoot_foot_2_1', 'RightFoot_foot_2_1_Effector',\n 'LeftFoot_foot_0_0', 'LeftFoot_foot_0_1', 'LeftFoot_foot_0_1_Effector',\n 'LeftFoot_foot_1_0', 'LeftFoot_foot_1_1', 'LeftFoot_foot_1_1_Effector',\n 'LeftFoot_foot_2_0', 'LeftFoot_foot_2_1', 'LeftFoot_foot_2_1_Effector',\n ], 0.)\n\n # torso : 10\n massMap['Hips'] += 2.\n massMap['Spine'] += 8.\n\n # head : 3\n massMap['Spine1'] += 3.\n\n # right upper arm : 2\n massMap['RightArm'] += 2.\n\n # left upper arm : 2\n massMap['LeftArm'] += 2.\n\n # right lower arm : 1\n massMap['RightForeArm'] = 1.\n # massMap['RightForeArm'] = 2.\n\n # left lower arm : 1\n massMap['LeftForeArm'] = 1.\n # massMap['LeftForeArm'] = 2.\n\n # right thigh : 7\n massMap['Hips'] += 2.\n massMap['RightUpLeg'] += 5.\n\n # left thigh : 7\n massMap['Hips'] += 2.\n massMap['LeftUpLeg'] += 5.\n\n # right shin : 5\n massMap['RightLeg'] += 5.\n\n # left shin : 5\n massMap['LeftLeg'] += 5.\n\n # right foot : 4\n massMap['RightFoot'] += 2.\n # massMap['RightFoot'] += .4\n\n # left foot : 4\n massMap['LeftFoot'] += 2.\n # massMap['LeftFoot'] += .4\n '''\n massMap['RightFoot_foot_0_0'] = .3\n massMap['RightFoot_foot_0_1'] = .3\n massMap['RightFoot_foot_1_0'] = .3\n massMap['RightFoot_foot_1_1'] = .3\n massMap['RightFoot_foot_2_0'] = .3\n massMap['RightFoot_foot_2_1'] = .3\n massMap['LeftFoot_foot_0_0'] = .3\n massMap['LeftFoot_foot_0_1'] = .3\n massMap['LeftFoot_foot_1_0'] = .3\n massMap['LeftFoot_foot_1_1'] = .3\n massMap['LeftFoot_foot_2_0'] = .3\n massMap['LeftFoot_foot_2_1'] = .3\n #'''\n\n massMap['RightFoot_foot_0_0'] = .1\n massMap['RightFoot_foot_0_1'] = .1\n massMap['RightFoot_foot_0_0_0'] = .1\n massMap['RightFoot_foot_0_1_0'] = .1\n massMap['RightFoot_foot_1_0'] = .1\n massMap['RightFoot_foot_1_1'] = .1\n massMap['RightFoot_foot_1_2'] = .1\n massMap['LeftFoot_foot_0_0'] = .1\n massMap['LeftFoot_foot_0_1'] = .1\n massMap['LeftFoot_foot_0_0_0'] = .1\n massMap['LeftFoot_foot_0_1_0'] = .1\n massMap['LeftFoot_foot_1_0'] = .1\n massMap['LeftFoot_foot_1_1'] = .1\n massMap['LeftFoot_foot_1_2'] = .1\n\n return massMap\n\n\ndef buildMcfg():\n massMap = buildMassMap()\n mcfg = ypc.ModelConfig()\n mcfg.defaultDensity = 1000.\n mcfg.defaultBoneRatio = .9\n\n totalMass = 0.\n for name in massMap:\n node = mcfg.addNode(name)\n node.mass = massMap[name]\n # totalMass += node.mass\n\n # width : x axis on body frame\n # height: y axis on body frame\n # length: z axis on body frame\n node = mcfg.getNode('Hips')\n node.length = .2\n node.width = .25\n\n node = mcfg.getNode('Spine1')\n node.length = .2\n node.offset = (0,0,0.1)\n\n node = mcfg.getNode('Spine')\n node.width = .22\n\n node = mcfg.getNode('RightFoot')\n node.length = .25\n # node.length = .27\n # node.offset = (0,0,0.01)\n node.width = .1\n node.geom = 'MyFoot1'\n\n node = mcfg.getNode('LeftFoot')\n node.length = .25\n # node.length = .27\n # node.offset = (0,0,0.01)\n node.width = .1\n node.geom = 'MyFoot1'\n\n def capsulize(node_name):\n node_capsule = mcfg.getNode(node_name)\n node_capsule.geom = 'MyFoot4'\n node_capsule.width = 0.01\n node_capsule.density = 200.\n # node.addGeom('MyFoot4', [np.array([0.]*3), mm.exp([0., math.pi/4., 0.])], ypc.CapsuleMaterial(1000., .02, .2))\n # node.addGeom('MyFoot4', [np.array([0.]*3), mm.exp([0., math.pi/4., 0.])], ypc.CapsuleMaterial(1000., .02, .1))\n # node.addGeom('MyFoot4', [np.array([0.]*3), mm.exp([0., 0., 0.])], ypc.CapsuleMaterial(1000., .01, -1))\n # node.addGeom('MyFoot4', None, ypc.CapsuleMaterial(1000., .02, .1))\n\n # capsulize('RightFoot')\n # capsulize('LeftFoot')\n\n if SEGMENT_FOOT:\n node = mcfg.getNode('RightFoot')\n node.density = 200.\n node.geom = 'MyFoot5'\n node.width = 0.01\n node.jointType = 'B'\n\n node = mcfg.getNode('LeftFoot')\n node.density = 200.\n node.geom = 'MyFoot5'\n node.width = 0.01\n node.jointType = 'B'\n\n # bird foot\n # capsulize('RightFoot_foot_0_0')\n # capsulize('RightFoot_foot_0_1')\n # capsulize('RightFoot_foot_1_0')\n # capsulize('RightFoot_foot_1_1')\n # capsulize('RightFoot_foot_2_0')\n # capsulize('RightFoot_foot_2_1')\n # capsulize('LeftFoot_foot_0_0')\n # capsulize('LeftFoot_foot_0_1')\n # capsulize('LeftFoot_foot_1_0')\n # capsulize('LeftFoot_foot_1_1')\n # capsulize('LeftFoot_foot_2_0')\n # capsulize('LeftFoot_foot_2_1')\n\n\n # human foot\n if SEGMENT_FOOT:\n footJointType = 'B'\n capsulDensity = 400.\n\n # RightFoot_foot_0_0 : outside metatarsals\n capsulize('RightFoot_foot_0_0')\n node = mcfg.getNode('RightFoot_foot_0_0')\n node.addGeom('MyFoot3', [SEGMENT_FOOT_MAG*np.array([-0.3, 0., 2.5*0.25]), mm.exp([0., -math.atan2(1.2, 2.5), 0.])],\n ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, SEGMENT_FOOT_MAG*2.5 + 2.*SEGMENT_FOOT_RAD))\n node.addGeom('MyFoot3', [SEGMENT_FOOT_MAG*np.array([-0.3-1.2, 0., 2.5*0.25]), mm.exp([0., -math.atan2(1.2, 2.5), 0.])],\n ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, SEGMENT_FOOT_MAG*2.5 + 2.*SEGMENT_FOOT_RAD))\n # node.addGeom('MyFoot4', [0.02*np.array([-1.2, 0., 0.]), mm.exp([0., 0., 0.])], ypc.CapsuleMaterial(1000., .01, -1))\n node.jointType = footJointType\n\n # RightFoot_foot_0_0_0 : outside phalanges\n capsulize('RightFoot_foot_0_0_0')\n node = mcfg.getNode('RightFoot_foot_0_0_0')\n node.addGeom('MyFoot4', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.addGeom('MyFoot4', [SEGMENT_FOOT_MAG*np.array([-1.2, 0., 0.]), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.jointType = footJointType\n\n # RightFoot_foot_0_1 : inside metatarsals\n capsulize('RightFoot_foot_0_1')\n node = mcfg.getNode('RightFoot_foot_0_1')\n node.addGeom('MyFoot3', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.addGeom('MyFoot3', [SEGMENT_FOOT_MAG*np.array([1.2, 0., 0.]), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity,SEGMENT_FOOT_RAD, -1))\n node.jointType = footJointType\n\n # RightFoot_foot_0_1_0 : inside phalanges\n capsulize('RightFoot_foot_0_1_0')\n node = mcfg.getNode('RightFoot_foot_0_1_0')\n node.addGeom('MyFoot4', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.addGeom('MyFoot4', [SEGMENT_FOOT_MAG*np.array([1.2, 0., 0.]), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.jointType = footJointType\n\n # RightFoot_foot_1_0 : center heel\n capsulize('RightFoot_foot_1_0')\n node = mcfg.getNode('RightFoot_foot_1_0')\n node.addGeom('MyFoot3', [SEGMENT_FOOT_MAG*np.array([0., 0., .7]), mm.exp([0.]*3)],\n ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, SEGMENT_FOOT_MAG*2. + SEGMENT_FOOT_RAD * 2.))\n # node.addGeom('MyFoot4', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(1000., .01, -1))\n node.jointType = footJointType\n\n # RightFoot_foot_1_1 : inside heel\n capsulize('RightFoot_foot_1_1')\n node = mcfg.getNode('RightFoot_foot_1_1')\n node.addGeom('MyFoot3', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.jointType = footJointType\n\n # RightFoot_foot_1_2 : outside heel\n capsulize('RightFoot_foot_1_2')\n node = mcfg.getNode('RightFoot_foot_1_2')\n node.addGeom('MyFoot3', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.jointType = footJointType\n\n\n capsulize('LeftFoot_foot_0_0')\n node = mcfg.getNode('LeftFoot_foot_0_0')\n node.addGeom('MyFoot3', [SEGMENT_FOOT_MAG*np.array([0.3, 0., 2.5*0.25]), mm.exp([0., math.atan2(1.2, 2.5), 0.])],\n ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, SEGMENT_FOOT_MAG*2.5+2.*SEGMENT_FOOT_RAD))\n node.addGeom('MyFoot3', [SEGMENT_FOOT_MAG*np.array([0.3+1.2, 0., 2.5*0.25]), mm.exp([0., math.atan2(1.2, 2.5), 0.])],\n ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, SEGMENT_FOOT_MAG*2.5+2.*SEGMENT_FOOT_RAD))\n # node.addGeom('MyFoot4', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(1000., .01, -1))\n node.jointType = footJointType\n\n capsulize('LeftFoot_foot_0_0_0')\n node = mcfg.getNode('LeftFoot_foot_0_0_0')\n node.addGeom('MyFoot4', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.addGeom('MyFoot4', [SEGMENT_FOOT_MAG*np.array([1.2, 0., 0.]), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.jointType = footJointType\n\n capsulize('LeftFoot_foot_0_1')\n node = mcfg.getNode('LeftFoot_foot_0_1')\n node.addGeom('MyFoot3', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.addGeom('MyFoot3', [SEGMENT_FOOT_MAG*np.array([-1.2, 0., 0.]), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.jointType = footJointType\n\n capsulize('LeftFoot_foot_0_1_0')\n node = mcfg.getNode('LeftFoot_foot_0_1_0')\n node.addGeom('MyFoot4', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.addGeom('MyFoot4', [SEGMENT_FOOT_MAG*np.array([-1.2, 0., 0.]), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.jointType = footJointType\n\n capsulize('LeftFoot_foot_1_0')\n node = mcfg.getNode('LeftFoot_foot_1_0')\n node.addGeom('MyFoot3', [SEGMENT_FOOT_MAG*np.array([0., 0., .7]), mm.exp([0.]*3)],\n ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, SEGMENT_FOOT_MAG*2.0+2.*SEGMENT_FOOT_RAD))\n # node.addGeom('MyFoot4', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(1000., .01, -1))\n node.jointType = footJointType\n\n capsulize('LeftFoot_foot_1_1')\n node = mcfg.getNode('LeftFoot_foot_1_1')\n node.addGeom('MyFoot3', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.jointType = footJointType\n\n capsulize('LeftFoot_foot_1_2')\n node = mcfg.getNode('LeftFoot_foot_1_2')\n node.addGeom('MyFoot3', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(capsulDensity, SEGMENT_FOOT_RAD, -1))\n node.jointType = footJointType\n\n\n return mcfg\n\n\ndef walkings(params, isCma=True):\n \"\"\"\n\n :type params: list[float]\n :return:\n \"\"\"\n class ForceInfo:\n def __init__(self, startFrame, duration, force):\n self.startFrame = startFrame # frame\n self.duration = duration # sec\n self.force = force # Newton\n self.targetBody = None\n\n #===============================================================================\n # load motion\n #===============================================================================\n MULTI_VIEWER = False\n CAMERA_TRACKING = False\n TORQUE_PLOT = False\n NO_FOOT_SLIDING = True\n\n # global parameters\n # Kt = 50.\n Kt = 300.\n Dt = 2.*(Kt**.5)\n # Dt = Kt/900.\n Ks = 1000.\n Ds = 2.*(Ks**.5)\n mu = 1.\n # Dt = 0.\n\n # constants\n c_min_contact_vel = 100.\n # c_min_contact_vel = 2.\n c_min_contact_time = .7\n c_landing_duration = .2\n c_taking_duration = .3\n # c_swf_mid_offset = .02\n c_swf_mid_offset = .0\n c_locking_vel = .05\n\n c_swf_offset = .0\n # c_swf_offset = .01\n # c_swf_offset = .005\n K_stp_pos = 0.\n\n # c5 = .5; c6 = .01\n c5 = .5; c6 = .02\n # c5 = .5; c6 = .05\n # c5 = 1.; c6 = .05\n # c5 = .0; c6 = .0\n\n K_stb_vel = .1\n K_stb_pos = .1\n\n OLD_SWING_HEIGHT = False\n # OLD_SWING_HEIGHT = True\n # HIGHER_OFFSET = True\n HIGHER_OFFSET = False\n\n motionDir = current_path+'/ppmotion/'\n # motionDir = './ppmotion/'\n #\n ## K_swp_vel_sag = .1; K_swp_vel_cor = .4; K_swp_pos_sag = .3; K_swp_pos_cor = 0.\n # K_swp_vel_sag = .05; K_swp_vel_cor = .2; K_swp_pos_sag = .2; K_swp_pos_cor = .2\n # K_swp_pos_sag_faster = .05\n # filename = 'wd2_WalkSameSame01.bvh'\n ## filename = 'wd2_WalkSameSame01_REPEATED.bvh'\n\n ## K_swp_vel_sag = .1; K_swp_vel_cor = .4; K_swp_pos_sag = .3; K_swp_pos_cor = 0.\n # K_swp_vel_sag = .05; K_swp_vel_cor = .25; K_swp_pos_sag = .5; K_swp_pos_cor = .2\n # K_swp_pos_sag_faster = .05\n # filename = 'wd2_WalkForwardSlow01.bvh'\n ## filename = 'wd2_WalkForwardSlow01_REPEATED.bvh' # 3 frame diff\n\n # K_swp_vel_sag = .1; K_swp_vel_cor = .4; K_swp_pos_sag = 1.; K_swp_pos_cor = 0.\n # K_stp_pos = .6\n K_swp_vel_sag = .0; K_swp_vel_cor = .3; K_swp_pos_sag = 1.2; K_swp_pos_cor = .2\n # K_swp_vel_sag = .0; K_swp_vel_cor = 1.3; K_swp_pos_sag = 1.2; K_swp_pos_cor = 1.\n K_swp_pos_sag_faster = .05\n # filename = 'wd2_WalkForwardNormal00.bvh'\n filename = 'wd2_WalkForwardNormal00_REPEATED.bvh'\n if SEGMENT_FOOT:\n filename = 'segfoot_'+filename\n\n ## K_swp_vel_sag = .1; K_swp_vel_cor = .4; K_swp_pos_sag = .3; K_swp_pos_cor = 0.\n ## K_stp_pos = 0.\n # K_swp_vel_sag = .05; K_swp_vel_cor = .2; K_swp_pos_sag = .3; K_swp_pos_cor = .2\n # K_swp_pos_sag_faster = .05\n ## filename = 'wd2_WalkHandWav00.bvh'\n # filename = 'wd2_WalkHandWav00_REPEATED.bvh'\n\n # mu = 2.\n ## K_swp_vel_sag = .1; K_swp_vel_cor = .4; K_swp_pos_sag = .3; K_swp_pos_cor = 0.\n ## K_stp_pos = 0.\n # K_swp_vel_sag = .0; K_swp_vel_cor = .3; K_swp_pos_sag = .2; K_swp_pos_cor = .2\n # K_swp_pos_sag_faster = .0\n ## filename = 'wd2_WalkAzuma01.bvh'\n # filename = 'wd2_WalkAzuma01_REPEATED.bvh' # 2 frame diff\n\n ## K_swp_vel_sag = .1; K_swp_vel_cor = .4; K_swp_pos_sag = 1.; K_swp_pos_cor = 0.\n ## K_stp_pos = 0.\n # K_swp_vel_sag = .0; K_swp_vel_cor = .3; K_swp_pos_sag = .2; K_swp_pos_cor = .2\n # K_swp_pos_sag_faster = .05\n ## filename = 'wd2_WalkSoldier00.bvh' # K_swp_pos_sag = .0\n # filename = 'wd2_WalkSoldier00_REPEATED.bvh'\n\n # mu = 2.\n # # K_swp_vel_sag = .2; K_swp_vel_cor = .4; K_swp_pos_sag = .5;K_swp_pos_cor = 0.\n # # K_stp_pos = 0.\n # K_swp_vel_sag = .05; K_swp_vel_cor = .3; K_swp_pos_sag = .5; K_swp_pos_cor = .2\n # K_swp_pos_sag_faster = .05\n # # filename = 'wd2_WalkForwardVFast00.bvh'\n # filename = 'wd2_WalkForwardVFast00_REPEATED.bvh'\n\n ## K_swp_vel_sag = .0; K_swp_vel_cor = .4; K_swp_pos_sag = .04; K_swp_pos_cor = .1\n ## K_swp_pos_sag_faster = .02\n ## K_stb_vel = .2\n # K_swp_vel_sag = .1; K_swp_vel_cor = .3; K_swp_pos_sag = 1.; K_swp_pos_cor = .3\n # K_swp_pos_sag_faster = .0\n # K_stb_vel = .3\n ## filename = 'wd2_WalkBackward00.bvh'\n # filename = 'wd2_WalkBackward00_REPEATED.bvh'\n\n\n # parameters\n if params is not None:\n _params = np.around(params, decimals=3)\n Ks = 1000.\n Ds = 2.*(Ks**.5)\n c_min_contact_vel = 100.\n # c_min_contact_vel = 2.\n c_min_contact_time = .7\n c_landing_duration = .2\n c_taking_duration = .3\n c_swf_mid_offset = .02\n # c_swf_mid_offset = .0\n c_locking_vel = .05\n\n c_swf_offset = .0\n # c_swf_offset = .01\n # c_swf_offset = .005\n K_stp_pos = _params[0]*_params[0]\n c5 = _params[1]*_params[1]\n c6 = _params[2]*_params[2]\n K_stb_vel = _params[3]*_params[3]\n K_stb_pos = _params[4]*_params[4]\n K_swp_vel_sag = _params[5]*_params[5]\n K_swp_vel_cor = _params[6]*_params[6]\n K_swp_pos_sag = _params[7]*_params[7]\n K_swp_pos_cor = _params[8]*_params[8]\n K_swp_pos_sag_faster = _params[9]*_params[9]\n\n # motion\n bvh = yf.readBvhFileAsBvh(motionDir+filename)\n\n if SEGMENT_FOOT:\n # partBvhFilePath = '../PyCommon/modules/samples/simpleJump_long_test2.bvh'\n partBvhFilePath = current_path+'/../PyCommon/modules/samples/simpleJump_long_test2.bvh'\n partBvh = yf.readBvhFileAsBvh(partBvhFilePath)\n bvh.replaceJointFromBvh('RightFoot', partBvh, SEGMENT_FOOT_MAG)\n partBvh = yf.readBvhFileAsBvh(partBvhFilePath)\n partBvh.mirror('YZ')\n bvh.replaceJointFromBvh('LeftFoot', partBvh, SEGMENT_FOOT_MAG)\n\n motion_ori = bvh.toJointMotion(1., False)\n\n # motion_ori = yf.readBvhFile(motionDir+filename)\n frameTime = 1/motion_ori.fps\n\n if 'REPEATED' in filename:\n REPEATED = True\n CAMERA_TRACKING = True\n else:\n REPEATED = False\n\n #===============================================================================\n # options\n #===============================================================================\n SEGMENT_EDITING = True\n STANCE_FOOT_STABILIZE = True\n MATCH_STANCE_LEG = True\n SWING_FOOT_PLACEMENT = True\n SWING_FOOT_HEIGHT = True\n\n SWING_FOOT_ORIENTATION = False\n\n STANCE_FOOT_PUSH = True\n STANCE_FOOT_BALANCING = True\n # STANCE_FOOT_BALANCING = False\n\n SWING_FOOT_CLEARANCE = True\n\n SEGMENT_GAIN_ADJUST = True\n\n stitch_func = lambda xx : 1. - yfg.hermite2nd(xx)\n stf_stabilize_func = yfg.concatenate([yfg.hermite2nd, yfg.one], [c_landing_duration])\n match_stl_func = yfg.hermite2nd\n swf_placement_func = yfg.hermite2nd\n # swf_placement_func = yfg.identity\n swf_height_func = yfg.hermite2nd\n swf_height_sine_func = yfg.sine\n # stf_balancing_func = yfg.concatenate([yfg.hermite2nd, yfg.one], [c_landing_duration])\n stf_balancing_func = yfg.hermite2nd\n # stf_balancing_func = yfg.hermite5th\n\n # forceInfos = [ForceInfo(70, .4, (100,0,0))]\n forceInfos = []\n\n #===============================================================================\n # initialize character\n #===============================================================================\n # mcfgfile = open(dir + 'mcfg', 'r')\n # mcfg = cPickle.load(mcfgfile)\n # mcfgfile.close()\n\n mcfg = buildMcfg()\n\n wcfg = ypc.WorldConfig()\n wcfg.planeHeight = 0.\n wcfg.useDefaultContactModel = False\n wcfg.lockingVel = c_locking_vel\n stepsPerFrame = 50\n wcfg.timeStep = frameTime/stepsPerFrame\n\n pydart.init()\n dartModel = cpm.DartModel(wcfg, motion_ori[0], mcfg, False)\n dartMotionModel = None # type: cpm.DartModel\n if not isCma:\n dartMotionModel = cpm.DartModel(wcfg, motion_ori[0], mcfg)\n # q = dartModel.skeleton.q\n # q[0:3] = mm.logSO3(motion_ori.getJointOrientationGlobal(0, 0))\n # q[3:6] = motion_ori.getJointPositionGlobal(0, 0)\n # dartModel.skeleton.set_positions(q)\n # q[3:6] = motion_ori.getJointPositionGlobal(0, 0)\n # pdController = PDController(dartModel.skeleton, wcfg.timeStep, Kt=1000., Dt=50.)\n pdController = PDController(dartModel.skeleton, wcfg.timeStep)\n # dartModel.skeleton.set_controller(pdController)\n # dartModel.world.set_gravity(np.array((0., 0., 0.)))\n dartModel.initializeHybridDynamics()\n dartModel.initializeForwardDynamics()\n\n # dartModel.skeleton.inv_mass_matrix()\n\n # print(dartModel.skeleton.coriolis_and_gravity_forces())\n\n # dartModel.getJoint('LeftFoot').set_actuator_type(pydart.Joint.FORCE)\n # dartModel.getJoint('RightFoot').set_actuator_type(pydart.Joint.FORCE)\n\n #===============================================================================\n # load segment info\n #===============================================================================\n skeleton = motion_ori[0].skeleton\n\n segname = os.path.splitext(filename)[0]+'.seg'\n segfile = open(motionDir+segname, 'r')\n seginfo = load(segfile)\n segfile.close()\n\n if not isCma:\n for seg in seginfo:\n print(seg)\n\n intervals = [info['interval'] for info in seginfo]\n states = [info['state'] for info in seginfo]\n temp_motion = copy.deepcopy(motion_ori)\n segments = yma.splitMotionIntoSegments(temp_motion, intervals)\n if not isCma:\n print(len(intervals), 'segments')\n for i in range(len(intervals)):\n print('%dth'%i, yba.GaitState.text[states[i]], intervals[i], ',',)\n print(\"\")\n\n motion_seg_orig = ym.JointMotion()\n motion_seg_orig += segments[0]\n motion_seg = ym.JointMotion()\n motion_seg += segments[0]\n motion_stitch = ym.JointMotion()\n motion_stitch += segments[0]\n\n motion_stf_stabilize = ym.JointMotion()\n motion_match_stl = ym.JointMotion()\n motion_swf_placement = ym.JointMotion()\n motion_swf_height = ym.JointMotion()\n motion_swf_orientation = ym.JointMotion()\n motion_stf_balancing = ym.JointMotion()\n motion_stf_push = ym.JointMotion()\n motion_control = ym.JointMotion()\n\n motion_debug1 = ym.JointMotion()\n motion_debug2 = ym.JointMotion()\n motion_debug3 = ym.JointMotion()\n\n P = ym.JointMotion()\n P_hat = ym.JointMotion()\n M_tc = ym.JointMotion()\n M_hat_tc_1 = ym.JointMotion()\n\n #===============================================================================\n # loop variable\n #===============================================================================\n seg_index = [0]\n acc_offset = [0]\n extended = [False]\n prev_R_swp = [None]\n stl_y_limit_num = [0]\n stl_xz_limit_num = [0]\n avg_dCM = [mm.O_Vec3()]\n # avg_stf_v = [mm.O_Vec3()]\n # avg_stf_av = [mm.O_Vec3()]\n\n # stf_push_func = [yfg.zero]\n step_length_cur = [0.]\n\n step_length_tar = [0.]\n step_axis = [mm.O_Vec3()]\n #===============================================================================\n # information\n #===============================================================================\n bodyIDsToCheck = range(dartModel.getBodyNum())\n # bodyIDsToCheck = [dartModel.getBody(\"LeftFoot\").index_in_skeleton(), dartModel.getBody(\"RightFoot\").index_in_skeleton()]\n mus = [mu]*len(bodyIDsToCheck)\n\n totalMass = dartModel.getTotalMass()\n # bodyMasses = controlModel.getBodyMasses()\n # totalMass = controlModel.getTotalMass()\n\n # hwangpil\n # extendedFootName = ['Foot_foot_0_0', 'Foot_foot_0_1', 'Foot_foot_1_0',\n # 'Foot_foot_1_1', 'Foot_foot_2_0', 'Foot_foot_2_1']\n\n extendedFootName = ['Foot_foot_0_0', 'Foot_foot_0_1', 'Foot_foot_0_0_0', 'Foot_foot_0_1_0', 'Foot_foot_1_0',\n 'Foot_foot_1_1', 'Foot_foot_1_2']\n\n # extendedFootName = ['Foot_foot_0_1', 'Foot_foot_1_1', 'Foot_foot_2_1']\n\n\n ToeName = ['Foot_foot_0_0_0', 'Foot_foot_0_1_0']\n HeelName = ['Foot_foot_1_0', 'Foot_foot_1_1', 'Foot_foot_1_2']\n\n lIDs = [skeleton.getJointIndex('Left'+name) for name in extendedFootName]\n rIDs = [skeleton.getJointIndex('Right'+name) for name in extendedFootName]\n\n lIDdic = {'Left'+name:skeleton.getJointIndex('Left'+name) for name in extendedFootName}\n rIDdic = {'Right'+name:skeleton.getJointIndex('Right'+name) for name in extendedFootName}\n footIdDic = lIDdic.copy()\n footIdDic.update(rIDdic)\n\n lToes = [skeleton.getJointIndex('Left'+name) for name in ToeName]\n rToes = [skeleton.getJointIndex('Right'+name) for name in ToeName]\n\n lHeels = [skeleton.getJointIndex('Left'+name) for name in HeelName]\n rHeels = [skeleton.getJointIndex('Right'+name) for name in HeelName]\n\n footDofNames = [] # type: list[str]\n footDofNames += sum(list(['j_Left'+name+'_x', 'j_Left'+name+'_y', 'j_Left'+name+'_z'] for name in extendedFootName), [])\n footDofNames += sum(list(['j_Right'+name+'_x', 'j_Right'+name+'_y', 'j_Right'+name+'_z'] for name in extendedFootName), [])\n\n footDofs = None\n if SEGMENT_FOOT:\n footDofs = dartModel.skeleton.dof_indices(footDofNames)\n LeftFootDofs = dartModel.skeleton.dof_indices(['j_LeftFoot_x','j_LeftFoot_y','j_LeftFoot_z'])\n RightFootDofs = dartModel.skeleton.dof_indices(['j_RightFoot_x','j_RightFoot_y','j_RightFoot_z'])\n\n # controlled foot joint dofs\n if SEGMENT_FOOT:\n variableDofIdx = dartModel.skeleton.dof_indices(footDofNames)\n # joint dofs except foot joint\n specifiedDofIdx = list(range(dartModel.getTotalDOF()))\n for dofidx in variableDofIdx:\n specifiedDofIdx.remove(dofidx)\n\n # for i in lIDs+rIDs:\n # controlModel.setHybridDynamics(i, \"DYNAMIC\")\n\n # each dof is whether KINEMATIC or not\n hdAccMask = [True]*dartModel.getTotalDOF()\n hdAccMask[:6] = [False]*6\n # for i in lIDs+rIDs:\n # hdAccMask[3+3*i : 6+3*i] = [False]*3\n\n # for i in range(1, len(dartModel.skeleton.joints)):\n # dartModel.skeleton.joints[i].set_actuator_type(pydart.Joint.ACCELERATION)\n\n\n lID = dartModel.skeleton.bodynode_index('LeftFoot')\n rID = dartModel.skeleton.bodynode_index('RightFoot')\n\n lUpLeg = skeleton.getJointIndex('LeftUpLeg');rUpLeg = skeleton.getJointIndex('RightUpLeg')\n lKnee = skeleton.getJointIndex('LeftLeg'); rKnee = skeleton.getJointIndex('RightLeg')\n lFoot = skeleton.getJointIndex('LeftFoot'); rFoot = skeleton.getJointIndex('RightFoot')\n spine = skeleton.getJointIndex('Spine')\n\n uppers = [skeleton.getJointIndex(name) for name in ['Hips', 'Spine', 'Spine1', 'LeftArm', 'LeftForeArm', 'RightArm', 'RightForeArm']]\n # upperMass = sum([bodyMasses[i] for i in uppers])\n lLegs = [skeleton.getJointIndex(name) for name in ['LeftUpLeg', 'LeftLeg', 'LeftFoot']]\n rLegs = [skeleton.getJointIndex(name) for name in ['RightUpLeg', 'RightLeg', 'RightFoot']]\n allJoints = set(range(skeleton.getJointNum()))\n\n\n '''\n footMass = sum([bodyMasses[i] for i in lIDs]) + bodyMasses[lID]\n HeelMass = sum([bodyMasses[i] for i in lHeels])\n ToeMass = sum([bodyMasses[i] for i in lToes])\n print('totalMass: ', totalMass)\n print('footMass: ', footMass)\n print('heelmass: ', HeelMass)\n print('ToeMass: ', ToeMass)\n #'''\n\n halfFootHeight = SEGMENT_FOOT_RAD\n if not SEGMENT_FOOT:\n halfFootHeight = dartModel.getBody(lFoot).shapenodes[0].shape.size()[1]/2.\n\n for fi in forceInfos:\n fi.targetBody = spine\n\n #hwangpil\n prev_contact_count = [0]\n\n #===========================================================================\n # data collection\n #===========================================================================\n rhip_torques = []\n rknee_torques = []\n rankle_torques = []\n rankle_torques = []\n\n #===============================================================================\n # rendering\n #===============================================================================\n rd_CM = [None]; rd_CP = [None]; rd_CMP = [None]\n rd_forces = [None]; rd_force_points = [None]\n rd_torques = []; rd_joint_positions = []\n\n rd_point1 = [None]\n rd_point2 = [None]\n rd_vec1 = [None]; rd_vecori1 = [None]\n rd_vec2 = [None]; rd_vecori2 = [None]\n rd_frame1 = [None]\n rd_frame2 = [None]\n\n rd_cForces = [None]\n rd_cPositions = [None]\n rd_cForcesControl = [None]\n rd_cPositionsControl = [None]\n\n viewer = None\n plot = None\n # plot = ymp.InteractivePlot()\n\n def getParamVal(paramname):\n return viewer.objectInfoWnd.getVal(paramname)\n\n # renderer settings\n if not isCma:\n if MULTI_VIEWER:\n viewer = ymv.MultiViewer(800, 655)\n # viewer = ymv.MultiViewer(800, 655, True)\n viewer.setRenderers1([yr.DartModelRenderer(dartMotionModel, MOTION_COLOR)])\n viewer.setRenderers2([yr.DartModelRenderer(dartModel, (200, 200, 0))])\n else:\n # viewer = ysv.SimpleViewer()\n # viewer = hsv.hpSimpleViewer(viewForceWnd=True)\n viewer = hsv.hpSimpleViewer(viewForceWnd=False)\n # viewer.record(False)\n if not isCma:\n viewer.doc.addRenderer('motionModel', yr.DartModelRenderer(dartMotionModel, (0,150,255), yr.POLYGON_LINE))\n viewer.doc.addRenderer('controlModel', yr.DartModelRenderer(dartModel, (50, 200, 200)))\n\n viewer.doc.addObject('motion_ori', motion_ori)\n viewer.doc.addObject('motion_stf_stabilize', motion_stf_stabilize)\n viewer.doc.addObject('motion_match_stl', motion_match_stl)\n viewer.doc.addObject('motion_swf_placement', motion_swf_placement)\n viewer.doc.addObject('motion_swf_height', motion_swf_height)\n viewer.doc.addObject('motion_swf_orientation', motion_swf_orientation)\n viewer.doc.addObject('motion_stf_push', motion_stf_push)\n viewer.doc.addObject('motion_stf_balancing', motion_stf_balancing)\n viewer.doc.addObject('motion_control', motion_control)\n\n viewer.doc.addRenderer('motion_ori', yr.JointMotionRenderer(motion_ori, (0,100,255), yr.LINK_BONE))\n motion_ori.resourceName = 'motion_ori'\n # viewer.doc.addRenderer('motion_seg_orig', yr.JointMotionRenderer(motion_seg_orig, (0,100,255), yr.LINK_BONE))\n # viewer.doc.addRenderer('motion_seg', yr.JointMotionRenderer(motion_seg, (0,150,255), yr.LINK_BONE))\n # viewer.doc.addRenderer('motion_stitch', yr.JointMotionRenderer(motion_stitch, (0,255,200), yr.LINK_BONE))\n\n viewer.doc.addRenderer('motion_match_stl', yr.JointMotionRenderer(motion_match_stl, (255,200,0), yr.LINK_BONE))\n viewer.doc.addRenderer('motion_swf_placement', yr.JointMotionRenderer(motion_swf_placement, (255,100,255), yr.LINK_BONE))\n viewer.doc.addRenderer('motion_swf_height', yr.JointMotionRenderer(motion_swf_height, (50,255,255), yr.LINK_BONE))\n viewer.doc.addRenderer('motion_stf_push', yr.JointMotionRenderer(motion_stf_push, (50,255,200), yr.LINK_BONE))\n viewer.doc.addRenderer('motion_stf_stabilize', yr.JointMotionRenderer(motion_stf_stabilize, (255,0,0), yr.LINK_BONE))\n viewer.doc.addRenderer('motion_stf_balancing', yr.JointMotionRenderer(motion_stf_balancing, (255,100,255), yr.LINK_BONE))\n viewer.doc.addRenderer('motion_control', yr.JointMotionRenderer(motion_control, (255,0,0), yr.LINK_BONE))\n # viewer.doc.addRenderer('motion_swf_orientation', yr.JointMotionRenderer(motion_swf_orientation, (255,100,0), yr.LINK_BONE))\n motion_stf_stabilize.resourceName = 'motion_stf_stabilize'\n motion_match_stl.resourceName = 'motion_match_stl'\n motion_swf_placement.resourceName = 'motion_swf_placement'\n motion_swf_height.resourceName = 'motion_swf_height'\n motion_swf_orientation.resourceName = 'motion_swf_orientation'\n motion_stf_push.resourceName = 'motion_stf_push'\n motion_stf_balancing.resourceName = 'motion_stf_balancing'\n motion_control.resourceName = 'motion_control'\n\n # viewer.doc.addRenderer('motion_debug1', yr.JointMotionRenderer(motion_debug1, (0,255,0), yr.LINK_BONE))\n # viewer.doc.addRenderer('motion_debug2', yr.JointMotionRenderer(motion_debug2, (255,0,255), yr.LINK_BONE))\n # viewer.doc.addRenderer('motion_debug3', yr.JointMotionRenderer(motion_debug3, (255,255,0), yr.LINK_BONE))\n\n # viewer.doc.addRenderer('M_tc', yr.JointMotionRenderer(M_tc, (255,255,0), yr.LINK_BONE))\n # viewer.doc.addRenderer('P_hat', yr.JointMotionRenderer(P_hat, (255,255,0), yr.LINK_BONE))\n # viewer.doc.addRenderer('P', yr.JointMotionRenderer(P, (255,255,0), yr.LINK_BONE))\n # viewer.doc.addRenderer('M_hat_tc_1', yr.JointMotionRenderer(M_hat_tc_1, (255,255,0), yr.LINK_BONE))\n\n # viewer.doc.addRenderer('rd_CM', yr.PointsRenderer(rd_CM, (255,255,0)))\n # viewer.doc.addRenderer('rd_CP', yr.PointsRenderer(rd_CP, (255,0,0)))\n # viewer.doc.addRenderer('rd_CMP', yr.PointsRenderer(rd_CMP, (0,255,0)))\n # viewer.doc.addRenderer('forces', yr.ForcesRenderer(rd_forces, rd_force_points, (255,0,0), ratio=.01, fromPoint=False))\n # viewer.doc.addRenderer('torques', yr.VectorsRenderer(rd_torques, rd_joint_positions, (255,0,0)))\n\n viewer.doc.addRenderer('rd_contactForcesControl', yr.VectorsRenderer(rd_cForcesControl, rd_cPositionsControl, (255, 0, 0), .1, 'rd_c1'))\n viewer.doc.addRenderer('rd_contactForces', yr.VectorsRenderer(rd_cForces, rd_cPositions, (0, 255, 0), .1, 'rd_c2'))\n\n viewer.doc.addRenderer('rd_point1', yr.PointsRenderer(rd_point1, (0,255,0)))\n viewer.doc.addRenderer('rd_point2', yr.PointsRenderer(rd_point2, (255,0,0)))\n # viewer.doc.addRenderer('rd_vec1', yr.VectorsRenderer(rd_vec1, rd_vecori1, (255,0,0)))\n viewer.doc.addRenderer('rd_vec2', yr.VectorsRenderer(rd_vec2, rd_vecori2, (0,255,0)))\n # viewer.doc.addRenderer('rd_frame1', yr.FramesRenderer(rd_frame1, (0,200,200)))\n viewer.doc.addRenderer('rd_frame2', yr.FramesRenderer(rd_frame2, (200,200,0)))\n # viewer.setMaxFrame(len(motion_ori)-1)\n\n viewer.objectInfoWnd.add1DSlider(\"penalty_grf_gain\", 0., 5000., 10., Ks)\n viewer.objectInfoWnd.add1DSlider(\"c_min_contact_vel\", 0., 200., .2, 100.)\n viewer.objectInfoWnd.add1DSlider(\"c_min_contact_time\", 0., 5., .01, .7)\n viewer.objectInfoWnd.add1DSlider(\"c_landing_duration\", 0., 5., .01, .2)\n viewer.objectInfoWnd.add1DSlider(\"c_taking_duration\", 0., 5., .01, .3)\n viewer.objectInfoWnd.add1DSlider(\"c_swf_mid_offset\", -1., 1., .001, c_swf_mid_offset)\n viewer.objectInfoWnd.add1DSlider(\"c_locking_vel\", 0., 1., .001, .05)\n\n viewer.objectInfoWnd.add1DSlider(\"c_swf_offset\", -1., 1., .001, .01)\n viewer.objectInfoWnd.add1DSlider(\"K_stp_pos\", 0., 1., .01, 0.)\n\n viewer.objectInfoWnd.add1DSlider(\"c5\", 0., 5., .01, c5)\n viewer.objectInfoWnd.add1DSlider(\"c6\", 0., 1., .01, c6)\n viewer.objectInfoWnd.add1DSlider(\"K_stb_vel\", 0., 1., .01, K_stb_vel)\n viewer.objectInfoWnd.add1DSlider(\"K_stb_pos\", 0., 1., .01, K_stb_pos)\n viewer.objectInfoWnd.add1DSlider(\"K_swp_vel_sag\", 0., 5., .01, K_swp_vel_sag)\n viewer.objectInfoWnd.add1DSlider(\"K_swp_vel_cor\", 0., 5., .01, K_swp_vel_cor)\n viewer.objectInfoWnd.add1DSlider(\"K_swp_pos_sag\", 0., 5., .01, K_swp_pos_sag)\n viewer.objectInfoWnd.add1DSlider(\"K_swp_pos_cor\", 0., 5., .01, K_swp_pos_cor)\n viewer.objectInfoWnd.add1DSlider(\"K_swp_pos_sag_faster\",0., 1., .01, K_swp_pos_sag_faster)\n\n viewer.objectInfoWnd.add1DSlider(\"LeftFootKp\", 0., 500., 10., 300.)\n viewer.objectInfoWnd.add1DSlider(\"LeftFootKd\", 0., 100., 1., 30.)\n viewer.objectInfoWnd.add1DSlider(\"RightFootKp\", 0., 500., 10., 300.)\n viewer.objectInfoWnd.add1DSlider(\"RightFootKd\", 0., 100., 1., 30.)\n\n if viewer.cForceWnd is not None:\n viewer.cForceWnd.addDataSet('expForce', FL_BLACK)\n viewer.cForceWnd.addDataSet('desForceMin', FL_RED)\n viewer.cForceWnd.addDataSet('desForceMax', FL_RED)\n viewer.cForceWnd.addDataSet('realForce', FL_GREEN)\n\n if not REPEATED:\n viewer.setMaxFrame(len(motion_ori)-1)\n else:\n viewer.setMaxFrame(MAX_FRAME)\n\n if CAMERA_TRACKING:\n if MULTI_VIEWER:\n cameraTargets1 = [None] * (viewer.getMaxFrame()+1)\n cameraTargets2 = [None] * (viewer.getMaxFrame()+1)\n else:\n cameraTargets = [None] * (viewer.getMaxFrame()+1)\n\n if TORQUE_PLOT:\n rhip_torques = [0.]*viewer.getMaxFrame()\n rknee_torques = [0.]*viewer.getMaxFrame()\n rankle_torques = [0.]*viewer.getMaxFrame()\n\n\n # ===============================================================================\n # viewer setting for parameter setting\n # ===============================================================================\n\n # pt = [0.]\n def postFrameCallback_Always(frame):\n # if frame==1: pt[0] = time.time()\n # if frame==31: print 'elapsed time for 30 frames:', time.time()-pt[0]\n if CAMERA_TRACKING:\n if MULTI_VIEWER:\n if cameraTargets1[frame] is None:\n # cameraTargets1[frame] = motionModel.getBodyPositionGlobal(0)\n cameraTargets1[frame] = dartMotionModel.getBodyPositionGlobal(0)\n # cameraTargets1[frame] = motion_ori[frame].getJointPositionGlobal(0)\n viewer.setCameraTarget1(cameraTargets1[frame])\n\n if cameraTargets2[frame] is None:\n # cameraTargets2[frame] = controlModel.getJointPositionGlobal(0)\n cameraTargets2[frame] = dartModel.getJointPositionGlobal(0)\n viewer.setCameraTarget2(cameraTargets2[frame])\n\n else:\n if cameraTargets[frame] is None:\n cameraTargets[frame] = dartModel.getJointPositionGlobal(0)\n # cameraTargets[frame] = controlModel.getJointPositionGlobal(0)\n viewer.setCameraTarget(cameraTargets[frame])\n if plot is not None:\n plot.updateVline(frame)\n\n\n if not isCma:\n viewer.setPostFrameCallback_Always(postFrameCallback_Always)\n\n if plot is not None:\n plot.setXlimit(0, len(motion_ori))\n plot.setYlimit(-0.05, .05)\n plot.addDataSet('zero')\n plot.addDataSet('diff')\n plot.addDataSet('debug1')\n plot.addDataSet('debug2')\n\n\n def viewer_onClose(data):\n if plot is not None:\n plot.close()\n viewer.onClose(data)\n viewer.callback(viewer_onClose)\n\n if not isCma:\n for bodynode in dartModel.skeleton.bodynodes:\n print(bodynode.name, bodynode.mass())\n\n feedback = hbf.HpBipedFeedback(dartModel, motion_ori, seginfo)\n\n def simulateCallback(frame):\n if not isCma:\n print('frame: ', frame)\n # c_min_contact_vel, c_min_contact_time, c_landing_duration, \\\n # c_taking_duration, c_swf_mid_offset, c_locking_vel, c_swf_offset, \\\n # K_stp_pos, c5, c6, K_stb_vel, K_stb_pos, K_swp_vel_sag, K_swp_vel_cor, \\\n # K_swp_pos_sag, K_swp_pos_cor, K_swp_pos_sag_faster = viewer.objectInfoWnd.getVals()\n if not isCma:\n # if not isCma and params is None:\n Ks = getParamVal(\"penalty_grf_gain\")\n Ds = 2.*(Ks**.5)\n c_min_contact_vel = getParamVal(\"c_min_contact_vel\")\n c_min_contact_time = getParamVal(\"c_min_contact_time\")\n c_landing_duration = getParamVal(\"c_landing_duration\")\n c_taking_duration = getParamVal(\"c_taking_duration\")\n c_swf_mid_offset = getParamVal(\"c_swf_mid_offset\")\n c_locking_vel = getParamVal(\"c_locking_vel\")\n c_swf_offset = getParamVal(\"c_swf_offset\")\n K_stp_pos = getParamVal(\"K_stp_pos\")\n c5 = getParamVal(\"c5\")\n c6 = getParamVal(\"c6\")\n K_stb_vel = getParamVal(\"K_stb_vel\")\n K_stb_pos = getParamVal(\"K_stb_pos\")\n K_swp_vel_sag = getParamVal(\"K_swp_vel_sag\")\n K_swp_vel_cor = getParamVal(\"K_swp_vel_cor\")\n K_swp_pos_sag = getParamVal(\"K_swp_pos_sag\")\n K_swp_pos_cor = getParamVal(\"K_swp_pos_cor\")\n K_swp_pos_sag_faster = getParamVal(\"K_swp_pos_sag_faster\")\n elif params is not None:\n _params = np.around(params, decimals=3)\n Ks = 1000.\n Ds = 2. * (Ks ** .5)\n c_min_contact_vel = 100.\n # c_min_contact_vel = 2.\n c_min_contact_time = .7\n c_landing_duration = .2\n c_taking_duration = .3\n c_swf_mid_offset = .02\n c_locking_vel = .05\n\n # c_swf_offset = .0\n c_swf_offset = .01\n # c_swf_offset = .005\n K_stp_pos = _params[0] * _params[0]\n c5 = _params[1] * _params[1]\n c6 = _params[2] * _params[2]\n K_stb_vel = _params[3] * _params[3]\n K_stb_pos = _params[4] * _params[4]\n K_swp_vel_sag = _params[5] * _params[5]\n K_swp_vel_cor = _params[6] * _params[6]\n K_swp_pos_sag = _params[7] * _params[7]\n K_swp_pos_cor = _params[8] * _params[8]\n K_swp_pos_sag_faster = _params[9] * _params[9]\n\n # feedback.refresh_frame_dyn_information(motion_seg, frame, avg_dCM)\n\n # seginfo\n segIndex = seg_index[0]\n curState = seginfo[segIndex]['state']\n cur_interval = yma.offsetInterval(acc_offset[0], seginfo[segIndex]['interval'])\n stanceLegs = seginfo[segIndex]['stanceHips']\n swingLegs = seginfo[segIndex]['swingHips']\n stanceFoots = seginfo[segIndex]['stanceFoots']\n swingFoots = seginfo[segIndex]['swingFoots']\n swingKnees = seginfo[segIndex]['swingKnees']\n groundHeight = seginfo[segIndex]['ground_height']\n maxStfPushFrame = seginfo[segIndex]['max_stf_push_frame']\n\n # hwangpil\n # temporary change\n for legList in (stanceLegs, swingLegs):\n for legIdx in range(len(legList)):\n if legList[legIdx] == 10:\n legList[legIdx] = skeleton.getJointIndex('RightUpLeg')\n\n for footList in (stanceFoots, swingFoots):\n for footIdx in range(len(footList)):\n if footList[footIdx] == 12:\n footList[footIdx] = skeleton.getJointIndex('RightFoot')\n\n stanceToes = []\n if skeleton.getJointIndex('LeftFoot') in stanceFoots:\n stanceToes.extend(lToes)\n if skeleton.getJointIndex('RightFoot') in stanceFoots:\n stanceToes.extend(rToes)\n\n stanceHeels = []\n if skeleton.getJointIndex('LeftFoot') in stanceFoots:\n stanceHeels.extend(lHeels)\n if skeleton.getJointIndex('RightFoot') in stanceFoots:\n stanceHeels.extend(rHeels)\n\n swingToes = []\n if skeleton.getJointIndex('LeftFoot') in swingFoots:\n swingToes.extend(lToes)\n if skeleton.getJointIndex('RightFoot') in swingFoots:\n swingToes.extend(rToes)\n\n swingHeels = []\n if skeleton.getJointIndex('LeftFoot') in swingFoots:\n swingHeels.extend(lHeels)\n if skeleton.getJointIndex('RightFoot') in swingFoots:\n swingHeels.extend(rHeels)\n\n prev_frame = frame-1 if frame>0 else 0\n\n # information\n dCM_tar = motion_seg.getJointVelocityGlobal(0, prev_frame)\n CM_tar = motion_seg.getJointPositionGlobal(0, prev_frame)\n stf_tar = motion_seg.getJointPositionGlobal(stanceFoots[0], prev_frame)\n CMr_tar = CM_tar - stf_tar\n\n # dCM : average velocity of root of controlModel over 1 frame\n dCM = avg_dCM[0]\n CM = dartModel.getBody(\"Hips\").com()\n CMreal = dartModel.getCOM()\n stf = dartModel.getJointPositionGlobal(stanceFoots[0])\n CMr = CM - stf\n\n # diff_dCM : diff of velocity of COM between current and desired\n diff_dCM = mm.projectionOnPlane(dCM-dCM_tar, (1,0,0), (0,0,1))\n # diff_dCM_axis : perpendicular of diff_dCM\n diff_dCM_axis = np.cross((0,1,0), diff_dCM)\n rd_vec1[0] = diff_dCM\n rd_vecori1[0] = CM_tar\n\n diff_CMr = mm.projectionOnPlane(CMr-CMr_tar, (1,0,0), (0,0,1))\n diff_CMr_axis = np.cross((0,1,0), diff_CMr)\n\n direction = mm.normalize2(mm.projectionOnPlane(dCM_tar, (1,0,0), (0,0,1)))\n directionAxis = np.cross((0,1,0), direction)\n\n diff_dCM_sag, diff_dCM_cor = mm.projectionOnVector2(diff_dCM, direction)\n diff_dCM_sag_axis = np.cross((0,1,0), diff_dCM_sag)\n diff_dCM_cor_axis = np.cross((0,1,0), diff_dCM_cor)\n\n diff_CMr_sag, diff_CMr_cor = mm.projectionOnVector2(diff_CMr, direction)\n diff_CMr_sag_axis = np.cross((0,1,0), diff_CMr_sag)\n diff_CMr_cor_axis = np.cross((0,1,0), diff_CMr_cor)\n\n t = (frame-cur_interval[0])/float(cur_interval[1]-cur_interval[0])\n t_raw = t\n if t>1.: t=1.\n\n\n p_root = motion_stitch[frame].getJointPositionGlobal(0)\n R_root = motion_stitch[frame].getJointOrientationGlobal(0)\n\n motion_seg_orig.goToFrame(frame)\n motion_seg.goToFrame(frame)\n motion_stitch.goToFrame(frame)\n\n motion_debug1.append(motion_stitch[frame].copy())\n motion_debug1.goToFrame(frame)\n motion_debug2.append(motion_stitch[frame].copy())\n motion_debug2.goToFrame(frame)\n motion_debug3.append(motion_stitch[frame].copy())\n motion_debug3.goToFrame(frame)\n\n # paper implementation\n M_tc.append(motion_stitch[prev_frame])\n M_tc.goToFrame(frame)\n P_hat.append(M_tc[frame].copy())\n P_hat.goToFrame(frame)\n\n # p_temp = ym.JointPosture(skeleton)\n # p_temp.rootPos = controlModel.getJointPositionGlobal(0)\n # p_temp.setJointOrientationsLocal(controlModel.getJointOrientationsLocal())\n # P.append(p_temp)\n # P.goToFrame(frame)\n\n '''\n # Jacobian Transpose Balance Control\n balanceKp = 100.\n balanceKd = 100.\n balanceDiff = dartMotionModel.getCOM() - dartModel.getCOM()\n balanceDiff[1] = 0.\n balanceVelDiff = -dartModel.skeleton.com_velocity()\n balanceVelDiff[1] = 0.\n balanceTorque = np.dot(dartModel.getBody('RightFoot').world_jacobian()[3:6].T,\n balanceKp*balanceDiff + balanceKd*balanceVelDiff)\n balanceTorque[:6] = np.array([0.]*6)\n '''\n\n '''\n # stance foot stabilize\n motion_stf_stabilize.append(motion_stitch[frame].copy())\n motion_stf_stabilize.goToFrame(frame)\n if STANCE_FOOT_STABILIZE:\n for stanceFoot in stanceFoots:\n R_target_foot = motion_seg[frame].getJointOrientationGlobal(stanceFoot)\n R_current_foot = motion_stf_stabilize[frame].getJointOrientationGlobal(stanceFoot)\n motion_stf_stabilize[frame].setJointOrientationGlobal(stanceFoot, mm.slerp(R_current_foot, R_target_foot , stf_stabilize_func(t)))\n # motion_stf_stabilize[frame].setJointOrientationGlobal(stanceFoot, cm.slerp(R_current_foot, R_target_foot , stf_stabilize_func(t)))\n # R_target_foot = motion_seg[frame].getJointOrientationLocal(stanceFoot)\n # R_current_foot = motion_stf_stabilize[frame].getJointOrientationLocal(stanceFoot)\n # motion_stf_stabilize[frame].setJointOrientationLocal(stanceFoot, cm.slerp(R_current_foot, R_target_foot , stf_stabilize_func(t)))\n #'''\n\n # match stance leg\n # motion_match_stl.append(motion_stf_stabilize[frame].copy())\n motion_match_stl.append(motion_stitch[frame].copy())\n motion_match_stl.goToFrame(frame)\n if MATCH_STANCE_LEG:\n # hbf.match_stance_leg(t, dartModel, motion_match_stl, frame, curState, stanceLegs)\n if curState!=yba.GaitState.STOP:\n for stanceLegIdx in range(len(stanceLegs)):\n stanceLeg = stanceLegs[stanceLegIdx]\n # stanceFoot = stanceFoots[stanceLegIdx]\n\n # motion stance leg -> character stance leg as time goes\n R_motion = motion_match_stl[frame].getJointOrientationGlobal(stanceLeg)\n R_character = dartModel.getJointOrientationGlobal(stanceLeg)\n motion_match_stl[frame].setJointOrientationGlobal(stanceLeg, mm.slerp(R_motion, R_character, match_stl_func(t)))\n\n\n # swing foot placement\n # TODO:\n # in segment foot case, hip has noise slitly\n motion_swf_placement.append(motion_match_stl[frame].copy())\n motion_swf_placement.goToFrame(frame)\n if SWING_FOOT_PLACEMENT:\n t_swing_foot_placement = swf_placement_func(t)\n\n if extended[0]:\n R_swp_sag = prev_R_swp[0][0]\n R_swp_cor = prev_R_swp[0][1]\n else:\n clampAngle = math.pi/6.\n R_swp_sag = mm.I_SO3(); R_swp_cor = mm.I_SO3()\n # R_swp_sag = np.dot(R_swp_sag, mm.exp(diff_dCM_sag_axis * K_swp_vel_sag * -t_swing_foot_placement))\n # R_swp_cor = np.dot(R_swp_cor, mm.exp(diff_dCM_cor_axis * K_swp_vel_cor * -t_swing_foot_placement))\n # if np.dot(direction, diff_CMr_sag) < 0:\n # R_swp_sag = np.dot(R_swp_sag, mm.exp(diff_CMr_sag_axis * K_swp_pos_sag * -t_swing_foot_placement))\n # else:\n # R_swp_sag = np.dot(R_swp_sag, mm.exp(diff_CMr_sag_axis * K_swp_pos_sag_faster * -t_swing_foot_placement))\n # R_swp_cor = np.dot(R_swp_cor, mm.exp(diff_CMr_cor_axis * K_swp_pos_cor * -t_swing_foot_placement))\n R_swp_sag = np.dot(R_swp_sag, mm.clampExp(diff_dCM_sag_axis * K_swp_vel_sag * -t_swing_foot_placement, clampAngle))\n R_swp_cor = np.dot(R_swp_cor, mm.clampExp(diff_dCM_cor_axis * K_swp_vel_cor * -t_swing_foot_placement, clampAngle))\n if np.dot(direction, diff_CMr_sag) < 0:\n R_swp_sag = np.dot(R_swp_sag, mm.clampExp(diff_CMr_sag_axis * K_swp_pos_sag * -t_swing_foot_placement, clampAngle))\n else:\n R_swp_sag = np.dot(R_swp_sag, mm.clampExp(diff_CMr_sag_axis * K_swp_pos_sag_faster * -t_swing_foot_placement, clampAngle))\n R_swp_cor = np.dot(R_swp_cor, mm.clampExp(diff_CMr_cor_axis * K_swp_pos_cor * -t_swing_foot_placement, clampAngle))\n\n for i in range(len(swingLegs)):\n swingLeg = swingLegs[i]\n swingFoot = swingFoots[i]\n\n # save swing foot global orientation\n R_swf = motion_swf_placement[frame].getJointOrientationGlobal(swingFoot)\n\n # rotate swing leg\n motion_swf_placement[frame].mulJointOrientationGlobal(swingLeg, R_swp_sag)\n motion_swf_placement[frame].mulJointOrientationGlobal(swingLeg, R_swp_cor)\n\n # hwangpil\n # temporal code.... for heel strike and ankle pushup\n # motion_swf_placement[frame].mulJointOrientationGlobal(swingFoot, mm.exp([0., 0., -0.17*t_swing_foot_placement]))\n # motion_swf_placement[frame].mulJointOrientationGlobal(swingFoot, mm.exp([0.2*t_swing_foot_placement, 0., 0.]))\n\n # hwangpil\n # foot placement based on difference\n # CM = dartModel.getBody(\"Hips\").com()\n swf = dartModel.getJointPositionGlobal(swingFoot)\n CMr_swf = CM - swf\n\n # CM_tar = motion_seg.getJointPositionGlobal(0, prev_frame)\n swf_tar = motion_seg[frame].getJointPositionGlobal(swingFoot)\n CMr_swf_tar = CM_tar - swf_tar\n\n CMr_swf_proj = mm.projectionOnPlane(CMr_swf, mm.unitX(), mm.unitY())\n CMr_swf_tar_proj = mm.projectionOnPlane(CMr_swf_tar, mm.unitX(), mm.unitY())\n\n angle = mm.getAngleFromVectors(CMr_swf_proj, CMr_swf_tar_proj)\n\n motion_swf_placement[frame].mulJointOrientationGlobal(swingLeg, mm.exp(mm.unitZ(), -.2*angle))\n\n # diff_CMr_swf = mm.projectionOnPlane(CMr_swf-CMr_swf_tar, (1,0,0), (0,0,1))\n #\n # newPosition = motion_swf_placement[frame].getJointPositionGlobal(swingFoot)\n # # newPosition += (diff_CMr_swf + diff_dCM)*t_swing_foot_placement\n # newPosition += 0.1*diff_CMr_swf * t_swing_foot_placement\n # aik.ik_analytic(motion_swf_placement[frame], swingFoot, newPosition)\n\n # restore swing foot global orientation\n motion_swf_placement[frame].setJointOrientationGlobal(swingFoot, R_swf)\n\n prev_R_swp[0] = (R_swp_sag, R_swp_cor)\n\n # swing foot height\n # TODO:\n # in segment foot case, hip has noise largely\n toe_offset = 0.\n motion_swf_height.append(motion_swf_placement[frame].copy())\n motion_swf_height.goToFrame(frame)\n if SWING_FOOT_HEIGHT:\n for swingFoot in swingFoots:\n stanceFoot = stanceFoots[0]\n\n # save foot global orientation\n R_foot = motion_swf_height[frame].getJointOrientationGlobal(swingFoot)\n R_stance_foot = motion_swf_height[frame].getJointOrientationGlobal(stanceFoot)\n\n d_height_tar = 0\n if OLD_SWING_HEIGHT:\n height_tar = motion_swf_height[frame].getJointPositionGlobal(swingFoot)[1] \\\n - motion_swf_height[frame].getJointPositionGlobal(stanceFoot)[1]\n else:\n height_tar = motion_swf_height[prev_frame].getJointPositionGlobal(swingFoot)[1] - groundHeight\n d_height_tar = motion_swf_height.getJointVelocityGlobal(swingFoot, prev_frame)[1]\n\n # rotate\n motion_swf_height[frame].rotateByTarget(dartModel.getJointOrientationGlobal(0))\n\n d_height_cur = 0\n if OLD_SWING_HEIGHT:\n height_cur = motion_swf_height[frame].getJointPositionGlobal(swingFoot)[1] \\\n - motion_swf_height[frame].getJointPositionGlobal(stanceFoot)[1]\n else:\n height_cur = dartModel.getJointPositionGlobal(swingFoot)[1] - halfFootHeight - c_swf_offset\n # height_cur = dartModel.getJointPositionGlobal(swingFoot)[1] - halfFootHeight\n d_height_cur = dartModel.getJointVelocityGlobal(swingFoot)[1]\n\n if OLD_SWING_HEIGHT:\n offset_height = (height_tar - height_cur) * swf_height_func(t) * c5\n else:\n offset_height = ((height_tar - height_cur) * c5\n + (d_height_tar - d_height_cur) * c6) * swf_height_func(t)\n\n offset_sine = c_swf_mid_offset * swf_height_sine_func(t)\n\n offset = 0.\n offset += offset_height\n offset += offset_sine\n\n if offset > 0.:\n newPosition = motion_swf_height[frame].getJointPositionGlobal(swingFoot)\n newPosition[1] += offset\n aik.ik_analytic(motion_swf_height[frame], swingFoot, newPosition)\n else:\n if HIGHER_OFFSET:\n newPosition = motion_swf_height[frame].getJointPositionGlobal(stanceFoot)\n newPosition[1] -= offset\n aik.ik_analytic(motion_swf_height[frame], stanceFoot, newPosition)\n\n motion_swf_height[frame].rotateByTarget(R_root)\n\n # restore foot global orientation\n motion_swf_height[frame].setJointOrientationGlobal(swingFoot, R_foot)\n motion_swf_height[frame].setJointOrientationGlobal(stanceFoot, R_stance_foot)\n\n toe_offset = offset\n\n if plot is not None:\n plot.addDataPoint('debug1', frame, offset_height)\n # plot.addDataPoint('debug2', frame, height_cur)\n # plot.addDataPoint('diff', frame, diff)\n\n # stance foot push\n motion_stf_push.append(motion_swf_height[frame].copy())\n motion_stf_push.goToFrame(frame)\n if STANCE_FOOT_PUSH:\n # for swingFoot in swingFoots:\n for stanceFoot in stanceFoots:\n stf_push_func = yfg.concatenate([yfg.sine, yfg.zero], [c_taking_duration*2])\n\n R_swp_sag = mm.exp((step_length_tar[0] - step_length_cur[0])*step_axis[0] * K_stp_pos * -stf_push_func(t))\n\n motion_stf_push[frame].mulJointOrientationGlobal(stanceFoot, R_swp_sag)\n\n # '''\n # stance foot stabilize\n motion_stf_stabilize.append(motion_stf_push[frame].copy())\n motion_stf_stabilize.goToFrame(frame)\n if STANCE_FOOT_STABILIZE:\n for stanceFoot in stanceFoots:\n R_target_foot = motion_stf_push[frame].getJointOrientationGlobal(stanceFoot)\n R_current_foot = motion_stf_stabilize[frame].getJointOrientationGlobal(stanceFoot)\n motion_stf_stabilize[frame].setJointOrientationGlobal(stanceFoot,\n mm.slerp(R_current_foot, R_target_foot, stf_stabilize_func(t)))\n #'''\n\n # stance foot balancing\n # motion_stf_balancing.append(motion_stf_push[frame].copy())\n # TODO:\n # in segment foot case, stance foot unstable\n motion_stf_balancing.append(motion_stf_stabilize[frame].copy())\n motion_stf_balancing.goToFrame(frame)\n if STANCE_FOOT_BALANCING:\n R_stb = mm.exp(diff_dCM_axis * K_stb_vel * stf_balancing_func(t))\n R_stb = np.dot(R_stb, mm.exp(diff_CMr_axis * K_stb_pos * stf_balancing_func(t)))\n for stanceFoot in stanceFoots:\n if frame < 5: break\n if t > 0.5: break #hwangpil\n motion_stf_balancing[frame].mulJointOrientationGlobal(stanceFoot, R_stb)\n\n\n # hwangpil\n if SEGMENT_FOOT:\n if SWING_FOOT_CLEARANCE:\n print(t)\n if 0.5 < t < 0.8:\n for swingToe in swingToes:\n toeAngle = -math.pi/6.\n motion_stf_balancing[frame].mulJointOrientationGlobal(swingToe, mm.rotZ(toeAngle))\n elif t<0.2:\n for swingToe in swingToes:\n toeAngle = math.pi/6.\n motion_stf_balancing[frame].mulJointOrientationGlobal(swingToe, mm.rotZ(toeAngle))\n\n # hwangpil\n # stance foot parallelizing with ground when contact is made\n if 0.1 < t < 0.9:\n pos_toe = [dartModel.getJointPositionGlobal(stanceToe) for stanceToe in stanceToes]\n pos_heel = dartModel.getJointPositionGlobal(stanceHeels[0])\n up_vec = np.cross(pos_toe[1] - pos_heel, pos_toe[0] - pos_heel)\n R_foot_diff = mm.getSO3FromVectors(mm.unitY(), up_vec)\n # R_foot_diff = mm.getSO3FromVectors(up_vec, mm.unitY())\n R_foot = mm.slerp(mm.I_SO3(), R_foot_diff, 0.05)\n motion_stf_balancing[frame].mulJointOrientationGlobal(stanceFoots[0], R_foot)\n\n # hwangpil\n # swing foot height control\n if False:\n for swing_foot in swingFoots:\n new_position = motion_seg[frame].getJointPositionGlobal(swing_foot)\n aik.ik_analytic(motion_stf_balancing[frame], swing_foot, new_position)\n\n # hwangpil\n # hip adjustizing\n if True:\n # get hip orientation on coronal plane\n hip_ori_cur = dartModel.getJointOrientationGlobal(0)\n hip_ori_tar = motion_stf_balancing[frame].getJointOrientationGlobal(0)\n\n hip_ori_cur_x = np.dot(hip_ori_cur, mm.unitX())\n hip_ori_cur_y = np.dot(hip_ori_cur, mm.unitY())\n hip_ori_cur_z = np.dot(hip_ori_cur, mm.unitZ())\n hip_ori_cur_xy_2 = (hip_ori_cur_x + hip_ori_cur_y) * .5\n hip_ori_cur_yz_2 = (hip_ori_cur_y + hip_ori_cur_z) * .5\n hip_ori_cur_xz_2 = (hip_ori_cur_x + hip_ori_cur_z) * .5\n\n hip_ori_tar_x = np.dot(hip_ori_tar, mm.unitX())\n hip_ori_tar_y = np.dot(hip_ori_tar, mm.unitY())\n hip_ori_tar_z = np.dot(hip_ori_tar, mm.unitZ())\n hip_ori_tar_xy_2 = (hip_ori_tar_x + hip_ori_tar_y) * .5\n hip_ori_tar_yz_2 = (hip_ori_tar_y + hip_ori_tar_z) * .5\n hip_ori_tar_xz_2 = (hip_ori_tar_x + hip_ori_tar_z) * .5\n\n # hip_ori_cur_xy_2_projected = mm.projectionOnPlane(hip_ori_cur_xy_2, hip_ori_tar_x, hip_ori_tar_y)\n # hip_ori_cur_yz_2_projected = mm.projectionOnPlane(hip_ori_cur_yz_2, hip_ori_tar_y, hip_ori_tar_z)\n hip_ori_cur_xy_2_projected = mm.projectionOnPlane(hip_ori_cur_xy_2, mm.unitZ(), mm.unitY())\n hip_ori_cur_yz_2_projected = mm.projectionOnPlane(hip_ori_cur_yz_2, hip_ori_tar_y, hip_ori_tar_z)\n\n cor_angle = mm.getAngleFromVectors(hip_ori_cur_xy_2_projected, hip_ori_tar_xy_2)\n sag_angle = mm.getAngleFromVectors(hip_ori_cur_yz_2_projected, hip_ori_tar_yz_2)\n\n for stance_leg in stanceLegs:\n if stance_leg == motion_ori[0].skeleton.getJointIndex('LeftUpLeg'):\n motion_stf_balancing[frame].mulJointOrientationGlobal(stance_leg, mm.exp(hip_ori_tar_z, 1.*cor_angle))\n # motion_stf_balancing[frame].mulJointOrientationGlobal(stance_leg, mm.exp(hip_ori_tar_z, 1.5*cor_angle))\n else:\n motion_stf_balancing[frame].mulJointOrientationGlobal(stance_leg, mm.exp(hip_ori_tar_z, -1.*cor_angle))\n # motion_stf_balancing[frame].mulJointOrientationGlobal(stance_leg, mm.exp(hip_ori_tar_z, -1.5*cor_angle))\n # motion_stf_balancing[frame].mulJointOrientationGlobal(stance_leg, mm.exp(hip_ori_tar_x, sag_angle))\n\n for swing_leg in swingLegs:\n if swing_leg == motion_ori[0].skeleton.getJointIndex('LeftUpLeg'):\n motion_stf_balancing[frame].mulJointOrientationGlobal(swing_leg, mm.exp(hip_ori_tar_z, 1.*cor_angle))\n else:\n motion_stf_balancing[frame].mulJointOrientationGlobal(swing_leg, mm.exp(hip_ori_tar_z, -1.*cor_angle))\n\n # ankle push\n if False:\n for swing_foot in swingFoots:\n if t < 0.2:\n if swing_foot == motion_ori[0].skeleton.getJointIndex('LeftFoot'):\n motion_stf_balancing[frame].mulJointOrientationGlobal(swing_foot, mm.rotZ((1.-t/.2) * math.pi/6.))\n # motion_stf_balancing[frame].mulJointOrientationGlobal(swing_foot, mm.rotZ(math.pi/2.))\n\n # hwangpil\n # ankle push\n if False:\n for swing_foot in swingFoots:\n if t < 0.2:\n motion_stf_balancing[frame].mulJointOrientationGlobal(swing_foot, mm.rotZ((1.-t/.2) * math.pi/6.))\n # motion_stf_balancing[frame].mulJointOrientationGlobal(swing_foot, mm.rotZ(math.pi/2.))\n\n # hwangpil\n # stance foot tilting\n if True:\n for stance_foot in stanceFoots:\n if t > 0.5:\n R_stf_cur = dartModel.getJointOrientationGlobal(stance_foot)\n R_stf_tar = motion_stf_balancing[frame].getJointOrientationGlobal(stance_foot)\n diff_stf = mm.logSO3(np.dot(R_stf_tar, R_stf_cur.T))\n print('diff_stf: ', diff_stf)\n diff_stf[0] = 0.\n diff_stf[1] = 0.\n R_diff_stf = mm.exp(diff_stf)\n # motion_stf_balancing[frame].mulJointOrientationGlobal(stance_foot, R_diff_stf)\n\n\n\n # hwangpil\n # swing foot parallelizing with ground\n def swf_par_func(_x):\n if _x<.5:\n return -.5*math.pow(1.-2.*_x, 1./3.) + .5\n else:\n return .5*math.pow(2.*_x-1., 1./3.) + .5\n\n if False:\n for swingFoot in swingFoots:\n swingBody = dartModel.getBody(swingFoot)\n for shapeNode in swingBody.shapenodes:\n if shapeNode.has_collision_aspect():\n geomType = shapeNode.shape.shape_type_name()\n geomT = np.dot(swingBody.world_transform(), shapeNode.relative_transform())\n if geomType == \"BOX\":\n shape = shapeNode.shape # type: pydart.BoxShape\n data = shape.size() * .5\n footVec = np.dot(geomT[:3, :3], np.array((0., 1., 0.)))\n R_swf_current = np.eye(3)\n R_swf_par = mm.getSO3FromVectors(footVec, np.array((0., 1., 0.)))\n motion_stf_balancing[frame].mulJointOrientationGlobal(swingFoot,\n mm.slerp(R_swf_current, R_swf_par, swf_par_func(t)))\n\n '''\n # swing foot heel strike adjustment\n # make heel as flat as possible to ground\n swf_heel_func = yfg.hermite2nd\n for swingHeel in swingHeels:\n joint_vec_cur = np.dot(dartModel.getJointOrientationGlobal(swingHeel), np.array((0., 0., 1.)))\n joint_vec_tar = copy.deepcopy(joint_vec_cur)\n joint_vec_tar[1] = 0.\n R_target_heel = mm.exp(swf_heel_func(t)*mm.logSO3(mm.getSO3FromVectors(joint_vec_cur, joint_vec_tar)))\n motion_stf_balancing[frame].mulJointOrientationGlobal(swingHeel, R_target_heel)\n # stance foot ankle pushup adjustment\n # stf_ankle_func = yfg.hermite2nd\n stf_ankle_func = lambda x: -2*(x**2)+3*(x**3)\n if len(stanceFoots) == 1:\n for stanceFoot in stanceFoots:\n R_target_ankle = mm.exp(stf_ankle_func(t)*mm.deg2Rad(30.)*np.array([1., 0., 0.]))\n motion_stf_balancing[frame].mulJointOrientationLocal(stanceFoot, R_target_ankle)\n # stance foot toe adjustment\n # stf_toe_func = yfg.hermite2nd\n stf_toe_func = lambda x: -2*(x**8)+3*(x**9)\n if len(stanceFoots) == 1:\n for stanceToe in stanceToes:\n # joint_vec_cur = np.dot(controlModel.getJointOrientationGlobal(stanceToe), np.array((0., 0., 1.)))\n ## joint_vec_cur = np.dot(motion_stf_balancing[frame].getJointOrientationGlobal(stanceToe), np.array((0., 0., 1.)))\n # joint_vec_tar = copy.deepcopy(joint_vec_cur)\n # joint_vec_tar[1] = 0.\n ## R_target_toe = mm.exp(stf_toe_func(t)*mm.logSO3(mm.getSO3FromVectors(joint_vec_cur, joint_vec_tar)))\n # R_target_toe = mm.getSO3FromVectors(joint_vec_cur, joint_vec_tar)\n # motion_stf_balancing[frame].mulJointOrientationGlobal(stanceToe, R_target_toe)\n R_target_toe = mm.exp(stf_toe_func(t)*mm.deg2Rad(-30.)*np.array([1., 0., 0.]))\n motion_stf_balancing[frame].mulJointOrientationLocal(stanceToe, R_target_toe)\n #'''\n\n # foot adjustment\n if SEGMENT_FOOT and False:\n # hfi.footAdjust(motion_stf_balancing[frame], footIdDic, SEGMENT_FOOT_MAG, SEGMENT_FOOT_RAD, .03)\n hfi.footAdjust(motion_stf_balancing[frame], footIdDic, SEGMENT_FOOT_MAG, SEGMENT_FOOT_RAD, toe_offset)\n\n\n # control trajectory\n # motion_control.append(motion_stitch[frame].copy())\n # motion_control.append(motion_swf_height[frame].copy())\n # motion_control.append(motion_match_stl[frame].copy())\n motion_control.append(motion_stf_balancing[frame].copy())\n motion_control.goToFrame(frame)\n\n #=======================================================================\n # tracking with inverse dynamics\n #=======================================================================\n\n weightMap = [1.] * (skeleton.getJointNum())\n\n if False:\n toeWeights = 0.001\n\n for jointIdx in lIDs:\n weightMap[jointIdx] = toeWeights\n\n for jointIdx in rIDs:\n weightMap[jointIdx] = toeWeights\n\n th_r = motion_control.getDOFPositions(frame)\n # th_r = motion_stitch.getDOFPositions(frame)\n # th_r = motion_ori.getDOFPositions(frame)\n th = dartModel.skeleton.q\n\n dth_r = motion_control.getDOFVelocities(frame)\n # dth_r = motion_ori.getDOFVelocities(frame)\n dth = dartModel.skeleton.dq\n\n ddth_r = motion_control.getDOFAccelerations(frame)\n # ddth_r = motion_ori.getDOFAccelerations(frame)\n # ddth_des = yct.getDesiredDOFAccelerations(th_r, th, dth_r, dth, ddth_r, Kt, Dt, weightMap)\n\n totalDOF = dartModel.getTotalDOF()\n ddth_des_flat = ype.makeFlatList(totalDOF)\n dth_r_flat = ype.makeFlatList(totalDOF)\n # ype.flatten(ddth_des, ddth_des_flat)\n # ype.flatten(dth_r, dth_r_flat)\n\n # print dartModel.skeleton.q[:6]\n # print dartModel.getBody(0).com(), dartModel.skeleton.joint(0).position_in_world_frame(), dartModel.skeleton.q[:6]\n\n\n del rd_frame2[:]\n rd_frame2.append(dartModel.getBody(0).world_transform())\n\n #=======================================================================\n # simulation\n #=======================================================================\n CP = mm.v3(0.,0.,0.)\n F = mm.v3(0.,0.,0.)\n avg_dCM[0] = mm.v3(0.,0.,0.)\n\n # external force rendering info\n if not isCma:\n del rd_forces[:]; del rd_force_points[:]\n for fi in forceInfos:\n if fi.startFrame <= frame and frame < fi.startFrame + fi.duration*(1/frameTime):\n rd_forces.append(fi.force)\n # rd_force_points.append(controlModel.getBodyPositionGlobal(fi.targetBody))\n rd_force_points.append(dartModel.getBodyPositionGlobal(fi.targetBody))\n\n contactPositions = None\n # dartModel.update(motion_ori[frame])\n pdController.setTartgetPose(th_r)\n\n # bodyIDs = [body.index_in_skeleton for body in dartModel.world.collision_result.contacted_bodies]\n\n if not isCma and not SEGMENT_GAIN_ADJUST:\n # change foot Kd and Kp\n if SEGMENT_FOOT:\n for dofs in footDofs:\n # pdController.setKpKd(dofs, 500., 20.)\n pdController.setKpKd(dofs, 50., 5.)\n\n for dofs in LeftFootDofs:\n pdController.setKpKd(dofs, getParamVal('LeftFootKp'), getParamVal('LeftFootKd'))\n\n for dofs in RightFootDofs:\n pdController.setKpKd(dofs, getParamVal('RightFootKp'), getParamVal('RightFootKd'))\n\n elif not isCma and SEGMENT_GAIN_ADJUST:\n # change foot Kd and Kp\n if SEGMENT_FOOT:\n if stanceFoots[0] == rID and t>0.2:\n for dof in lIDs:\n pdController.setKpKd(dof, 50., 5.)\n for dof in rIDs:\n pdController.setKpKd(dof, 500., 20.)\n elif stanceFoots[0] == lID and t > 0.2:\n for dof in rIDs:\n pdController.setKpKd(dof, 50., 5.)\n for dof in lIDs:\n pdController.setKpKd(dof, 500., 20.)\n else:\n for dof in footDofs:\n pdController.setKpKd(dof, 50., 5.)\n\n for dofs in LeftFootDofs:\n pdController.setKpKd(dofs, getParamVal('LeftFootKp'), getParamVal('LeftFootKd'))\n\n for dofs in RightFootDofs:\n pdController.setKpKd(dofs, getParamVal('RightFootKp'), getParamVal('RightFootKd'))\n\n elif True:\n # change foot Kd and Kp\n for dofs in LeftFootDofs:\n pdController.setKpKd(dofs, 300., 30.)\n\n for dofs in RightFootDofs:\n pdController.setKpKd(dofs, 300., 30.)\n\n for dofs in footDofs:\n pdController.setKpKd(dofs, 500., 20.)\n\n else:\n # change foot Kd and Kp\n for dofs in LeftFootDofs:\n pdController.setKpKd(dofs, 80., 10.)\n\n for dofs in RightFootDofs:\n pdController.setKpKd(dofs, 80., 10.)\n\n simulContactForces = np.zeros(3)\n cForcesControl = []\n cPointsControl = []\n\n if frame > 40:\n for i in range(stepsPerFrame):\n # bodyIDs, contactPositions, contactPositionLocals, contactForces = dartModel.calcPenaltyForce(bodyIDsToCheck, mus, Ks, Ds)\n bodyIDs = dartModel.skeleton.self_collision_check()\n\n # _tau = np.zeros(dartModel.skeleton.q.shape)\n _tau = pdController.compute()\n bodyIDs, contactPositions, contactPositionLocals, contactForces, timeStamp = \\\n hdls.calcLCPForces(motion_ori, dartModel.world, dartModel, bodyIDsToCheck, 1., _tau)\n # dartModel.applyPenaltyForce(bodyIDs, contactPositions, contactForces, localForce=False)\n # print('penalty force sum: ', sum(contactForce for contactForce in contactForces))\n\n _ddq = pdController.compute()\n controlTau = None\n if False and SEGMENT_FOOT:\n _ddq = pdController.compute()\n _ddq0 = _ddq[specifiedDofIdx]\n temp1, cPointsControl, temp3, cForcesControl, controlTau = hdls.calcLCPbasicControl(\n motion_ori, dartModel.world, dartModel, bodyIDsToCheck, mu, np.array([0., 300., 0.]), [1., 1., 1.],\n tau0=_ddq, variableDofIdx=footDofs)\n if not isCma:\n print('controlTau: ', controlTau)\n # dartModel.skeleton.set_accelerations(_ddq)\n\n dartModel.skeleton.set_forces(pdController.compute())\n # dartModel.skeleton.set_forces(pdController.compute()+balanceTorque)\n dartModel.step()\n sumForce = sum([(-contact.force if contact.bodynode1.name == 'ground' else contact.force)\n for contact in dartModel.world.collision_result.contacts])\n simulContactForces += sumForce\n '''\n if False and i % 5 == 0:\n # bodyIDs, contactPositions, contactPositionLocals, contactForces = vpWorld.calcPenaltyForce(bodyIDsToCheck, mus, Ks, Ds)\n bodyIDs, contactPositions, contactPositionLocals, contactForces, timeStamp \\\n = hls.calcLCPForcesHD(motion_ori, vpWorld, dartModel, bodyIDsToCheck, 1., ddth_des_flat, ddth_des_flat, solver='qp', hdAccMask=hdAccMask)\n\n if contactForces is not None:\n lContactNum = sum([sum([j==i for j in bodyIDs]) for i in lIDs])\n rContactNum = sum([sum([j==i for j in bodyIDs]) for i in rIDs])\n if 1 <= lContactNum <= 2:\n lbodyIDbs = [any([j==i for i in lIDs])for j in bodyIDs]\n lbodyIDs = [i for i, x in enumerate(lbodyIDbs) if x]\n for i in reversed(lbodyIDs):\n bodyIDs.pop(i)\n contactPositions.pop(i)\n contactPositionLocals.pop(i)\n contactForces.pop(i)\n\n if 1 <= rContactNum <= 2:\n rbodyIDbs = [any([j==i for i in rIDs])for j in bodyIDs]\n rbodyIDs = [i for i, x in enumerate(rbodyIDbs) if x]\n for i in reversed(rbodyIDs):\n bodyIDs.pop(i)\n contactPositions.pop(i)\n contactPositionLocals.pop(i)\n contactForces.pop(i)\n\n if contactForces is not None:\n vpWorld.applyPenaltyForce(bodyIDs, contactPositionLocals, contactForces)\n\n # print contactForces\n\n # apply external force\n for fi in forceInfos:\n if fi.startFrame <= frame and frame < fi.startFrame + fi.duration*(1/frameTime):\n # controlModel.applyBodyForceGlobal(fi.targetBody, fi.force)\n dartModel.getBody(fi.targetBody).add_ext_force(fi.force)\n\n # for i in rIDs+lIDs:\n # controlModel.setJointTorqueLocal(i, ddth_des[i])\n # controlModel.setDOFAccelerations(ddth_des)\n # controlModel.solveHybridDynamics()\n\n # if TORQUE_PLOT:\n # rhip_torques[frame] += mm.length(controlModel.getJointTorqueLocal(rUpLeg))\n # rknee_torques[frame] += mm.length(controlModel.getJointTorqueLocal(rKnee))\n # rankle_torques[frame] += mm.length(controlModel.getJointTorqueLocal(rFoot))\n\n # rd_torques[:] = [controlModel.getJointTorqueLocal(j)/100. for j in range(1, skeleton.getJointNum())]\n # rd_joint_positions[:] = controlModel.getJointPositionsGlobal()\n\n # vpWorld.step()\n # yvu.align2D(controlModel)\n '''\n\n\n '''\n if contactForces is not None and len(contactForces) > 0:\n CP += yrp.getCP(contactPositions, contactForces)\n F += sum(contactForces)\n '''\n avg_dCM[0] += dartModel.getJointVelocityGlobal(0)\n # avg_dCM[0] += yrp.getCM(controlModel.getJointVelocitiesGlobal(), bodyMasses, upperMass, uppers)\n # avg_dCM[0] += yrp.getCM(controlModel.getJointVelocitiesGlobal(), bodyMasses, totalMass)\n\n # if len(stanceFoots)>0:\n # avg_stf_v[0] += controlModel.getJointVelocityGlobal(stanceFoots[0])\n # avg_stf_av[0] += controlModel.getJointAngVelocityGlobal(stanceFoots[0])\n\n\n bodyIDs, contactPositions, contactPositionLocals, velocities = dartModel.getContactPoints(bodyIDsToCheck)\n\n contactPoints = [contact.point for contact in dartModel.world.collision_result.contacts]\n contactForces = [(-contact.force if contact.bodynode1.name == 'ground' else contact.force)\n for contact in dartModel.world.collision_result.contacts]\n\n sumForce = sum(contactForces)\n\n if not isCma and viewer.cForceWnd is not None:\n # graph calculated force\n viewer.cForceWnd.insertData('realForce', frame, simulContactForces[1]/stepsPerFrame)\n\n if not isCma:\n del rd_cForces[:]\n del rd_cPositions[:]\n for idx in range(len(contactPoints)):\n rd_cForces.append(contactForces[idx] / 50.)\n rd_cPositions.append(contactPoints[idx])\n\n del rd_cForcesControl[:]\n del rd_cPositionsControl[:]\n for idx in range(len(cForcesControl)):\n rd_cForces.append(cForcesControl[idx] / 50.)\n rd_cPositions.append(cPointsControl[idx])\n\n # bodyIDs = [body.index_in_skeleton() for body in contacted_bodies]\n # contacted_bodies = dartModel.world.collision_result.contacted_bodies # type: list[pydart.BodyNode]\n # bodyIDs = []\n # for body in contacted_bodies:\n # ground_skeleton = body.skeleton # type: pydart.Skeleton\n # if ground_skeleton.name == \"grount skeleton\":\n # print(\"hehe\")\n\n if not isCma:\n del rd_point2[:]\n if contactPositions is not None:\n rd_point2.extend(contactPositions)\n\n if not isCma:\n del rd_point1[:]\n rd_point1.append(dartModel.getCOM())\n\n if not isCma:\n del rd_point2[:]\n rd_point2.append(dartMotionModel.getCOM())\n\n\n CP /= stepsPerFrame\n F /= stepsPerFrame\n avg_dCM[0] /= stepsPerFrame\n\n # if len(stanceFoots)>0:\n # avg_stf_v[0] /= stepsPerFrame\n # avg_stf_av[0] /= stepsPerFrame\n # rd_vec1[0] = avg_stf_av[0]; rd_vec1[0][0] = 0.; rd_vec1[0][2] = 0.\n # rd_vecori1[0]= controlModel.getJointPositionGlobal(stanceFoots[0])\n\n #=======================================================================\n # segment editing\n #=======================================================================\n lastFrame = False\n\n # print curState\n # print bodyIDs\n\n if SEGMENT_EDITING:\n if curState==yba.GaitState.STOP:\n if frame == len(motion_seg)-1:\n lastFrame = True\n\n elif (curState==yba.GaitState.LSWING or curState==yba.GaitState.RSWING) and t > c_min_contact_time:\n contact = False\n\n if not SEGMENT_FOOT:\n # original box foot\n swingID = lID if curState==yba.GaitState.LSWING else rID\n\n if swingID in bodyIDs:\n minContactVel = 1000.\n for i in range(len(bodyIDs)):\n if bodyIDs[i]==swingID:\n vel = dartModel.getBodyVelocityGlobal(swingID, contactPositionLocals[i])\n vel[1] = 0\n contactVel = mm.length(vel)\n if contactVel < minContactVel: minContactVel = contactVel\n if minContactVel < c_min_contact_vel: contact = True\n\n else:\n # segmented foot\n swingIDs = copy.deepcopy(lIDs) if curState==yba.GaitState.LSWING else copy.deepcopy(rIDs)\n\n contact = False\n contact_count = 0\n\n for swingID in swingIDs:\n if swingID in bodyIDs:\n minContactVel = 1000.\n for idx in range(len(bodyIDs)):\n if bodyIDs[idx] == swingID:\n vel = dartModel.getBodyVelocityGlobal(swingID, contactPositionLocals[idx])\n vel[1] = 0\n contactVel = mm.length(vel)\n contact_count += 1\n if contactVel < minContactVel:\n minContactVel = contactVel\n if minContactVel < c_min_contact_vel and contact_count > 2:\n contact = True\n elif minContactVel < c_min_contact_vel and contact_count > 1 and prev_contact_count[0] > 1 :\n contact = True\n\n prev_contact_count[0] = contact_count\n\n extended[0] = False\n\n if contact:\n if not isCma:\n print(frame, 'foot touch')\n lastFrame = True\n acc_offset[0] += frame - cur_interval[1]\n\n elif frame == len(motion_seg)-1:\n if not isCma:\n print(frame, 'extend frame', frame+1)\n\n preserveJoints = []\n # preserveJoints = [lFoot, rFoot]\n # preserveJoints = [lFoot, rFoot, lKnee, rKnee]\n # preserveJoints = [lFoot, rFoot, lKnee, rKnee, lUpLeg, rUpLeg]\n stanceKnees = [rKnee] if curState==yba.GaitState.LSWING else [lKnee]\n preserveJoints = [stanceFoots[0], stanceKnees[0], stanceLegs[0]]\n\n diff = 3\n motion_seg_orig.extend([motion_seg_orig[-1]])\n motion_seg.extend(ymt.extendByIntegration_root(motion_seg, 1, diff))\n\n motion_stitch.extend(ymt.extendByIntegration_constant(motion_stitch, 1, preserveJoints, diff))\n\n extended[0] = True\n else:\n if frame == len(motion_seg)-1: lastFrame = True\n\n if lastFrame:\n if segIndex < len(segments)-1:\n if not isCma:\n print('%d (%d): end of %dth seg (%s, %s)'%(frame, frame-cur_interval[1],segIndex, yba.GaitState.text[curState], cur_interval))\n if plot is not None:\n plot.addDataPoint('diff', frame, (frame-cur_interval[1])*.01)\n\n if len(stanceFoots)>0 and len(swingFoots)>0:\n step_cur = dartModel.getJointPositionGlobal(0) - dartModel.getJointPositionGlobal(stanceFoots[0])\n step_tar = motion_seg[cur_interval[1]].getJointPositionGlobal(0) - motion_seg[cur_interval[1]].getJointPositionGlobal(stanceFoots[0])\n\n step_cur = mm.projectionOnPlane(step_cur, (1,0,0), (0,0,1))\n step_tar = mm.projectionOnPlane(step_tar, (1,0,0), (0,0,1))\n\n step_cur_sag, step_cur_cor = mm.projectionOnVector2(step_cur, direction)\n step_tar_sag, step_tar_cor = mm.projectionOnVector2(step_tar, direction)\n\n step_length_tar[0] = mm.length(step_tar_sag)\n if np.inner(step_tar_sag, step_cur_sag) > 0:\n step_length_cur[0] = mm.length(step_cur_sag)\n else:\n step_length_cur[0] = -mm.length(step_cur_sag)\n\n step_axis[0] = directionAxis\n\n seg_index[0] += 1\n curSeg = segments[seg_index[0]]\n stl_y_limit_num[0] = 0\n stl_xz_limit_num[0] = 0\n\n del motion_seg_orig[frame+1:]\n motion_seg_orig.extend(ymb.getAttachedNextMotion(curSeg, motion_seg_orig[-1], False, False))\n\n del motion_seg[frame+1:]\n del motion_stitch[frame+1:]\n transitionLength = len(curSeg)-1\n\n d = motion_seg[-1] - curSeg[0]\n d.rootPos[1] = 0.\n motion_seg.extend(ymb.getAttachedNextMotion(curSeg, d, True, False))\n\n if NO_FOOT_SLIDING:\n if segIndex == len(segments)-2:\n Rl = motion_control[-1].getJointOrientationLocal(lUpLeg)\n Rr = motion_control[-1].getJointOrientationLocal(rUpLeg)\n Rlk = motion_control[-1].getJointOrientationLocal(lKnee)\n Rrk = motion_control[-1].getJointOrientationLocal(rKnee)\n Rlf = motion_control[-1].getJointOrientationLocal(lFoot)\n Rrf = motion_control[-1].getJointOrientationLocal(rFoot)\n for p in curSeg:\n p.setJointOrientationLocal(lUpLeg, Rl, False)\n p.setJointOrientationLocal(rUpLeg, Rr, False)\n p.setJointOrientationLocal(lKnee, Rlk, False)\n p.setJointOrientationLocal(rKnee, Rrk, False)\n p.setJointOrientationLocal(lFoot, Rlf, False)\n p.setJointOrientationLocal(rFoot, Rrf, False)\n p.updateGlobalT()\n\n d = motion_control[-1] - curSeg[0]\n d.rootPos[1] = 0.\n motion_stitch.extend(ymb.getStitchedNextMotion(curSeg, d, transitionLength, stitch_func, True, False))\n\n else:\n motion_seg_orig.append(motion_seg_orig[-1])\n motion_seg.append(motion_seg[-1])\n motion_stitch.append(motion_control[-1])\n\n\n # rendering\n # motionModel.update(motion_ori[frame])\n if not isCma:\n # dartMotionModel.update(motion_stitch[frame])\n # dartMotionModel.update(motion_stf_balancing[frame])\n dartMotionModel.update(motion_seg[frame])\n # dartMotionModel.update(motion_ori[frame])\n # motionModel.update(motion_seg[frame])\n\n rd_CP[0] = CP\n # rd_CMP[0] = (CMreal[0] - (F[0]/F[1])*CMreal[1], 0, CMreal[2] - (F[2]/F[1])*CMreal[1])\n\n if plot is not None:\n plot.addDataPoint('zero', frame, 0)\n plot.updatePoints()\n\n if not isCma:\n viewer.setSimulateCallback(simulateCallback)\n\n if MULTI_VIEWER:\n viewer.startTimer(frameTime / 1.4)\n else:\n viewer.startTimer(frameTime * .1)\n viewer.show()\n\n Fl.run()\n else:\n objectiveSum = 0\n successSum = 0\n comSum = 0\n velSum = 0\n dirSum = 0\n\n for i in range(MAX_FRAME):\n simulateCallback(i)\n\n _com = dartModel.getCOM()\n\n if i > 50:\n successSum -= 1\n\n comSum += _com[2] * _com[2]\n\n _com_vel = dartModel.skeleton.com_velocity()\n _com_vel[1] = 0.\n velSum += (np.linalg.norm(_com_vel) - 0.7)*(np.linalg.norm(_com_vel)-0.7)\n\n dirDiff = mm.normalize(_com_vel) - np.array((-1., 0., 0.))\n dirSum += np.dot(dirDiff, dirDiff)\n\n if _com[1] < 0.65 or _com[1] > 1.0:\n break\n if i % 50 == 0 and (np.isnan(velSum) or np.isnan(dirSum)):\n break\n\n # objectiveSum = successSum + .3*comSum + velSum\n objectiveSum = successSum + velSum + .3*dirSum\n # print(objectiveSum, successSum, velSum, .3*dirSum, params)\n del motion_stitch[:]\n del motion_debug1[:]\n del motion_debug2[:]\n del motion_debug3[:]\n del motion_control[:]\n del motion_stf_balancing[:]\n del motion_match_stl[:]\n del motion_ori[:]\n del motion_seg[:]\n del motion_seg_orig[:]\n del motion_stf_push[:]\n del motion_stf_stabilize[:]\n del motion_swf_height[:]\n del motion_swf_placement[:]\n del motion_swf_orientation[:]\n return float(objectiveSum), float(successSum), float(velSum), float(.3*dirSum)\n # return float(objectiveSum)\n\n\nif __name__ == '__main__':\n # c_min_contact_vel = 100.\n # c_min_contact_time = .7\n # c_landing_duration = .2\n # c_taking_duration = .3\n # c_swf_mid_offset = .0\n # c_locking_vel = .05\n # c_swf_offset = .01\n\n # K_stp_pos = 0.\n # c5 = .7\n # c6 = .02\n # K_stb_vel = .1\n # K_stb_pos = .1\n # K_swp_vel_sag = .0\n # K_swp_vel_cor = 1.3\n # K_swp_pos_sag = 1.2\n # K_swp_pos_cor = 1.\n # K_swp_pos_sag_faster = .05\n\n # viewer.objectInfoWnd.add1DSlider(\"c_min_contact_vel\", 0., 200., .2, 100.)\n # viewer.objectInfoWnd.add1DSlider(\"c_min_contact_time\", 0., 5., .01, .7)\n # viewer.objectInfoWnd.add1DSlider(\"c_landing_duration\", 0., 5., .01, .2)\n # viewer.objectInfoWnd.add1DSlider(\"c_taking_duration\", 0., 5., .01, .3)\n # viewer.objectInfoWnd.add1DSlider(\"c_swf_mid_offset\", -1., 1., .001, 0.)\n # viewer.objectInfoWnd.add1DSlider(\"c_locking_vel\", 0., 1., .001, .05)\n # viewer.objectInfoWnd.add1DSlider(\"c_swf_offset\", -1., 1., .001, .01)\n\n # viewer.objectInfoWnd.add1DSlider(\"K_stp_pos\", 0., 1., .01, 0.)\n # viewer.objectInfoWnd.add1DSlider(\"c5\", 0., 5., .01, .7)\n # viewer.objectInfoWnd.add1DSlider(\"c6\", 0., 1., .01, .02)\n # viewer.objectInfoWnd.add1DSlider(\"K_stb_vel\", 0., 1., .01, .1)\n # viewer.objectInfoWnd.add1DSlider(\"K_stb_pos\", 0., 1., .01, .1)\n # viewer.objectInfoWnd.add1DSlider(\"K_swp_vel_sag\", 0., 5., .01, 0.)\n # viewer.objectInfoWnd.add1DSlider(\"K_swp_vel_cor\", 0., 5., .01, 1.3)\n # viewer.objectInfoWnd.add1DSlider(\"K_swp_pos_sag\", 0., 5., .01, 1.2)\n # viewer.objectInfoWnd.add1DSlider(\"K_swp_pos_cor\", 0., 5., .01, 1.)\n # viewer.objectInfoWnd.add1DSlider(\"K_swp_pos_sag_faster\",0., 1., .01, .05)\n\n\n # walkings(None, False)\n\n\n # hand tuning\n # params = [0., .7, .02, .1, .1, .0, 1.3, 1.2, 1., .05]\n # 325 frames success, Ks = 600.\n params = [ 0.01918975, 0.86622863, 0.15111008, 0.50972221, 0.09746768, -0.09129272, 1.12736657, 1.2873114 , 0.84409227, 0.38928674]\n\n # 347 frames success, Ks = 600. ????????\n # params = [-0.0096717475861028673, 0.51455174209881782, 0.1414213562373095, 0.31622776601683794, 0.19555994814530026, 0.0, 1.1401754250991381, 1.457290633087426, 0.78654212710618387, 0.61027611069961429]\n\n # 287 frames success, Ks = 1000.\n # params = [-0.15744347, 0.67592998, 0.14142136, 0.31622777, 0.35696289, 0., 1.14017543, 1.27637941, 0.95735647, 0.23835687]\n\n\n\n # 400 frames success, box foot, LCP, Kp = 200, Kd = 20\n # params = [-0.11523854, 0.56103475, 0.14142136, 0.31622777, 0.13175649, 0. , 1.14017543, 1.18703622, 0.77193057, 0.20490717]\n\n # infinite frames success, box foot, LCP, Kp = 200, Kd = 20, foot Kp = 80, foot Kd = 10\n params = [-0.13880733, 0.3439617, 0.14142136, 0.31622777, -0.18792631, 0., 1.14017543, 1.53473264, 1.07681499, 0.22992996]\n\n\n # 1220 frames success, parameter rounding, box foot, LCP, Kp = 200, Kd = 20, foot Kp = 80, foot Kd = 10,\n params = [-0.11608721, 0.42672724, 0.14142136, 0.31622777, -0.12770363, 0., 1.14017543, 1.63989139, 1.01964141, 0.18439344]\n\n # 1850 frames success, parameter rounding, box foot, LCP, Kp = 200, Kd = 20, foot Kp = 80, foot Kd = 10,\n params = [-0.10540525, 0.40167391, 0.14142136, 0.31622777, -0.06906434, 0., 1.14017543, 1.57445634, 1.01106981, 0.23834485]\n\n # infinite frames success, parameter rounding, box foot, LCP, Kp = 200, Kd = 20, foot Kp = 80, foot Kd = 10,\n # params = [-0.03424024, 0.32955692, 0.0850351 , 0.28576747, -0.10735104, 0.00185764, 1.36932697, 1.27616424, 0.97477866, 0.29608671]\n\n params = [ 0.23265769, 1.04283873, -0.29465862, 0.3544647, 0.2997252, -0.17338881, 2.08012922, 1.09571025, 0.6792339, -0.35920458]\n\n # DartTrackingFoot0 result, c_swf_mid_offset = 0.02\n params = [ 0.00745384, -0.56053261, 0.00921962, 0.42575388, 1.03165526, 0.69931117, 1.42782163, 1.65119398, 1.1237301 , 0.5327249 ]\n\n params = [0., .7, .02, .1, .1, .0, 1.3, 1.2, 1., .05]\n params = [ 0.52572998, 0.15153905, -0.59859175, 0.93952107, 0.49886098, -0.1271257, 0.7328913, 0.87975694, 1.73943837, -0.97777014]\n\n # 120 frames success\n params = [-0.03373822, 0.21621505, -0.46121163, 0.97844009, 1.26921316, 0.07107696, 1.43362972, 0.10045292, 1.40123327, -0.67596869]\n\n # 195 frames success\n params = [-0.156885745146, 0.224351871531, -0.651388957459, 0.803834992348, 1.05714177435, 0.00542880291931, 1.56462249867, -0.111631227361, 1.37037255808, -1.00517210154]\n isCma = False\n\n params = [-0.156885745146, 0.224351871531, 0., 0.803834992348, 1.05714177435, 0.00542880291931, 1.56462249867, -0.111631227361, 1.37037255808, -1.00517210154]\n if len(sys.argv) == 1 and not isCma:\n walkings(params, False)\n elif len(sys.argv) == 2 and sys.argv[1] == '-view' and not isCma:\n walkings(params, False)\n elif (len(sys.argv) == 2 and sys.argv[1] == '-cma') or isCma:\n # from PyCommon.modules.Math.Nomalizer import Normalizer\n # normalizer = Normalizer([0.]*10., [1., 5., .2, 1., 1., 3., 3., 3., 3., .5], [1.]*10, [-1.]*10)\n # c6, K_stb_vel, K_swp_vel_sag, K_swp_vel_cor is velocity gain\n # cmaOption = cma.CMAOptions('fixed_variables')\n # cmaOption.set('fixed_variables', {2:math.sqrt(.02), 3:math.sqrt(.1), 5:math.sqrt(0.), 6:math.sqrt(1.3)})\n # cma.fmin(walkings, np.sqrt([0., .5, .02, .1, .1, .0, 0.3, 1.2, .5, .05]).tolist(), .1, args=(True,), options=cmaOption)\n # cma.fmin(walkings, params, .1, args=(True,), options=cmaOption)\n # cma.fmin(walkings, params, .1, args=(True,))\n\n from datetime import datetime\n filename = datetime.now().strftime('%Y%m%d%H%M')+\".opt\"\n fout = open(filename, \"w\")\n fout.write(os.path.basename(__file__)+'\\n')\n es = cma.CMAEvolutionStrategy(params, .1,\n {'maxiter':100})\n fout.close()\n # {'maxiter':2, 'fixed_variables':{2:math.sqrt(.02), 3:math.sqrt(.1), 5:math.sqrt(0.), 6:math.sqrt(1.3)}})\n pool = mp.Pool(es.popsize)\n cmaCount = 0\n while not es.stop():\n fout = open(filename, \"a\")\n X = es.ask()\n f_values = pool.map_async(walkings, X).get()\n obj_values = [f_value[0] for f_value in f_values]\n es.tell(X, obj_values)\n es.disp()\n es.logger.add()\n\n print(cmaCount, min(f_values), X[np.argmin(obj_values)])\n fout.write(str(cmaCount)+' '+str(min(f_values)))\n for x in X[np.argmin(obj_values)]:\n fout.write(' '+str(x)+',')\n fout.write('\\n')\n cmaCount += 1\n fout.close()\n\n print(\"------------best-----------\")\n print(\"eval: \", es.best.evals)\n print(\"f: \", es.best.f)\n print(\"x: \", es.best.x)\n"
] | [
[
"numpy.eye",
"numpy.zeros",
"numpy.argmin",
"numpy.inner",
"numpy.cross",
"numpy.isnan",
"numpy.array",
"numpy.around",
"numpy.dot",
"numpy.linalg.norm"
]
] |
bradduy/computer_vision | [
"cfe97e84a5e216819497405a79ef2ef0ca2b95fe"
] | [
"Data Science/MachineLearningFromPytorch.py"
] | [
"import torch\n\n# f = w * x\n\n# f = 2 * x\nX = torch.tensor([1,2,3,4], dtype=torch.float32) # training sample\nY = torch.tensor([2,4,6,8], dtype=torch.float32) # testing sample\n\nw = torch.tensor(0.0, dtype=torch.float32, requires_grad=True)\n\n#model prediction\ndef forward(x):\n return w * x\n\n# loss = MSE\ndef loss(y, y_predicted):\n return ((y_predicted - y)**2).mean()\n\n#gradient\n#MSE = 1/N * (w*x -y)**2\n#dJ/dw = 1/N 2x (w*x -y)\ndef gradient(x, y, y_predicted):\n return np.dot(2*x, y_predicted-y).mean()\n\nprint(f'Prediction before training: f(5) = {forward(5):.3f}')\n\n#training\nlearning_rate = 0.01\nn_inters = 20\nfor epoch in range(n_inters):\n #prediction = forward pass\n y_pred = forward(X)\n\n #loss\n l = loss(Y, y_pred)\n\n # gradients = backward pass\n l.backward() # dl/dw\n\n #update weights\n with torch.no_grad():\n w -= learning_rate * w.grad\n\n # zero gradients:\n w.grad.zero_()\n\n if epoch % 2 == 0:\n print(f'epoch {epoch+1}: w = {w:.3f}, loss = {l:.8f}')\n\nprint(f'Prediction after training: f(5) = {forward(5):.3f}')\n"
] | [
[
"torch.no_grad",
"torch.tensor"
]
] |
nirbhayjm/rlpyt | [
"a2741201bbf33f5408306198d220d90f8f7b7250"
] | [
"rlpyt/models/pg/atari_lstm_model.py"
] | [
"import torch\nimport torch.nn.functional as F\n\nfrom rlpyt.models.conv2d import Conv2dHeadModel\nfrom rlpyt.utils.collections import namedarraytuple\nfrom rlpyt.utils.tensor import infer_leading_dims, restore_leading_dims\n\nRnnState = namedarraytuple(\n \"RnnState\", [\"h\", \"c\"]\n) # For downstream namedarraytuples to work\n\n\nclass AtariLstmModel(torch.nn.Module):\n \"\"\"Recurrent model for Atari agents: a convolutional network into an FC layer\n into an LSTM which outputs action probabilities and state-value estimate.\n \"\"\"\n\n def __init__(\n self,\n image_shape,\n output_size,\n fc_sizes=512, # Between conv and lstm.\n lstm_size=512,\n use_maxpool=False,\n channels=None, # None uses default.\n kernel_sizes=None,\n strides=None,\n paddings=None,\n ):\n \"\"\"Instantiate neural net module according to inputs.\"\"\"\n super().__init__()\n self.conv = Conv2dHeadModel(\n image_shape=image_shape,\n channels=channels or [16, 32],\n kernel_sizes=kernel_sizes or [8, 4],\n strides=strides or [4, 2],\n paddings=paddings or [0, 1],\n use_maxpool=use_maxpool,\n hidden_sizes=fc_sizes, # Applies nonlinearity at end.\n )\n self.lstm = torch.nn.LSTM(self.conv.output_size + output_size + 1, lstm_size)\n self.pi = torch.nn.Linear(lstm_size, output_size)\n self.value = torch.nn.Linear(lstm_size, 1)\n\n def forward(self, image, prev_action, prev_reward, init_rnn_state):\n \"\"\"\n Compute action probabilities and value estimate from input state.\n Infers leading dimensions of input: can be [T,B], [B], or []; provides\n returns with same leading dims. Convolution layers process as [T*B,\n *image_shape], with T=1,B=1 when not given. Expects uint8 images in\n [0,255] and converts them to float32 in [0,1] (to minimize image data\n storage and transfer). Recurrent layers processed as [T,B,H]. Used in\n both sampler and in algorithm (both via the agent). Also returns the\n next RNN state.\n \"\"\"\n img = image.type(torch.float) # Expect torch.uint8 inputs\n img = img.mul_(1.0 / 255) # From [0-255] to [0-1], in place.\n\n # Infer (presence of) leading dimensions: [T,B], [B], or [].\n lead_dim, T, B, img_shape = infer_leading_dims(img, 3)\n\n fc_out = self.conv(img.view(T * B, *img_shape))\n lstm_input = torch.cat(\n [\n fc_out.view(T, B, -1),\n prev_action.view(T, B, -1), # Assumed onehot.\n prev_reward.view(T, B, 1),\n ],\n dim=2,\n )\n init_rnn_state = None if init_rnn_state is None else tuple(init_rnn_state)\n lstm_out, (hn, cn) = self.lstm(lstm_input, init_rnn_state)\n pi = F.softmax(self.pi(lstm_out.view(T * B, -1)), dim=-1)\n v = self.value(lstm_out.view(T * B, -1)).squeeze(-1)\n\n # Restore leading dimensions: [T,B], [B], or [], as input.\n pi, v = restore_leading_dims((pi, v), lead_dim, T, B)\n # Model should always leave B-dimension in rnn state: [N,B,H].\n next_rnn_state = RnnState(h=hn, c=cn)\n\n return pi, v, next_rnn_state\n"
] | [
[
"torch.nn.LSTM",
"torch.nn.Linear"
]
] |
PeppeSaccardi/pytorch-lightning | [
"046110797227c352126c779c207e076ce9682eae"
] | [
"tests/checkpointing/test_trainer_checkpoint.py"
] | [
"# Copyright The PyTorch Lightning team.\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 os\nfrom copy import deepcopy\n\nimport torch\n\nimport pytorch_lightning as pl\nfrom pytorch_lightning import seed_everything, Trainer\nfrom pytorch_lightning.callbacks import ModelCheckpoint\nfrom tests.helpers import BoringModel\n\n\ndef test_finetuning_with_resume_from_checkpoint(tmpdir):\n \"\"\"\n This test validates that generated ModelCheckpoint is pointing to the right best_model_path during test\n \"\"\"\n\n seed_everything(4)\n\n checkpoint_callback = ModelCheckpoint(monitor=\"val_loss\", dirpath=tmpdir, filename=\"{epoch:02d}\", save_top_k=-1)\n\n class ExtendedBoringModel(BoringModel):\n def configure_optimizers(self):\n optimizer = torch.optim.SGD(self.layer.parameters(), lr=0.001)\n lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1)\n return [optimizer], [lr_scheduler]\n\n def validation_step(self, batch, batch_idx):\n output = self.layer(batch)\n loss = self.loss(batch, output)\n self.log(\"val_loss\", loss, on_epoch=True, prog_bar=True)\n\n model = ExtendedBoringModel()\n model.validation_epoch_end = None\n trainer = Trainer(\n default_root_dir=tmpdir,\n max_epochs=1,\n limit_train_batches=12,\n limit_val_batches=6,\n limit_test_batches=12,\n callbacks=[checkpoint_callback],\n logger=False,\n )\n trainer.fit(model)\n assert os.listdir(tmpdir) == [\"epoch=00.ckpt\"]\n\n best_model_paths = [checkpoint_callback.best_model_path]\n results = []\n\n for idx in range(3, 6):\n # load from checkpoint\n trainer = pl.Trainer(\n default_root_dir=tmpdir,\n max_epochs=idx,\n limit_train_batches=12,\n limit_val_batches=12,\n limit_test_batches=12,\n resume_from_checkpoint=best_model_paths[-1],\n progress_bar_refresh_rate=0,\n )\n trainer.fit(model)\n trainer.test()\n results.append(deepcopy(trainer.callback_metrics))\n best_model_paths.append(trainer.checkpoint_callback.best_model_path)\n\n for idx in range(len(results) - 1):\n assert results[idx][\"val_loss\"] > results[idx + 1][\"val_loss\"]\n\n for idx, best_model_path in enumerate(best_model_paths):\n if idx == 0:\n assert best_model_path.endswith(f\"epoch=0{idx}.ckpt\")\n else:\n assert f\"epoch={idx + 1}\" in best_model_path\n\n\ndef test_accumulated_gradient_batches_with_resume_from_checkpoint(tmpdir):\n \"\"\"\n This test validates that accumulated gradient is properly recomputed and reset on the trainer.\n \"\"\"\n\n ckpt = ModelCheckpoint(dirpath=tmpdir, save_last=True)\n model = BoringModel()\n trainer_kwargs = dict(\n max_epochs=1, accumulate_grad_batches={0: 2}, callbacks=ckpt, limit_train_batches=1, limit_val_batches=0\n )\n trainer = Trainer(**trainer_kwargs)\n trainer.fit(model)\n\n trainer_kwargs[\"max_epochs\"] = 2\n trainer_kwargs[\"resume_from_checkpoint\"] = ckpt.last_model_path\n trainer = Trainer(**trainer_kwargs)\n trainer.fit(model)\n"
] | [
[
"torch.optim.lr_scheduler.StepLR"
]
] |
nschmucker/Sundial | [
"3c1ef3ac422314b7d811c842065f0992a8ff8aeb"
] | [
"sundial.py"
] | [
"\"\"\"\nsundial.py\nThis file contains code to run an indoor sundial\nDeveloped on Python 3.7.3 / Raspberry Pi 4\nNathaniel Schmucker\n\"\"\"\n\nfrom busio import I2C\nfrom board import SCL, SDA\nfrom adafruit_pca9685 import PCA9685\nfrom adafruit_motor import servo\n\nfrom pysolar.solar import get_altitude, get_azimuth\nfrom scipy.optimize import fsolve\nfrom numpy import isclose\nfrom math import cos, sin, tan, pi\n\nimport requests\nimport datetime\nfrom time import sleep\n\n\n# --- Global constants; update to reflect physical sundial ---\nGNOMON_LOC = (0, 0, 0) # By definition, center on gnomon tip\nGNOMON_LENGTH = None\nARM_LOC = (0, -8, 6) # Pivot point of movable arm\nARM_LENGTH = 13.25 # Consistent units with ARM_LOC\n\n# Independence Hall\nLAT = 39.95 \nLON = -75.15 \n\nAPI_KEY = \"API_KEY\"\nBASE_URL = \"https://data.climacell.co/v4/timelines?\"\nURL = BASE_URL + \\\n \"location=\" + str(LAT) + \",\" + str(LON) + \\\n \"&fields=cloudCover\" + \\\n \"×teps=current\" + \\\n \"&apikey=\" + API_KEY\n\n\n# --- Variables; need to update for initial code execution ---\n# See helper_sundial_inputs.py\ngnomon = {\n \"loc\": GNOMON_LOC,\n \"length\": GNOMON_LENGTH,\n \"alt\": 0, # radians, relative to horizon\n \"az\": 0 # radians, relative to north\n}\narm = {\n \"loc\": ARM_LOC,\n \"length\": ARM_LENGTH,\n \"alt\": 0, # radians, relative to horizon\n \"az\": 0 # radians, relative to north\n}\nlast_sunrise = {\n \"alt\": -0.5,\n \"az\": 2.1,\n \"t\": 10.3\n}\nguess = {\n \"alt\": 0.1,\n \"az\": 3.6,\n \"t\": 7.1\n}\ntimes = {\n \"now\": datetime.datetime.now(datetime.timezone.utc),\n \"last_sunrise\": datetime.datetime(2021, 4, 10, 10, 21, tzinfo=datetime.timezone.utc)\n}\n\nis_led_on = gnomon[\"alt\"] >= 0\n\n\n# --- Functions ---\ndef get_cloudcover():\n \"\"\"Helper function to retrieve current cloudcover\n \n Uses climacell API: https://docs.climacell.co/reference/welcome\n \"\"\"\n \n r = requests.get(URL)\n j = r.json()\n cloud_cover = j[\"data\"][\"timelines\"][0][\"intervals\"][0][\"values\"][\"cloudCover\"]/100\n \n return cloud_cover # [0,1]\n\ndef mimic_clouds(raw_val):\n \"\"\"Helper function to adjust LED brightness for cloudcover\n\n Never goes below 80%, even if 100% cloudy\n \"\"\"\n \n pct_sun = 1 - get_cloudcover()\n pct_to_adj = 0.8 + 0.2*pct_sun\n adj_val = int(int(raw_val)*pct_to_adj)\n \n return adj_val\n\ndef update_leds():\n \"\"\"Adjust LED based on whether sun is up and % cloudiness\"\"\"\n \n brightness = 0xffff if is_led_on else 0\n adjusted_brightness = mimic_clouds(brightness)\n \n led0.duty_cycle = adjusted_brightness\n led2.duty_cycle = adjusted_brightness\n led4.duty_cycle = adjusted_brightness\n\ndef func(vars):\n \"\"\"Intersection of a line and a sphere\n\n Coordinate system centered on gnomon tip\n Line passes through gnomon tip and is in line with the sun\n Sphere is centered on the arm's pivot and has arm-length radius\n \"\"\"\n \n alt, az, t = vars\n return [(arm[\"loc\"][0] + arm[\"length\"]*cos(alt)*cos(az-pi/2)) - (gnomon[\"loc\"][0] + t*cos(gnomon[\"az\"]-pi/2)),\n (arm[\"loc\"][1] + arm[\"length\"]*cos(alt)*sin(az-pi/2)) - (gnomon[\"loc\"][1] + t*sin(gnomon[\"az\"]-pi/2)),\n (arm[\"loc\"][2] + arm[\"length\"]*sin(alt)) - (gnomon[\"loc\"][2] + t*tan(gnomon[\"alt\"]))]\n\ndef validate_fsolve(x):\n \"\"\"Ensure fsolve successfully found roots in the right quadrant\"\"\"\n \n finds_zeros = all(isclose(func(x), [0.0, 0.0, 0.0]))\n positive_t = x[2] >= 0\n\n return (finds_zeros and positive_t)\n\ndef rotate_angle(angle, min_val, max_val):\n \"\"\"Adjust if our roots are the wrong multiple of 2pi\n\n e.g., sin(0) = sin(2pi) = sin(4pi) = ...\n \"\"\"\n \n a = angle\n while a < min_val: a += 2*pi\n while a > max_val: a += -2*pi\n\n return a\n\n\n# --- Setup Servo hat and assign LEDs and servos to their channels\ni2c = I2C(SCL, SDA)\nhat = PCA9685(i2c)\nhat.frequency = 50\n\nservo_alt = servo.Servo(hat.channels[13], min_pulse=600, max_pulse=2500)\nservo_az = servo.Servo(hat.channels[15], min_pulse=600, max_pulse=2500)\nled0 = hat.channels[0]\nled2 = hat.channels[2]\nled4 = hat.channels[4]\n\nunstable_math = False\nwhile not unstable_math:\n times[\"now\"] = datetime.datetime.now(datetime.timezone.utc)\n \n # Get sun's location at current time (in radians)\n gnomon[\"alt\"] = get_altitude(LAT, LON, times[\"now\"])*pi/180\n gnomon[\"az\"] = get_azimuth(LAT, LON, times[\"now\"])*pi/180\n \n if gnomon[\"alt\"] < 0:\n # Sleep until 10 minutes before this morning's sunrise\n # and then increments of 1 minute until sunrise\n if is_led_on:\n sleep_time = times[\"last_sunrise\"] + datetime.timedelta(days=1, minutes=-10) - times[\"now\"]\n else:\n sleep_time = datetime.timedelta(minutes=1)\n \n # Prep our next guess to be the last sunrise alt/az/t\n guess[\"alt\"] = last_sunrise[\"alt\"]\n guess[\"az\"] = last_sunrise[\"az\"]\n guess[\"t\"] = last_sunrise[\"t\"]\n \n # Light off and move servos\n is_led_on = False\n update_leds()\n \n servo_alt.angle = 135\n servo_az.angle = 90\n \n sleep(int(sleep_time))\n \n else:\n # Calculate sun's location relative to arm pivot point\n root = fsolve(func, (guess[\"alt\"], guess[\"az\"], guess[\"t\"]))\n\n # Validate fsolve worked and then continue with updates\n if validate_fsolve(root):\n # Move our alt and az to be in the correct range\n arm[\"alt\"] = rotate_angle(root[0], -pi/2, pi/2)\n arm[\"az\"] = rotate_angle(root[1], pi/2, 3*pi/2)\n \n # If the sun is coming up, refresh our best guess for sunrise time/alt/az/t\n if not is_led_on:\n times[\"last_sunrise\"] = times[\"now\"]\n last_sunrise[\"alt\"] = arm[\"alt\"]\n last_sunrise[\"az\"] = arm[\"az\"]\n last_sunrise[\"t\"] = root[2]\n \n # Prep our next guess to be the latest solution\n guess[\"alt\"] = arm[\"alt\"]\n guess[\"az\"] = arm[\"az\"]\n guess[\"t\"] = root[2]\n\n # Move servos and light on\n servo_alt.angle = (arm[\"alt\"]+pi/2)*180/pi\n servo_az.angle = (pi*3/2-arm[\"az\"])*180/pi\n \n is_led_on = True\n update_leds()\n\n # Sleep 240 seconds (1 degree of earth's rotation)\n sleep(240)\n else:\n unstable_math = True\n\n# Light off and servos to home position\nis_led_on = False\nupdate_leds()\nservo_alt.angle = 135\nservo_az.angle = 90\n"
] | [
[
"scipy.optimize.fsolve"
]
] |
sangyx/graph-tricks | [
"618bea55e221a9a3caedbe73aaa584303e583a98"
] | [
"benchmark/pyg/model.py"
] | [
"import torch\nimport torch.nn as nn\nfrom torch_geometric.nn import MessagePassing\nimport torch.nn.functional as F\nfrom torch_geometric.nn import global_mean_pool, GCNConv, SAGEConv\nfrom torch_geometric.utils import degree\n\nfrom ogb.graphproppred.mol_encoder import AtomEncoder, BondEncoder\n\n### GIN convolution along the graph structure\nclass EGINConv(MessagePassing):\n def __init__(self, emb_dim):\n '''\n emb_dim (int): node embedding dimensionality\n '''\n\n super(EGINConv, self).__init__(aggr=\"add\")\n\n self.mlp = torch.nn.Sequential(torch.nn.Linear(emb_dim, 2*emb_dim), torch.nn.BatchNorm1d(2*emb_dim), torch.nn.ReLU(), torch.nn.Linear(2*emb_dim, emb_dim))\n self.eps = torch.nn.Parameter(torch.Tensor([0]))\n\n self.edge_encoder = BondEncoder(emb_dim=emb_dim)\n \n def reset_parameters(self):\n for c in self.mlp.children():\n if hasattr(c, 'reset_parameters'):\n c.reset_parameters()\n nn.init.constant_(self.eps.data, 0)\n for emb in self.edge_encoder.bond_embedding_list:\n nn.init.xavier_uniform_(emb.weight.data)\n\n def forward(self, x, edge_index, edge_attr):\n edge_embedding = self.edge_encoder(edge_attr)\n out = self.mlp((1 + self.eps) *x + self.propagate(edge_index, x=x, edge_attr=edge_embedding))\n\n return out\n\n def message(self, x_j, edge_attr):\n return F.relu(x_j + edge_attr)\n\n def update(self, aggr_out):\n return aggr_out\n\n### GCN convolution along the graph structure\nclass EGCNConv(MessagePassing):\n def __init__(self, emb_dim):\n super(EGCNConv, self).__init__(aggr='add')\n\n self.linear = torch.nn.Linear(emb_dim, emb_dim)\n self.root_emb = torch.nn.Embedding(1, emb_dim)\n self.edge_encoder = BondEncoder(emb_dim = emb_dim)\n \n def reset_parameters(self):\n self.linear.reset_parameters()\n self.root_emb.reset_parameters()\n for emb in self.edge_encoder.bond_embedding_list:\n nn.init.xavier_uniform_(emb.weight.data)\n\n def forward(self, x, edge_index, edge_attr):\n x = self.linear(x)\n edge_embedding = self.edge_encoder(edge_attr)\n\n row, col = edge_index\n\n #edge_weight = torch.ones((edge_index.size(1), ), device=edge_index.device)\n deg = degree(row, x.size(0), dtype = x.dtype) + 1\n deg_inv_sqrt = deg.pow(-0.5)\n deg_inv_sqrt[deg_inv_sqrt == float('inf')] = 0\n\n norm = deg_inv_sqrt[row] * deg_inv_sqrt[col]\n\n return self.propagate(edge_index, x=x, edge_attr=edge_embedding, norm=norm) + F.relu(x + self.root_emb.weight) * 1./deg.view(-1,1)\n\n def message(self, x_j, edge_attr, norm):\n return norm.view(-1, 1) * F.relu(x_j + edge_attr)\n\n def update(self, aggr_out):\n return aggr_out\n\n\nclass EGCN(nn.Module):\n\n def __init__(self, hidden_channels, out_channels, num_layers,\n dropout):\n\n super(EGCN, self).__init__()\n\n self.node_encoder = AtomEncoder(hidden_channels)\n\n self.convs = nn.ModuleList()\n self.bns = nn.ModuleList()\n\n for i in range(num_layers):\n self.convs.append(\n EGCNConv(hidden_channels))\n if i != num_layers - 1:\n self.bns.append(nn.BatchNorm1d(hidden_channels))\n\n self.dropout = dropout\n\n self.out = nn.Linear(hidden_channels, out_channels)\n\n def reset_parameters(self):\n for emb in self.node_encoder.atom_embedding_list:\n torch.nn.init.xavier_uniform_(emb.weight.data)\n\n num_layers = len(self.convs)\n\n for i in range(num_layers):\n self.convs[i].reset_parameters()\n if i != num_layers - 1:\n self.bns[i].reset_parameters()\n\n self.out.reset_parameters()\n\n def forward(self, batched_data):\n x, edge_index, edge_attr, batch = batched_data.x, batched_data.edge_index, batched_data.edge_attr, batched_data.batch\n\n h = self.node_encoder(x)\n\n for i, conv in enumerate(self.convs[:-1]):\n h = conv(h, edge_index, edge_attr)\n h = self.bns[i](h)\n h = F.relu(h)\n h = F.dropout(h, p=self.dropout, training=self.training)\n h = self.convs[-1](h, edge_index, edge_attr)\n h = F.dropout(h, self.dropout, training=self.training)\n\n h = global_mean_pool(h, batch)\n h = self.out(h)\n\n return h\n\n\nclass EGIN(nn.Module):\n def __init__(self, hidden_channels, out_channels, num_layers,\n dropout):\n\n super(EGIN, self).__init__()\n\n self.node_encoder = AtomEncoder(hidden_channels)\n\n self.convs = nn.ModuleList()\n self.bns = nn.ModuleList()\n\n for i in range(num_layers):\n self.convs.append(\n EGINConv(hidden_channels))\n if i != num_layers - 1:\n self.bns.append(nn.BatchNorm1d(hidden_channels))\n\n self.dropout = dropout\n\n self.out = nn.Linear(hidden_channels, out_channels)\n\n def reset_parameters(self):\n for emb in self.node_encoder.atom_embedding_list:\n nn.init.xavier_uniform_(emb.weight.data)\n \n num_layers = len(self.convs)\n\n for i in range(num_layers):\n self.convs[i].reset_parameters()\n if i != num_layers - 1:\n self.bns[i].reset_parameters()\n\n self.out.reset_parameters()\n\n def forward(self, batched_data):\n x, edge_index, edge_attr, batch = batched_data.x, batched_data.edge_index, batched_data.edge_attr, batched_data.batch\n\n h = self.node_encoder(x)\n\n for i, conv in enumerate(self.convs[:-1]):\n h = conv(h, edge_index, edge_attr)\n h = self.bns[i](h)\n h = F.relu(h)\n h = F.dropout(h, p=self.dropout, training=self.training)\n h = self.convs[-1](h, edge_index, edge_attr)\n h = F.dropout(h, self.dropout, training=self.training)\n\n h = global_mean_pool(h, batch)\n h = self.out(h)\n\n return h\n\n\nclass GCN(torch.nn.Module):\n def __init__(self, in_channels, hidden_channels, out_channels, num_layers,\n dropout):\n super(GCN, self).__init__()\n\n self.convs = torch.nn.ModuleList()\n self.convs.append(GCNConv(in_channels, hidden_channels, cached=True))\n self.bns = torch.nn.ModuleList()\n self.bns.append(torch.nn.BatchNorm1d(hidden_channels))\n for _ in range(num_layers - 2):\n self.convs.append(\n GCNConv(hidden_channels, hidden_channels, cached=True))\n self.bns.append(torch.nn.BatchNorm1d(hidden_channels))\n self.convs.append(GCNConv(hidden_channels, out_channels, cached=True))\n\n self.dropout = dropout\n\n def reset_parameters(self):\n for conv in self.convs:\n conv.reset_parameters()\n for bn in self.bns:\n bn.reset_parameters()\n\n def forward(self, x, adj_t):\n for i, conv in enumerate(self.convs[:-1]):\n x = conv(x, adj_t)\n x = self.bns[i](x)\n x = F.relu(x)\n x = F.dropout(x, p=self.dropout, training=self.training)\n x = self.convs[-1](x, adj_t)\n return x\n\n\nclass SAGE(torch.nn.Module):\n def __init__(self, in_channels, hidden_channels, out_channels, num_layers,\n dropout):\n super(SAGE, self).__init__()\n\n self.convs = torch.nn.ModuleList()\n self.convs.append(SAGEConv(in_channels, hidden_channels))\n self.bns = torch.nn.ModuleList()\n self.bns.append(torch.nn.BatchNorm1d(hidden_channels))\n for _ in range(num_layers - 2):\n self.convs.append(SAGEConv(hidden_channels, hidden_channels))\n self.bns.append(torch.nn.BatchNorm1d(hidden_channels))\n self.convs.append(SAGEConv(hidden_channels, out_channels))\n\n self.dropout = dropout\n\n def reset_parameters(self):\n for conv in self.convs:\n conv.reset_parameters()\n for bn in self.bns:\n bn.reset_parameters()\n\n def forward(self, x, adj_t):\n for i, conv in enumerate(self.convs[:-1]):\n x = conv(x, adj_t)\n x = self.bns[i](x)\n x = F.relu(x)\n x = F.dropout(x, p=self.dropout, training=self.training)\n x = self.convs[-1](x, adj_t)\n return x"
] | [
[
"torch.nn.init.xavier_uniform_",
"torch.nn.Linear",
"torch.nn.init.constant_",
"torch.nn.functional.dropout",
"torch.nn.BatchNorm1d",
"torch.nn.Embedding",
"torch.nn.functional.relu",
"torch.nn.ModuleList",
"torch.nn.ReLU",
"torch.Tensor"
]
] |
rjpower/tensorflow-io | [
"39aa0b46cfaa403121fdddbd491a03d2f3190a87"
] | [
"tensorflow_io/cifar/__init__.py"
] | [
"# Copyright 2018 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\"\"\"CIFAR File Dataset.\n\n@@CIFAR10Dataset\n@@CIFAR100Dataset\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom tensorflow_io.cifar.python.ops.cifar_ops import CIFAR10Dataset\nfrom tensorflow_io.cifar.python.ops.cifar_ops import CIFAR100Dataset\n\nfrom tensorflow.python.util.all_util import remove_undocumented\n\n_allowed_symbols = [\n \"CIFAR10Dataset\",\n \"CIFAR100Dataset\",\n]\n\nremove_undocumented(__name__, allowed_exception_list=_allowed_symbols)\n"
] | [
[
"tensorflow.python.util.all_util.remove_undocumented"
]
] |
usccolumbia/deeperGATGNN | [
"24ee53b23d1559040b7aab971768434753b582ff"
] | [
"matdeeplearn/models/super_mpnn.py"
] | [
"import torch\r\nfrom torch import Tensor\r\nimport torch.nn.functional as F\r\nfrom torch.nn import Sequential, Linear, ReLU, BatchNorm1d, GRU\r\nimport torch_geometric\r\nfrom torch_geometric.nn import (\r\n Set2Set,\r\n global_mean_pool,\r\n global_add_pool,\r\n global_max_pool,\r\n NNConv,\r\n DiffGroupNorm\r\n)\r\nfrom torch_scatter import scatter_mean, scatter_add, scatter_max, scatter\r\n\r\n\r\n# SUPER_MPNN\r\nclass SUPER_MPNN(torch.nn.Module):\r\n def __init__(\r\n self,\r\n data,\r\n dim1=64,\r\n dim2=64,\r\n dim3=64,\r\n pre_fc_count=1,\r\n gc_count=3,\r\n post_fc_count=1,\r\n pool=\"global_mean_pool\",\r\n pool_order=\"early\",\r\n batch_norm=\"True\",\r\n batch_track_stats=\"True\",\r\n act=\"relu\",\r\n dropout_rate=0.0,\r\n **kwargs\r\n ):\r\n super(SUPER_MPNN, self).__init__()\r\n\r\n \r\n if batch_track_stats == \"False\":\r\n self.batch_track_stats = False \r\n else:\r\n self.batch_track_stats = True \r\n self.batch_norm = batch_norm\r\n self.pool = pool\r\n self.act = act\r\n self.pool_order = pool_order\r\n self.dropout_rate = dropout_rate\r\n \r\n ##Determine gc dimension dimension\r\n assert gc_count > 0, \"Need at least 1 GC layer\" \r\n if pre_fc_count == 0:\r\n gc_dim = data.num_features\r\n else:\r\n gc_dim = dim1\r\n ##Determine post_fc dimension\r\n if pre_fc_count == 0:\r\n post_fc_dim = data.num_features\r\n else:\r\n post_fc_dim = dim1\r\n ##Determine output dimension length\r\n if data[0].y.ndim == 0:\r\n output_dim = 1\r\n else:\r\n output_dim = len(data[0].y[0])\r\n\r\n ##Set up pre-GNN dense layers (NOTE: in v0.1 this is always set to 1 layer)\r\n if pre_fc_count > 0:\r\n self.pre_lin_list = torch.nn.ModuleList()\r\n for i in range(pre_fc_count):\r\n if i == 0:\r\n lin = torch.nn.Linear(data.num_features, dim1)\r\n self.pre_lin_list.append(lin)\r\n else:\r\n lin = torch.nn.Linear(dim1, dim1)\r\n self.pre_lin_list.append(lin)\r\n elif pre_fc_count == 0:\r\n self.pre_lin_list = torch.nn.ModuleList()\r\n\r\n ##Set up GNN layers\r\n self.conv_list = torch.nn.ModuleList()\r\n self.gru_list = torch.nn.ModuleList()\r\n self.bn_list = torch.nn.ModuleList()\r\n for i in range(gc_count):\r\n nn = Sequential(\r\n Linear(data.num_edge_features, dim3), ReLU(), Linear(dim3, gc_dim * gc_dim)\r\n )\r\n conv = NNConv(\r\n gc_dim, gc_dim, nn, aggr=\"mean\"\r\n ) \r\n self.conv_list.append(conv)\r\n gru = GRU(gc_dim, gc_dim)\r\n self.gru_list.append(gru)\r\n\r\n ##Track running stats set to false can prevent some instabilities; this causes other issues with different val/test performance from loader size?\r\n if self.batch_norm == \"True\":\r\n #bn = BatchNorm1d(gc_dim, track_running_stats=self.batch_track_stats)\r\n bn = DiffGroupNorm(gc_dim, 10, track_running_stats=self.batch_track_stats)\r\n self.bn_list.append(bn)\r\n\r\n ##Set up post-GNN dense layers (NOTE: in v0.1 there was a minimum of 2 dense layers, and fc_count(now post_fc_count) added to this number. In the current version, the minimum is zero)\r\n if post_fc_count > 0:\r\n self.post_lin_list = torch.nn.ModuleList()\r\n for i in range(post_fc_count):\r\n if i == 0:\r\n ##Set2set pooling has doubled dimension\r\n if self.pool_order == \"early\" and self.pool == \"set2set\":\r\n lin = torch.nn.Linear(post_fc_dim * 2, dim2)\r\n else:\r\n lin = torch.nn.Linear(post_fc_dim, dim2)\r\n self.post_lin_list.append(lin)\r\n else:\r\n lin = torch.nn.Linear(dim2, dim2)\r\n self.post_lin_list.append(lin)\r\n self.lin_out = torch.nn.Linear(dim2, output_dim)\r\n\r\n elif post_fc_count == 0:\r\n self.post_lin_list = torch.nn.ModuleList()\r\n if self.pool_order == \"early\" and self.pool == \"set2set\":\r\n self.lin_out = torch.nn.Linear(post_fc_dim*2, output_dim)\r\n else:\r\n self.lin_out = torch.nn.Linear(post_fc_dim, output_dim) \r\n\r\n ##Set up set2set pooling (if used)\r\n if self.pool_order == \"early\" and self.pool == \"set2set\":\r\n self.set2set = Set2Set(post_fc_dim, processing_steps=3)\r\n elif self.pool_order == \"late\" and self.pool == \"set2set\":\r\n self.set2set = Set2Set(output_dim, processing_steps=3, num_layers=1)\r\n # workaround for doubled dimension by set2set; if late pooling not reccomended to use set2set\r\n self.lin_out_2 = torch.nn.Linear(output_dim * 2, output_dim)\r\n\r\n def forward(self, data):\r\n\r\n ##Pre-GNN dense layers\r\n for i in range(0, len(self.pre_lin_list)):\r\n if i == 0:\r\n out = self.pre_lin_list[i](data.x)\r\n out = getattr(F, self.act)(out)\r\n #prev_out = out\r\n else:\r\n out = self.pre_lin_list[i](out)\r\n out = getattr(F, self.act)(out)\r\n #out = torch.add(out, prev_out)\r\n #prev_out = out\r\n prev_out = out\r\n\r\n ##GNN layers\r\n if len(self.pre_lin_list) == 0:\r\n h = data.x.unsqueeze(0) \r\n else:\r\n h = out.unsqueeze(0) \r\n for i in range(0, len(self.conv_list)):\r\n if len(self.pre_lin_list) == 0 and i == 0:\r\n if self.batch_norm == \"True\":\r\n m = self.conv_list[i](data.x, data.edge_index, data.edge_attr)\r\n m = self.bn_list[i](m)\r\n else:\r\n m = self.conv_list[i](data.x, data.edge_index, data.edge_attr)\r\n else:\r\n if self.batch_norm == \"True\":\r\n m = self.conv_list[i](out, data.edge_index, data.edge_attr)\r\n m = self.bn_list[i](m)\r\n else:\r\n m = self.conv_list[i](out, data.edge_index, data.edge_attr) \r\n m = getattr(F, self.act)(m) \r\n m = F.dropout(m, p=self.dropout_rate, training=self.training)\r\n out, h = self.gru_list[i](m.unsqueeze(0), h)\r\n out = out.squeeze(0)\r\n out = torch.add(out, prev_out)\r\n prev_out = out \r\n\r\n ##Post-GNN dense layers\r\n if self.pool_order == \"early\":\r\n if self.pool == \"set2set\":\r\n out = self.set2set(out, data.batch)\r\n else:\r\n out = getattr(torch_geometric.nn, self.pool)(out, data.batch)\r\n for i in range(0, len(self.post_lin_list)):\r\n out = self.post_lin_list[i](out)\r\n out = getattr(F, self.act)(out)\r\n #out = torch.add(out, prev_out)\r\n #prev_out = out\r\n out = self.lin_out(out)\r\n #out = torch.add(out, prev_out)\r\n #prev_out = out\r\n\r\n elif self.pool_order == \"late\":\r\n for i in range(0, len(self.post_lin_list)):\r\n out = self.post_lin_list[i](out)\r\n out = getattr(F, self.act)(out)\r\n #out = torch.add(out, prev_out)\r\n #prev_out = out\r\n out = self.lin_out(out)\r\n #out = torch.add(out, prev_out)\r\n #prev_out = out\r\n\r\n if self.pool == \"set2set\":\r\n out = self.set2set(out, data.batch)\r\n out = self.lin_out_2(out)\r\n #out = torch.add(out, prev_out)\r\n #prev_out = out\r\n else:\r\n out = getattr(torch_geometric.nn, self.pool)(out, data.batch)\r\n \r\n if out.shape[1] == 1:\r\n return out.view(-1)\r\n else:\r\n return out\r\n"
] | [
[
"torch.nn.Linear",
"torch.nn.functional.dropout",
"torch.add",
"torch.nn.GRU",
"torch.nn.ModuleList",
"torch.nn.ReLU"
]
] |
foocker/Image2Katex | [
"775efd6a68168fe46572e5017a861321c342e623"
] | [
"models/decoder.py"
] | [
"'''\nFilename: decoder.py\nProject: models\nFile Created: Wednesday, 11th July 2018 3:37:09 pm\nAuthor: xiaofeng ([email protected])\n--------------------------\nLast Modified: Sunday, 2nd December 2018 4:09:59 pm\nModified By: xiaofeng ([email protected])\n---------------------------\nCopyright: 2018.06 - 2018 OnionMath. OnionMath\n'''\n\nfrom __future__ import division\n\nimport tensorflow as tf\n\nfrom models.component.attention_cell_compile import AttCell\nfrom models.component.decoder_beamsearch import BeamSearchDecoderCell\n# from .component.attention_cell_step import AttCell\nfrom models.component.decoder_dynamic import dynamic_decode\nfrom models.component.decoder_greedy import GreedyDecoderCell\nfrom tensorflow.contrib.rnn import GRUCell, LSTMCell\nfrom models.component.LnRnn import LNGRUCell, LNLSTMCell\nfrom models.component.word_embeding import Embedding, embedding_initializer\n\n\nclass DecoderAtt(object):\n def __init__(self, config, vocab):\n self._config = config\n self._vocab = vocab\n self._name = self._config.model.get('decoder_name')\n self._vocabsize = self._vocab.vocab_size\n self._id_end = self._config.dataset.get('id_end')\n self._embeding_dim = self._config.model.get('embeding_dims')\n self._encoder_dim = self._config.model.get('rnn_encoder_dim')\n self._decoder_dim = self._config.model.get('rnn_decoder_dim')\n self._att_dim = self._config.model.get('att_dim')\n assert self._encoder_dim * 2 == self._decoder_dim, \\\n \"Encoder bilstm out dim is the double encoder dim and it must be equal with decoder dim\"\n\n self._tiles = 1 if self._config.model.decoding == 'greedy' else self._config.model.beam_size\n\n self._vocab_embeding = tf.get_variable(\n \"vocab_embeding\", dtype=tf.float32, shape=[self._vocabsize, self._embeding_dim],\n initializer=embedding_initializer())\n self._start_token = tf.squeeze(input=self._vocab_embeding[0, :], name='start_flage')\n\n def __call__(self, encoder_out, droupout, input_sequence=None):\n\n self._batch_size = tf.shape(encoder_out)[0]\n\n with tf.variable_scope(self._name, reuse=False):\n sequence_embeding = Embedding('embeding', self._vocab_embeding, input_sequence)\n # attention cell come from Rnn\n \"\"\" Uniform gru cell \"\"\"\n RnnCell = GRUCell(name='DecoderGru', num_units=self._decoder_dim)\n \"\"\" LN gru cell \"\"\"\n # RnnCell = LNGRUCell(name='DecoderGru', num_units=self._decoder_dim)\n att_cell = AttCell(\n name='AttCell', att_input=encoder_out, cell=RnnCell, n_hid=self._decoder_dim,\n dim_att=self._att_dim, dim_o=self._decoder_dim, dropuout=droupout,\n vacab_size=self._vocabsize)\n # [batch,sequence_length]\n # sequence_length is equal with the input label length\n sequence_length = tf.tile(tf.expand_dims(\n tf.shape(sequence_embeding)[1], 0), [self._batch_size])\n\n pred_train, _ = tf.nn.dynamic_rnn(\n att_cell, sequence_embeding, initial_state=att_cell.initial_state(),\n sequence_length=sequence_length, dtype=tf.float32, swap_memory=True)\n # evaluating , predict\n with tf.variable_scope(self._name, reuse=True):\n \"\"\" uniform gru cell \"\"\"\n RnnCell = GRUCell(name='DecoderGru', num_units=self._decoder_dim)\n \"\"\" LN gru cell \"\"\"\n # RnnCell = LNGRUCell(name='DecoderGru', num_units=self._decoder_dim)\n att_cell = AttCell(\n name='AttCell', att_input=encoder_out, cell=RnnCell, n_hid=self._decoder_dim,\n dim_att=self._att_dim, dim_o=self._decoder_dim, dropuout=droupout,\n vacab_size=self._vocabsize, tiles=self._tiles)\n if self._config.model.decoding == 'beams_search':\n decoder_cell = BeamSearchDecoderCell(\n self._vocab_embeding, att_cell, self._batch_size, self._start_token,\n self._id_end, self._config.model.beam_size,\n self._config.model.div_gamma, self._config.model.div_prob)\n else:\n decoder_cell = GreedyDecoderCell(\n self._vocab_embeding, att_cell, self._batch_size, self._start_token,\n self._id_end)\n pred_validate, _ = dynamic_decode(\n decoder_cell, self._config.model.MaxPredictLength + 1)\n\n return pred_train, pred_validate\n"
] | [
[
"tensorflow.squeeze",
"tensorflow.contrib.rnn.GRUCell",
"tensorflow.shape",
"tensorflow.variable_scope"
]
] |
tareknaous/visual-clustering | [
"73ab04b560c72917ddb5ad69594afee59ebd44d7"
] | [
"dataset.py"
] | [
"import numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn import datasets\n\n#blobs\nn_samples = 1500\nblobs = datasets.make_blobs(n_samples=n_samples, centers=4, random_state=3)\n# plt.scatter(blobs[0][:,0],blobs[0][:,1])\n# plt.show()\n\ncluster_0_points = []\ncluster_1_points = []\ncluster_2_points = []\ncluster_3_points = []\n\nfor i in range(0,len(blobs[0])):\n if blobs[1][i] == 0:\n cluster_0_points.append(blobs[0][i])\n if blobs[1][i] == 1:\n cluster_1_points.append(blobs[0][i])\n if blobs[1][i] == 2:\n cluster_2_points.append(blobs[0][i])\n if blobs[1][i] == 3:\n cluster_3_points.append(blobs[0][i])\n\n\nclusters = []\n\nclusters.append(cluster_0_points)\nclusters.append(cluster_1_points)\nclusters.append(cluster_2_points)\nclusters.append(cluster_3_points)\n\n\n\nfrom scipy.spatial import ConvexHull, convex_hull_plot_2d\nimport matplotlib.pyplot as plt\n\n#Cluster 0\nhull_0 = ConvexHull(cluster_0_points)\npoints_0 = np.array(cluster_0_points)\n\nfor simplex in hull_0.simplices:\n plt.plot(points_0[simplex, 0], points_0[simplex, 1], 'k-')\n\n\n\n#Cluster 1\nhull_1 = ConvexHull(cluster_1_points)\npoints_1 = np.array(cluster_1_points)\n\nfor simplex in hull_1.simplices:\n plt.plot(points_1[simplex, 0], points_1[simplex, 1], 'k-')\n\n\n#Cluster 2\nhull_2 = ConvexHull(cluster_2_points)\npoints_2 = np.array(cluster_2_points)\n\nfor simplex in hull_2.simplices:\n plt.plot(points_2[simplex, 0], points_2[simplex, 1], 'k-')\n\n\n\n#Cluster 3\nhull_3 = ConvexHull(cluster_3_points)\npoints_3 = np.array(cluster_3_points)\n\nfor simplex in hull_3.simplices:\n plt.plot(points_3[simplex, 0], points_3[simplex, 1], 'k-')\n\n\nplt.show()"
] | [
[
"scipy.spatial.ConvexHull",
"matplotlib.pyplot.show",
"numpy.array",
"matplotlib.pyplot.plot",
"sklearn.datasets.make_blobs"
]
] |
wgfi110/athena | [
"e704884ec6a3a947769d892aa267578038e49ecb"
] | [
"athena/data/datasets/base.py"
] | [
"# coding=utf-8\n# Copyright (C) 2019 ATHENA AUTHORS; Xiangang Li; Shuaijiang Zhao\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\"\"\" base dataset \"\"\"\n\nimport math\nimport random\nimport os\nfrom absl import logging\nimport tensorflow as tf\nfrom athena.transform import AudioFeaturizer\nfrom ..feature_normalizer import FeatureNormalizer\nfrom ...utils.hparam import register_and_parse_hparams\nfrom ...utils.data_queue import DataQueue\n\n\ndef data_loader(dataset_builder, batch_size=16, num_threads=1):\n \"\"\"data loader\n \"\"\"\n num_samples = len(dataset_builder)\n if num_samples == 0:\n raise ValueError(\"num samples is empty\")\n\n if num_threads == 1:\n def _gen_data():\n \"\"\"multi thread loader\n \"\"\"\n for i in range(num_samples):\n yield dataset_builder[i]\n else:\n # multi-thread\n logging.info(\"loading data using %d threads\" % num_threads)\n data_queue = DataQueue(\n lambda i: dataset_builder[i],\n capacity=4096,\n num_threads=num_threads,\n max_index=num_samples\n )\n def _gen_data():\n \"\"\"multi thread loader\n \"\"\"\n for _ in range(num_samples):\n yield data_queue.get()\n\n # make dataset using from_generator\n dataset = tf.compat.v2.data.Dataset.from_generator(\n _gen_data,\n output_types=dataset_builder.sample_type,\n output_shapes=dataset_builder.sample_shape,\n )\n\n # Padding the features to its max length dimensions.\n dataset = dataset.padded_batch(\n batch_size=batch_size,\n padded_shapes=dataset_builder.sample_shape,\n drop_remainder=True,\n )\n\n # Prefetch to improve speed of input pipeline.\n dataset = dataset.prefetch(buffer_size=500)\n return dataset\n\n\nclass BaseDatasetBuilder:\n \"\"\"base dataset builder\n \"\"\"\n default_config = {}\n\n def __init__(self, config=None):\n # hparams\n self.hparams = register_and_parse_hparams(\n self.default_config, config, cls=self.__class__)\n logging.info(\"hparams: {}\".format(self.hparams))\n self.entries = []\n\n def reload_config(self, config):\n \"\"\" reload the config \"\"\"\n if config is not None:\n self.hparams.override_from_dict(config)\n\n def preprocess_data(self, file_path):\n \"\"\" loading data \"\"\"\n raise NotImplementedError\n\n def __getitem__(self, index):\n raise NotImplementedError\n\n def __len__(self):\n return len(self.entries)\n\n @property\n def sample_type(self):\n \"\"\"example types\n \"\"\"\n raise NotImplementedError\n\n @property\n def sample_shape(self):\n \"\"\"examples shapes\n \"\"\"\n raise NotImplementedError\n\n @property\n def sample_signature(self):\n \"\"\"examples signature\n \"\"\"\n raise NotImplementedError\n\n def as_dataset(self, batch_size=16, num_threads=1):\n \"\"\"return tf.data.Dataset object\n \"\"\"\n return data_loader(self, batch_size, num_threads)\n\n def shard(self, num_shards, index):\n \"\"\"creates a Dataset that includes only 1/num_shards of this dataset\n \"\"\"\n if index >= num_shards:\n raise ValueError(\"the index should smaller the num_shards\")\n logging.info(\"Creates the sub-dataset which is the %d part of %d\" % (index, num_shards))\n original_entries = self.entries\n self.entries = []\n total_samples = (len(original_entries) // num_shards) * num_shards\n for i in range(total_samples):\n if i % num_shards == index:\n self.entries.append(original_entries[i])\n return self\n\n def batch_wise_shuffle(self, batch_size=64):\n \"\"\"Batch-wise shuffling of the data entries.\n\n Each data entry is in the format of (audio_file, file_size, transcript).\n If epoch_index is 0 and sortagrad is true, we don't perform shuffling and\n return entries in sorted file_size order. Otherwise, do batch_wise shuffling.\n\n Args:\n batch_size (int, optional): an integer for the batch size. Defaults to 64.\n \"\"\"\n if len(self.entries) == 0:\n return self\n logging.info(\"perform batch_wise_shuffle with batch_size %d\" % batch_size)\n max_buckets = int(math.floor(len(self.entries) / batch_size))\n total_buckets = list(range(max_buckets))\n random.shuffle(total_buckets)\n shuffled_entries = []\n for i in total_buckets:\n shuffled_entries.extend(self.entries[i * batch_size : (i + 1) * batch_size])\n shuffled_entries.extend(self.entries[max_buckets * batch_size :])\n self.entries = shuffled_entries\n return self\n\n def compute_cmvn_if_necessary(self, is_necessary=True):\n \"\"\" compute cmvn file\n \"\"\"\n return self\n\n\nclass SpeechBaseDatasetBuilder(BaseDatasetBuilder):\n \"\"\" speech base dataset \"\"\"\n default_config = {\n \"audio_config\": {\"type\": \"Fbank\"},\n \"num_cmvn_workers\": 1,\n \"cmvn_file\": None,\n \"data_csv\": None\n }\n\n def __init__(self, config=None):\n super().__init__(config=config)\n self.speakers = []\n self.audio_featurizer = AudioFeaturizer(self.hparams.audio_config)\n self.feature_normalizer = FeatureNormalizer(self.hparams.cmvn_file)\n\n @property\n def num_class(self):\n \"\"\" return the number of classes \"\"\"\n raise NotImplementedError\n\n def compute_cmvn_if_necessary(self, is_necessary=True):\n \"\"\"vitural interface\n \"\"\"\n if not is_necessary:\n return self\n if os.path.exists(self.hparams.cmvn_file):\n return self\n feature_dim = self.audio_featurizer.dim * self.audio_featurizer.num_channels\n with tf.device(\"/cpu:0\"):\n self.feature_normalizer.compute_cmvn(\n self.entries, self.speakers, self.audio_featurizer, feature_dim,\n self.hparams.num_cmvn_workers\n )\n self.feature_normalizer.save_cmvn([\"speaker\", \"mean\", \"var\"])\n return self\n"
] | [
[
"tensorflow.device",
"tensorflow.compat.v2.data.Dataset.from_generator"
]
] |
wangbingok1118/SSD_Pytorch | [
"8d3f924671cec367c3c420eba2f002cc5b5181bb"
] | [
"demo.py"
] | [
"import os\nos.environ[\"CUDA_VISIBLE_DEVICES\"] = \"1,0\"\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nimport torch.backends.cudnn as cudnn\nimport torch.nn.init as init\nimport argparse\nfrom torch.autograd import Variable\nimport torch.utils.data as data\nfrom data import COCODetection, VOCDetection, detection_collate, BaseTransform, preproc\nfrom layers.modules import MultiBoxLoss, RefineMultiBoxLoss\nfrom layers.functions import Detect\nfrom utils.nms_wrapper import nms, soft_nms\nfrom configs.config import cfg, cfg_from_file, VOC_CLASSES, COCO_CLASSES\nfrom utils.box_utils import draw_rects\nimport numpy as np\nimport time\nimport os\nimport sys\nimport pickle\nimport datetime\nfrom models.model_builder import SSD\nimport yaml\nimport cv2\n\n\ndef arg_parse():\n parser = argparse.ArgumentParser(\n description='Single Shot MultiBox Detection')\n parser.add_argument(\n \"--images\",\n dest='images',\n help=\"Image / Directory containing images to perform detection upon\",\n default=\"images\",\n type=str)\n parser.add_argument(\n '--weights',\n default='weights/ssd_darknet_300.pth',\n type=str,\n help='Trained state_dict file path to open')\n parser.add_argument(\n '--cfg',\n dest='cfg_file',\n help='Config file for training (and optionally testing)')\n parser.add_argument(\n '--save_folder',\n default='eval/',\n type=str,\n help='File path to save results')\n parser.add_argument(\n '--num_workers',\n default=8,\n type=int,\n help='Number of workers used in dataloading')\n parser.add_argument(\n '--retest', default=False, type=bool, help='test cache results')\n args = parser.parse_args()\n return args\n\n\ndef im_detect(img, net, detector, transform, thresh=0.01):\n with torch.no_grad():\n t0 = time.time()\n w, h = img.shape[1], img.shape[0]\n x = transform(img)[0].unsqueeze(0)\n x = x.cuda()\n t1 = time.time()\n output = net(x)\n boxes, scores = detector.forward(output)\n t2 = time.time()\n max_conf, max_id = scores[0].topk(1, 1, True, True)\n pos = max_id > 0\n if len(pos) == 0:\n return np.empty((0, 6))\n boxes = boxes[0][pos.view(-1, 1).expand(len(pos), 4)].view(-1, 4)\n scores = max_conf[pos].view(-1, 1)\n max_id = max_id[pos].view(-1, 1)\n inds = scores > thresh\n if len(inds) == 0:\n return np.empty((0, 6))\n boxes = boxes[inds.view(-1, 1).expand(len(inds), 4)].view(-1, 4)\n scores = scores[inds].view(-1, 1)\n max_id = max_id[inds].view(-1, 1)\n c_dets = torch.cat((boxes, scores, max_id.float()), 1).cpu().numpy()\n img_classes = np.unique(c_dets[:, -1])\n output = None\n flag = False\n for cls in img_classes:\n cls_mask = np.where(c_dets[:, -1] == cls)[0]\n image_pred_class = c_dets[cls_mask, :]\n keep = nms(image_pred_class, cfg.TEST.NMS_OVERLAP, force_cpu=True)\n keep = keep[:50]\n image_pred_class = image_pred_class[keep, :]\n if not flag:\n output = image_pred_class\n flag = True\n else:\n output = np.concatenate((output, image_pred_class), axis=0)\n output[:, 0:2][output[:, 0:2] < 0] = 0\n output[:, 2:4][output[:, 2:4] > 1] = 1\n scale = np.array([w, h, w, h])\n output[:, :4] = output[:, :4] * scale\n t3 = time.time()\n print(\"transform_t:\", round(t1 - t0, 3), \"detect_time:\",\n round(t2 - t1, 3), \"nms_time:\", round(t3 - t2, 3))\n return output\n\n\ndef main():\n global args\n args = arg_parse()\n ssh_run_param(args)\n cfg_from_file(args.cfg_file)\n bgr_means = cfg.TRAIN.BGR_MEAN\n dataset_name = cfg.DATASETS.DATA_TYPE\n batch_size = cfg.TEST.BATCH_SIZE\n num_workers = args.num_workers\n if cfg.DATASETS.DATA_TYPE == 'VOC':\n trainvalDataset = VOCDetection\n classes = VOC_CLASSES\n top_k = 200\n else:\n trainvalDataset = COCODetection\n classes = COCO_CLASSES\n top_k = 300\n valSet = cfg.DATASETS.VAL_TYPE\n num_classes = cfg.MODEL.NUM_CLASSES\n save_folder = args.save_folder\n if not os.path.exists(save_folder):\n os.mkdir(save_folder)\n torch.set_default_tensor_type('torch.cuda.FloatTensor')\n cfg.TRAIN.TRAIN_ON = False\n net = SSD(cfg)\n\n checkpoint = torch.load(args.weights)\n state_dict = checkpoint['model']\n from collections import OrderedDict\n new_state_dict = OrderedDict()\n for k, v in state_dict.items():\n head = k[:7]\n if head == 'module.':\n name = k[7:] # remove `module.`\n else:\n name = k\n new_state_dict[name] = v\n net.load_state_dict(new_state_dict)\n\n detector = Detect(cfg)\n img_wh = cfg.TEST.INPUT_WH\n ValTransform = BaseTransform(img_wh, bgr_means, (2, 0, 1))\n input_folder = args.images\n thresh = cfg.TEST.CONFIDENCE_THRESH\n for item in os.listdir(input_folder)[2:3]:\n img_path = os.path.join(input_folder, item)\n print(img_path)\n img = cv2.imread(img_path)\n dets = im_detect(img, net, detector, ValTransform, thresh)\n draw_img = draw_rects(img, dets, classes)\n out_img_name = \"output_\" + item\n save_path = os.path.join(save_folder, out_img_name)\n cv2.imwrite(save_path, img)\n\n\ndef ssh_run_param(args):\n args.cfg_file = './configs/refine_vgg_voc_512.yaml'\n\n\nif __name__ == '__main__':\n st = time.time()\n main()\n print(\"final time\", time.time() - st)\n"
] | [
[
"torch.load",
"numpy.empty",
"numpy.concatenate",
"torch.no_grad",
"torch.set_default_tensor_type",
"numpy.array",
"numpy.where",
"numpy.unique"
]
] |
inaccel/TF2 | [
"1a3ce4c63675a30156bfcf3a1b9682154ef13183"
] | [
"TransForm_Kit/Quantization/debug/Pytorch-ResNet50-Log2QuantizeLoad-FPGA_Quantize-Batch-2.py"
] | [
"\n# coding: utf-8\n\n\nimport math\nimport struct\nimport cv2\nimport numpy as np\nimport torch\nimport torch.nn as nn\nimport torch.utils.model_zoo as model_zoo\nimport torch.utils.data as data\nimport torchvision\nimport torchvision.models as tvmodel\nimport torchvision.transforms as transforms\nimport torchvision.datasets as datasets\nimport torch.nn.functional as F\nfrom torch.nn.parameter import Parameter\nfrom torch.autograd import Variable\nfrom collections import OrderedDict\nimport matplotlib.pyplot as plt\nimport os\nimport gc\n#os.environ['CUDA_VISIBLE_DEVICES']='2'\n\nlayer_name_binQ = ['data','conv1-scale','res2a_branch2a-scale','res2a_branch2b-scale','res2c','res2b_branch2a-scale','res2b_branch2b-scale','res2c','res2c_branch2a-scale','res2c_branch2b-scale','res2c','res3a_branch2a-scale','res3a_branch2b-scale','res3d','res3b_branch2a-scale','res3b_branch2b-scale','res3d','res3c_branch2a-scale','res3c_branch2b-scale','res3d','res3d_branch2a-scale','res3d_branch2b-scale','res3d','res4a_branch2a-scale','res4a_branch2b-scale','res4f','res4b_branch2a-scale','res4b_branch2b-scale','res4f','res4c_branch2a-scale','res4c_branch2b-scale','res4f','res4d_branch2a-scale','res4d_branch2b-scale','res4f','res4e_branch2a-scale','res4e_branch2b-scale','res4f','res4f_branch2a-scale','res4f_branch2b-scale','res4f','res5a_branch2a-scale','res5a_branch2b-scale','res5c','res5b_branch2a-scale','res5b_branch2b-scale','res5c','res5c_branch2a-scale','res5c_branch2b-scale','res5c','fc1000']\n\nlayer_name_bin = ['data','conv1-scale','res2a_branch2a-scale','res2a_branch2b-scale','res2a_branch2c-scale','res2a_branch1-scale','res2a','res2b_branch2a-scale','res2b_branch2b-scale','res2b_branch2c-scale','res2b','res2c_branch2a-scale','res2c_branch2b-scale','res2c_branch2c-scale','res2c','res3a_branch2a-scale','res3a_branch2b-scale','res3a_branch2c-scale','res3a_branch1-scale','res3a','res3b_branch2a-scale','res3b_branch2b-scale','res3b_branch2c-scale','res3b','res3c_branch2a-scale','res3c_branch2b-scale','res3c_branch2c-scale','res3c','res3d_branch2a-scale','res3d_branch2b-scale','res3d_branch2c-scale','res3d','res4a_branch2a-scale','res4a_branch2b-scale','res4a_branch2c-scale','res4a_branch1-scale','res4a','res4b_branch2a-scale','res4b_branch2b-scale','res4b_branch2c-scale','res4b','res4c_branch2a-scale','res4c_branch2b-scale','res4c_branch2c-scale','res4c','res4d_branch2a-scale','res4d_branch2b-scale','res4d_branch2c-scale','res4d','res4e_branch2a-scale','res4e_branch2b-scale','res4e_branch2c-scale','res4e','res4f_branch2a-scale','res4f_branch2b-scale','res4f_branch2c-scale','res4f','res5a_branch2a-scale','res5a_branch2b-scale','res5a_branch2c-scale','res5a_branch1-scale','res5a','res5b_branch2a-scale','res5b_branch2b-scale','res5b_branch2c-scale','res5b','res5c_branch2a-scale','res5c_branch2b-scale','res5c_branch2c-scale','res5c','pool5','fc1000']\n\nlayer_count = 0\nfilter_count = 0\nfeature_file_count = 0\ndef FeatureWrite(name,x):\n with open('Feature_int8/resnet50/'+name+'.txt','w') as data:\n for i in range(x.shape[0]):\n for j in range(x.shape[1]):\n for k in range(x.shape[2]):\n for l in range(x.shape[3]):\n st = x[i][j][k][l].item()\n st = str(st)\n data.write(st)\n data.write('\\n')\n\ndef FeatureWriteFC(name,x):\n with open('Feature_int8/resnet50/'+name,'w') as data:\n for i in range(x.size(0)):\n for j in range(x.size(1)):\n st = x[i][j].item()\n st = str(st)\n data.write(st)\n data.write('\\n') \n\ndef FeatureWriteFC_Bin(name,x):\n with open('Feature_int8/resnet50/'+name,'wb') as data:\n for i in range(x.size(0)):\n for j in range(x.size(1)):\n st = x[i][j].item()\n st = struct.pack('f',st)\n data.write(st)\n\n\ndef GetQ(Q): \n global layer_name_binQ\n q_list = []\n for m in range(51):\n Q_key = layer_name_binQ[m]\n with open('../channel_q/resnet50/' + Q_key,'r') as data:\n line = data.readline()\n linedata = line.strip().split(' ')\n for item in linedata:\n item = np.int8(item)\n q_list.append(item)\n print(len(q_list))\n Q[Q_key] = q_list\n q_list = []\n return(Q) \n\ndef GetRealWeight(Filter,Q):\n global filter_name,layer_name_binQ,INFLAT\n filter_count = 0\n for i in range(50):\n print('**********')\n if i == 3 or i == 12 or i == 24 or i == 42:\n res = 2\n else:\n res = 1 \n Q1_key = layer_name_binQ[i] \n Q2_key = layer_name_binQ[i+1]\n for n in range(res):\n if n == 1:\n Q1_key = layer_name_binQ[i-2]\n filter_key = filter_name[filter_count]\n print(filter_key)\n out_c = Filter[filter_key].shape[0]\n in_c = Filter[filter_key].shape[1]\n for j in range(out_c):\n Filter[filter_key][j] = Filter[filter_key][j] + Q[Q2_key][j] + INFLAT\n for k in range(in_c):\n Filter[filter_key][j][k] = Filter[filter_key][j][k] - Q[Q1_key][k]\n filter_min = np.min(Filter[filter_key])\n filter_max = np.max(Filter[filter_key])\n print(filter_min)\n print(filter_max)\n Filter[filter_key][Filter[filter_key]<0] = 0\n filter_count = filter_count + 1\n print('**********')\n return (Filter)\n\ndef GetBias(bias,Q2_key):\n global layer_name_binQ,INFLAT,Q\n #Q2_key = layer_name_binQ[1] \n out_c = len(Q[Q2_key])\n bias_power = np.zeros((out_c))\n bias_power = np.float32(bias_power)\n bias = np.array(bias)\n for i in range(out_c):\n power_num = Q[Q2_key][i] + INFLAT \n bias_power[i] = bias[i]*pow(2.,power_num)\n return (bias_power)\n\ndef Conv2dInt8(input_data,weight,weight2,stride,padding):\n npd = ((0,0),(0,0),(padding,padding),(padding,padding))\n input_data = np.lib.pad(input_data,npd,'constant',constant_values=0)\n input_size = input_data.shape \n weight_size = weight.shape\n N = input_size[0]\n in_c = input_size[1]\n out_c = weight_size[0]\n\n out_h = int((input_size[2] - weight_size[2])/stride + 1)\n out_w = int((input_size[3] - weight_size[3])/stride + 1)\n conv_result = np.ones((N,out_c,out_h,out_w))\n conv_result = np.int32(conv_result)\n inputdata = np.int8(input_data) \n weight = np.int32(weight)\n weight2 = np.int8(weight2)\n for i in range(N):\n for j in range(out_c):\n for k in np.arange(input_size[2] - weight_size[2] + 1)[::stride]:\n for l in np.arange(input_size[3] - weight_size[3] + 1)[::stride]:\n conv_result[i,j,k//stride,l//stride] = np.sum((input_data[i,:,k:k + weight_size[2],l:l + weight_size[3]]<<weight[j,:])*weight2[j,:])\n return (conv_result)\n\ndef BN(conv_result,bias_power,alpha,beta):\n global layer_count,layer_name_binQ,Q,INFLAT\n Q2_key = layer_name_binQ[layer_count] \n N = conv_result.shape[0]\n out_c = conv_result.shape[1]\n out_h = conv_result.shape[2]\n out_w = conv_result.shape[3]\n bias_power = np.float32(bias_power)\n bn_result = np.zeros((N,out_c,out_h,out_w))\n bn_result = np.float32(bn_result)\n for i in range(N):\n for j in range(out_c):\n bn_result[i][j] = (alpha[j]*(conv_result[i][j] + bias_power[j]) + beta[j]*pow(2.,(Q[Q2_key][j]+INFLAT)))*pow(2.,-INFLAT)\n bn_result = np.round(bn_result)\n return (bn_result)\n\ndef FC(x,weight,weight2,bias):\n global BatchSize\n x = np.int8(x)\n weight = np.int32(weight)\n weight2 = np.int8(weight2)\n print(\"the shape of the output is :\",end=' ')\n print(weight.shape[0])\n out = np.ones((BatchSize,weight.shape[0]))\n out = np.int32(out)\n for i in range(BatchSize):\n for j in range(weight.shape[0]):\n out[i,j] = np.sum((x[i,:]<<weight[j,:])*weight2[j,:])#bias[j]\n out = torch.Tensor(out)\n bias = torch.Tensor(bias)\n out[0,:] = out[0,:] + bias[:]\n out[0,:] = out[0,:]*pow(2.,-INFLAT)\n out = torch.round(out)\n out[out<-128] = -128\n out[out>127] = 127\n return (out)\n\n\"\"\"\nclass PreProcess(object):\n def __call__(self,image):\n w = 224\n h = 224\n image = np.array(image)\n img_matlab = image.copy()\n tmp = img_matlab[:,:,2].copy()\n img_matlab[:,:,2] = img_matlab[:,:,0]\n img_matlab[:,:,0] = tmp\n\n imgFloat = img_matlab.astype(float)\n imgResize = cv2.resize(imgFloat,(w,h))\n imgResize[:,:,0] = imgResize[:,:,0] - 110.177\n imgResize[:,:,1] = imgResize[:,:,1] - 117.644\n imgResize[:,:,2] = imgResize[:,:,2] - 117.378\n imgProc = imgResize\n imgProc = np.swapaxes(imgProc, 0, 2)\n imgProc = np.swapaxes(imgProc, 1, 2)\n imgProc = torch.Tensor(imgProc)\n return imgProc \n\"\"\"\n\nBatchSize= 1\ndata_dir = '/data/yutong/imagenet'\n#transform = transforms.Compose([PreProcess()])\ntransform = transforms.Compose([\n transforms.Resize(256),\n transforms.CenterCrop(224),\n transforms.ToTensor(),\n transforms.Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])\n])\nval = datasets.ImageFolder(os.path.join(data_dir,'val'),transform)\nValLoader = data.DataLoader(val,batch_size=BatchSize,shuffle=False)\n\n# ResNet50\n\ndef conv3x3(in_planes, out_planes, stride=1, groups=1, dilation=1):\n #3x3 convolution with padding\n return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,\n padding=dilation, groups=groups, bias=False, dilation=dilation)\n\n\ndef conv1x1(in_planes, out_planes, stride=1):\n #1x1 convolution\n return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)\n\nclass Bottleneck(nn.Module):\n expansion = 4\n __constants__ = ['downsample']\n\n def __init__(self, inplanes, planes, stride=1, downsample=None, groups=1,\n base_width=64, dilation=1, norm_layer=None):\n super(Bottleneck,self).__init__()\n if norm_layer is None:\n norm_layer = nn.BatchNorm2d\n width = int(planes * (base_width / 64.)) * groups\n # Both self.conv2 and self.downsample layers downsample the input when stride != 1\n self.conv1 = conv1x1(inplanes, width)\n self.bn1 = norm_layer(width)\n self.conv2 = conv3x3(width, width, stride, groups, dilation)\n self.bn2 = norm_layer(width)\n self.conv3 = conv1x1(width, planes * self.expansion)\n self.bn3 = norm_layer(planes * self.expansion)\n self.relu = nn.ReLU(inplace=True)\n self.downsample = downsample\n self.stride = stride\n \n def forward(self,x):\n global layer_name_bin,filter_name,bn_name,layer_count,filter_count,feature_file_count,Filter,Filter2,alpha,beta\n stride = self.stride\n x = np.int8(x)\n identity = x\n filter_key = filter_name[filter_count]\n bn_key = bn_name[filter_count]\n out = Conv2dInt8(x,Filter[filter_key],Filter2[filter_key],1,0)\n layer_count = layer_count + 1\n feature_file_count = feature_file_count + 1\n bias = np.zeros((out.shape[1]))\n print('FilterCount = ',end=' ')\n print(filter_count)\n out = BN(out,bias,alpha[bn_key],beta[bn_key])\n out[out<-128] = -128\n out[out>127] = 127\n filter_count = filter_count + 1\n FeatureWrite(layer_name_bin[feature_file_count],out)\n out = torch.Tensor(out)\n out = self.relu(out)\n \n filter_key = filter_name[filter_count]\n bn_key = bn_name[filter_count]\n out = np.int8(out)\n out = Conv2dInt8(out,Filter[filter_key],Filter2[filter_key],stride,1) #padding=dialation\n layer_count = layer_count + 1\n feature_file_count = feature_file_count + 1\n bias = np.zeros((out.shape[1]))\n out = BN(out,bias,alpha[bn_key],beta[bn_key])\n out[out<-128] = -128\n out[out>127] = 127\n filter_count = filter_count + 1\n FeatureWrite(layer_name_bin[feature_file_count],out)\n out = torch.Tensor(out)\n out = self.relu(out)\n\n filter_key = filter_name[filter_count]\n print(len(bn_name))\n print(filter_count)\n bn_key = bn_name[filter_count]\n out = np.int8(out)\n out = Conv2dInt8(out,Filter[filter_key],Filter2[filter_key],1,0)\n layer_count = layer_count + 1\n feature_file_count = feature_file_count + 1\n bias = np.zeros((out.shape[1]))\n out = BN(out,bias,alpha[bn_key],beta[bn_key])\n filter_count = filter_count + 1\n #out = np.int16(out)\n out[out<-128] = -128\n out[out>127] = 127\n FeatureWrite(layer_name_bin[feature_file_count],out)\n out = np.int16(out)\n if self.downsample is not None:\n filter_key = filter_name[filter_count]\n bn_key = bn_name[filter_count]\n identity = Conv2dInt8(identity,Filter[filter_key],Filter2[filter_key],stride,0)\n feature_file_count = feature_file_count + 1 # add by shenfw\n bias = np.zeros((identity.shape[1]))\n identity = BN(identity,bias,alpha[bn_key],beta[bn_key])\n #identity = np.int16(identity)\n identity[identity<-128] = -128\n identity[identity>127] = 127\n FeatureWrite(layer_name_bin[feature_file_count],identity) # add by shenfw\n identity = np.int16(identity)\n filter_count = filter_count + 1\n \n out += identity\n out[out>127] = 127\n out[out<-128] = -128\n #FeatureWrite(layer_name_bin[layer_count],out)\n out = torch.Tensor(out)\n out = self.relu(out) \n feature_file_count = feature_file_count + 1\n FeatureWrite(layer_name_bin[feature_file_count],out)\n return out\n\nclass ResNet(nn.Module):\n \n def __init__(self,block,layers,num_classes=1000,zero_init_residual=False,\n groups=1, width_per_group=64, replace_stride_with_dilation=None,\n norm_layer=None):\n super(ResNet,self).__init__()\n if norm_layer is None:\n norm_layer = nn.BatchNorm2d\n self._norm_layer = norm_layer\n\n self.inplanes = 64\n self.dilation = 1\n if replace_stride_with_dilation is None:\n # each element in the tuple indicates if we should replace\n # the 2x2 stride with a dilated convolution instead\n replace_stride_with_dilation = [False, False, False]\n if len(replace_stride_with_dilation) != 3:\n raise ValueError(\"replace_stride_with_dilation should be None \"\n \"or a 3-element tuple, got {}\".format(replace_stride_with_dilation))\n self.groups = groups\n self.base_width = width_per_group\n self.conv1 = nn.Conv2d(3,self.inplanes,kernel_size=7,stride=2,padding=3,bias=False)\n self.bn1 = norm_layer(self.inplanes)\n self.relu = nn.ReLU(inplace=True)\n self.maxpool = nn.MaxPool2d(kernel_size=3,stride=2,padding=1)\n \n self.layer1 = self._make_layer(block,64,layers[0])\n self.layer2 = self._make_layer(block,128,layers[1],stride=2,dilate=replace_stride_with_dilation[0])\n self.layer3 = self._make_layer(block,256,layers[2],stride=2,dilate=replace_stride_with_dilation[1])\n self.layer4 = self._make_layer(block,512,layers[3],stride=2,dilate=replace_stride_with_dilation[2])\n self.avgpool = nn.AdaptiveAvgPool2d((1,1))\n self.fc = nn.Linear(512*block.expansion,num_classes)\n \n for m in self.modules():\n if isinstance(m,nn.Conv2d):\n nn.init.kaiming_normal_(m.weight,mode='fan_out',nonlinearity='relu')\n elif isinstance(m,(nn.BatchNorm2d, nn.GroupNorm)):\n nn.init.constant_(m.weight,1)\n nn.init.constant_(m.bias,0)\n \n if zero_init_residual:\n for m in self.modules():\n if isinstance(m,Bottleneck):\n nn.init.constant_(m.bn3.weight,0)\n elif isinstance(m,BasicBolck):\n nn.init.constant_(m.bn2.weight,0)\n \n def _make_layer(self,block,planes,blocks,stride=1,dilate=False):\n norm_layer = self._norm_layer\n downsample = None\n previous_dilation = self.dilation\n if dilate:\n self.dilation *= stride\n stride = 1\n if stride != 1 or self.inplanes != planes*block.expansion:\n downsample = nn.Sequential(\n conv1x1(self.inplanes,planes*block.expansion,stride),\n norm_layer(planes*block.expansion),\n )\n \n layers = []\n layers.append(block(self.inplanes,planes,stride,downsample))\n self.inplanes = planes*block.expansion\n for _ in range(1,blocks):\n layers.append(block(self.inplanes, planes, groups=self.groups,\n base_width=self.base_width, dilation=self.dilation,\n norm_layer=norm_layer))\n \n return nn.Sequential(*layers)\n \n def forward(self,x):\n global Q, fc_weight, fc_bias, layer_name_bin,filter_name,bn_name,layer_count,filter_count,feature_file_count,Filter,Filter2,bias_power,fc_bias,alpha,beta\n filter_key = filter_name[filter_count]\n bn_key = bn_name[filter_count]\n \n x = Conv2dInt8(x,Filter[filter_key],Filter2[filter_key],2,3)\n feature_file_count = feature_file_count + 1\n layer_count = layer_count + 1\n bias_power = np.zeros((x.shape[1]))\n x = BN(x,bias_power,alpha[bn_key],beta[bn_key])\n filter_count = filter_count + 1\n x[x<-128] = -128\n x[x>127] = 127\n FeatureWrite(layer_name_bin[feature_file_count],x)\n x = torch.Tensor(x)\n x = self.relu(x)\n #npd = ((0,0),(0,0),(0,1),(0,1))\n #x = np.lib.pad(x,npd,'constant',constant_values=0)\n #pd = (0,1,0,1)\n #x = F.pad(x,pd,'constant',0)\n x = self.maxpool(x)\n FeatureWrite('pool1',x);\n x = self.layer1(x)\n x = self.layer2(x)\n x = self.layer3(x)\n x = self.layer4(x)\n \n \n x = self.avgpool(x)\n x = torch.round(x)\n FeatureWriteFC('pool5.txt',x)\n x = x.view(x.size(0),-1)\n Q2_key = layer_name_binQ[50]\n bias = GetBias(fc_bias,Q2_key)\n print(filter_count)\n print(len(filter_name))\n filter_key = filter_name[filter_count]\n out = FC(x,Filter[filter_key],Filter2[filter_key],bias)\n \n FeatureWriteFC('fc1000.txt',out)\n filter_count = 0\n layer_count = 0\n feature_file_count = 0\n print('end')\n Q_fc = Q[layer_name_binQ[50]]\n for i in range(1000):\n out[0,i] = out[0,i]*pow(2.,-Q_fc[i]) \n FeatureWriteFC('fc-dequantization.txt',out)\n return out\n \n def resnet50(pretrained=False,**kwargs):\n model = ResNet(Bottleneck,[3,4,6,3],**kwargs)\n return model\n\ncnn = ResNet.resnet50()\ncnn.eval()\n\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nmodel2 = tvmodel.resnet50()#.to(device)\nmodel2 = torch.nn.DataParallel(model2)#.cuda()\nmodel2.eval()\ncheckpoint = torch.load('../weights/resnet50.pth.tar',map_location='cpu')\nmodel2.load_state_dict(checkpoint['state_dict'])\n\nfilter_name = []\nbn_name = []\nINFLAT = np.int8(15) #15\nQ = OrderedDict()\nFilter = OrderedDict()\nFilter2 = OrderedDict()\nalpha = OrderedDict()\nbeta = OrderedDict()\nbias = []\nfc_weight = torch.ones(1000,2048)\nfc_bias = []\nPars = model2.state_dict()\ncount = 0\nfor key in Pars:\n if count%6 == 0:\n Pars2 = torch.abs(Pars[key])\n Pars2[Pars2>0] = torch.round(torch.log2(Pars2[Pars2>0]))\n Filter[key] = Pars2\n Filter[key] = Filter[key].cpu().numpy()\n Filter[key] = np.int8(Filter[key])\n Filter2[key] = Pars[key]\n Filter2[key][abs(Filter2[key])<0.00001] = 0\n Filter2[key][Filter2[key]<0] = -1\n Filter2[key][Filter2[key]>0] = 1\n Filter2[key] = Filter2[key].cpu().numpy()\n Filter2[key] = np.int8(Filter2[key])\n filter_name.append(key)\n if count == 318:\n fc_weight = Pars[key].cpu().numpy()\n #if count == 1: // pytorch has no bias for conv\n # bias_num = Pars[key].size(0)\n # for i in range(bias_num):\n # bias.append(Pars[key][i]) \n if count == 319:\n bias_num = Pars[key].size(0)\n for i in range(bias_num):\n fc_bias.append(Pars[key][i])\n if (count-1)%6 == 0 and count != 319:\n alpha0 = Pars[key]\n if (count-2)%6 == 0:\n beta0 = Pars[key]\n if (count-3)%6 == 0:\n mean = Pars[key]\n if (count-4)%6 == 0:\n bn_name.append(key)\n var = Pars[key]\n alpha[key] = alpha0/(torch.sqrt(var+0.00001))\n beta[key] = -alpha[key]*mean + beta0 \n alpha[key] = alpha[key].cpu().numpy()\n beta[key] = beta[key].cpu().numpy() \n \n count = count + 1\n\nQ = GetQ(Q)\nFilter = GetRealWeight(Filter,Q)\n\nQ2_key = layer_name_binQ[1]\n#bias_power = GetBias(bias,Q2_key)\n#bias_power = np.array(bias_power)\n\ndef accuracy(output,target,topk=(1,5)):\n maxk = max(topk)\n batch_size = target.size(0)\n _,pred = output.topk(maxk,1,True,True)\n pred = pred.t()\n print(pred)\n correct = pred.eq(target.view(1,-1).expand_as(pred))\n print(correct)\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\n\nInputList = []\nInputX = np.zeros((1,3,224,224))\nprint(InputX.shape)\nwith open('Feature_float/resnet50/data.bin','rb') as fig:\n for i in range(150528):\n data = fig.read(4)\n data_float = struct.unpack(\"f\",data)[0]\n InputList.append(data_float)\n\nIndex = 0\nfor i in range(1):\n for j in range(3):\n for k in range(224):\n for l in range(224):\n InputX[i][j][k][l] = InputList[Index]\n Index = Index + 1\nfor i in range(InputX.shape[1]):\n InputX[0][i] = InputX[0][i]*pow(2,5)\n\nInputX = np.round(InputX)\nInputX[InputX<-128] = -128\nInputX[InputX>127] = 127\nInputX = np.int8(InputX)\nTemp1 = []\nTemp5 = []\n\nfor j,(test_x,test_y) in enumerate(ValLoader):\n test_x = InputX\n print('The test x is:')\n print(test_x)\n output_test = cnn(test_x)\n prec1,prec5 = accuracy(output_test.data,test_y,topk=(1,5))\n prec1 = prec1.cpu().numpy()\n prec5 = prec5.cpu().numpy()\n Temp1.append(prec1[0])\n Temp5.append(prec5[0])\n break\n\nTop1 = np.array(Temp1)\nTop5 = np.array(Temp5)\nprint('Top1 = ',end=' ')\nprint(Top1.mean(),end=' ')\nprint('Top5 = ',end=' ')\nprint(Top5.mean())\n#\"\"\"\n"
] | [
[
"numpy.ones",
"numpy.sum",
"torch.sqrt",
"numpy.lib.pad",
"torch.cuda.is_available",
"torch.nn.Conv2d",
"torch.nn.init.kaiming_normal_",
"torch.round",
"torch.nn.DataParallel",
"torch.Tensor",
"numpy.int8",
"torch.nn.MaxPool2d",
"torch.ones",
"torch.load",
"numpy.zeros",
"torch.nn.AdaptiveAvgPool2d",
"numpy.float32",
"numpy.int32",
"numpy.arange",
"numpy.max",
"torch.log2",
"numpy.min",
"numpy.int16",
"numpy.array",
"torch.nn.Linear",
"torch.nn.init.constant_",
"torch.abs",
"torch.nn.Sequential",
"numpy.round",
"torch.nn.ReLU"
]
] |
franklu2014/foocat | [
"5d452996ba139693fcbcda05c7500b24b9d1ad50"
] | [
"foocat/foocat.py"
] | [
"import pandas as pd\n\n\ndef catbind(a, b):\n \"\"\"\n Concatenates two pandas categoricals.\n\n Parameters\n ----------\n a : pandas.core.arrays.categorical.Categorical\n A pandas categorical.\n b : pandas.core.arrays.categorical.Categorical\n A pandas categorical that you wish to concatenate to a.\n\n Returns\n -------\n pandas.core.arrays.categorical.Categorical\n The new concatenated pandas categorical.\n\n Examples\n --------\n >>> from foocat import foocat\n >>> a = pd.Categorical([\"character\", \"hits\", \"your\", \"eyeballs\"])\n >>> b = pd.Categorical([\"but\", \"integer\", \"where it\", \"counts\"])\n >>> foocat.catbind(a, b)\n [character, hits, your, eyeballs, but, integer, where it, counts]\n Categories (8, object): [but, character, counts,\n eyeballs, hits, integer, where it, your]\n \"\"\"\n concatenated = pd.concat([pd.Series(a.astype(\"str\")),\n pd.Series(b.astype(\"str\"))])\n return pd.Categorical(concatenated)\n"
] | [
[
"pandas.Categorical"
]
] |
Hzfinfdu/BBT_CPM | [
"ee095727c714902fa6f8f5deebf1c30dc1956520"
] | [
"mpu/layers.py"
] | [
"# coding=utf-8\n# Copyright (c) 2019, NVIDIA CORPORATION. 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\n# Parts of the code here are adapted from PyTorch\n# repo: https://github.com/pytorch/pytorch\n\n\nimport math\n\nimport torch\nimport torch.nn.functional as F\nimport torch.nn.init as init\nfrom torch.nn.parameter import Parameter\n\nfrom apex.normalization.fused_layer_norm import FusedLayerNorm as LayerNorm\n\nfrom .initialize import get_model_parallel_rank\nfrom .initialize import get_model_parallel_world_size\nfrom .mappings import copy_to_model_parallel_region\nfrom .mappings import gather_from_model_parallel_region\nfrom .mappings import reduce_from_model_parallel_region\nfrom .mappings import scatter_to_model_parallel_region\nfrom .random import get_cuda_rng_tracker\nfrom .utils import divide\nfrom .utils import split_tensor_along_last_dim\nfrom .utils import VocabUtility\n\n\ndef _initialize_affine_weight(weight, output_size, input_size,\n per_partition_size, partition_dim, init_method,\n stride=1, return_master_weight=False):\n \"\"\"Initialize affine weight for model parallel.\n\n Build the master weight on all processes and scatter\n the relevant chunk.\"\"\"\n # If we only use 1 process for model parallelism, bypass scatter.\n world_size = get_model_parallel_world_size()\n if world_size == 1:\n init_method(weight)\n if return_master_weight:\n return weight\n return None\n\n # Initialize master weight\n master_weight = torch.empty(output_size, input_size,\n dtype=weight.dtype,\n requires_grad=False)\n init_method(master_weight)\n\n # Split and copy\n per_partition_per_stride_size = divide(per_partition_size, stride)\n weight_list = torch.split(master_weight, per_partition_per_stride_size,\n dim=partition_dim)\n rank = get_model_parallel_rank()\n my_weight_list = weight_list[rank::world_size]\n\n with torch.no_grad():\n torch.cat(my_weight_list, dim=partition_dim, out=weight)\n if return_master_weight:\n return master_weight\n return None\n\n\nclass VocabParallelEmbedding(torch.nn.Module):\n \"\"\"Embedding parallelized in the vocabulary dimension.\n\n This is mainly adapted from torch.nn.Embedding and all the default\n values are kept.\n Arguments:\n num_embeddings: vocabulary size.\n embedding_dim: size of hidden state.\n init_method: method to initialize weights.\n \"\"\"\n def __init__(self, num_embeddings, embedding_dim,\n init_method=init.xavier_normal_):\n super(VocabParallelEmbedding, self).__init__()\n # Keep the input dimensions.\n self.num_embeddings = num_embeddings\n self.embedding_dim = embedding_dim\n # Set the detauls for compatibility.\n self.padding_idx = None\n self.max_norm = None\n self.norm_type = 2.\n self.scale_grad_by_freq = False\n self.sparse = False\n self._weight = None\n # Divide the weight matrix along the vocaburaly dimension.\n self.vocab_start_index, self.vocab_end_index = \\\n VocabUtility.vocab_range_from_global_vocab_size(\n self.num_embeddings, get_model_parallel_rank(),\n get_model_parallel_world_size())\n self.num_embeddings_per_partition = self.vocab_end_index - \\\n self.vocab_start_index\n\n # Allocate weights.\n self.weight = Parameter(torch.Tensor(self.num_embeddings_per_partition,\n self.embedding_dim))\n self.weight.model_parallel = True\n # And initialize.\n _initialize_affine_weight(\n self.weight, self.num_embeddings, self.embedding_dim,\n self.num_embeddings_per_partition, 0, init_method)\n\n def forward(self, input_):\n # Build the mask.\n input_mask = (input_ < self.vocab_start_index) | \\\n (input_ >= self.vocab_end_index)\n # Mask the input.\n masked_input = input_.clone() - self.vocab_start_index\n masked_input[input_mask] = 0\n # Get the embeddings.\n output_parallel = F.embedding(masked_input, self.weight,\n self.padding_idx, self.max_norm,\n self.norm_type, self.scale_grad_by_freq,\n self.sparse)\n # Mask the output embedding.\n output_parallel[input_mask, :] = 0.0\n # Reduce across all the model parallel GPUs.\n output = reduce_from_model_parallel_region(output_parallel)\n return output\n\n\nclass ParallelEmbedding(torch.nn.Module):\n \"\"\"Embedding parallelized in the embedding dimension.\n\n This is mainly adapted from torch.nn.Embedding and all the default\n values are kept.\n Arguments:\n num_embeddings: vocabulary size.\n embedding_dim: size of hidden state.\n init_method: method to initialize weights.\n \"\"\"\n def __init__(self, num_embeddings, embedding_dim,\n init_method=init.xavier_normal_,\n keep_master_weight_for_test=False):\n super(ParallelEmbedding, self).__init__()\n # Keep the input dimensions.\n self.num_embeddings = num_embeddings\n self.embedding_dim = embedding_dim\n # Set some detauls for compatibility.\n self.padding_idx = None\n self.max_norm = None\n self.norm_type = 2.\n self.scale_grad_by_freq = False\n self.sparse = False\n self._weight = None\n # Divide the weight matrix along the embedding dimension.\n world_size = get_model_parallel_world_size()\n self.embedding_dim_per_partition = divide(self.embedding_dim,\n world_size)\n\n # Allocate weights.\n self.weight = Parameter(torch.Tensor(self.num_embeddings,\n self.embedding_dim_per_partition))\n self.weight.model_parallel = True\n # And initialize. split the weights to different model parallel devices\n _initialize_affine_weight(\n self.weight, self.num_embeddings, self.embedding_dim,\n self.embedding_dim_per_partition, 1, init_method,\n stride=1, return_master_weight=False)\n\n def forward(self, input_):\n input_parallel = copy_to_model_parallel_region(input_)\n output_parallel = F.embedding(input_parallel, self.weight,\n self.padding_idx, self.max_norm,\n self.norm_type, self.scale_grad_by_freq,\n self.sparse)\n output = gather_from_model_parallel_region(output_parallel)\n return output\n\n\nclass ColumnParallelLinear(torch.nn.Module):\n \"\"\"Linear layer with column parallelism.\n\n NOTE: This function will NOT do all-reduce unless gather_output is True\n\n The linear layer is defined as Y = XA + b. A is parallelized along\n its second dimension as A = [A_1, ..., A_p].\n\n Arguments:\n input_size: first dimension of matrix A.\n output_size: second dimension of matrix A.\n bias: If true, add bias\n gather_output: If true, call all-gether on output and make Y avaiable\n to all GPUs, otherwise, every GPU will have its output\n which is Y_i = XA_i\n init_method: method to initialize weights. Note that bias is always set\n to zero.\n stride: For the strided linear layers.\n keep_master_weight_for_test: This was added for testing and should be\n set to False. It returns the master weights\n used for initialization.\n \"\"\"\n def __init__(self, input_size, output_size, bias=True, gather_output=True,\n init_method=init.xavier_normal_, stride=1,\n keep_master_weight_for_test=False):\n super(ColumnParallelLinear, self).__init__()\n\n # Keep input parameters\n self.input_size = input_size\n self.output_size = output_size\n self.gather_output = gather_output\n # Divide the weight matrix along the last dimension.\n world_size = get_model_parallel_world_size()\n self.output_size_per_partition = divide(output_size, world_size)\n\n # Parameters.\n # Note: torch.nn.functional.linear performs XA^T + b and as a result\n # we allocate the transpose.\n self.weight = Parameter(torch.Tensor(self.output_size_per_partition,\n self.input_size))\n self.weight.model_parallel = True\n if bias:\n self.bias = Parameter(torch.Tensor(self.output_size_per_partition))\n self.bias.model_parallel = True\n # Always initialize bias to zero.\n with torch.no_grad():\n self.bias.zero_()\n else:\n self.register_parameter('bias', None)\n\n # Initialize weight.\n self.master_weight = _initialize_affine_weight(\n self.weight, self.output_size, self.input_size,\n self.output_size_per_partition, 0, init_method,\n stride=stride, return_master_weight=keep_master_weight_for_test)\n\n def forward(self, input_):\n # Set up backprop all-reduce.\n input_parallel = copy_to_model_parallel_region(input_)\n # Matrix multiply.\n output_parallel = F.linear(input_parallel, self.weight, self.bias)\n if self.gather_output:\n # All-gather across the partitions.\n output = gather_from_model_parallel_region(output_parallel)\n else:\n output = output_parallel\n return output\n\n\nclass RowParallelLinear(torch.nn.Module):\n \"\"\"Linear layer with row parallelism.\n\n NOTE: This function will do all-reduce\n\n The linear layer is defined as Y = XA + b. A is parallelized along\n its first dimension and X along its second dimension as:\n - -\n | A_1 |\n | . |\n A = | . | X = [X_1, ..., X_p]\n | . |\n | A_p |\n - -\n Arguments:\n input_size: first dimension of matrix A.\n output_size: second dimension of matrix A.\n bias: If true, add bias. Note that bias is not parallelized.\n input_is_parallel: If true, we assume that the input is already\n split across the GPUs and we do not split\n again.\n init_method: method to initialize weights. Note that bias is always set\n to zero.\n stride: For the strided linear layers.\n keep_master_weight_for_test: This was added for testing and should be\n set to False. It returns the master weights\n used for initialization.\n \"\"\"\n def __init__(self, input_size, output_size, bias=True,\n input_is_parallel=False,\n init_method=init.xavier_normal_, stride=1,\n keep_master_weight_for_test=False):\n super(RowParallelLinear, self).__init__()\n\n # Keep input parameters\n self.input_size = input_size\n self.output_size = output_size\n self.input_is_parallel = input_is_parallel\n # Divide the weight matrix along the last dimension.\n world_size = get_model_parallel_world_size()\n self.input_size_per_partition = divide(input_size, world_size)\n\n # Parameters.\n # Note: torch.nn.functional.linear performs XA^T + b and as a result\n # we allocate the transpose.\n self.weight = Parameter(torch.Tensor(self.output_size,\n self.input_size_per_partition))\n self.weight.model_parallel = True\n if bias:\n self.bias = Parameter(torch.Tensor(self.output_size))\n # Always initialize bias to zero.\n with torch.no_grad():\n self.bias.zero_()\n else:\n self.register_parameter('bias', None)\n\n # Initialize weight.\n self.master_weight = _initialize_affine_weight(\n self.weight, self.output_size, self.input_size,\n self.input_size_per_partition, 1, init_method,\n stride=stride, return_master_weight=keep_master_weight_for_test)\n\n def forward(self, input_):\n # Set up backprop all-reduce.\n if self.input_is_parallel:\n input_parallel = input_\n else:\n input_parallel = scatter_to_model_parallel_region(input_)\n # Matrix multiply.\n output_parallel = F.linear(input_parallel, self.weight)\n # All-reduce across all the partitions.\n output_ = reduce_from_model_parallel_region(output_parallel)\n if self.bias is not None:\n output = output_ + self.bias\n else:\n output = output_\n return output\n"
] | [
[
"torch.empty",
"torch.nn.functional.embedding",
"torch.split",
"torch.nn.functional.linear",
"torch.no_grad",
"torch.cat",
"torch.Tensor"
]
] |
wjj19950828/tvm | [
"9c63f4fc318652f6fff68342da2d11b26592a3e0"
] | [
"tests/python/frontend/pytorch/test_forward.py"
] | [
"# Licensed to the Apache Software Foundation (ASF) under one\n# or more contributor license agreements. See the NOTICE file\n# distributed with this work for additional information\n# regarding copyright ownership. The ASF licenses this file\n# to you under the Apache License, Version 2.0 (the\n# \"License\"); you may not use this file except in compliance\n# with the License. You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing,\n# software distributed under the License is distributed on an\n# \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n# KIND, either express or implied. See the License for the\n# specific language governing permissions and limitations\n# under the License.\n# pylint: disable=import-self, invalid-name, unused-argument\n\"\"\"Unit tests for various models and operators\"\"\"\nimport os\nimport sys\nfrom time import time\n\nimport numpy as np\nimport torch\nimport torchvision\nimport tvm\nimport tvm.testing\nfrom packaging import version as package_version\nfrom scipy.stats import t as tdistr\nfrom torch.nn import Module\nfrom torch.nn import functional as F\nfrom tvm import relay\nfrom tvm.contrib import graph_executor\nfrom tvm.contrib.nvcc import have_fp16\nimport pytest\n\nsys.setrecursionlimit(10000)\n\n\ndef list_ops(expr):\n class OpLister(tvm.relay.ExprVisitor):\n def visit_op(self, expr):\n if expr not in self.node_set:\n self.node_list.append(expr)\n return super().visit_op(expr)\n\n def list_nodes(self, expr):\n self.node_set = {}\n self.node_list = []\n self.visit(expr)\n return self.node_list\n\n return OpLister().list_nodes(expr)\n\n\ndef assert_shapes_match(tru, est):\n if tru.shape != est.shape:\n msg = \"Output shapes {} and {} don't match\"\n raise AssertionError(msg.format(tru.shape, est.shape))\n\n\ndef load_torchvision(model_name):\n \"\"\"Given a model name, returns a Torchvision model in eval mode as well\n as an example input.\"\"\"\n with torch.no_grad():\n if model_name.startswith(\"inception\"):\n height = width = 299\n mean = [0.5, 0.5, 0.5]\n std = [0.5, 0.5, 0.5]\n else:\n height = width = 224\n mean = [0.485, 0.456, 0.406]\n std = [0.229, 0.224, 0.225]\n input_shape = [1, 3, height, width]\n input_data = torch.randn(input_shape).float()\n for channel in range(3):\n input_data[:, channel] -= mean[channel]\n input_data[:, channel] /= std[channel]\n\n if model_name.startswith(\"googlenet\"):\n model = getattr(torchvision.models, model_name)(pretrained=True, aux_logits=True)\n else:\n model = getattr(torchvision.models, model_name)(pretrained=True)\n model = model.float().eval()\n return model, [input_data]\n\n\ndef load_pretrainedmodels(model_name):\n \"\"\"Given a model name, returns a pretrainedmodels.pytorch model in eval\n mode as well as an example input.\"\"\"\n import pretrainedmodels # https://github.com/Cadene/pretrained-models.pytorch\n\n model = getattr(pretrainedmodels, model_name)().float().eval()\n input_shape = [1, *model.input_size]\n input_data = torch.rand(input_shape).float() * 256\n for channel in range(3):\n input_data[:, channel] -= model.mean[channel]\n input_data[:, channel] /= model.std[channel]\n return model, [input_data]\n\n\ndef load_model(model_name):\n \"\"\"Given a model name, returns a model as well as an example input.\"\"\"\n if hasattr(torchvision.models, model_name):\n return load_torchvision(model_name)\n try:\n import pretrainedmodels\n\n if hasattr(pretrainedmodels, model_name):\n return load_pretrainedmodels(model_name)\n except ModuleNotFoundError:\n raise ModuleNotFoundError(\"Please install pretrainedmodels.pytorch\")\n raise RuntimeError(\"Model not supported\")\n\n\ndef confidence_interval(mean, stdev, count, alpha=0.01):\n \"\"\"Returns the lower and upper bounds of the confidence interval of a random\n variable. Confidence is 1 - alpha (default confidence is 99%).\"\"\"\n stdval = tdistr.ppf(1 - alpha / 2, count - 1)\n lower, upper = mean + np.array([-1, 1]) * stdval * stdev / np.sqrt(count)\n return lower, upper\n\n\ndef measure_latency(model, input_shapes, output_shapes, thresh, dryruns=40):\n \"\"\"Compute the latency of the given model\"\"\"\n latencies = []\n count = 0\n while True:\n if isinstance(model, Module):\n input_data = [torch.rand(shape).float() for shape in input_shapes]\n if torch.cuda.is_available():\n input_data = list(map(lambda x: x.cuda(), input_data))\n model = model.cuda()\n t_start = time()\n with torch.no_grad():\n model(*input_data)\n t_end = time()\n latencies.append(t_end - t_start)\n else:\n input_data = {}\n for i, shape in enumerate(input_shapes):\n name = \"input\" + str(i)\n arr = np.random.random(shape).astype(\"float32\")\n input_data[name] = tvm.nd.array(arr)\n t_start = time()\n model.set_input(**input_data)\n model.run()\n for i, shape in enumerate(output_shapes):\n arr = np.zeros(shape).astype(\"float32\")\n model.get_output(i, tvm.nd.array(arr))\n t_end = time()\n count += 1\n if count < dryruns:\n continue\n latencies.append(t_end - t_start)\n mean = np.mean(latencies)\n stdev = np.std(latencies)\n sample_size = len(latencies)\n if sample_size > dryruns:\n lower, upper = confidence_interval(mean, stdev, sample_size)\n est = (upper + lower) / 2\n err = (upper - lower) / 2\n if err < thresh:\n return est\n\n\ndef verify_model(\n model_name, input_data=[], custom_convert_map={}, rtol=1e-5, atol=1e-5, expected_ops=[]\n):\n \"\"\"Assert that the output of a compiled model matches with that of its\n baseline.\"\"\"\n if isinstance(model_name, str):\n baseline_model, baseline_input = load_model(model_name)\n elif isinstance(input_data, list):\n baseline_model = model_name\n baseline_input = input_data\n elif isinstance(input_data, torch.Tensor) or len(input_data.shape) == 0:\n baseline_model = model_name\n baseline_input = [input_data]\n else:\n assert False, \"Unexpected input format\"\n\n if torch.cuda.is_available():\n if isinstance(baseline_model, torch.nn.Module):\n baseline_model = baseline_model.cuda()\n baseline_input = [inp.cuda() for inp in baseline_input]\n\n with torch.no_grad():\n baseline_outputs = baseline_model(*[input.clone() for input in baseline_input])\n\n if isinstance(baseline_outputs, tuple):\n baseline_outputs = tuple(out.cpu().numpy() for out in baseline_outputs)\n else:\n baseline_outputs = (baseline_outputs.cpu().numpy(),)\n\n trace = torch.jit.trace(baseline_model, [input.clone() for input in baseline_input])\n if isinstance(baseline_model, torch.nn.Module):\n trace = trace.float().eval()\n\n if torch.cuda.is_available():\n trace = trace.cuda()\n else:\n trace = trace.cpu()\n\n input_names = [\"input{}\".format(idx) for idx, inp in enumerate(baseline_input)]\n input_shapes = list(zip(input_names, [inp.shape for inp in baseline_input]))\n mod, params = relay.frontend.from_pytorch(trace, input_shapes, custom_convert_map)\n for arg in mod[\"main\"].params[: len(input_names)]:\n assert arg.name_hint in input_names\n compiled_input = dict(zip(input_names, [inp.clone().cpu().numpy() for inp in baseline_input]))\n\n with tvm.transform.PassContext(opt_level=3):\n for target, dev in tvm.testing.enabled_targets():\n relay_graph, relay_lib, relay_params = relay.build(mod, target=target, params=params)\n relay_model = graph_executor.create(relay_graph, relay_lib, dev)\n relay_model.set_input(**relay_params)\n for name, inp in compiled_input.items():\n relay_model.set_input(name, inp)\n relay_model.run()\n\n for i, baseline_output in enumerate(baseline_outputs):\n compiled_output = relay_model.get_output(i).numpy()\n\n assert_shapes_match(baseline_output, compiled_output)\n tvm.testing.assert_allclose(baseline_output, compiled_output, rtol=rtol, atol=atol)\n\n if expected_ops:\n\n def visit(op):\n if isinstance(op, tvm.ir.op.Op):\n if op.name in expected_ops:\n expected_ops.remove(op.name)\n\n tvm.relay.analysis.post_order_visit(mod[\"main\"].body, visit)\n\n if expected_ops:\n msg = \"TVM Relay do not contain expected ops {}\"\n raise AssertionError(msg.format(expected_ops))\n\n del model_name\n del baseline_model\n torch.cuda.empty_cache()\n\n\n# Single operator tests\[email protected]_gpu\ndef test_forward_pixel_shuffle():\n torch.set_grad_enabled(False)\n input_shape = [1, 144, 16, 16]\n\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.PixelShuffle(2).float().eval(), input_data=input_data)\n verify_model(torch.nn.PixelShuffle(3).float().eval(), input_data=input_data)\n verify_model(torch.nn.PixelShuffle(4).float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_add():\n torch.set_grad_enabled(False)\n input_shape = [10]\n\n class Add1(Module):\n def forward(self, *args):\n return args[0] + args[0]\n\n class Add2(Module):\n def forward(self, *args):\n return args[0] + 1\n\n class Add3(Module):\n def forward(self, *args):\n ones = torch.ones(input_shape, dtype=torch.float)\n if torch.cuda.is_available():\n ones = ones.cuda()\n return args[0] + ones\n\n class Add4(Module):\n def forward(self, *args):\n ones = torch.ones([], dtype=torch.float)\n if torch.cuda.is_available():\n ones = ones.cuda()\n return args[0] + ones\n\n input_data = torch.rand(input_shape).float()\n verify_model(Add1().float().eval(), input_data=input_data)\n verify_model(Add2().float().eval(), input_data=input_data)\n verify_model(Add3().float().eval(), input_data=input_data)\n verify_model(Add4().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_subtract():\n torch.set_grad_enabled(False)\n input_shape = [10]\n\n class Subtract1(Module):\n def forward(self, *args):\n return args[0] - args[0]\n\n class Subtract2(Module):\n def forward(self, *args):\n return args[0] - 1\n\n class Subtract3(Module):\n def forward(self, *args):\n ones = torch.ones(input_shape)\n if torch.cuda.is_available():\n ones = ones.cuda()\n return args[0] - ones\n\n class Subtract4(Module):\n def forward(self, *args):\n ones = torch.ones([])\n if torch.cuda.is_available():\n ones = ones.cuda()\n return args[0] - ones\n\n input_data = torch.rand(input_shape).float()\n verify_model(Subtract1().float().eval(), input_data=input_data)\n verify_model(Subtract2().float().eval(), input_data=input_data)\n verify_model(Subtract3().float().eval(), input_data=input_data)\n verify_model(Subtract4().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_multiply():\n torch.set_grad_enabled(False)\n input_shape = [10]\n\n class Multiply1(Module):\n def forward(self, *args):\n return args[0] * args[0]\n\n class Multiply2(Module):\n def forward(self, *args):\n return args[0] * 1.0\n\n class Multiply3(Module):\n def forward(self, *args):\n ones = torch.ones(input_shape)\n if torch.cuda.is_available():\n ones = ones.cuda()\n return args[0] * ones\n\n class Multiply4(Module):\n def forward(self, *args):\n ones = torch.ones([])\n if torch.cuda.is_available():\n ones = ones.cuda()\n return args[0] * ones\n\n input_data = torch.rand(input_shape).float()\n verify_model(Multiply1().float().eval(), input_data=input_data)\n verify_model(Multiply2().float().eval(), input_data=input_data)\n verify_model(Multiply3().float().eval(), input_data=input_data)\n verify_model(Multiply4().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_min_max():\n class Max(Module):\n def forward(self, inp):\n return torch.max(inp)\n\n class Min(Module):\n def forward(self, inp):\n return torch.min(inp)\n\n class Max2(Module):\n def forward(self, inp):\n out, _ = torch.max(inp, 1, keepdim=True)\n return out\n\n class Min2(Module):\n def forward(self, inp):\n out, _ = torch.min(inp, 0, keepdim=False)\n return out\n\n class Max3(Module):\n def forward(self, lhs, rhs):\n return torch.max(lhs, rhs)\n\n class Min3(Module):\n def forward(self, lhs, rhs):\n return torch.min(lhs, rhs)\n\n input_data = [torch.rand((10, 10)), torch.rand((10, 10))]\n\n verify_model(Max(), input_data=input_data[0])\n verify_model(Min(), input_data=input_data[0])\n verify_model(Max2(), input_data=input_data[0])\n verify_model(Min2(), input_data=input_data[0])\n verify_model(Max3(), input_data=input_data)\n verify_model(Min3(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_reciprocal():\n torch.set_grad_enabled(False)\n input_shape = [2, 1, 10, 1, 10]\n\n class Reciprocal1(Module):\n def forward(self, *args):\n return args[0].reciprocal()\n\n input_data = torch.rand(input_shape).float()\n verify_model(Reciprocal1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_repeat():\n torch.set_grad_enabled(False)\n input_shape = [1, 3]\n\n class Repeat1(Module):\n def forward(self, *args):\n return args[0].repeat(1, 1)\n\n class Repeat2(Module):\n def forward(self, *args):\n return args[0].repeat(4, 2)\n\n class Repeat3(Module):\n def forward(self, *args):\n return args[0].repeat(4, 2, 1)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Repeat1().float().eval(), input_data=input_data)\n verify_model(Repeat2().float().eval(), input_data=input_data)\n verify_model(Repeat3().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_repeat_interleave():\n torch.set_grad_enabled(False)\n input_shape = [2, 2, 3]\n\n class RepeatInterleave1(Module):\n def forward(self, *args):\n return args[0].repeat_interleave(2)\n\n class RepeatInterleave2(Module):\n def forward(self, *args):\n return args[0].repeat_interleave(3, dim=0)\n\n class RepeatInterleave3(Module):\n def forward(self, *args):\n return args[0].repeat_interleave(2, dim=1)\n\n class RepeatInterleave4(Module):\n def forward(self, *args):\n return args[0].repeat_interleave(4, dim=2)\n\n input_data = torch.rand(input_shape).float()\n verify_model(RepeatInterleave1().float().eval(), input_data=input_data)\n verify_model(RepeatInterleave2().float().eval(), input_data=input_data)\n verify_model(RepeatInterleave3().float().eval(), input_data=input_data)\n verify_model(RepeatInterleave4().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_unsqueeze():\n torch.set_grad_enabled(False)\n input_shape = [10, 10]\n\n class Unsqueeze1(Module):\n def forward(self, *args):\n return args[0].unsqueeze(2)\n\n class Unsqueeze2(Module):\n def forward(self, *args):\n _ = args[0].unsqueeze_(2)\n # Check whether operations after inplace unsqueeze works as expected\n y = args[0].squeeze(2)\n return torch.add(y, y)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Unsqueeze1().float().eval(), input_data=input_data)\n verify_model(Unsqueeze2().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_squeeze():\n torch.set_grad_enabled(False)\n input_shape = [2, 1, 10, 1, 10]\n\n class Squeeze1(Module):\n def forward(self, *args):\n return args[0].squeeze()\n\n class Squeeze2(Module):\n def forward(self, *args):\n return args[0].squeeze(1)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Squeeze1().float().eval(), input_data=input_data)\n verify_model(Squeeze2().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_arange():\n torch.set_grad_enabled(False)\n\n class Arange1(Module):\n def forward(self, *args):\n return torch.arange(5)\n\n class Arange2(Module):\n def forward(self, *args):\n return torch.arange(2.5)\n\n class Arange3(Module):\n def forward(self, *args):\n return torch.arange(1, 4)\n\n class Arange4(Module):\n def forward(self, *args):\n return torch.arange(1, 2.5, 0.5)\n\n class Arange5(Module):\n def forward(self, *args):\n return torch.arange(1, 2, 1, dtype=torch.int32)\n\n class Arange6(Module):\n def forward(self, *args):\n return torch.arange(start=1, end=6, step=2)\n\n class Arange7(Module):\n def forward(self, *args):\n return torch.arange(1, 4, dtype=torch.float32)\n\n class Arange8(Module):\n def forward(self, *args):\n return torch.arange(1, 2, 1, dtype=torch.int16)\n\n class Arange9(Module):\n def forward(self, *args):\n end = torch.add(torch.tensor(4), 1)\n return torch.arange(end) + torch.ones((5,), dtype=torch.int64)\n\n class Arange10(Module):\n def forward(self, *args):\n end = torch.add(torch.tensor(4.0), torch.tensor(1.0))\n return torch.arange(end) + torch.ones((5,), dtype=torch.float)\n\n class Arange11(Module):\n def forward(self, *args):\n start = torch.add(torch.tensor(1), 1)\n end = torch.add(torch.tensor(4), 1)\n step = torch.add(torch.tensor(2), 1)\n out = torch.arange(start, end, step)\n return out + torch.ones((3,), dtype=torch.int64)\n\n class Arange12(Module):\n def forward(self, *args):\n start = torch.add(torch.tensor(1), 1)\n end = torch.add(torch.tensor(4), 1)\n step = torch.add(torch.tensor(2.5), torch.tensor(4.1))\n out = torch.arange(start, end, step)\n return out + torch.ones((3,), dtype=torch.float)\n\n verify_model(Arange1().float().eval())\n verify_model(Arange2().float().eval())\n verify_model(Arange3().float().eval())\n verify_model(Arange4().float().eval())\n verify_model(Arange5().float().eval())\n verify_model(Arange6().float().eval())\n verify_model(Arange7().float().eval())\n verify_model(Arange8().float().eval())\n verify_model(Arange9().float().eval())\n verify_model(Arange10().float().eval())\n verify_model(Arange11().float().eval())\n verify_model(Arange12().float().eval())\n\n\[email protected]_gpu\ndef test_forward_mesh_grid():\n torch.set_grad_enabled(False)\n\n class MeshGrid1(Module):\n def forward(self, *args):\n x = torch.tensor([1, 2, 3])\n y = torch.tensor([4, 5, 6])\n grid_x, grid_y = torch.meshgrid([x, y])\n return grid_x, grid_y\n\n class MeshGrid2(Module):\n def forward(self, *args):\n x = torch.tensor([1, 2, 3], dtype=torch.float32)\n y = torch.add(torch.tensor(5, dtype=torch.float32), 1)\n grid_x, grid_y = torch.meshgrid([x, y])\n return grid_x, grid_y\n\n verify_model(MeshGrid1().float().eval())\n verify_model(MeshGrid2().float().eval())\n\n\[email protected]_gpu\ndef test_forward_abs():\n torch.set_grad_enabled(False)\n input_shape = [2, 1, 10, 1, 10]\n\n class Abs1(Module):\n def forward(self, *args):\n return args[0].abs()\n\n input_data = torch.rand(input_shape).float()\n verify_model(Abs1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_concatenate():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class Concatenate1(Module):\n def forward(self, *args):\n return torch.cat([args[0][:, 0].unsqueeze(1), args[0][:, 1].unsqueeze(1)], 1)\n\n class Concatenate2(Module):\n def forward(self, *args):\n a = (args[0][:, :, 0] + 2) * 7\n b = (args[0][:, :, 1] + 3) * 11\n c = (args[0][:, :, 2] + 5) * 13\n return torch.cat([t.unsqueeze(2) for t in [a, b, c]], 2)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Concatenate1().float().eval(), input_data=input_data)\n verify_model(Concatenate2().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_relu():\n torch.set_grad_enabled(False)\n input_shape = [10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.ReLU().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_prelu():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.PReLU(num_parameters=3).eval(), input_data=input_data)\n # Test when input channel > 1 and num parameters = 1\n verify_model(torch.nn.PReLU(num_parameters=1).eval(), input_data=input_data)\n # Test when input dims < 2\n verify_model(torch.nn.PReLU(num_parameters=1).eval(), input_data=torch.randn(2))\n\n\[email protected]_gpu\ndef test_forward_leakyrelu():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.LeakyReLU().eval(), input_data=input_data)\n verify_model(torch.nn.LeakyReLU(negative_slope=0.05).eval(), input_data=input_data)\n verify_model(torch.nn.LeakyReLU(negative_slope=1.0, inplace=True).eval(), input_data=input_data)\n verify_model(\n torch.nn.LeakyReLU(negative_slope=1.25, inplace=True).eval(), input_data=input_data\n )\n\n\[email protected]_gpu\ndef test_forward_elu():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.ELU().eval(), input_data=input_data)\n verify_model(torch.nn.ELU(alpha=0.3).eval(), input_data=input_data)\n verify_model(torch.nn.ELU(alpha=1.0).eval(), input_data=input_data)\n verify_model(torch.nn.ELU(alpha=1.3).eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_celu():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.CELU().eval(), input_data=input_data)\n verify_model(torch.nn.CELU(alpha=0.3).eval(), input_data=input_data)\n verify_model(torch.nn.CELU(alpha=1.0).eval(), input_data=input_data)\n verify_model(torch.nn.CELU(alpha=1.3).eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_gelu():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.GELU().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_selu():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.SELU().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_softplus():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.Softplus().eval(), input_data=input_data)\n verify_model(torch.nn.Softplus(beta=1.5, threshold=20).eval(), input_data=input_data)\n verify_model(torch.nn.Softplus(beta=5, threshold=10).eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_softsign():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.Softsign().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_log_sigmoid():\n torch.set_grad_enabled(False)\n input_shape = [10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.LogSigmoid().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_adaptiveavgpool():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.AdaptiveAvgPool2d([1, 1]).eval(), input_data=input_data)\n verify_model(torch.nn.AdaptiveAvgPool2d([10, 10]).eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_maxpool2d():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n\n verify_model(torch.nn.MaxPool2d(kernel_size=[1, 1]).eval(), input_data)\n verify_model(torch.nn.MaxPool2d(kernel_size=[2, 2], dilation=[2, 3]).eval(), input_data)\n verify_model(torch.nn.MaxPool2d(kernel_size=[10, 10]).eval(), input_data)\n verify_model(torch.nn.MaxPool2d(kernel_size=[4, 4], padding=2, stride=2).eval(), input_data)\n\n # A functional variant (default strides = None case)\n class MaxPool2D(Module):\n def forward(self, *args):\n return torch.nn.functional.max_pool2d(args[0], kernel_size=[10, 10])\n\n verify_model(MaxPool2D(), input_data=input_data)\n\n class MaxPool2DWithIndices(Module):\n def __init__(self):\n super(MaxPool2DWithIndices, self).__init__()\n self.pool = torch.nn.MaxPool2d(kernel_size=[1, 1], return_indices=True)\n\n def forward(self, *args):\n output, indices = self.pool(args[0])\n return output\n\n class MaxPool2DWithIntStrides(Module):\n def forward(self, *args):\n # Makes kernel_size and strides a Relay expr to test converting back to int\n x_shape = args[0].shape\n kernel_size = [torch.tensor(x_shape[1]).int(), torch.tensor(x_shape[1]).int()]\n strides = [torch.tensor(x_shape[0]).int(), torch.tensor(x_shape[0]).int()]\n return torch.nn.functional.max_pool2d(args[0], kernel_size=[4, 4], stride=strides)\n\n verify_model(MaxPool2DWithIndices().float().eval(), input_data=input_data)\n verify_model(MaxPool2DWithIntStrides().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_maxpool1d():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10]\n input_data = torch.rand(input_shape).float()\n\n verify_model(torch.nn.MaxPool1d(kernel_size=1).eval(), input_data)\n verify_model(torch.nn.MaxPool1d(kernel_size=2, dilation=[1]).eval(), input_data)\n verify_model(torch.nn.MaxPool1d(kernel_size=10).eval(), input_data)\n verify_model(torch.nn.MaxPool1d(kernel_size=4, padding=2, stride=2).eval(), input_data)\n\n # A functional variant (default strides = None case)\n class MaxPool1D(Module):\n def forward(self, *args):\n return torch.nn.functional.max_pool1d(args[0], kernel_size=10)\n\n verify_model(MaxPool1D(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_maxpool3d():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10, 10]\n input_data = torch.rand(input_shape).float()\n\n verify_model(torch.nn.MaxPool3d(kernel_size=[1, 1, 1]).eval(), input_data)\n verify_model(torch.nn.MaxPool3d(kernel_size=[2, 2, 2], dilation=[1, 2, 3]).eval(), input_data)\n verify_model(torch.nn.MaxPool3d(kernel_size=[10, 10, 10]).eval(), input_data)\n verify_model(torch.nn.MaxPool3d(kernel_size=[4, 4, 4], padding=2, stride=2).eval(), input_data)\n\n # A functional variant (default strides = None case)\n class MaxPool3D(Module):\n def forward(self, *args):\n return torch.nn.functional.max_pool3d(args[0], kernel_size=[10, 10, 10])\n\n verify_model(MaxPool3D(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_split():\n torch.set_grad_enabled(False)\n input_shape = [4, 10]\n\n class Split(Module):\n def __init__(self, split_size_or_sections, dim):\n super(Split, self).__init__()\n self.split_size_or_sections = split_size_or_sections\n self.dim = dim\n\n def forward(self, *args):\n return torch.split(args[0], self.split_size_or_sections, self.dim)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Split(2, 0).float().eval(), input_data=input_data)\n verify_model(Split(3, 1).float().eval(), input_data=input_data)\n verify_model(Split(4, 1).float().eval(), input_data=input_data)\n verify_model(Split([2, 3, 5], 1).float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_avgpool1d():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10]\n\n class AvgPool1D2(Module):\n def forward(self, *args):\n return torch.nn.functional.avg_pool1d(args[0], kernel_size=[10])\n\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.AvgPool1d(kernel_size=[10]).eval(), input_data=input_data)\n verify_model(AvgPool1D2().float().eval(), input_data=input_data)\n verify_model(\n torch.nn.AvgPool1d(kernel_size=[5], stride=2, padding=2).eval(), input_data=input_data\n )\n\n\[email protected]_gpu\ndef test_forward_avgpool2d():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class AvgPool2D2(Module):\n def forward(self, *args):\n return torch.nn.functional.avg_pool2d(args[0], kernel_size=[10, 10])\n\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.AvgPool2d(kernel_size=[10, 10]).eval(), input_data=input_data)\n verify_model(AvgPool2D2().float().eval(), input_data=input_data)\n verify_model(\n torch.nn.AvgPool2d(kernel_size=5, stride=2, padding=2).eval(), input_data=input_data\n )\n\n\[email protected]_gpu\ndef test_forward_avgpool3d():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10, 10]\n\n class AvgPool3D1(Module):\n def forward(self, *args):\n return torch.nn.functional.avg_pool3d(args[0], kernel_size=[10, 10, 10])\n\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.AvgPool3d(kernel_size=[10, 10, 10]).eval(), input_data=input_data)\n verify_model(AvgPool3D1().float().eval(), input_data=input_data)\n verify_model(\n torch.nn.AvgPool3d(kernel_size=5, stride=2, padding=2).eval(), input_data=input_data\n )\n\n\[email protected]_gpu\ndef test_forward_hardtanh():\n torch.set_grad_enabled(False)\n input_shape = [10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.Hardtanh().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_conv():\n torch.set_grad_enabled(False)\n conv1d_input_shape = [1, 3, 10]\n conv2d_input_shape = [1, 3, 10, 10]\n\n class Conv2D1(Module):\n def __init__(self):\n super(Conv2D1, self).__init__()\n self.conv = torch.nn.Conv2d(3, 6, 7, bias=True)\n self.softmax = torch.nn.Softmax()\n\n def forward(self, *args):\n return self.softmax(self.conv(args[0]))\n\n class Conv2D2(Module):\n def __init__(self):\n super(Conv2D2, self).__init__()\n self.conv = torch.nn.Conv2d(3, 6, 7, bias=False)\n self.softmax = torch.nn.Softmax()\n\n def forward(self, *args):\n return self.softmax(self.conv(args[0]))\n\n class Conv2D3(Module):\n def __init__(self):\n super(Conv2D3, self).__init__()\n self.conv = torch.nn.Conv2d(3, 6, 7, groups=3, bias=False)\n self.softmax = torch.nn.Softmax()\n\n def forward(self, *args):\n return self.softmax(self.conv(args[0]))\n\n class Conv1D1(Module):\n def __init__(self):\n super(Conv1D1, self).__init__()\n self.conv = torch.nn.Conv1d(3, 6, 7)\n self.softmax = torch.nn.Softmax()\n\n def forward(self, *args):\n return self.softmax(self.conv(args[0]))\n\n class Conv1D2(Module):\n def __init__(self):\n super(Conv1D2, self).__init__()\n self.conv = torch.nn.Conv1d(3, 6, 7, bias=False)\n self.softmax = torch.nn.Softmax()\n\n def forward(self, *args):\n return self.softmax(self.conv(args[0]))\n\n class Conv1D3(Module):\n def __init__(self):\n super(Conv1D3, self).__init__()\n self.conv = torch.nn.Conv1d(3, 6, 7, groups=3, bias=False)\n self.softmax = torch.nn.Softmax()\n\n def forward(self, *args):\n return self.softmax(self.conv(args[0]))\n\n conv2d_input_data = torch.rand(conv2d_input_shape).float()\n verify_model(Conv2D1().float().eval(), input_data=conv2d_input_data)\n verify_model(Conv2D2().float().eval(), input_data=conv2d_input_data)\n # depth wise conv with channel mult 2\n verify_model(Conv2D3().float().eval(), input_data=conv2d_input_data)\n # group conv\n verify_model(\n torch.nn.Conv2d(8, 8, kernel_size=(3, 3), stride=(1, 1), groups=2).eval(),\n input_data=torch.randn((1, 8, 16, 16)),\n )\n\n conv1d_input_data = torch.rand(conv1d_input_shape).float()\n verify_model(Conv1D1().float().eval(), input_data=conv1d_input_data)\n verify_model(Conv1D2().float().eval(), input_data=conv1d_input_data)\n verify_model(Conv1D3().float().eval(), input_data=conv1d_input_data)\n\n\[email protected]_gpu\[email protected](\"in_channels\", [3], ids=lambda x: \"in_channels=\" + str(x))\[email protected](\"out_channels\", [5], ids=lambda x: \"out_channels=\" + str(x))\[email protected](\"kernel_size\", [3], ids=lambda x: \"kernel_size=\" + str(x))\[email protected](\"output_padding\", [0, 1, 2], ids=lambda x: \"output_padding=\" + str(x))\[email protected](\"groups\", [1], ids=lambda x: \"groups=\" + str(x))\[email protected](\"bias\", [True, False], ids=lambda x: \"bias=\" + str(x))\ndef test_forward_conv_transpose(\n in_channels, out_channels, kernel_size, output_padding, bias, groups\n):\n # Note we do not test with groups > 1 because that is not supported\n # in tvm for conv transpose operations\n\n # Output padding must be smaller than either stride or dilation so we\n # opt to make the stride 1 + output padding\n stride = output_padding + 1\n\n # Conv 3D Transpose Tests\n conv3d_input_shape = [1, in_channels, 16, 16, 16]\n conv3d_input_data = torch.rand(conv3d_input_shape).float()\n conv3d_transpose = torch.nn.ConvTranspose3d(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=kernel_size,\n stride=stride,\n output_padding=output_padding,\n groups=groups,\n bias=bias,\n ).eval()\n verify_model(conv3d_transpose, conv3d_input_data)\n\n # Conv 2D Transpose Tests\n conv2d_input_shape = [1, in_channels, 128, 256]\n conv2d_input_data = torch.rand(conv2d_input_shape).float()\n conv2d_transpose = torch.nn.ConvTranspose2d(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=kernel_size,\n stride=stride,\n output_padding=output_padding,\n groups=groups,\n bias=bias,\n ).eval()\n verify_model(conv2d_transpose, conv2d_input_data)\n\n # # Conv 1D Transpose Tests\n conv1d_input_shape = [1, in_channels, 10]\n conv1d_input_data = torch.rand(conv1d_input_shape).float()\n conv1d_transpose = torch.nn.ConvTranspose1d(\n in_channels=in_channels,\n out_channels=out_channels,\n kernel_size=kernel_size,\n stride=stride,\n output_padding=output_padding,\n groups=groups,\n bias=bias,\n ).eval()\n verify_model(conv1d_transpose, conv1d_input_data)\n\n\ndef test_forward_deform_conv():\n torch.set_grad_enabled(False)\n\n def test_run(\n batch_size,\n in_channels,\n out_channels,\n in_height,\n in_width,\n out_height,\n out_width,\n offset_groups,\n kh,\n kw,\n groups,\n ):\n input_shape = [batch_size, in_channels, in_height, in_width]\n offset_shape = [batch_size, 2 * offset_groups * kh * kw, out_height, out_width]\n weight_shape = [out_channels, in_channels // groups, kh, kw]\n input_data = torch.rand(input_shape)\n offset_data = torch.rand(offset_shape)\n weight_data = torch.rand(weight_shape)\n\n class DeformConv2D(Module):\n def forward(self, *args):\n return torchvision.ops.deform_conv2d(args[0], args[1], args[2])\n\n verify_model(\n DeformConv2D().float().eval(),\n input_data=[input_data, offset_data, weight_data],\n rtol=1e-4,\n atol=1e-4,\n )\n\n batch_size = 4\n in_channels, out_channels = 4, 6\n in_height, in_width = 10, 10\n out_height, out_width = 8, 8\n offset_groups = 2\n kh, kw = 3, 3\n groups = 1\n\n test_run(\n batch_size,\n in_channels,\n out_channels,\n in_height,\n in_width,\n out_height,\n out_width,\n offset_groups,\n kh,\n kw,\n groups,\n )\n\n batch_size = 5\n in_channels, out_channels = 4, 6\n in_height, in_width = 10, 10\n out_height, out_width = 8, 8\n offset_groups = 1\n kh, kw = 3, 3\n groups = 1\n\n test_run(\n batch_size,\n in_channels,\n out_channels,\n in_height,\n in_width,\n out_height,\n out_width,\n offset_groups,\n kh,\n kw,\n groups,\n )\n\n\[email protected]_gpu\ndef test_forward_threshold():\n torch.set_grad_enabled(False)\n input_shape = [1, 3]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.Threshold(0, 0).float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_contiguous():\n torch.set_grad_enabled(False)\n input_shape = [10]\n\n class Contiguous1(Module):\n def forward(self, *args):\n return args[0].contiguous()\n\n input_data = torch.rand(input_shape).float()\n verify_model(Contiguous1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_batchnorm():\n def init_weight(m):\n torch.nn.init.normal_(m.weight, 0, 0.01)\n torch.nn.init.normal_(m.bias)\n\n inp_2d = torch.rand((1, 16, 10, 10))\n inp_3d = torch.rand((1, 16, 10, 10, 10))\n\n for bn, inp in [(torch.nn.BatchNorm2d(16), inp_2d), (torch.nn.BatchNorm3d(16), inp_3d)]:\n init_weight(bn.eval())\n verify_model(bn.eval(), input_data=inp)\n\n\[email protected]_gpu\ndef test_forward_instancenorm():\n inp_2d = torch.rand((1, 16, 10, 10))\n inp_3d = torch.rand((1, 16, 10, 10, 10))\n\n for ins_norm, inp in [\n (torch.nn.InstanceNorm2d(16), inp_2d),\n (torch.nn.InstanceNorm3d(16), inp_3d),\n ]:\n verify_model(ins_norm.eval(), input_data=inp)\n\n\[email protected]_gpu\ndef test_forward_layernorm():\n def init_weight(m):\n torch.nn.init.normal_(m.weight, 0, 0.01)\n torch.nn.init.normal_(m.bias, 0.02)\n\n inp_2d = torch.rand((1, 16, 10, 10))\n inp_3d = torch.rand((1, 16, 10, 10, 10))\n for ln, inp in [(torch.nn.LayerNorm(10), inp_2d), (torch.nn.LayerNorm(10), inp_3d)]:\n init_weight(ln.eval())\n verify_model(ln.eval(), input_data=inp)\n\n\[email protected]_gpu\ndef test_forward_groupnorm():\n input_shape = [10, 6, 5, 5]\n input_data = torch.rand(input_shape).float()\n\n # Separate 6 channels into 3 groups\n verify_model(torch.nn.GroupNorm(3, 6).eval(), input_data=input_data)\n\n # Put all 6 channels into a single group (equivalent with LayerNorm)\n verify_model(torch.nn.GroupNorm(1, 6).eval(), input_data=input_data)\n\n # Separate 6 channels into 6 groups (equivalent with InstanceNorm)\n verify_model(torch.nn.GroupNorm(6, 6).eval(), input_data=input_data)\n\n input_shape = [1, 10, 4, 7]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.GroupNorm(1, 10).eval(), input_data=input_data)\n verify_model(torch.nn.GroupNorm(2, 10).eval(), input_data=input_data)\n verify_model(torch.nn.GroupNorm(5, 10).eval(), input_data=input_data)\n verify_model(torch.nn.GroupNorm(10, 10).eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_reshape():\n torch.set_grad_enabled(False)\n input_shape = [2, 1, 10, 1, 10]\n new_shape = [2, 1, 10, 10]\n\n class Reshape1(Module):\n def forward(self, *args):\n return args[0].reshape(new_shape)\n\n class Reshape2(Module):\n def forward(self, *args):\n return args[0].reshape([-1])\n\n class Reshape3(torch.nn.Module):\n def forward(self, x):\n x_shape = x.shape\n return x.reshape((x_shape[0] * x_shape[1], x_shape[2]))\n\n input_data = torch.rand(input_shape).float()\n verify_model(Reshape1(), input_data=input_data)\n verify_model(Reshape2(), input_data=input_data)\n verify_model(Reshape3(), input_data=torch.randn(2, 3, 4))\n\n\[email protected]_gpu\ndef test_flatten():\n class Flatten(Module):\n def forward(self, x):\n return torch.flatten(x)\n\n class BatchFlatten(Module):\n def forward(self, x):\n return torch.flatten(x, start_dim=1)\n\n inp = torch.rand((5, 2, 2))\n verify_model(Flatten(), input_data=inp)\n verify_model(BatchFlatten(), input_data=inp)\n\n\[email protected]_gpu\ndef test_forward_transpose():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class Transpose1(Module):\n def forward(self, *args):\n return args[0].transpose(2, 3)\n\n class Transpose2(Module):\n def forward(self, *args):\n return args[0].transpose(-2, -1)\n\n class Transpose3(Module):\n def forward(self, *args):\n return args[0].permute(0, 2, 3, 1)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Transpose1().float().eval(), input_data=input_data)\n verify_model(Transpose2().float().eval(), input_data=input_data)\n verify_model(Transpose3().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_size():\n torch.set_grad_enabled(False)\n input_shape = [1, 3]\n\n class Size1(Module):\n def forward(self, *args):\n return float(args[0].size(0)) * args[0]\n\n input_data = torch.rand(input_shape).float()\n verify_model(Size1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_type_as():\n torch.set_grad_enabled(False)\n input_shape = [1, 3]\n\n def _create_module(dtype):\n class TypeAs(Module):\n def forward(self, *args):\n expected_type_tensor = torch.zeros(1, 3, dtype=dtype)\n return args[0].type_as(expected_type_tensor)\n\n return TypeAs()\n\n input_data = torch.randn(input_shape).float()\n verify_model(_create_module(torch.float64), input_data=input_data)\n verify_model(_create_module(torch.float32), input_data=input_data)\n verify_model(_create_module(torch.int64), input_data=input_data)\n verify_model(_create_module(torch.int32), input_data=input_data)\n verify_model(_create_module(torch.int16), input_data=input_data)\n verify_model(_create_module(torch.int8), input_data=input_data)\n\n if torch.cuda.is_available():\n check_fp16 = False\n try:\n # Only check half precision on supported hardwares.\n if have_fp16(tvm.cuda(0).compute_version):\n check_fp16 = True\n except Exception as e:\n # If GPU is not enabled in TVM, skip the fp16 test.\n pass\n\n # Temporary disable fp16 test\n check_fp16 = False\n\n if check_fp16:\n verify_model(_create_module(torch.float16), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_view():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class View1(Module):\n def forward(self, *args):\n return args[0].view((1, 3 * 10 * 10))\n\n class View2(Module):\n def forward(self, *args):\n return args[0].view(args[0].shape[0], -1)\n\n class View3(Module):\n def forward(self, *args):\n d1 = torch.tensor(3) * torch.tensor(10) * torch.tensor(10)\n return args[0].view(args[0].shape[0], d1)\n\n input_data = torch.rand(input_shape).float()\n verify_model(View1().float().eval(), input_data=input_data)\n verify_model(View2().float().eval(), input_data=input_data)\n verify_model(View3().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_select():\n torch.set_grad_enabled(False)\n input_shape = [5, 3, 10, 10]\n\n class Select1(Module):\n def forward(self, *args):\n return args[0].select(1, 1)\n\n class IndexedSelect(Module):\n def __init__(self, inp, dim):\n super().__init__()\n self.inp = inp\n self.dim = dim\n if torch.cuda.is_available():\n self.inp = self.inp.cuda()\n\n def forward(self, index):\n return torch.index_select(self.inp, self.dim, index)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Select1().float().eval(), input_data=input_data)\n\n # test negative indexing\n verify_model(lambda x: x[-1], input_data=input_data)\n\n x = torch.randn(3, 4)\n indices = torch.tensor([0, 2])\n verify_model(IndexedSelect(x, 0).eval(), input_data=indices)\n verify_model(IndexedSelect(x, 1).eval(), input_data=indices)\n\n\[email protected]_gpu\ndef test_forward_clone():\n torch.set_grad_enabled(False)\n input_shape = [10]\n\n class Clone1(Module):\n def forward(self, *args):\n return args[0].clone()\n\n input_data = torch.rand(input_shape).float()\n verify_model(Clone1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_gather():\n torch.set_grad_enabled(False)\n\n class Gather1(Module):\n def forward(self, *args):\n return torch.gather(args[0], 0, args[1])\n\n class Gather2(Module):\n def forward(self, *args):\n return torch.gather(args[0], 1, args[1])\n\n class Gather3(Module):\n def forward(self, *args):\n return torch.gather(args[0], 2, args[1])\n\n input_data = torch.rand((4,)).float()\n index = torch.tensor([1])\n verify_model(Gather1().float().eval(), input_data=[input_data, index])\n\n input_data = torch.rand((2, 2)).float()\n index = torch.tensor([[1, 0], [0, 1]])\n verify_model(Gather1().float().eval(), input_data=[input_data, index])\n\n input_data = torch.tensor([[1, 2], [3, 4]])\n index = torch.tensor([[0, 0], [1, 0]])\n verify_model(Gather2().float().eval(), input_data=[input_data, index])\n\n input_data = torch.rand((2, 2)).float()\n index = torch.tensor([[1, 0], [0, 1]])\n verify_model(Gather2().float().eval(), input_data=[input_data, index])\n\n input_data = torch.rand((3, 3, 3)).float()\n index = torch.tensor(\n [\n [[1, 0, 0], [1, 0, 1], [0, 1, 1]],\n [[1, 1, 1], [1, 2, 1], [1, 0, 1]],\n [[1, 2, 1], [1, 2, 1], [1, 2, 1]],\n ]\n )\n verify_model(Gather3().float().eval(), input_data=[input_data, index])\n\n\[email protected]_gpu\ndef test_forward_logsoftmax():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class LogSoftmax1(Module):\n def forward(self, *args):\n return torch.nn.LogSoftmax(dim=1)(args[0][0, 0])\n\n input_data = torch.rand(input_shape).float()\n verify_model(LogSoftmax1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_norm():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class Norm1(Module):\n def forward(self, *args):\n return torch.norm(args[0], p=float(\"inf\"), dim=None, keepdim=False)\n\n class Norm2(Module):\n def forward(self, *args):\n return torch.norm(args[0], p=float(\"-inf\"), dim=None, keepdim=False)\n\n class Norm3(Module):\n def forward(self, *args):\n return torch.norm(args[0], p=float(\"-inf\"), dim=None, keepdim=True)\n\n class Norm4(Module):\n def forward(self, *args):\n return torch.norm(args[0], p=float(\"inf\"), dim=(1, 2), keepdim=False)\n\n class Norm5(Module):\n def forward(self, *args):\n return torch.norm(args[0], p=float(\"inf\"), dim=(1), keepdim=True)\n\n class Norm6(Module):\n def forward(self, *args):\n return torch.norm(args[0], p=float(0.5), dim=(1), keepdim=True)\n\n class Norm7(Module):\n def forward(self, *args):\n return torch.norm(args[0], p=float(1), dim=None, keepdim=False)\n\n class Norm8(Module):\n def forward(self, *args):\n return torch.norm(args[0], p=float(2.0), dim=(1), keepdim=True)\n\n class Norm9(Module):\n def forward(self, *args):\n return torch.norm(args[0], p=float(-0.5), dim=(1, 2), keepdim=True)\n\n class Norm10(Module):\n def forward(self, *args):\n return torch.norm(args[0], p=float(-2), dim=(1), keepdim=False)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Norm1().float().eval(), input_data=input_data)\n verify_model(Norm2().float().eval(), input_data=input_data)\n verify_model(Norm3().float().eval(), input_data=input_data)\n verify_model(Norm4().float().eval(), input_data=input_data)\n verify_model(Norm5().float().eval(), input_data=input_data)\n verify_model(Norm6().float().eval(), input_data=input_data)\n verify_model(Norm7().float().eval(), input_data=input_data)\n verify_model(Norm8().float().eval(), input_data=input_data)\n verify_model(Norm9().float().eval(), input_data=input_data)\n verify_model(Norm10().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_frobenius_norm():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class FroNorm1(Module):\n def forward(self, *args):\n return torch.norm(args[0])\n\n class FroNorm2(Module):\n def forward(self, *args):\n return torch.norm(args[0], p=\"fro\", dim=None, keepdim=True)\n\n class FroNorm3(Module):\n def forward(self, *args):\n return torch.norm(args[0], p=\"fro\", dim=(1), keepdim=True)\n\n class FroNorm4(Module):\n def forward(self, *args):\n return torch.norm(args[0], dim=None, keepdim=False)\n\n input_data = torch.rand(input_shape).float()\n verify_model(FroNorm1().float().eval(), input_data=input_data)\n verify_model(FroNorm2().float().eval(), input_data=input_data)\n verify_model(FroNorm3().float().eval(), input_data=input_data)\n verify_model(FroNorm4().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_sigmoid():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.Sigmoid().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_dense():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class Dense1(Module):\n def __init__(self):\n super(Dense1, self).__init__()\n self.linear = torch.nn.Linear(10, 7, bias=True)\n\n def forward(self, *args):\n return self.linear(args[0][0, 0])\n\n class Dense2(Module):\n def __init__(self):\n super(Dense2, self).__init__()\n self.linear = torch.nn.Linear(10, 7, bias=False)\n\n def forward(self, *args):\n return self.linear(args[0][0, 0])\n\n input_data = torch.rand(input_shape).float()\n verify_model(Dense1().float().eval(), input_data=input_data)\n verify_model(Dense2().float().eval(), input_data=input_data)\n\n trace = torch.jit.trace(Dense1(), [input_data])\n mod, params = relay.frontend.from_pytorch(\n trace,\n [(\"input\", input_shape)],\n )\n assert not any([op.name == \"multiply\" for op in list_ops(mod[\"main\"])])\n\n\[email protected]_gpu\ndef test_forward_linear():\n torch.set_grad_enabled(False)\n\n class Linear(Module):\n def forward(self, input, weight, bias):\n return F.linear(input, weight, bias)\n\n class LinearNoBias(Module):\n def forward(self, input, weight):\n return F.linear(input, weight)\n\n input2d = torch.rand([2, 2]).float()\n weight1d = torch.rand([2]).float()\n weight2d = torch.rand([2, 2]).float()\n bias1d = torch.rand([2]).float()\n bias2d = torch.rand([2, 2]).float()\n # 2D input, 2D weight, 1D bias\n verify_model(Linear(), input_data=[input2d, weight2d, bias1d])\n # 2D input, 2D weight, 2D bias\n verify_model(Linear(), input_data=[input2d, weight2d, bias2d])\n # 2D input, 2D weight, no bias\n verify_model(LinearNoBias(), input_data=[input2d, weight2d])\n # 2D input, 1D weight, 1D bias is not supported by torch.linear()\n # 2D input, 1D weight, no bias\n verify_model(LinearNoBias(), input_data=[input2d, weight1d])\n # TODO: Add the following cases when matmul(1D, _) is supported by TVM\n # 1D input, 2D weight, 1D bias\n # 1D input, 2D weight, no bias\n # 1D input, 1D weight, scalar bias\n # 1D input, 1D weight, no bias\n\n\[email protected]_gpu\ndef test_forward_dropout():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(torch.nn.Dropout(p=0.5).eval(), input_data=input_data[0, 0])\n verify_model(torch.nn.Dropout2d(p=0.5).eval(), input_data=input_data[0])\n verify_model(torch.nn.Dropout3d(p=0.5).eval(), input_data=input_data)\n verify_model(torch.nn.AlphaDropout(p=0.5).eval(), input_data=input_data[0, 0])\n\n\[email protected]_gpu\ndef test_forward_slice():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class Slice1(Module):\n def forward(self, *args):\n return args[0][:, :, :, :3]\n\n class Slice2(Module):\n def forward(self, *args):\n return args[0][0, :, :-3, :]\n\n class Slice3(Module):\n def forward(self, *args):\n x0 = torch.tensor(2) - torch.tensor(1)\n x1 = torch.tensor(3) + torch.tensor(1)\n return args[0][:, x0:, 1:x1, :]\n\n class SliceWithStride(torch.nn.Module):\n def forward(self, x):\n return x[..., 0::2] + x[..., 1::2]\n\n class SliceWithStride2(torch.nn.Module):\n def forward(self, x):\n return x[0::2, 0::2] + x[1::2, 1::2]\n\n class DynamicLengthSlice(torch.nn.Module):\n def forward(self, values, length):\n return values[0:length]\n\n input_data = torch.rand(input_shape).float()\n verify_model(Slice1(), input_data=input_data)\n verify_model(Slice2(), input_data=input_data)\n verify_model(Slice3(), input_data=input_data)\n verify_model(SliceWithStride(), input_data=torch.randn(1, 4))\n verify_model(SliceWithStride2(), input_data=torch.randn(4, 4))\n\n inp = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n slice_len = torch.tensor(2)\n targets = [\"llvm\", \"cuda\"]\n verify_trace_model(DynamicLengthSlice(), [inp, slice_len], targets)\n\n\[email protected]_gpu\ndef test_forward_narrow():\n torch.set_grad_enabled(False)\n input_shape = [3, 3]\n\n class Narrow1(Module):\n def forward(self, *args):\n return torch.narrow(args[0], 0, 0, 2)\n\n class Narrow2(Module):\n def forward(self, *args):\n return torch.narrow(args[0], 1, 1, 2)\n\n class Narrow3(Module):\n def forward(self, *args):\n begin = torch.tensor(2) - torch.tensor(1)\n length = torch.tensor(1) * torch.tensor(2)\n return torch.narrow(args[0], 1, begin, length)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Narrow1(), input_data=input_data)\n verify_model(Narrow2(), input_data=input_data)\n verify_model(Narrow3(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_mean():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class Mean1(Module):\n def forward(self, *args):\n return args[0].mean(2)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Mean1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_expand():\n torch.set_grad_enabled(False)\n\n class Expand1(Module):\n def forward(self, *args):\n return args[0].expand((3, -1, -1, -1))\n\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(Expand1().float().eval(), input_data=input_data)\n\n class Expand2(Module):\n def forward(self, *args):\n return args[0].expand((3, 3, 3, 1))\n\n input_shape = [3, 1]\n input_data = torch.rand(input_shape).float()\n verify_model(Expand2().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_pow():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class Pow1(Module):\n def forward(self, *args):\n return args[0] ** 2\n\n input_data = torch.rand(input_shape).float()\n verify_model(Pow1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_chunk():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 14, 14]\n\n class Chunk1(Module):\n def forward(self, *args):\n chunks = args[0].chunk(7, 2)\n return torch.cat(chunks, 2)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Chunk1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_upsample():\n class Upsample(Module):\n def __init__(self, size=None, scale=None, mode=\"nearest\", align_corners=None):\n super().__init__()\n self.size = size\n self.scale = scale\n self.mode = mode\n self.align_corners = align_corners\n\n def forward(self, x):\n return torch.nn.functional.interpolate(\n x,\n size=self.size,\n scale_factor=self.scale,\n mode=self.mode,\n align_corners=self.align_corners,\n )\n\n inp = torch.rand((1, 3, 32, 32))\n verify_model(Upsample(size=(64, 64), mode=\"nearest\"), inp)\n verify_model(Upsample(scale=2, mode=\"nearest\"), inp)\n verify_model(Upsample(size=(50, 50), mode=\"nearest\"), inp)\n verify_model(Upsample(size=(64, 64), mode=\"bilinear\", align_corners=True), inp)\n verify_model(Upsample(scale=2, mode=\"bilinear\", align_corners=True), inp)\n verify_model(Upsample(size=(50, 50), mode=\"bilinear\", align_corners=True), inp)\n\n\[email protected]_gpu\ndef test_to():\n \"\"\"test for aten::to(...)\"\"\"\n\n class ToCPU(Module):\n def forward(self, x):\n return x.to(\"cpu\")\n\n class ToFloat(Module):\n def forward(self, x):\n return x.float()\n\n class ToInt(Module):\n def forward(self, x):\n return x.int()\n\n class ToLong(Module):\n def forward(self, x):\n return x.long()\n\n class ToDouble(Module):\n def forward(self, x):\n return x.double()\n\n class ToFloat16(Module):\n def forward(self, x):\n return x.to(torch.float16)\n\n verify_model(ToCPU().eval(), torch.rand((1, 3, 32, 32)))\n verify_model(ToFloat().eval(), torch.zeros((1, 3, 32, 32), dtype=torch.int))\n verify_model(ToFloat().eval(), torch.tensor(2, dtype=torch.int))\n verify_model(ToInt().eval(), torch.zeros((1, 3, 32, 32)))\n verify_model(ToInt().eval(), torch.tensor(0.8))\n verify_model(ToLong().eval(), torch.tensor(0.8))\n verify_model(ToDouble().eval(), torch.tensor(0.8))\n verify_model(ToFloat16().eval(), torch.tensor(2, dtype=torch.float32))\n verify_model(ToFloat16().eval(), torch.zeros((1, 3, 32, 32), dtype=torch.int))\n\n\[email protected]_gpu\ndef test_adaptive_pool3d():\n for ishape in [(1, 32, 16, 16, 16), (1, 32, 9, 15, 15), (1, 32, 13, 7, 7)]:\n inp = torch.rand(ishape)\n verify_model(torch.nn.AdaptiveMaxPool3d((1, 1, 1)).eval(), inp)\n verify_model(torch.nn.AdaptiveMaxPool3d((2, 2, 2)).eval(), inp)\n verify_model(torch.nn.AdaptiveAvgPool3d((1, 1, 1)).eval(), inp)\n verify_model(torch.nn.AdaptiveAvgPool3d((2, 2, 2)).eval(), inp)\n verify_model(torch.nn.AdaptiveAvgPool3d((4, 8, 8)).eval(), inp)\n verify_model(torch.nn.AdaptiveMaxPool3d((7, 8, 9)).eval(), inp)\n\n\[email protected]_gpu\ndef test_forward_functional_pad():\n torch.set_grad_enabled(False)\n pad = (0, 0)\n\n class Pad1(Module):\n def forward(self, *args):\n return torch.nn.functional.pad(args[0], pad, \"constant\", 0)\n\n input_data = torch.rand((3, 3, 4, 2))\n pad = (1, 1)\n verify_model(Pad1().float().eval(), input_data=input_data)\n\n pad = (1, 1, 2, 2)\n verify_model(Pad1().float().eval(), input_data=input_data)\n\n pad = (0, 1, 2, 1, 3, 3)\n verify_model(Pad1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_zero_pad2d():\n inp = torch.rand((1, 1, 3, 3))\n verify_model(torch.nn.ZeroPad2d(2).eval(), inp)\n verify_model(torch.nn.ZeroPad2d((1, 1, 2, 0)).eval(), inp)\n\n\[email protected]_gpu\ndef test_forward_constant_pad1d():\n inp = torch.rand((1, 2, 4))\n verify_model(torch.nn.ConstantPad2d(2, 3.5).eval(), inp)\n\n inp = torch.rand((1, 2, 3))\n verify_model(torch.nn.ConstantPad2d((3, 1), 3.5).eval(), inp)\n\n\[email protected]_gpu\ndef test_forward_constant_pad2d():\n inp = torch.rand((1, 2, 2, 2))\n verify_model(torch.nn.ConstantPad2d(2, 3.5).eval(), inp)\n verify_model(torch.nn.ConstantPad2d((3, 0, 2, 1), 3.5).eval(), inp)\n\n\[email protected]_gpu\ndef test_forward_constant_pad3d():\n inp = torch.rand((1, 3, 2, 2, 2))\n verify_model(torch.nn.ConstantPad3d(3, 3.5).eval(), inp)\n verify_model(torch.nn.ConstantPad3d((3, 4, 5, 6, 0, 1), 3.5).eval(), inp)\n\n\[email protected]_gpu\ndef test_forward_reflection_pad1d():\n inp = torch.rand((1, 2, 4))\n verify_model(torch.nn.ReflectionPad1d(2).eval(), inp)\n verify_model(torch.nn.ReflectionPad1d((3, 1)).eval(), inp)\n\n inp = torch.rand((2, 4, 5))\n verify_model(torch.nn.ReflectionPad1d((2, 3)).eval(), inp)\n\n\[email protected]_gpu\ndef test_forward_reflection_pad2d():\n inp = torch.rand((1, 1, 3, 3))\n verify_model(torch.nn.ReflectionPad2d(2).eval(), inp)\n verify_model(torch.nn.ReflectionPad2d((1, 1, 2, 0)).eval(), inp)\n\n inp = torch.rand((2, 4, 5, 6))\n verify_model(torch.nn.ReflectionPad2d((1, 3, 2, 4)).eval(), inp)\n\n\[email protected]_gpu\ndef test_forward_replication_pad1d():\n inp = torch.rand((1, 2, 4))\n verify_model(torch.nn.ReplicationPad1d(2).eval(), inp)\n verify_model(torch.nn.ReplicationPad1d((3, 1)).eval(), inp)\n\n inp = torch.rand((2, 4, 5))\n verify_model(torch.nn.ReplicationPad1d((2, 3)).eval(), inp)\n\n\[email protected]_gpu\ndef test_forward_replication_pad2d():\n inp = torch.rand((1, 1, 3, 3))\n verify_model(torch.nn.ReplicationPad2d(2).eval(), inp)\n verify_model(torch.nn.ReplicationPad2d((1, 1, 2, 0)).eval(), inp)\n\n inp = torch.rand((2, 4, 5, 6))\n verify_model(torch.nn.ReplicationPad2d((1, 3, 2, 4)).eval(), inp)\n\n\[email protected]_gpu\ndef test_forward_replication_pad3d():\n inp = torch.rand((1, 1, 3, 3, 3))\n verify_model(torch.nn.ReplicationPad3d(3).eval(), inp)\n verify_model(torch.nn.ReplicationPad3d((1, 1, 2, 2, 1, 1)).eval(), inp)\n\n inp = torch.rand((7, 5, 4, 5, 6))\n verify_model(torch.nn.ReplicationPad3d((2, 3, 2, 5, 1, 4)).eval(), inp)\n\n\[email protected]_gpu\ndef test_forward_upsample3d():\n inp = torch.arange(1, 9, dtype=torch.float32).view(1, 1, 2, 2, 2)\n verify_model(torch.nn.Upsample(scale_factor=2, mode=\"nearest\").eval(), inp)\n verify_model(torch.nn.Upsample(scale_factor=2, mode=\"trilinear\").eval(), inp)\n verify_model(\n torch.nn.Upsample(scale_factor=2, mode=\"trilinear\", align_corners=True).eval(), inp\n )\n\n\ndef test_forward_nms():\n \"\"\"dynamic Non-Maximum Suppression\"\"\"\n torch.set_grad_enabled(False)\n\n class NonMaxSupression(Module):\n def __init__(self, iou_thres):\n super().__init__()\n self.iou_threshold = iou_thres\n\n def forward(self, *args):\n return torchvision.ops.nms(args[0], args[1], self.iou_threshold)\n\n # Generate random input data\n def _gen_rand_inputs(num_boxes):\n box_len = 4\n boxes = torch.rand(num_boxes, box_len, dtype=torch.float) * 0.5\n boxes[:, 2] += boxes[:, 0]\n boxes[:, 3] += boxes[:, 1]\n scores = torch.from_numpy(np.random.uniform(-1, 1, size=(num_boxes,)).astype(np.float32))\n return boxes, scores\n\n targets = [\"llvm\", \"cuda\"]\n\n for num_boxes, iou_thres in [(10, 0.3), (100, 0.5), (500, 0.9)]:\n in_boxes, in_scores = _gen_rand_inputs(num_boxes)\n verify_trace_model(NonMaxSupression(iou_thres), [in_boxes, in_scores], targets)\n\n\ndef test_forward_roi_align():\n \"\"\"ROI align\"\"\"\n torch.set_grad_enabled(False)\n\n class ROIAlign(Module):\n def __init__(self, output_sizes, spatial_scale=1.0, sampling_ratio=-1):\n super().__init__()\n self.spatial_scale = spatial_scale\n self.sampling_ratio = sampling_ratio\n self.output_sizes = output_sizes\n\n def forward(self, *args):\n return torchvision.ops.roi_align(\n args[0],\n args[1],\n self.output_sizes,\n self.spatial_scale,\n self.sampling_ratio,\n )\n\n in_data = torch.Tensor(np.random.uniform(size=(1, 8, 100, 100)))\n in_boxes = torch.Tensor(np.random.uniform(0.0, 100.0, size=(35, 4)))\n in_batch = torch.zeros((35, 1), dtype=torch.float)\n in_boxes = torch.cat([in_batch, in_boxes], dim=1)\n\n verify_model(ROIAlign(7), [in_data, in_boxes])\n verify_model(ROIAlign((10, 10), 0.7, 5), [in_data, in_boxes])\n verify_model(ROIAlign(15, 0.9, 3), [in_data, in_boxes])\n\n\[email protected]_gpu\ndef test_conv3d():\n for ishape in [(1, 32, 16, 16, 16), (1, 32, 9, 15, 15), (1, 32, 13, 7, 7)]:\n inp = torch.rand(ishape)\n verify_model(torch.nn.Conv3d(32, 16, (3, 3, 3), padding=(1, 1, 1)).eval(), inp),\n verify_model(torch.nn.Conv3d(32, 16, (5, 5, 5), padding=(2, 2, 2)).eval(), inp),\n verify_model(torch.nn.Conv3d(32, 16, kernel_size=1).eval(), inp)\n # downsample\n verify_model(torch.nn.Conv3d(32, 16, kernel_size=1, stride=2).eval(), inp)\n\n\[email protected]_gpu\ndef test_conv3d_transpose():\n for ishape in [(1, 8, 10, 5, 10), (1, 8, 5, 8, 8), (1, 8, 13, 7, 7)]:\n inp = torch.rand(ishape)\n verify_model(\n torch.nn.ConvTranspose3d(\n in_channels=8, out_channels=33, kernel_size=3, stride=2\n ).eval(),\n inp,\n ),\n verify_model(\n torch.nn.ConvTranspose3d(\n in_channels=8,\n out_channels=20,\n kernel_size=(3, 5, 2),\n stride=(2, 1, 1),\n padding=(0, 4, 2),\n ).eval(),\n inp,\n ),\n verify_model(\n torch.nn.ConvTranspose3d(in_channels=8, out_channels=20, kernel_size=1).eval(), inp\n )\n verify_model(\n torch.nn.ConvTranspose3d(in_channels=8, out_channels=5, kernel_size=1, stride=2).eval(),\n inp,\n )\n\n\n# Model tests\[email protected]_gpu\ndef test_resnet18():\n torch.set_grad_enabled(False)\n verify_model(\"resnet18\", atol=1e-4, rtol=1e-4)\n\n\[email protected]_gpu\ndef test_squeezenet1_0():\n torch.set_grad_enabled(False)\n verify_model(\"squeezenet1_0\", atol=1e-4, rtol=1e-4)\n\n\[email protected]_gpu\ndef test_squeezenet1_1():\n torch.set_grad_enabled(False)\n verify_model(\"squeezenet1_1\", atol=1e-4, rtol=1e-4)\n\n\[email protected]_gpu\ndef test_densenet121():\n torch.set_grad_enabled(False)\n verify_model(\"densenet121\", atol=1e-4, rtol=1e-4)\n\n\[email protected]_gpu\ndef test_inception_v3():\n torch.set_grad_enabled(False)\n verify_model(\"inception_v3\", atol=1e-4, rtol=1e-4)\n\n\[email protected]_gpu\ndef test_googlenet():\n torch.set_grad_enabled(False)\n verify_model(\"googlenet\", atol=1e-4, rtol=1e-4)\n\n\[email protected]_gpu\ndef test_mnasnet0_5():\n torch.set_grad_enabled(False)\n verify_model(\"mnasnet0_5\", atol=1e-4, rtol=1e-4)\n\n\[email protected]_gpu\ndef test_mobilenet_v2():\n torch.set_grad_enabled(False)\n verify_model(\"mobilenet_v2\", atol=1e-4, rtol=1e-4)\n\n\n\"\"\"\n#TODO: Fix VGG and AlexNet issues (probably due to pooling)\[email protected]_gpu\ndef test_alexnet():\n torch.set_grad_enabled(False)\n verify_model(\"alexnet\")\n\[email protected]_gpu\ndef test_vgg11():\n torch.set_grad_enabled(False)\n verify_model(\"vgg11\")\n\[email protected]_gpu\ndef test_vgg11_bn():\n torch.set_grad_enabled(False)\n verify_model(\"vgg11_bn\")\n\"\"\"\n\n\[email protected]_gpu\ndef test_custom_conversion_map():\n def get_roi_align():\n pool_size = 5\n n_channels = 2 * (pool_size ** 2)\n x = torch.rand(2, n_channels, 10, 10)\n rois = torch.tensor(\n [\n [0, 0, 0, 9, 9], # format is (xyxy)\n [0, 0, 5, 4, 9],\n [0, 5, 5, 9, 9],\n [1, 0, 0, 9, 9],\n ],\n dtype=torch.float,\n )\n roi_align = torchvision.ops.RoIAlign(pool_size, spatial_scale=1, sampling_ratio=-1)\n return roi_align.eval(), [x, rois]\n\n def convert_roi_align():\n def _impl(inputs, input_types):\n spatial_scale = inputs[2]\n pooled_size = (inputs[3], inputs[4])\n sampling_ratio = inputs[5]\n return relay.op.vision.roi_align(\n inputs[0], inputs[1], pooled_size, spatial_scale, sampling_ratio\n )\n\n return _impl\n\n custom_map = {\"torchvision::roi_align\": convert_roi_align()}\n model, inputs = get_roi_align()\n\n verify_model(model, inputs, custom_map)\n\n\[email protected]_gpu\ndef test_segmentation_models():\n class SegmentationModelWrapper(Module):\n def __init__(self, model):\n super().__init__()\n self.model = model\n\n def forward(self, inp):\n out = self.model(inp)\n return out[\"out\"]\n\n fcn = torchvision.models.segmentation.fcn_resnet101(pretrained=True)\n deeplab = torchvision.models.segmentation.deeplabv3_resnet101(pretrained=True)\n\n inp = [torch.rand((1, 3, 300, 300), dtype=torch.float)]\n\n verify_model(SegmentationModelWrapper(fcn.eval()), inp, atol=1e-4, rtol=1e-4)\n verify_model(SegmentationModelWrapper(deeplab.eval()), inp, atol=1e-4, rtol=1e-4)\n\n\[email protected]_gpu\ndef test_3d_models():\n input_shape = (1, 3, 4, 56, 56)\n resnet3d = torchvision.models.video.r3d_18(pretrained=True).eval()\n verify_model(resnet3d, [torch.rand(input_shape)], atol=1e-4, rtol=1e-4)\n\n\ndef _get_default_vm_targets():\n return [tgt for (tgt, _) in tvm.testing.enabled_targets()]\n\n\ndef verify_script_model(pt_model, ishapes, targets, idtype=None):\n script_module = torch.jit.script(pt_model)\n\n verify_model_vm(script_module, ishapes, idtype=idtype, targets=targets)\n\n\ndef verify_trace_model(pt_model, idata, targets):\n traced_model = torch.jit.trace(pt_model, idata)\n ishapes = [data.shape for data in idata]\n verify_model_vm(traced_model, ishapes, idata=idata, targets=targets)\n\n\ndef convert_pt_to_tvm_type(idtype):\n \"\"\"Accepts a pytorch dtype and returns string TVM dtype.\"\"\"\n # TVM does not support PyTorch complex dtypes\n if idtype == torch.float64:\n curr_dtype = \"float64\"\n elif idtype == torch.float32:\n curr_dtype = \"float32\"\n elif idtype == torch.float16:\n curr_dtype = \"float16\"\n elif idtype == torch.bfloat16:\n curr_dtype = \"bfloat16\"\n elif idtype == torch.int64:\n curr_dtype = \"int64\"\n elif idtype == torch.int32:\n curr_dtype = \"int32\"\n elif idtype == torch.int16:\n curr_dtype = \"int16\"\n elif idtype == torch.int8:\n curr_dtype = \"int8\"\n elif idtype == torch.uint8:\n curr_dtype = \"uint8\"\n elif idtype == torch.bool:\n curr_dtype = \"bool\"\n else:\n raise NotImplementedError(\"Unsupported dtype: {}\".format(idtype))\n return curr_dtype\n\n\ndef verify_model_vm(input_model, ishapes, idtype=None, idata=None, targets=[\"llvm\"]):\n if not idtype:\n idtype = torch.float\n\n input_names = [\"i{}\".format(idx) for idx, ish in enumerate(ishapes)]\n tvm_dtype = convert_pt_to_tvm_type(idtype)\n input_dtypes = [tvm_dtype] * len(input_names)\n input_shapes = list(zip(input_names, list(zip(ishapes, input_dtypes))))\n\n if idata:\n input_data = idata\n # If no input_data provided, generate random data of specified dtype\n else:\n if idtype == torch.bool:\n input_data = [\n torch.Tensor.bool(torch.randint(low=0, high=2, size=shape)) for shape in ishapes\n ]\n # Torch dtype can be float, complex, int, or Bool. Complex not supported, so if not float or Bool,\n # dtype must be int!\n elif not idtype.is_floating_point:\n input_data = [\n torch.randint(low=0, high=10, size=shape, dtype=idtype) for shape in ishapes\n ]\n else:\n input_data = [torch.randn(shape, dtype=idtype) for shape in ishapes]\n\n # Compile via VM\n mod, params = relay.frontend.from_pytorch(input_model, input_shapes)\n\n for tgt in targets:\n print(\"Running on target\", tgt)\n dev = tvm.device(tgt, 0)\n\n executor = relay.create_executor(\"vm\", mod=mod, device=dev, target=tgt)\n evaluator = executor.evaluate()\n\n # Inference\n for name, inp in zip(input_names, input_data):\n params[name] = inp.numpy()\n vm_res = evaluator(**params)\n\n # Baseline result\n with torch.no_grad():\n pt_result = input_model(*input_data)\n\n # Verify the accuracy\n if isinstance(pt_result, tuple):\n # handle multiple outputs\n for i in range(len(pt_result)):\n tvm_res = vm_res[i].numpy()\n tvm.testing.assert_allclose(tvm_res, pt_result[i].numpy(), rtol=1e-5, atol=1e-5)\n elif not isinstance(pt_result, torch.Tensor):\n tvm_res = vm_res.numpy().item()\n assert pt_result == tvm_res\n else:\n tvm.testing.assert_allclose(vm_res.numpy(), pt_result.numpy(), rtol=1e-5, atol=1e-5)\n\n\[email protected]_gpu\ndef test_control_flow():\n class SimpleIf(torch.nn.Module):\n def __init__(self, N, M):\n super().__init__()\n self.weight = torch.nn.Parameter(torch.rand(N, M))\n\n def forward(self, inp):\n if inp.sum() > 0.0:\n output = self.weight + inp\n else:\n output = self.weight - inp\n return output\n\n class NestedIf(torch.nn.Module):\n def __init__(self, N, M):\n super().__init__()\n self.weight = torch.nn.Parameter(torch.rand(N, M))\n\n def forward(self, inp):\n if inp.sum() > 0.0:\n if inp.mean() > 0.0:\n output = self.weight + inp\n else:\n output = self.weight - inp\n else:\n if inp.mean() >= 0.0:\n output = self.weight * inp\n else:\n output = self.weight / inp\n\n return output\n\n class ScalarLoop(torch.nn.Module):\n def forward(self, inp):\n a = 0\n for i in range(inp.size(0)):\n b = i * i\n b = b + 1\n a += b\n if a != 0:\n a += 1\n else:\n a += 2\n return a\n\n class SimpleLoop(torch.nn.Module):\n def forward(self, inp):\n a = inp\n for i in range(inp.size(0)):\n b = a * 2.0\n c = a + b\n a += c\n return a\n\n class LoopWithIf(torch.nn.Module):\n def forward(self, inp):\n a = inp\n for i in range(inp.size(0)):\n b = a * 2.0\n b = a + b\n if b.sum() > 0.0:\n a += b\n else:\n a -= b\n return a\n\n class NestedLoop(torch.nn.Module):\n def forward(self, inp):\n a = inp\n for i in range(inp.size(0)):\n b = a * float(i)\n for j in range(inp.size(1)):\n a += b * float(j)\n return a\n\n class SimpleScalarWhileLoop(torch.nn.Module):\n def forward(self, inp):\n a = 1\n i = 0\n while i <= inp.size(0):\n a += i\n i += 2\n i = 0\n # also test constant init cond\n while i < 10:\n a += i\n i += 3\n return a\n\n class SimpleWhileLoop(torch.nn.Module):\n def forward(self, inp):\n a = inp\n i = 0\n while i < inp.size(0):\n a += a * float(i) * 2.0\n i += 1\n return a\n\n models = [\n SimpleIf(10, 20),\n NestedIf(10, 20),\n ScalarLoop(),\n SimpleLoop(),\n LoopWithIf(),\n SimpleScalarWhileLoop(),\n SimpleWhileLoop(),\n NestedLoop(),\n ]\n\n for pt_model in models:\n verify_script_model(pt_model.eval(), [(10, 20)], _get_default_vm_targets())\n\n\[email protected]_gpu\ndef test_simple_rnn():\n # The mixed tracing and scripting example from\n # https://pytorch.org/tutorials/beginner/Intro_to_TorchScript_tutorial.html#mixing-scripting-and-tracing\n class DecisionGate(torch.nn.Module):\n def forward(self, x):\n if x.sum() > 0:\n return x\n else:\n return -x\n\n class Cell(torch.nn.Module):\n def __init__(self, dg):\n super(Cell, self).__init__()\n self.dg = dg\n self.linear = torch.nn.Linear(4, 4)\n\n def forward(self, x, h):\n new_h = torch.tanh(self.dg(self.linear(x)) + h)\n return new_h, new_h\n\n class RNNLoop(torch.nn.Module):\n def __init__(self):\n super().__init__()\n x = torch.rand(10, 4, dtype=torch.float)\n h = torch.rand(10, 4, dtype=torch.float)\n self.cell = torch.jit.trace(Cell(DecisionGate()), (x, h))\n\n def forward(self, xs):\n h = torch.zeros(10, 4, dtype=torch.float)\n y = torch.zeros(10, 4, dtype=torch.float)\n for i in range(xs.size(0)):\n y, h = self.cell(xs[i], h)\n return y\n\n verify_script_model(RNNLoop().eval(), [(10, 10, 4)], _get_default_vm_targets())\n\n\[email protected]_gpu\ndef test_forward_reduce_sum():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class ReduceSum1(Module):\n def forward(self, *args):\n return args[0].sum(1)\n\n class ReduceSum2(Module):\n def forward(self, *args):\n return args[0].sum(dim=1, keepdim=False)\n\n class ReduceSum3(Module):\n def forward(self, *args):\n return args[0].sum(dim=2, keepdim=True)\n\n class ReduceSum4(Module):\n def forward(self, *args):\n return args[0].sum(dim=(2, 3), keepdim=True)\n\n class ReduceSum5(Module):\n def forward(self, *args):\n return args[0].sum(dim=(2, 3), keepdim=False)\n\n input_data = torch.rand(input_shape).float()\n verify_model(ReduceSum1().float().eval(), input_data=input_data)\n verify_model(ReduceSum2().float().eval(), input_data=input_data)\n verify_model(ReduceSum3().float().eval(), input_data=input_data)\n verify_model(ReduceSum4().float().eval(), input_data=input_data)\n verify_model(ReduceSum5().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_reduce_prod():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class ReduceProd1(Module):\n def forward(self, *args):\n return args[0].prod(1)\n\n class ReduceProd2(Module):\n def forward(self, *args):\n return args[0].prod(dim=1, keepdim=False)\n\n class ReduceProd3(Module):\n def forward(self, *args):\n return args[0].prod(dim=2, keepdim=True)\n\n input_data = torch.rand(input_shape).float()\n verify_model(ReduceProd1().float().eval(), input_data=input_data)\n verify_model(ReduceProd2().float().eval(), input_data=input_data)\n verify_model(ReduceProd3().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_argmin():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class ArgMin1(Module):\n def forward(self, *args):\n return args[0].argmin(1)\n\n class ArgMin2(Module):\n def forward(self, *args):\n return args[0].argmin(dim=1, keepdim=False)\n\n class ArgMin3(Module):\n def forward(self, *args):\n return args[0].argmin(dim=2, keepdim=True)\n\n input_data = torch.rand(input_shape).float()\n verify_model(ArgMin1().float().eval(), input_data=input_data)\n verify_model(ArgMin2().float().eval(), input_data=input_data)\n verify_model(ArgMin3().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_argmax():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class ArgMax1(Module):\n def forward(self, *args):\n return args[0].argmax(1)\n\n class ArgMax2(Module):\n def forward(self, *args):\n return args[0].argmax(dim=1, keepdim=False)\n\n class ArgMax3(Module):\n def forward(self, *args):\n return args[0].argmax(dim=2, keepdim=True)\n\n input_data = torch.rand(input_shape).float()\n verify_model(ArgMax1().float().eval(), input_data=input_data)\n verify_model(ArgMax2().float().eval(), input_data=input_data)\n verify_model(ArgMax3().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_std():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class Std1(Module):\n def forward(self, *args):\n return args[0].std(1, unbiased=False)\n\n class Std2(Module):\n def forward(self, *args):\n return args[0].std(dim=1, keepdim=False, unbiased=False)\n\n class Std3(Module):\n def forward(self, *args):\n return args[0].std(dim=2, keepdim=True, unbiased=False)\n\n class Std4(Module):\n def forward(self, *args):\n return args[0].std(dim=(2, 3), keepdim=True, unbiased=False)\n\n class Std5(Module):\n def forward(self, *args):\n return args[0].std(dim=(2, 3), keepdim=False, unbiased=False)\n\n class Std6(Module):\n def forward(self, *args):\n return args[0].std(unbiased=False)\n\n class Std7(Module):\n def forward(self, *args):\n return args[0].std(dim=1, keepdim=False, unbiased=True)\n\n class Std8(Module):\n def forward(self, *args):\n return args[0].std(dim=(2, 3), keepdim=True, unbiased=True)\n\n class Std9(Module):\n def forward(self, *args):\n return args[0].std(unbiased=True)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Std1().float().eval(), input_data=input_data)\n verify_model(Std2().float().eval(), input_data=input_data)\n verify_model(Std3().float().eval(), input_data=input_data)\n verify_model(Std4().float().eval(), input_data=input_data)\n verify_model(Std5().float().eval(), input_data=input_data)\n verify_model(Std6().float().eval(), input_data=input_data)\n verify_model(Std7().float().eval(), input_data=input_data)\n verify_model(Std8().float().eval(), input_data=input_data)\n verify_model(Std9().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_variance():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class Variance1(Module):\n def forward(self, *args):\n return args[0].var(1, unbiased=False)\n\n class Variance2(Module):\n def forward(self, *args):\n return args[0].var(dim=1, keepdim=False, unbiased=False)\n\n class Variance3(Module):\n def forward(self, *args):\n return args[0].var(dim=2, keepdim=True, unbiased=False)\n\n class Variance4(Module):\n def forward(self, *args):\n return args[0].var(dim=(2, 3), keepdim=True, unbiased=False)\n\n class Variance5(Module):\n def forward(self, *args):\n return args[0].var(dim=(2, 3), keepdim=False, unbiased=False)\n\n class Variance6(Module):\n def forward(self, *args):\n return args[0].var(unbiased=False)\n\n class Variance7(Module):\n def forward(self, *args):\n return args[0].var(dim=1, keepdim=False, unbiased=True)\n\n class Variance8(Module):\n def forward(self, *args):\n return args[0].var(dim=(2, 3), keepdim=True, unbiased=True)\n\n class Variance9(Module):\n def forward(self, *args):\n return args[0].var(unbiased=True)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Variance1().float().eval(), input_data=input_data)\n verify_model(Variance2().float().eval(), input_data=input_data)\n verify_model(Variance3().float().eval(), input_data=input_data)\n verify_model(Variance4().float().eval(), input_data=input_data)\n verify_model(Variance5().float().eval(), input_data=input_data)\n verify_model(Variance6().float().eval(), input_data=input_data)\n verify_model(Variance7().float().eval(), input_data=input_data)\n verify_model(Variance8().float().eval(), input_data=input_data)\n verify_model(Variance9().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_rsub():\n torch.set_grad_enabled(False)\n\n class Rsub1(Module):\n def forward(self, *args):\n return torch.rsub(args[0], args[1])\n\n class Rsub2(Module):\n def forward(self, *args):\n return torch.rsub(args[0], args[1], alpha=0.5)\n\n d1 = torch.rand([1, 3]).float()\n d2 = torch.rand([1, 3]).float()\n d3 = torch.rand([1, 3]).int()\n verify_model(Rsub1().float().eval(), input_data=[d1, d2])\n verify_model(Rsub1().float().eval(), input_data=[d1, d3])\n verify_model(Rsub2().float().eval(), input_data=[d1, d2])\n verify_model(Rsub2().float().eval(), input_data=[d1, d3])\n\n\[email protected]_gpu\ndef test_forward_embedding():\n torch.set_grad_enabled(False)\n\n input_data = torch.randint(0, 10, [2, 4]).long()\n verify_model(torch.nn.Embedding(10, 3).float().eval(), input_data=input_data)\n\n input_data = torch.randint(0, 4, [2, 3, 4]).long()\n verify_model(torch.nn.Embedding(4, 5, sparse=False).float().eval(), input_data=input_data)\n\n input_data = torch.randint(0, 4, [2, 3, 4]).long()\n verify_model(torch.nn.Embedding(4, 5, sparse=True).float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_onehot():\n torch.set_grad_enabled(False)\n\n class OneHot1(Module):\n def forward(self, *args):\n return torch.nn.functional.one_hot(args[0], num_classes=3)\n\n class OneHot2(Module):\n def forward(self, *args):\n return torch.nn.functional.one_hot(args[0], num_classes=5)\n\n input_data = torch.arange(0, 5) % 3\n verify_model(OneHot1().float().eval(), input_data=input_data)\n\n input_data = torch.arange(0, 5) % 4\n verify_model(OneHot2().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_isfinite():\n torch.set_grad_enabled(False)\n\n class IsFinite1(Module):\n def forward(self, *args):\n return torch.isfinite(args[0])\n\n input_data = torch.tensor([1, float(\"inf\"), 2, float(\"-inf\"), float(\"nan\")]).float()\n verify_model(IsFinite1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_isnan():\n torch.set_grad_enabled(False)\n\n class IsNan1(Module):\n def forward(self, *args):\n return torch.isnan(args[0])\n\n input_data = torch.tensor([1, float(\"inf\"), 2, float(\"-inf\"), float(\"nan\")]).float()\n verify_model(IsNan1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_isinf():\n torch.set_grad_enabled(False)\n\n class IsInf1(Module):\n def forward(self, *args):\n return torch.isinf(args[0])\n\n input_data = torch.tensor([1, float(\"inf\"), 2, float(\"-inf\"), float(\"nan\")]).float()\n verify_model(IsInf1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_clamp():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class Clamp1(Module):\n def forward(self, *args):\n return torch.clamp(args[0], min=-0.5, max=0.5)\n\n class Clamp2(Module):\n def forward(self, *args):\n return torch.clamp(args[0], min=-0.3)\n\n class Clamp3(Module):\n def forward(self, *args):\n return torch.clamp(args[0], max=1.0)\n\n class Clamp_MinExpr_MaxConstant(Module):\n def forward(self, *args):\n h, w = args[0].shape[2:]\n amin = h / 100.0\n return torch.clamp(args[0], min=amin, max=w)\n\n input_data = torch.rand(input_shape).float()\n verify_model(Clamp1().float().eval(), input_data=input_data)\n verify_model(Clamp2().float().eval(), input_data=input_data)\n verify_model(Clamp3().float().eval(), input_data=input_data)\n verify_model(Clamp_MinExpr_MaxConstant().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_clamp_():\n torch.set_grad_enabled(False)\n\n class ClampInPlace(Module):\n def __init__(self, min, max):\n super(ClampInPlace, self).__init__()\n self.min = min\n self.max = max\n\n def forward(self, *args):\n return torch.clamp_(args[0], self.min, self.max)\n\n for ishape, min, max in (([4, 8], 0.1, 0.9), ([7, 6], 0.2, 0.5)):\n input_data = torch.rand(ishape).float()\n verify_model(ClampInPlace(min, max).float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_ones():\n torch.set_grad_enabled(False)\n\n class Ones1(Module):\n def forward(self, *args):\n return torch.ones(2, 3)\n\n verify_model(Ones1().float().eval(), input_data=[])\n\n\[email protected]_gpu\ndef test_forward_ones_like():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class OnesLike1(Module):\n def forward(self, *args):\n return torch.ones_like(args[0])\n\n class OnesLike2(Module):\n def forward(self, *args):\n return torch.ones_like(args[0], dtype=torch.int8)\n\n class OnesLike3(Module):\n def forward(self, *args):\n return torch.ones_like(args[0], dtype=torch.float)\n\n input_data = torch.rand(input_shape).float()\n verify_model(OnesLike1().float().eval(), input_data=input_data)\n verify_model(OnesLike2().float().eval(), input_data=input_data)\n verify_model(OnesLike3().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_zeros():\n torch.set_grad_enabled(False)\n\n class Zeros1(Module):\n def forward(self, *args):\n return torch.zeros(2, 3)\n\n verify_model(Zeros1().float().eval(), input_data=[])\n\n\[email protected]_gpu\ndef test_forward_zeros_like():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class ZerosLike1(Module):\n def forward(self, *args):\n return torch.zeros_like(args[0])\n\n class ZerosLike2(Module):\n def forward(self, *args):\n return torch.zeros_like(args[0], dtype=torch.int32)\n\n class ZerosLike3(Module):\n def forward(self, *args):\n return torch.zeros_like(args[0], dtype=torch.float)\n\n input_data = torch.rand(input_shape).float()\n verify_model(ZerosLike1().float().eval(), input_data=input_data)\n verify_model(ZerosLike2().float().eval(), input_data=input_data)\n verify_model(ZerosLike3().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_full():\n torch.set_grad_enabled(False)\n\n class Full1(Module):\n def forward(self, *args):\n return torch.full((2, 3), 3.14)\n\n class Full2(Module):\n def forward(self, *args):\n return torch.full((1, 2, 3), 1.0, dtype=torch.int32)\n\n verify_model(Full1().float().eval(), input_data=[])\n verify_model(Full2().float().eval(), input_data=[])\n\n\[email protected]_gpu\ndef test_forward_full_like():\n torch.set_grad_enabled(False)\n input_shape = [1, 3, 10, 10]\n\n class FullLike1(Module):\n def forward(self, *args):\n return torch.full_like(args[0], 3.14)\n\n class FullLike2(Module):\n def forward(self, *args):\n return torch.full_like(args[0], 22.22, dtype=torch.int32)\n\n class FullLike3(Module):\n def forward(self, *args):\n return torch.full_like(args[0], 1.4, dtype=torch.float)\n\n input_data = torch.rand(input_shape).float()\n verify_model(FullLike1().float().eval(), input_data=input_data)\n verify_model(FullLike2().float().eval(), input_data=input_data)\n verify_model(FullLike3().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_linspace():\n torch.set_grad_enabled(False)\n\n class Linspace1(Module):\n def forward(self, *args):\n return torch.linspace(5, 10, steps=100)\n\n class Linspace2(Module):\n def forward(self, *args):\n return torch.linspace(-10, 10, steps=5)\n\n class Linspace3(Module):\n def forward(self, *args):\n return torch.linspace(start=-10, end=10, steps=5)\n\n class Linspace4(Module):\n def forward(self, *args):\n return torch.linspace(start=-10, end=10, steps=1)\n\n class Linspace5(Module):\n def forward(self, *args):\n return torch.linspace(1, 2, 1, dtype=torch.int32)\n\n class Linspace6(Module):\n def forward(self, *args):\n return torch.linspace(start=1, end=6, steps=2)\n\n class Linspace7(Module):\n def forward(self, *args):\n return torch.linspace(1, 4, steps=100, dtype=torch.float32)\n\n class Linspace8(Module):\n def forward(self, *args):\n return torch.linspace(1, 2, 1, dtype=torch.int16)\n\n verify_model(Linspace1().float().eval())\n verify_model(Linspace2().float().eval())\n verify_model(Linspace3().float().eval())\n verify_model(Linspace4().float().eval())\n verify_model(Linspace5().float().eval())\n verify_model(Linspace6().float().eval())\n verify_model(Linspace7().float().eval())\n verify_model(Linspace8().float().eval())\n\n\[email protected]_gpu\ndef test_forward_take():\n torch.set_grad_enabled(False)\n\n class Take1(Module):\n def forward(self, *args):\n indices = torch.tensor([[0, 0], [1, 0]])\n if torch.cuda.is_available():\n indices = indices.cuda()\n return torch.take(args[0], indices)\n\n class Take2(Module):\n def forward(self, *args):\n return torch.take(args[0], args[1])\n\n input_data = torch.tensor([[1, 2], [3, 4]])\n verify_model(Take1().float().eval(), input_data=input_data)\n indices = torch.tensor([[0, 0], [1, 0]])\n verify_model(Take2().float().eval(), input_data=[input_data, indices])\n indices = torch.tensor([0, -1])\n verify_model(Take2().float().eval(), input_data=[input_data, indices])\n\n\[email protected]_gpu\ndef test_forward_topk():\n torch.set_grad_enabled(False)\n\n class Topk1(Module):\n def forward(self, *args):\n return torch.topk(args[0], k=3)\n\n class Topk2(Module):\n def forward(self, *args):\n return torch.topk(args[0], k=3, dim=-2)\n\n class Topk3(Module):\n def forward(self, *args):\n return torch.topk(args[0], k=3, dim=3)\n\n class Topk4(Module):\n def forward(self, *args):\n return torch.topk(args[0], k=3, largest=True)\n\n class Topk5(Module):\n def forward(self, *args):\n return torch.topk(args[0], k=3, largest=False)\n\n class Topk6(Module):\n def forward(self, *args):\n return torch.topk(args[0], k=3, sorted=True)\n\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(Topk1().float().eval(), input_data=input_data)\n verify_model(Topk2().float().eval(), input_data=input_data)\n verify_model(Topk3().float().eval(), input_data=input_data)\n verify_model(Topk4().float().eval(), input_data=input_data)\n verify_model(Topk5().float().eval(), input_data=input_data)\n verify_model(Topk6().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_logical_not():\n torch.set_grad_enabled(False)\n\n class LogicalNot1(Module):\n def forward(self, *args):\n return torch.logical_not(args[0])\n\n input_data = torch.tensor([True, False])\n verify_model(LogicalNot1().float().eval(), input_data=input_data)\n\n input_data = torch.tensor([0, 1, -10], dtype=torch.int8)\n verify_model(LogicalNot1().float().eval(), input_data=input_data)\n\n input_data = torch.tensor([0.0, 1.5, -10.0], dtype=torch.double)\n verify_model(LogicalNot1().float().eval(), input_data=input_data)\n\n input_data = torch.tensor([0.0, 1.0, -10.0], dtype=torch.int32)\n verify_model(LogicalNot1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_bitwise_not():\n torch.set_grad_enabled(False)\n\n class BitwiseNot1(Module):\n def forward(self, *args):\n return torch.bitwise_not(args[0])\n\n input_data = torch.tensor([0, 1, -10], dtype=torch.int8)\n verify_model(BitwiseNot1().float().eval(), input_data=input_data)\n\n input_data = torch.tensor([0.0, 1.0, -10.0], dtype=torch.int32)\n verify_model(BitwiseNot1().float().eval(), input_data=input_data)\n\n input_data = torch.tensor([True, False])\n verify_model(BitwiseNot1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_bitwise_xor():\n torch.set_grad_enabled(False)\n\n class BitwiseXor1(Module):\n def forward(self, *args):\n return torch.bitwise_xor(args[0], args[1])\n\n class BitwiseXor2(Module):\n def forward(self, *args):\n rhs = torch.tensor([1, 0, 3], dtype=torch.int8)\n if torch.cuda.is_available():\n rhs = rhs.cuda()\n return torch.bitwise_xor(args[0], rhs)\n\n lhs = torch.tensor([-1, -2, 3], dtype=torch.int8)\n rhs = torch.tensor([1, 0, 3], dtype=torch.int8)\n verify_model(BitwiseXor1().float().eval(), input_data=[lhs, rhs])\n\n lhs = torch.tensor([True, True, False])\n rhs = torch.tensor([False, True, False])\n verify_model(BitwiseXor1().float().eval(), input_data=[lhs, rhs])\n\n lhs = torch.tensor([-1, -2, 3], dtype=torch.int8)\n verify_model(BitwiseXor2().float().eval(), input_data=[lhs])\n\n\[email protected]_gpu\ndef test_forward_logical_xor():\n torch.set_grad_enabled(False)\n\n class LogicalXor1(Module):\n def forward(self, *args):\n return torch.logical_xor(args[0], args[1])\n\n class LogicalXor2(Module):\n def forward(self, *args):\n rhs = torch.tensor([1, 0, 3], dtype=torch.int8)\n if torch.cuda.is_available():\n rhs = rhs.cuda()\n return torch.logical_xor(args[0], rhs)\n\n lhs = torch.tensor([-1, -2, 3], dtype=torch.int8)\n rhs = torch.tensor([1, 0, 3], dtype=torch.int8)\n verify_model(LogicalXor1().float().eval(), input_data=[lhs, rhs])\n\n lhs = torch.tensor([True, True, False])\n rhs = torch.tensor([False, True, False])\n verify_model(LogicalXor1().float().eval(), input_data=[lhs, rhs])\n\n lhs = torch.tensor([-1, -2, 3], dtype=torch.int8)\n verify_model(LogicalXor2().float().eval(), input_data=[lhs])\n\n\[email protected]_gpu\ndef test_forward_unary():\n torch.set_grad_enabled(False)\n\n class Sqrt1(Module):\n def forward(self, *args):\n return torch.sqrt(args[0])\n\n class RSqrt1(Module):\n def forward(self, *args):\n return torch.rsqrt(args[0])\n\n class Ceil1(Module):\n def forward(self, *args):\n return torch.ceil(args[0])\n\n class Floor1(Module):\n def forward(self, *args):\n return torch.floor(args[0])\n\n class Round1(Module):\n def forward(self, *args):\n return torch.round(args[0])\n\n class Cos1(Module):\n def forward(self, *args):\n return torch.cos(args[0])\n\n class Sin1(Module):\n def forward(self, *args):\n return torch.sin(args[0])\n\n class Tan1(Module):\n def forward(self, *args):\n return torch.tan(args[0])\n\n class Tanh1(Module):\n def forward(self, *args):\n return torch.tanh(args[0])\n\n class Acos1(Module):\n def forward(self, *args):\n return torch.acos(args[0])\n\n class Asin1(Module):\n def forward(self, *args):\n return torch.asin(args[0])\n\n class Atan1(Module):\n def forward(self, *args):\n return torch.atan(args[0])\n\n class Log1(Module):\n def forward(self, *args):\n return torch.log(args[0])\n\n class Exp1(Module):\n def forward(self, *args):\n return torch.exp(args[0])\n\n class Erf1(Module):\n def forward(self, *args):\n return torch.erf(args[0])\n\n class Trunc1(Module):\n def forward(self, *args):\n return torch.trunc(args[0])\n\n class Sign1(Module):\n def forward(self, *args):\n return torch.sign(args[0])\n\n class Neg1(Module):\n def forward(self, *args):\n return torch.neg(args[0])\n\n class Sinh1(Module):\n def forward(self, *args):\n return torch.sinh(args[0])\n\n class Cosh1(Module):\n def forward(self, *args):\n return torch.cosh(args[0])\n\n class Log2_1(Module):\n def forward(self, *args):\n return torch.log2(args[0])\n\n class Log10_1(Module):\n def forward(self, *args):\n return torch.log10(args[0])\n\n class Log1p_1(Module):\n def forward(self, *args):\n return torch.log1p(args[0])\n\n input_shape = [1, 3, 10, 10]\n input_data = torch.rand(input_shape).float()\n verify_model(Sqrt1().float().eval(), input_data=input_data)\n verify_model(RSqrt1().float().eval(), input_data=input_data)\n verify_model(Ceil1().float().eval(), input_data=input_data)\n verify_model(Floor1().float().eval(), input_data=input_data)\n verify_model(Round1().float().eval(), input_data=input_data)\n verify_model(Cos1().float().eval(), input_data=input_data)\n verify_model(Cosh1().float().eval(), input_data=input_data)\n verify_model(Sin1().float().eval(), input_data=input_data)\n verify_model(Sinh1().float().eval(), input_data=input_data)\n verify_model(Tan1().float().eval(), input_data=input_data)\n verify_model(Tanh1().float().eval(), input_data=input_data)\n verify_model(Acos1().float().eval(), input_data=input_data)\n verify_model(Asin1().float().eval(), input_data=input_data)\n verify_model(Atan1().float().eval(), input_data=input_data)\n verify_model(Log1().float().eval(), input_data=input_data)\n verify_model(Log2_1().float().eval(), input_data=input_data)\n verify_model(Log10_1().float().eval(), input_data=input_data)\n verify_model(Log1p_1().float().eval(), input_data=input_data)\n verify_model(Exp1().float().eval(), input_data=input_data)\n verify_model(Erf1().float().eval(), input_data=input_data)\n verify_model(Trunc1().float().eval(), input_data=input_data)\n verify_model(Sign1().float().eval(), input_data=input_data)\n verify_model(Neg1().float().eval(), input_data=input_data)\n\n\[email protected]_gpu\ndef test_forward_where():\n torch.set_grad_enabled(False)\n\n class Where1(Module):\n def forward(self, *args):\n y = torch.ones([3, 2])\n if torch.cuda.is_available():\n y = y.cuda()\n return torch.where(args[0] > 0, args[0], y)\n\n class Where2(Module):\n def forward(self, *args):\n return torch.where(args[0] > 0, args[0], args[1])\n\n class Where3(Module):\n def forward(self, *args):\n return torch.where(args[0])[0]\n\n x = torch.rand([3, 2]).float()\n verify_model(Where1(), input_data=[x])\n y = torch.rand([3, 2])\n verify_model(Where2(), input_data=[x, y])\n\n # a single argument variant, equivalent to torch.nonzero(..., as_tuple=True)\n inp = torch.rand([10])\n inp[3:8] = 0\n verify_trace_model(Where3(), [inp], [\"llvm\"])\n\n\[email protected]_gpu\ndef test_forward_addcdiv():\n torch.set_grad_enabled(False)\n\n class Addcdiv1(Module):\n def forward(self, *args):\n t1 = torch.ones([3, 1])\n t2 = torch.ones([1, 3])\n if torch.cuda.is_available():\n t1 = t1.cuda()\n t2 = t2.cuda()\n return torch.addcdiv(args[0], 0.1, t1, t2)\n\n class Addcdiv2(Module):\n def forward(self, *args):\n return torch.addcdiv(args[0], 0.5, args[1], args[2])\n\n input_data = torch.rand([1, 3]).float()\n verify_model(Addcdiv1().float().eval(), input_data=input_data)\n t1 = torch.rand([3, 1]).float()\n t2 = torch.rand([1, 3]).float()\n verify_model(Addcdiv2().float().eval(), input_data=[input_data, t1, t2])\n\n\[email protected]_gpu\ndef test_forward_addcmul():\n torch.set_grad_enabled(False)\n\n class Addcmul1(Module):\n def forward(self, *args):\n t1 = torch.ones([3, 1])\n t2 = torch.ones([1, 3])\n if torch.cuda.is_available():\n t1 = t1.cuda()\n t2 = t2.cuda()\n return torch.addcmul(args[0], 0.1, t1, t2)\n\n class Addcmul2(Module):\n def forward(self, *args):\n return torch.addcmul(args[0], 0.5, args[1], args[2])\n\n input_data = torch.rand([1, 3]).float()\n verify_model(Addcmul1().float().eval(), input_data=input_data)\n t1 = torch.rand([3, 1]).float()\n t2 = torch.rand([1, 3]).float()\n verify_model(Addcmul2().float().eval(), input_data=[input_data, t1, t2])\n\n\[email protected]_gpu\ndef test_forward_true_divide():\n if package_version.parse(torch.__version__) < package_version.parse(\"1.5.0\"):\n return\n torch.set_grad_enabled(False)\n\n class TrueDivide(Module):\n def forward(self, *args):\n return torch.true_divide(args[0], args[1])\n\n dividend = torch.rand([5, 3]).float()\n # divisor could be either tensor or scalar\n divisor_tensor = torch.rand([5, 3]).float() + 0.5\n divisor_scalar = torch.tensor(1.0, dtype=torch.float32)\n verify_model(\n TrueDivide().float().eval(), input_data=[dividend, divisor_tensor], atol=1e-4, rtol=1e-4\n )\n verify_model(\n TrueDivide().float().eval(), input_data=[dividend, divisor_scalar], atol=1e-4, rtol=1e-4\n )\n\n\[email protected]_gpu\ndef test_forward_is_floating_point():\n torch.set_grad_enabled(False)\n\n class IsFloatingPoint(Module):\n def forward(self, arg):\n # `torch.jit.trace` cannot accept something that outputs\n # a Bool, so `torch.jit.script` will be used instead\n return torch.is_floating_point(arg)\n\n targets = _get_default_vm_targets()\n verify_script_model(IsFloatingPoint(), [(1, 1)], targets, idtype=torch.float64)\n verify_script_model(IsFloatingPoint(), [(1, 1)], targets, idtype=torch.float32)\n verify_script_model(IsFloatingPoint(), [(1, 1)], targets, idtype=torch.float16)\n # todo(dvisnty): Run the test for bfloat16 when full bfloat16 support is implemented\n # verify_script_model(IsFloatingPoint(), [(1,1)], targets, idtype=torch.bfloat16)\n verify_script_model(IsFloatingPoint(), [(1, 1)], targets, idtype=torch.int64)\n verify_script_model(IsFloatingPoint(), [(1, 1)], targets, idtype=torch.int32)\n verify_script_model(IsFloatingPoint(), [(1, 1)], targets, idtype=torch.int16)\n verify_script_model(IsFloatingPoint(), [(1, 1)], targets, idtype=torch.int8)\n verify_script_model(IsFloatingPoint(), [(1, 1)], targets, idtype=torch.uint8)\n\n\[email protected]_gpu\ndef test_forward_traced_function():\n def fn(t1, t2):\n return t1 + t2\n\n tensor1 = torch.randn(3, 4)\n tensor2 = torch.randn(3, 4)\n verify_model(fn, input_data=[tensor1, tensor2])\n\n\[email protected]_gpu\ndef test_forward_dtypes():\n def fn(t1, t2):\n return 2.5 * t1 + t2\n\n for dt in [torch.int32, torch.int64, torch.double]:\n tensor1 = torch.randn(3, 4).to(dtype=dt)\n tensor2 = torch.randn(3, 4).to(dtype=dt)\n verify_model(fn, input_data=[tensor1, tensor2])\n\n class ModuleWithIntParameters(Module):\n def __init__(self, arr):\n super().__init__()\n self.param = torch.nn.Parameter(torch.LongTensor(arr), requires_grad=False)\n\n def forward(self, x):\n return x.long() + self.param\n\n shape = (10, 10)\n param = torch.ones(shape, dtype=torch.long)\n inp = torch.ones(shape, dtype=torch.int)\n verify_model(ModuleWithIntParameters(param), input_data=inp)\n\n\[email protected]_gpu\ndef test_weight_names():\n tm = torch.jit.trace(torch.nn.Linear(3, 4), [torch.randn(2, 3)])\n mod, params = relay.frontend.from_pytorch(tm, [(\"input\", (2, 3))])\n assert set(params.keys()) == set(n for n, p in tm.named_parameters())\n\n\[email protected]_gpu\ndef test_duplicate_weight_use():\n # The test cases doesn't make any sense as a neural network,\n # the issue popped up in shared input/output embeddings of bert,\n # but this is quicker\n class Test(Module):\n def __init__(self):\n super().__init__()\n self.lin = torch.nn.Linear(5, 3)\n\n def forward(self, x):\n x = self.lin(x)\n x = x @ self.lin.weight\n return x\n\n verify_model(Test(), input_data=[torch.randn(5, 5)])\n\n\[email protected]_gpu\ndef test_forward_matmul():\n torch.set_grad_enabled(False)\n\n class MatMul1(Module):\n def forward(self, *args):\n return torch.matmul(args[0], args[1])\n\n # matrix x vector\n tensor1 = torch.randn(3, 4)\n tensor2 = torch.randn(4)\n verify_model(MatMul1().float().eval(), input_data=[tensor1, tensor2])\n\n # matrix x matrix\n tensor1 = torch.randn(10, 4)\n tensor2 = torch.randn(4, 10)\n verify_model(MatMul1().float().eval(), input_data=[tensor1, tensor2], expected_ops=[\"nn.dense\"])\n\n # batched matrix x batched matrix\n tensor1 = torch.randn(10, 3, 4)\n tensor2 = torch.randn(10, 4, 5)\n verify_model(\n MatMul1().float().eval(), input_data=[tensor1, tensor2], expected_ops=[\"nn.batch_matmul\"]\n )\n\n # batched matrix x broadcasted matrix\n tensor1 = torch.randn(10, 3, 4)\n tensor2 = torch.randn(4, 5)\n verify_model(MatMul1().float().eval(), input_data=[tensor1, tensor2], expected_ops=[\"nn.dense\"])\n\n # broadcasted matrix x batched matrix\n tensor1 = torch.randn(10, 4)\n tensor2 = torch.randn(3, 4, 5)\n verify_model(MatMul1().float().eval(), input_data=[tensor1, tensor2], expected_ops=[\"nn.dense\"])\n\n # batched matrix x batched matrix\n tensor1 = torch.randn(1, 12, 14, 64)\n tensor2 = torch.randn(1, 12, 64, 14)\n verify_model(MatMul1().float().eval(), input_data=[tensor1, tensor2])\n\n\ndef test_forward_index():\n torch.set_grad_enabled(False)\n input_shape = [3, 4, 5, 6]\n\n class Index0(Module):\n def forward(self, x):\n return x[[0, 1], [0, 2], :2, 4]\n\n input_data = torch.rand(input_shape).float()\n verify_model(Index0().eval(), input_data=input_data)\n\n class Index1(Module):\n def forward(self, x):\n return x[[0], [1, 2, 3, 0], [3, 1, 2, 2], [4, 2, 1, 0]]\n\n input_data = torch.rand(input_shape).float()\n verify_model(Index1().eval(), input_data=input_data)\n\n\ndef test_logsumexp():\n class Logsumexp(Module):\n def __init__(self, dim, keepdim=False):\n super().__init__()\n self.dim = dim\n self.keepdim = keepdim\n\n def forward(self, x):\n return torch.logsumexp(x, self.dim, self.keepdim)\n\n input_shape = (100, 100)\n input_data = torch.rand(input_shape)\n\n verify_model(Logsumexp(0), input_data=input_data)\n verify_model(Logsumexp(0, keepdim=True), input_data=input_data)\n # Also test on double\n verify_model(Logsumexp(1, keepdim=True), input_data=input_data.double())\n\n\ndef test_stack():\n class Stack(torch.nn.Module):\n def __init__(self, axis=0):\n super().__init__()\n self.axis = axis\n\n def forward(self, x):\n return torch.stack((x, x), dim=self.axis)\n\n inp = torch.randn(8, 8, 8)\n verify_model(Stack(), input_data=inp)\n verify_model(Stack(axis=-1), input_data=inp)\n verify_model(Stack(axis=3), input_data=inp)\n verify_model(Stack(axis=-4), input_data=inp)\n\n\ndef test_stack_dynamic():\n class Stack(torch.nn.Module):\n def forward(self, x):\n tensor_list = []\n for i in range(x.size(0)):\n # this is a workaround to avoid generating impure aten::append op\n tensor_list += [x[i]]\n # relay tensor array only supports stacking on the first axis\n return torch.stack(tensor_list, dim=0)\n\n verify_script_model(Stack(), [(8, 8, 8)], _get_default_vm_targets())\n\n\ndef test_forward_unbind():\n class Unbind(torch.nn.Module):\n def __init__(self, axis=0):\n super().__init__()\n self.axis = axis\n\n def forward(self, x):\n return torch.unbind(x, self.axis)\n\n inp = torch.randn(8, 8, 8)\n verify_model(Unbind(0), input_data=inp)\n verify_model(Unbind(1), input_data=inp)\n verify_model(Unbind(2), input_data=inp)\n\n\ndef test_forward_nonzero():\n class Nonzero(Module):\n def __init__(self, as_tuple=False):\n super().__init__()\n self.as_tuple = as_tuple\n\n def forward(self, data):\n return torch.nonzero(data, as_tuple=self.as_tuple)\n\n inp = torch.Tensor(np.array([[0, 1, 0], [2, 0, 9], [-1, -1, 0]]).astype(\"float32\"))\n verify_trace_model(Nonzero(), [inp], [\"llvm\"])\n\n\ndef test_forward_scatter():\n # integer cannot be traced\n def test_fn_scatter(dim):\n return lambda data, index, src: torch.scatter(data, dim=dim, index=index, src=src)\n\n def test_fn_scatter_add(dim):\n return lambda data, index, src: torch.scatter_add(data, dim=dim, index=index, src=src)\n\n in_data = torch.zeros(3, 5)\n in_index = torch.tensor([[0, 1, 2, 0, 0], [2, 0, 0, 1, 2]])\n in_src = torch.rand(2, 5)\n\n targets = [\"llvm\", \"cuda\"]\n verify_trace_model(test_fn_scatter(0), [in_data, in_index, in_src], targets)\n verify_trace_model(test_fn_scatter_add(0), [in_data, in_index, in_src], targets)\n\n in_data = torch.zeros(2, 4)\n in_index = torch.tensor([[2], [3]])\n in_src = torch.rand(2, 1)\n\n verify_trace_model(test_fn_scatter(1), [in_data, in_index, in_src], targets)\n verify_trace_model(test_fn_scatter_add(1), [in_data, in_index, in_src], targets)\n\n\ndef test_forward_index_put():\n # torch.index_put for 2D tensor and default accumulate (False)\n def test_fn_index_put2():\n return lambda data, xidx, yidx, values: torch.index_put(\n data, indices=[xidx, yidx], values=values\n )\n\n # torch.index_put for 3D tensor and accumulate=True\n def test_fn_index_put3a():\n return lambda data, xidx, yidx, zidx, values: torch.index_put(\n data, indices=[xidx, yidx, zidx], values=values, accumulate=True\n )\n\n shape = (3, 5)\n in_data = torch.zeros(shape)\n xidx = torch.tensor([0, 1, 2, 2])\n yidx = torch.tensor([0, 1, 3, 4])\n values = torch.tensor([2.0, 4.0, 7.0, 9.0])\n\n targets = [\"llvm\", \"cuda\"]\n verify_trace_model(test_fn_index_put2(), [in_data, xidx, yidx, values], targets)\n\n shape = (3, 5, 3)\n in_data = torch.zeros(shape)\n xidx = torch.tensor([0, 1, 2, 2, 0])\n yidx = torch.tensor([0, 1, 3, 4, 0])\n zidx = torch.tensor([0, 1, 1, 2, 0])\n values = torch.tensor([2.0, 4.0, 7.0, 9.0, 1.0])\n\n verify_trace_model(test_fn_index_put3a(), [in_data, xidx, yidx, zidx, values], targets)\n\n\ndef test_numel():\n class Numel(Module):\n def forward(self, data):\n return torch.tensor(torch.numel(data))\n\n targets = _get_default_vm_targets()\n verify_script_model(Numel(), [(1,)], targets)\n verify_script_model(Numel(), [(3, 5)], targets)\n verify_script_model(Numel(), [(3, 5, 8)], targets)\n\n\ndef test_forward_pretrained_bert_base_uncased():\n ######################################################################\n # This is an example how to run BERT models using TVM\n # ---------------------------------------------------\n \"\"\"\n Refer the bert example given in https://pypi.org/project/pytorch-pretrained-bert\n\n # To get started, pretrained bert package needs to be installed as prerequisite.\n\n .. code-block:: bash\n\n # install bert package\n pip install pytorch_pretrained_bert==0.6.2 --user\n \"\"\"\n\n try:\n from pytorch_pretrained_bert import BertForMaskedLM, BertTokenizer\n except:\n print(\"Torch pretrained bert package must be installed to run this script.\")\n return\n\n ######################################################################\n # Load the tokenizer and tokenize the input\n # -----------------------------------------\n\n # Load pre-trained model tokenizer (vocabulary)\n tokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\")\n\n # Tokenized input\n text = \"[CLS] Who was Jim Henson ? [SEP] Jim Henson was a puppeteer [SEP]\"\n tokenized_text = tokenizer.tokenize(text)\n\n # Mask a token that we will try to predict back with `BertForMaskedLM`\n masked_index = 8\n tokenized_text[masked_index] = \"[MASK]\"\n assert tokenized_text == [\n \"[CLS]\",\n \"who\",\n \"was\",\n \"jim\",\n \"henson\",\n \"?\",\n \"[SEP]\",\n \"jim\",\n \"[MASK]\",\n \"was\",\n \"a\",\n \"puppet\",\n \"##eer\",\n \"[SEP]\",\n ]\n\n # Convert token to vocabulary indices\n indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text)\n # Define sentence A and B indices associated to 1st and 2nd sentences (see paper)\n segments_ids = [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1]\n\n # Convert inputs to PyTorch tensors\n tokens_tensor = torch.tensor([indexed_tokens])\n segments_tensors = torch.tensor([segments_ids])\n\n ######################################################################\n # Load a pretrained PyTorch model bert-base-uncased\n # -------------------------------------------------\n\n # Bert Model with a language modeling\n model = BertForMaskedLM.from_pretrained(\"bert-base-uncased\")\n model.eval()\n\n ######################################################################\n # Predict all tokens with pytorch\n # -------------------------------\n\n with torch.no_grad():\n torch_preds = model(tokens_tensor, segments_tensors)\n\n ######################################################################\n # Make TorchScripted model via jit trace\n # --------------------------------------\n\n scripted_model = torch.jit.trace(model, (tokens_tensor, segments_tensors)).eval()\n\n ######################################################################\n # Import the graph to Relay\n # -------------------------\n # Convert PyTorch graph to Relay graph. The input name can be arbitrary.\n\n input_1 = \"input_ids\"\n input_2 = \"input.2\"\n shape_list = [(input_1, list(tokens_tensor.shape)), (input_2, list(segments_tensors.shape))]\n\n mod, params = relay.frontend.from_pytorch(scripted_model, shape_list)\n\n ######################################################################\n # Compile the model with relay\n # ----------------------------\n\n target = \"llvm\"\n with tvm.transform.PassContext(opt_level=3):\n relay_graph, relay_lib, relay_params = relay.build(mod, target=target, params=params)\n\n ######################################################################\n # Execute on TVM\n # --------------\n\n dev = tvm.device(target, 0)\n relay_model = graph_executor.create(relay_graph, relay_lib, dev)\n relay_model.set_input(**relay_params)\n relay_model.set_input(input_1, tokens_tensor)\n relay_model.set_input(input_2, segments_tensors)\n relay_model.run()\n compiled_output = relay_model.get_output(0).numpy()\n\n ######################################################################\n # Validate the outputs\n # --------------------\n # Compare the torch and tvm outputs\n\n tvm.testing.assert_allclose(torch_preds, compiled_output, rtol=1e-3, atol=1e-3)\n\n ######################################################################\n # Process the output\n # ------------------\n # Process the model output to token.\n\n # Torch output to token\n torch_pred_idx = torch.argmax(torch_preds[0, masked_index]).item()\n torch_pred_token = tokenizer.convert_ids_to_tokens([torch_pred_idx])[0]\n\n # TVM output to token\n tvm_pred_idx = compiled_output[0, masked_index].argmax()\n tvm_pred_token = tokenizer.convert_ids_to_tokens([tvm_pred_idx])[0]\n\n assert torch_pred_idx == tvm_pred_idx\n assert torch_pred_token == tvm_pred_token\n\n # Print the outputs\n print(\"Torch top-1 id: {}, token: {}\".format(torch_pred_idx, torch_pred_token))\n print(\"TVM top-1 id: {}, token: {}\".format(tvm_pred_idx, tvm_pred_token))\n\n\ndef test_convert_torch_script_with_input_types():\n def model_fn(x, y):\n x = x.to(dtype=torch.int32)\n y = x + y\n return y\n\n ishape = (4, 5)\n input_x = torch.rand(ishape, dtype=torch.float32)\n input_y = torch.randint(low=0, high=100, size=ishape, dtype=torch.int32)\n inputs = [input_x, input_y]\n script_module = torch.jit.trace(model_fn, inputs)\n\n fname = \"tmp.pt\"\n torch.jit.save(script_module, fname)\n loaded = torch.jit.load(fname)\n os.remove(fname)\n\n verify_model(loaded.eval(), input_data=inputs)\n\n def expected(x_shape, y_shape):\n # use a fixed order of args so alpha equal check can pass\n x = relay.var(\"x\", shape=x_shape, dtype=\"float32\")\n y = relay.var(\"y\", shape=y_shape, dtype=\"int32\")\n args = [x, y]\n x1 = relay.cast(x, \"int32\")\n y1 = relay.add(x1, y)\n mod = tvm.IRModule.from_expr(relay.Function(args, y1))\n return mod[\"main\"]\n\n input_infos = [(\"input0\", (ishape, \"float\")), (\"input1\", (ishape, \"int\"))]\n mod, params = relay.frontend.from_pytorch(loaded, input_infos)\n\n expected_mod = expected(ishape, ishape)\n\n assert tvm.ir.structural_equal(expected_mod, mod[\"main\"], map_free_vars=True)\n\n\ndef test_bincount():\n def test_fn(x, weights=None):\n return torch.bincount(x, weights=weights)\n\n inp = torch.randint(0, 100, (10000,), dtype=torch.int64)\n weights = torch.linspace(0, 100, steps=10000)\n\n targets = [\"llvm\", \"cuda\"]\n verify_trace_model(test_fn, [inp], targets)\n verify_trace_model(test_fn, [inp, weights], targets)\n\n\ndef test_hard_swish():\n examples = [torch.rand(8).float(), torch.rand(8, 10).float(), torch.rand(1, 1, 10).float()]\n for input in examples:\n verify_model(torch.nn.Hardswish().eval(), input_data=input)\n verify_model(torch.nn.Hardswish(inplace=True).eval(), input_data=input)\n\n\ndef test_hard_sigmoid():\n examples = [torch.rand(8).float(), torch.rand(8, 10).float(), torch.rand(1, 1, 10).float()]\n for input in examples:\n verify_model(torch.nn.Hardsigmoid().eval(), input_data=input)\n verify_model(torch.nn.Hardsigmoid(inplace=True).eval(), input_data=input)\n\n\ndef test_cumsum():\n def test_fn(dim, dtype=None):\n return lambda x: torch.cumsum(x, dim=dim, dtype=dtype)\n\n inp = torch.randint(0, 100, (10000,), dtype=torch.int32)\n verify_model(test_fn(0), [inp])\n verify_model(test_fn(0), [inp.to(torch.int64)])\n verify_model(test_fn(0, dtype=torch.int64), [inp.to(torch.int64)])\n\n inp = torch.randn((100, 100), dtype=torch.float32)\n verify_model(test_fn(dim=0, dtype=torch.float64), [inp])\n verify_model(test_fn(dim=1), [inp])\n\n inp = torch.randn((100, 100), dtype=torch.float32) > 0.5\n verify_model(test_fn(dim=0, dtype=torch.int32), [inp])\n\n\ndef test_masked_fill():\n def test_fn(x, mask):\n return torch.masked_fill(x, mask, 0.0)\n\n inp = torch.randn(100, 100)\n verify_model(test_fn, [inp, inp > 0.5])\n verify_model(test_fn, [inp.to(torch.float64), inp > 0.5])\n\n\ndef test_transformer():\n model = torch.nn.Transformer(d_model=256, nhead=8, num_encoder_layers=6, num_decoder_layers=6)\n model = model.eval()\n src = torch.rand((10, 32, 256))\n tgt = torch.rand((20, 32, 256))\n verify_model(model.eval(), input_data=[src, tgt])\n\n\ndef test_argsort():\n def test_fn(dim, descending):\n return lambda x: torch.argsort(x, dim=dim, descending=descending)\n\n inp = torch.randn(100)\n verify_model(test_fn(0, True), [inp])\n verify_model(test_fn(0, False), [inp])\n\n inp = torch.randn(100, 100)\n verify_model(test_fn(0, True), [inp])\n verify_model(test_fn(0, False), [inp])\n verify_model(test_fn(1, True), [inp])\n verify_model(test_fn(1, False), [inp])\n\n\ndef test_sort():\n def test_fn(dim, descending):\n return lambda x: torch.sort(x, dim=dim, descending=descending)\n\n inp = torch.randn(100)\n verify_model(test_fn(0, True), [inp])\n verify_model(test_fn(-1, False), [inp])\n\n inp = torch.randn(100, 100)\n verify_model(test_fn(0, True), [inp])\n verify_model(test_fn(-2, False), [inp])\n verify_model(test_fn(1, True), [inp])\n verify_model(test_fn(-1, False), [inp])\n\n\ndef test_logical_and():\n def test_fn(x, y):\n return torch.logical_and(x, y)\n\n a = torch.tensor([0, 1, 10, 0], dtype=torch.int8)\n b = torch.tensor([4, 0, 1, 0], dtype=torch.int8)\n verify_model(test_fn, [a, b])\n\n a = torch.tensor([True, False, True])\n b = torch.tensor([True, False, False])\n verify_model(test_fn, [a, b])\n\n\ndef test_masked_select():\n def test_fn(x, mask):\n return torch.masked_select(x, mask)\n\n for shape in [(10,), (3, 4), (16, 32, 64)]:\n x = torch.randn(*shape)\n mask = x.ge(0.5)\n verify_trace_model(test_fn, [x, mask], [\"llvm\", \"cuda\", \"nvptx\"])\n\n\ndef test_unique():\n def test_fn(is_sorted, return_inverse, return_counts):\n return lambda x: torch.unique(x, is_sorted, return_inverse, return_counts)\n\n in_data = torch.randint(0, 20, (10,), dtype=torch.int32)\n targets = [\"llvm\", \"cuda\", \"nvptx\"]\n verify_trace_model(test_fn(True, True, True), [in_data], targets)\n verify_trace_model(test_fn(True, False, True), [in_data], targets)\n verify_trace_model(test_fn(True, True, False), [in_data], targets)\n verify_trace_model(test_fn(True, False, True), [in_data], targets)\n in_data = torch.randint(0, 20, (20,), dtype=torch.int64)\n verify_trace_model(test_fn(True, True, True), [in_data], targets)\n verify_trace_model(test_fn(True, False, True), [in_data], targets)\n verify_trace_model(test_fn(True, True, False), [in_data], targets)\n verify_trace_model(test_fn(True, False, True), [in_data], targets)\n\n\ndef test_forward_nll_loss():\n torch.set_grad_enabled(False)\n N, C = 10, 3\n predictions = torch.rand((N, C)).float()\n targets = torch.randint(0, 3, (N,))\n weights = torch.tensor([1, 2, 3]).float()\n verify_model(torch.nn.NLLLoss().eval(), input_data=[predictions, targets])\n verify_model(torch.nn.NLLLoss(weight=weights).eval(), input_data=[predictions, targets])\n verify_model(torch.nn.NLLLoss(ignore_index=1).eval(), input_data=[predictions, targets])\n verify_model(torch.nn.NLLLoss(reduction=\"sum\").eval(), input_data=[predictions, targets])\n verify_model(torch.nn.NLLLoss(reduction=\"none\").eval(), input_data=[predictions, targets])\n\n # multidimension nll loss (aten::nll_loss2d)\n d1, d2 = 2, 3\n predictions = torch.rand((N, C, d1, d2)).float()\n targets = torch.randint(0, 3, (N, d1, d2))\n verify_model(torch.nn.NLLLoss().eval(), input_data=[predictions, targets])\n verify_model(torch.nn.NLLLoss(weight=weights).eval(), input_data=[predictions, targets])\n verify_model(torch.nn.NLLLoss(ignore_index=1).eval(), input_data=[predictions, targets])\n verify_model(torch.nn.NLLLoss(reduction=\"sum\").eval(), input_data=[predictions, targets])\n verify_model(torch.nn.NLLLoss(reduction=\"none\").eval(), input_data=[predictions, targets])\n\n\[email protected]_gpu\ndef test_forward_flip():\n torch.set_grad_enabled(False)\n\n class Flip(Module):\n def __init__(self, axis=0):\n super().__init__()\n self.axis = axis\n\n def forward(self, x):\n return x.flip([self.axis])\n\n input = torch.randn(2, 3, 4)\n verify_model(Flip(axis=0), input_data=input)\n verify_model(Flip(axis=1), input_data=input)\n verify_model(Flip(axis=2), input_data=input)\n verify_model(Flip(axis=-1), input_data=input)\n\n\nif __name__ == \"__main__\":\n # some structural tests\n test_forward_traced_function()\n test_forward_dtypes()\n test_weight_names()\n test_duplicate_weight_use()\n\n # Single operator tests\n test_forward_pixel_shuffle()\n test_forward_add()\n test_forward_subtract()\n test_forward_multiply()\n test_forward_matmul()\n test_forward_rsub()\n test_forward_onehot()\n test_forward_embedding()\n test_forward_reshape()\n test_forward_reciprocal()\n test_forward_repeat()\n test_forward_repeat_interleave()\n test_forward_squeeze()\n test_forward_unsqueeze()\n test_forward_concatenate()\n test_forward_reduce_sum()\n test_forward_reduce_prod()\n test_forward_argmin()\n test_forward_argmax()\n test_forward_norm()\n test_forward_frobenius_norm()\n test_forward_std()\n test_forward_variance()\n test_forward_relu()\n test_forward_prelu()\n test_forward_leakyrelu()\n test_forward_elu()\n test_forward_celu()\n test_forward_gelu()\n test_forward_selu()\n test_forward_log_sigmoid()\n test_forward_adaptiveavgpool()\n test_forward_maxpool2d()\n test_forward_maxpool1d()\n test_forward_maxpool3d()\n test_forward_hardtanh()\n test_forward_conv()\n test_forward_conv_transpose()\n test_forward_threshold()\n test_forward_contiguous()\n test_forward_batchnorm()\n test_forward_instancenorm()\n test_forward_layernorm()\n test_forward_groupnorm()\n test_forward_transpose()\n test_forward_size()\n test_forward_view()\n test_forward_select()\n test_forward_take()\n test_forward_topk()\n test_forward_where()\n test_forward_addcdiv()\n test_forward_addcmul()\n test_forward_true_divide()\n test_forward_is_floating_point()\n test_forward_clone()\n test_forward_softplus()\n test_forward_softsign()\n test_forward_logsoftmax()\n test_forward_sigmoid()\n test_forward_dense()\n test_forward_avgpool1d()\n test_forward_avgpool2d()\n test_forward_avgpool3d()\n test_forward_dropout()\n test_forward_slice()\n test_forward_narrow()\n test_forward_mean()\n test_forward_expand()\n test_forward_pow()\n test_forward_unary()\n test_forward_clamp()\n test_forward_clamp_()\n test_forward_logical_not()\n test_forward_bitwise_not()\n test_forward_bitwise_xor()\n test_forward_logical_xor()\n test_forward_isfinite()\n test_forward_isnan()\n test_forward_isinf()\n test_forward_ones()\n test_forward_ones_like()\n test_forward_zeros()\n test_forward_zeros_like()\n test_forward_full()\n test_forward_full_like()\n test_forward_linspace()\n test_forward_arange()\n test_forward_mesh_grid()\n test_forward_chunk()\n test_forward_split()\n test_forward_gather()\n test_upsample()\n test_forward_upsample3d()\n test_forward_nms()\n test_forward_roi_align()\n test_to()\n test_flatten()\n test_type_as()\n test_forward_functional_pad()\n test_forward_zero_pad2d()\n test_forward_constant_pad1d()\n test_forward_constant_pad2d()\n test_forward_constant_pad3d()\n test_forward_reflection_pad1d()\n test_forward_reflection_pad2d()\n test_forward_replication_pad1d()\n test_forward_replication_pad2d()\n test_forward_replication_pad3d()\n test_adaptive_pool3d()\n test_conv3d()\n test_conv3d_transpose()\n test_forward_index()\n test_min_max()\n test_logsumexp()\n test_stack()\n test_stack_dynamic()\n test_forward_unbind()\n test_forward_nonzero()\n test_forward_scatter()\n test_forward_index_put()\n test_numel()\n test_bincount()\n test_cumsum()\n test_masked_fill()\n test_transformer()\n test_sort()\n test_argsort()\n test_logical_and()\n test_masked_select()\n test_unique()\n test_hard_swish()\n test_hard_sigmoid()\n test_forward_nll_loss()\n test_forward_flip()\n\n # Model tests\n test_resnet18()\n test_squeezenet1_0()\n test_squeezenet1_1()\n test_densenet121()\n # disable inception test for now, since loading it takes ~5min on torchvision-0.5 due to scipy bug\n # See https://discuss.pytorch.org/t/torchvisions-inception-v3-takes-much-longer-to-load-than-other-models/68756\n # test_inception_v3()\n test_googlenet()\n test_mnasnet0_5()\n test_mobilenet_v2()\n\n test_custom_conversion_map()\n\n test_segmentation_models()\n test_3d_models()\n\n # Quantization test\n from qnn_test import test_quantized_imagenet, test_quantized_modules\n\n test_quantized_modules()\n test_quantized_imagenet()\n\n # Test simple conditionals and loop\n test_control_flow()\n test_simple_rnn()\n\n # More complex recurrent models\n from test_lstm import test_custom_lstm\n\n test_custom_lstm()\n\n # Test bert model\n test_forward_pretrained_bert_base_uncased()\n\n # Test convert torch script(jit) with specific inputs' types\n test_convert_torch_script_with_input_types()\n"
] | [
[
"torch.nn.ReflectionPad1d",
"torch.addcdiv",
"torch.rand",
"torch.masked_fill",
"torch.jit.save",
"torch.nn.Conv2d",
"torch.meshgrid",
"torch.cat",
"torch.neg",
"torch.jit.trace",
"torch.nn.ConstantPad2d",
"torch.nn.BatchNorm3d",
"torch.randn",
"torch.take",
"torch.isinf",
"torch.norm",
"torch.nn.functional.max_pool3d",
"torch.sin",
"torch.nn.functional.avg_pool3d",
"numpy.mean",
"torch.sort",
"torch.ceil",
"torch.logical_and",
"torch.index_put",
"torch.nn.functional.max_pool2d",
"torch.bincount",
"torch.logical_not",
"torch.nn.ReplicationPad2d",
"torch.nn.ConstantPad3d",
"torch.split",
"torch.nn.Softsign",
"torch.zeros_like",
"torch.zeros",
"torch.nn.ConvTranspose1d",
"numpy.array",
"torch.nn.functional.interpolate",
"torch.jit.script",
"torch.nonzero",
"torch.asin",
"torch.no_grad",
"torch.cumsum",
"torch.cuda.is_available",
"torch.nn.ReflectionPad2d",
"torch.max",
"torch.jit.load",
"torch.nn.Sigmoid",
"torch.logical_xor",
"torch.nn.Dropout",
"torch.log1p",
"torch.atan",
"torch.scatter",
"torch.cos",
"torch.set_grad_enabled",
"torch.erf",
"torch.nn.Softmax",
"torch.true_divide",
"torch.nn.init.normal_",
"torch.nn.ConvTranspose3d",
"torch.gather",
"torch.nn.Threshold",
"torch.nn.LogSigmoid",
"torch.nn.AvgPool3d",
"torch.nn.SELU",
"torch.nn.MaxPool1d",
"scipy.stats.t.ppf",
"torch.argmax",
"torch.flatten",
"torch.nn.LogSoftmax",
"torch.log2",
"torch.nn.AlphaDropout",
"torch.masked_select",
"torch.nn.Hardswish",
"torch.nn.Transformer",
"torch.nn.Hardtanh",
"torch.topk",
"torch.is_floating_point",
"torch.scatter_add",
"numpy.sqrt",
"torch.nn.Dropout3d",
"torch.nn.Conv3d",
"torch.clamp",
"torch.nn.LeakyReLU",
"torch.stack",
"torch.nn.functional.avg_pool2d",
"torch.nn.MaxPool3d",
"torch.argsort",
"torch.nn.AdaptiveMaxPool3d",
"torch.nn.functional.one_hot",
"torch.log",
"torch.nn.Upsample",
"torch.nn.InstanceNorm2d",
"torch.floor",
"torch.cuda.empty_cache",
"torch.nn.BatchNorm2d",
"torch.add",
"torch.nn.functional.pad",
"torch.nn.functional.avg_pool1d",
"torch.unique",
"torch.index_select",
"torch.log10",
"torch.nn.AdaptiveAvgPool3d",
"torch.nn.Softplus",
"numpy.random.uniform",
"torch.nn.MaxPool2d",
"torch.ones_like",
"torch.nn.AvgPool1d",
"numpy.zeros",
"torch.nn.AdaptiveAvgPool2d",
"torch.nn.Hardsigmoid",
"torch.cosh",
"torch.logsumexp",
"torch.nn.Linear",
"torch.nn.PReLU",
"torch.nn.Dropout2d",
"torch.sinh",
"torch.nn.Embedding",
"torch.exp",
"torch.nn.GELU",
"torch.clamp_",
"torch.where",
"torch.numel",
"torch.full_like",
"torch.tan",
"torch.nn.ZeroPad2d",
"torch.matmul",
"torch.min",
"torch.randint",
"torch.addcmul",
"torch.LongTensor",
"torch.trunc",
"torch.nn.CELU",
"torch.sqrt",
"torch.bitwise_not",
"torch.bitwise_xor",
"torch.nn.ConvTranspose2d",
"torch.nn.GroupNorm",
"torch.round",
"torch.linspace",
"torch.nn.InstanceNorm3d",
"torch.sign",
"torch.arange",
"torch.nn.LayerNorm",
"torch.tanh",
"torch.nn.AvgPool2d",
"torch.acos",
"torch.isfinite",
"torch.nn.PixelShuffle",
"torch.ones",
"torch.nn.ReplicationPad3d",
"torch.rsub",
"torch.tensor",
"torch.nn.Conv1d",
"torch.nn.functional.max_pool1d",
"torch.nn.ReplicationPad1d",
"numpy.std",
"torch.isnan",
"torch.unbind",
"torch.nn.NLLLoss",
"torch.nn.functional.linear",
"torch.full",
"numpy.random.random",
"torch.rsqrt",
"torch.narrow",
"torch.nn.ELU",
"torch.nn.ReLU"
]
] |
Mehrad0711/bootleg | [
"f812b6200eb84b0163d353f0d4f73308a921fcfa"
] | [
"bootleg/layers/attn_networks.py"
] | [
"\"\"\"Attention networks.\"\"\"\nimport logging\n\nimport torch\nimport torch.nn as nn\n\nimport bootleg.utils.model_utils\nfrom bootleg.layers.helper_modules import MLP, AttnBlock, NormAndSum, SelfAttnBlock\nfrom bootleg.symbols.constants import (\n BERT_WORD_DIM,\n DISAMBIG,\n KG_BIAS_LOAD_CLASS,\n MAIN_CONTEXT_MATRIX,\n)\nfrom bootleg.utils import model_utils\nfrom bootleg.utils.embedding_utils import get_max_candidates\n\nlogger = logging.getLogger(__name__)\n\n\nclass AttnNetwork(nn.Module):\n \"\"\"Base attention network.\n\n Args:\n args: args\n entity_symbols: entity symbols\n \"\"\"\n\n def __init__(self, args, entity_symbols):\n super(AttnNetwork, self).__init__()\n self.num_entities_with_pad_and_nocand = (\n entity_symbols.num_entities_with_pad_and_nocand\n )\n # Number of candidates\n self.K = get_max_candidates(entity_symbols, args.data_config)\n # Number of aliases\n self.M = args.data_config.max_aliases\n self.hidden_size = args.model_config.hidden_size\n self.num_heads = args.model_config.num_heads\n self.num_model_stages = args.model_config.num_model_stages\n assert (\n self.num_model_stages > 0\n ), f\"You must have > 0 model stages. You have {self.num_model_stages}\"\n self.num_fc_layers = args.model_config.num_fc_layers\n self.ff_inner_size = args.model_config.ff_inner_size\n\n def forward(\n self,\n sent_embedding,\n sent_embedding_mask,\n entity_embedding,\n entity_embedding_mask,\n start_span_idx,\n end_span_idx,\n batch_on_the_fly_data,\n ):\n \"\"\"Model forward.\n\n Args:\n sent_embedding: sentence embedding (B x N x L)\n sent_embedding_mask: sentence embedding mask (B x N)\n entity_embedding: entity embedding (B x M x K x H)\n entity_embedding_mask: entity embedding mask (B x M x K)\n start_span_idx: start mention index into sentence (B x M)\n end_span_idx: end mention index into sentence (B x M)\n batch_on_the_fly_data: batch on the fly dictionary with values (B x (M*K) x (M*K)) of KG adjacency matrices\n\n Returns: Dict of Dict of intermediate layer candidate scores (B x M x K),\n Dict of all output entity embeddings from each KG matrix (B x M x K x H)\n \"\"\"\n raise NotImplementedError\n\n\nclass Bootleg(AttnNetwork):\n \"\"\"Bootleg attention network V1.\n\n Args:\n args: args\n entity_symbols: entity symbols\n \"\"\"\n\n def __init__(self, args, entity_symbols):\n super(Bootleg, self).__init__(args, entity_symbols)\n self.dropout = args.train_config.dropout\n\n # For each stage, create a transformer block for phrase (entity_word) and co-occurrence (self_entity) modules\n self.attention_modules = nn.ModuleDict()\n self.combine_modules = nn.ModuleDict()\n for i in range(self.num_model_stages):\n self.attention_modules[f\"stage_{i}_entity_word\"] = AttnBlock(\n size=self.hidden_size,\n ff_inner_size=args.model_config.ff_inner_size,\n dropout=self.dropout,\n num_heads=self.num_heads,\n )\n self.attention_modules[f\"stage_{i}_self_entity\"] = SelfAttnBlock(\n size=self.hidden_size,\n ff_inner_size=args.model_config.ff_inner_size,\n dropout=self.dropout,\n num_heads=self.num_heads,\n )\n self.combine_modules[f\"stage_{i}_combine\"] = NormAndSum(self.hidden_size)\n\n # For the KG bias module\n self.kg_bias_list = []\n self.kg_bias_keys = []\n for emb in args.data_config.ent_embeddings:\n if emb.load_class == KG_BIAS_LOAD_CLASS:\n # self.kg_bias_weights[emb.key] = torch.nn.Parameter(torch.tensor(2.0))\n setattr(self, emb.key, torch.nn.Parameter(torch.tensor(2.0)))\n self.kg_bias_list.append(getattr(self, emb.key))\n self.kg_bias_keys.append(emb.key)\n self.kg_bias_keys = sorted(self.kg_bias_keys)\n # If we have kg bias terms, we want to take the average of those context matrices when generating the final\n # context matrix to be returned. The no_kg_key is used for the context matrix without kg_bias terms added.\n # If we use the key ending in _nokg, it will not be averaged in the final result. If we do not have kg bias\n # terms, we want the nokg context matrix to be the final matrix. MAIN_CONTEXT_MATRIX key allows for this.\n if len(self.kg_bias_keys) > 0:\n self.no_kg_key = \"context_matrix_nokg\"\n else:\n self.no_kg_key = MAIN_CONTEXT_MATRIX\n self.kg_softmax = nn.Softmax(dim=2)\n\n # Two things to note, the attn mask is a block diagonal matrix prevent an alias from paying attention to its\n # own K candidates in the attention layer This works because the original input is added to the output of\n # this attention, meaning an alias becomes its original embedding plus the contributions of the other\n # aliases in the sentence. Second, the attn mask is added to the attention before softmax (added to Q dot\n # V^T) -- softmax makes e^(-1e9+old_value) become zero When setting it to be -inf, you can get nans in the\n # loss if all entities end up being masked out (eg only one alias in the sentence)\n self.e2e_entity_mask = torch.zeros((self.K * self.M, self.K * self.M))\n for i in range(self.M):\n self.e2e_entity_mask[\n i * self.K : (i + 1) * self.K, i * self.K : (i + 1) * self.K\n ] = 1.0\n # Must manually move this to the device as it's not part of a module...we can probably fix this\n self.e2e_entity_mask = self.e2e_entity_mask.masked_fill(\n (self.e2e_entity_mask == 1), float(-1e9)\n )\n\n # Track attention weights\n self.attention_weights = {}\n\n # Prediction layers: each stage except the last gets a prediction layer\n # Last layer's prediction head is added in slice heads\n disambig_task = nn.ModuleDict()\n for i in range(self.num_model_stages - 1):\n disambig_task[bootleg.utils.model_utils.get_stage_head_name(i)] = MLP(\n self.hidden_size, self.hidden_size, 1, self.num_fc_layers, self.dropout\n )\n self.predict_layers = {DISAMBIG: disambig_task}\n self.predict_layers = nn.ModuleDict(self.predict_layers)\n\n def forward(\n self,\n sent_embedding,\n sent_embedding_mask,\n entity_embedding,\n entity_embedding_mask,\n start_span_idx,\n end_span_idx,\n batch_on_the_fly_data,\n ):\n \"\"\"Model forward.\n\n Args:\n sent_embedding: sentence embedding (B x N x L)\n sent_embedding_mask: sentence embedding mask (B x N)\n entity_embedding: entity embedding (B x M x K x H)\n entity_embedding_mask: entity embedding mask (B x M x K)\n start_span_idx: start mention index into sentence (B x M)\n end_span_idx: end mention index into sentence (B x M)\n batch_on_the_fly_data: batch on the fly dictionary with values (B x (M*K) x (M*K)) of KG adjacency matrices\n\n Returns: Dict of Dict of intermediate layer candidate scores (B x M x K),\n Dict of all output entity embeddings from each KG matrix (B x M x K x H)\n \"\"\"\n batch_size = sent_embedding.shape[0]\n out = {DISAMBIG: {}}\n\n # Create KG bias matrices for each kg bias key\n kg_bias_norms = {}\n for key in self.kg_bias_keys:\n bias_weight = getattr(self, key) # self.kg_bias_weights[key]\n kg_bias = (\n batch_on_the_fly_data[key]\n .float()\n .to(sent_embedding.device)\n .reshape(batch_size, self.M * self.K, self.M * self.K)\n )\n kg_bias_diag = kg_bias + bias_weight * torch.eye(self.M * self.K).repeat(\n batch_size, 1, 1\n ).view(batch_size, self.M * self.K, self.M * self.K).to(kg_bias.device)\n kg_bias_norm = self.kg_softmax(\n kg_bias_diag.masked_fill((kg_bias_diag == 0), float(-1e9))\n )\n kg_bias_norms[key] = kg_bias_norm\n sent_tensor = sent_embedding.transpose(0, 1)\n\n # Resize the alias embeddings and the entity mask from B x M x K x D -> B x (M*K) x D\n entity_embedding = entity_embedding.contiguous().view(\n batch_size, self.M * self.K, self.hidden_size\n )\n entity_embedding = entity_embedding.transpose(0, 1) # reshape for attention\n key_padding_mask_entities = entity_embedding_mask.contiguous().view(\n batch_size, self.M * self.K\n )\n\n # Iterate through stages\n query_tensor = entity_embedding\n for stage_index in range(self.num_model_stages):\n # As we are adding a residual in the attention modules, we can make embs empty\n embs = []\n context_mat_dict = {}\n # ============================================================================\n # Phrase module: compute attention between entities and words\n # ============================================================================\n word_entity_attn_context, word_entity_attn_weights = self.attention_modules[\n f\"stage_{stage_index}_entity_word\"\n ](\n q=query_tensor,\n x=sent_tensor,\n key_mask=sent_embedding_mask,\n attn_mask=None,\n )\n # Add embeddings to be merged in the output\n embs.append(word_entity_attn_context)\n # Save the attention weights\n self.attention_weights[\n f\"stage_{stage_index}_entity_word\"\n ] = word_entity_attn_weights\n\n # ============================================================================\n # Co-occurrence module: compute self attention over entities\n # ============================================================================\n # Move entity mask to device\n # TODO: move to device in init?\n self.e2e_entity_mask = self.e2e_entity_mask.to(\n key_padding_mask_entities.device\n )\n\n entity_attn_context, entity_attn_weights = self.attention_modules[\n f\"stage_{stage_index}_self_entity\"\n ](\n x=query_tensor,\n key_mask=key_padding_mask_entities,\n attn_mask=self.e2e_entity_mask,\n )\n # Mask out MxK of single aliases, alias_indices is batch x M, mask is true when single alias\n non_null_aliases = (\n self.K\n - key_padding_mask_entities.reshape(batch_size, self.M, self.K).sum(-1)\n ) != 0\n entity_attn_post_mask = (\n (non_null_aliases.sum(1) == 1)\n .unsqueeze(1)\n .expand(batch_size, self.K * self.M)\n .transpose(0, 1)\n )\n entity_attn_post_mask = entity_attn_post_mask.unsqueeze(-1).expand_as(\n entity_attn_context\n )\n entity_attn_context = torch.where(\n entity_attn_post_mask,\n torch.zeros_like(entity_attn_context),\n entity_attn_context,\n )\n\n # Add embeddings to be merged in the output\n embs.append(entity_attn_context)\n # Save the attention weights\n self.attention_weights[\n f\"stage_{stage_index}_self_entity\"\n ] = entity_attn_weights\n\n # Combine module output\n context_matrix_nokg = self.combine_modules[f\"stage_{stage_index}_combine\"](\n embs\n )\n context_mat_dict[self.no_kg_key] = context_matrix_nokg.transpose(\n 0, 1\n ).reshape(batch_size, self.M, self.K, self.hidden_size)\n # ============================================================================\n # KG module: add in KG connectivity bias\n # ============================================================================\n for key in self.kg_bias_keys:\n context_matrix_kg = torch.bmm(\n kg_bias_norms[key], context_matrix_nokg.transpose(0, 1)\n ).transpose(0, 1)\n context_matrix_kg = (context_matrix_nokg + context_matrix_kg) / 2\n context_mat_dict[f\"context_matrix_{key}\"] = context_matrix_kg.transpose(\n 0, 1\n ).reshape(batch_size, self.M, self.K, self.hidden_size)\n\n if stage_index < self.num_model_stages - 1:\n score = model_utils.max_score_context_matrix(\n context_mat_dict,\n self.predict_layers[DISAMBIG][\n bootleg.utils.model_utils.get_stage_head_name(stage_index)\n ],\n )\n out[DISAMBIG][\n f\"{bootleg.utils.model_utils.get_stage_head_name(stage_index)}\"\n ] = score\n\n # This will take the average of the context matrices that do not end in the key \"_nokg\";\n # if there are not kg bias terms, it will select the context_matrix_nokg\n # (as it's key, in this setting, will not end in _nokg)\n query_tensor = (\n model_utils.generate_final_context_matrix(\n context_mat_dict, ending_key_to_exclude=\"_nokg\"\n )\n .reshape(batch_size, self.M * self.K, self.hidden_size)\n .transpose(0, 1)\n )\n return {\n \"intermed_scores\": out,\n \"ent_embs\": context_mat_dict,\n \"final_scores\": None,\n }\n\n\nclass BootlegM2E(AttnNetwork):\n \"\"\"Bootleg attention network with a mention to entity canidate tensformer\n layer.\n\n Args:\n args: args\n entity_symbols: entity symbols\n \"\"\"\n\n def __init__(self, args, entity_symbols):\n super(BootlegM2E, self).__init__(args, entity_symbols)\n self.dropout = args.train_config.dropout\n\n # For each stage, create a transformer block for phrase (entity_word) and co-occurrence (self_entity) modules\n self.attention_modules = nn.ModuleDict()\n self.combine_modules = nn.ModuleDict()\n for i in range(self.num_model_stages):\n self.attention_modules[f\"stage_{i}_entity_word\"] = AttnBlock(\n size=self.hidden_size,\n ff_inner_size=args.model_config.ff_inner_size,\n dropout=self.dropout,\n num_heads=self.num_heads,\n )\n self.attention_modules[f\"stage_{i}_self_entity\"] = SelfAttnBlock(\n size=self.hidden_size,\n ff_inner_size=args.model_config.ff_inner_size,\n dropout=self.dropout,\n num_heads=self.num_heads,\n )\n self.attention_modules[f\"stage_{i}_mention_entity\"] = AttnBlock(\n size=self.hidden_size,\n ff_inner_size=args.model_config.ff_inner_size,\n dropout=self.dropout,\n num_heads=self.num_heads,\n )\n self.combine_modules[f\"stage_{i}_combine\"] = NormAndSum(self.hidden_size)\n\n # For the KG bias module\n # self.kg_bias_weights = nn.ParameterDict() # ParameterDicts are buggy in DataParallel\n # self.kg_bias_list = []\n self.kg_bias_keys = []\n for emb in args.data_config.ent_embeddings:\n if emb.load_class == KG_BIAS_LOAD_CLASS:\n # self.kg_bias_weights[emb.key] = torch.nn.Parameter(torch.tensor(2.0))\n # setattr(self, emb.key, torch.nn.Parameter(torch.tensor(2.0)))\n # self.kg_bias_list.append(getattr(self, emb.key))\n self.kg_bias_keys.append(emb.key)\n self.kg_bias_keys = sorted(self.kg_bias_keys)\n # If we have kg bias terms, we want to take the average of those context matrices when generating the final\n # context matrix to be returned. The no_kg_key is used for the context matrix without kg_bias terms added.\n # If we use the key ending in _nokg, it will not be averaged in the final result. If we do not have kg bias\n # terms, we want the nokg context matrix to be the final matrix. MAIN_CONTEXT_MATRIX key allows for this.\n if len(self.kg_bias_keys) > 0:\n self.no_kg_key = \"context_matrix_nokg\"\n else:\n self.no_kg_key = MAIN_CONTEXT_MATRIX\n self.kg_softmax = nn.Softmax(dim=2)\n\n # Two things to note, the attn mask is a block diagonal matrix prevent an alias from paying attention to its\n # own K candidates in the attention layer This works because the original input is added to the output of\n # this attention, meaning an alias becomes its original embedding plus the contributions of the other\n # aliases in the sentence. Second, the attn mask is added to the attention before softmax (added to Q dot\n # V^T) -- softmax makes e^(-1e9+old_value) become zero When setting it to be -inf, you can get nans in the\n # loss if all entities end up being masked out (eg only one alias in the sentence)\n self.e2e_entity_mask = torch.zeros((self.K * self.M, self.K * self.M))\n for i in range(self.M):\n self.e2e_entity_mask[\n i * self.K : (i + 1) * self.K, i * self.K : (i + 1) * self.K\n ] = 1.0\n # Must manually move this to the device as it's not part of a module...we can probably fix this\n self.e2e_entity_mask = self.e2e_entity_mask.masked_fill(\n (self.e2e_entity_mask == 1), float(-1e9)\n )\n\n # Track attention weights\n self.attention_weights = {}\n\n # Prediction layers: each stage except the last gets a prediction layer\n # Last layer's prediction head is added in slice heads\n disambig_task = nn.ModuleDict()\n for i in range(self.num_model_stages - 1):\n disambig_task[bootleg.utils.model_utils.get_stage_head_name(i)] = MLP(\n self.hidden_size, self.hidden_size, 1, self.num_fc_layers, self.dropout\n )\n self.predict_layers = {DISAMBIG: disambig_task}\n self.predict_layers = nn.ModuleDict(self.predict_layers)\n\n def forward(\n self,\n sent_embedding,\n sent_embedding_mask,\n entity_embedding,\n entity_embedding_mask,\n start_span_idx,\n end_span_idx,\n batch_on_the_fly_data,\n ):\n \"\"\"Model forward.\n\n Args:\n sent_embedding: sentence embedding (B x N x L)\n sent_embedding_mask: sentence embedding mask (B x N)\n entity_embedding: entity embedding (B x M x K x H)\n entity_embedding_mask: entity embedding mask (B x M x K)\n start_span_idx: start mention index into sentence (B x M)\n end_span_idx: end mention index into sentence (B x M)\n batch_on_the_fly_data: batch on the fly dictionary with values (B x (M*K) x (M*K)) of KG adjacency matrices\n\n Returns: Dict of Dict of intermediate layer candidate scores (B x M x K),\n Dict of all output entity embeddings from each KG matrix (B x M x K x H)\n \"\"\"\n batch_size = sent_embedding.shape[0]\n out = {DISAMBIG: {}}\n\n # Create KG bias matrices for each kg bias key\n kg_bias_norms = {}\n for key in self.kg_bias_keys:\n kg_bias_norms[key] = (\n batch_on_the_fly_data[key]\n .float()\n .reshape(batch_size, self.M * self.K, self.M * self.K)\n )\n\n # get mention embedding\n # average words in mention; batch x M x dim\n mention_tensor_start = model_utils.select_alias_word_sent(\n start_span_idx, sent_embedding\n )\n mention_tensor_end = model_utils.select_alias_word_sent(\n end_span_idx, sent_embedding\n )\n mention_tensor = (mention_tensor_start + mention_tensor_end) / 2\n\n # reshape for alias attention where each mention attends to its K candidates\n # query = batch*M x 1 x dim, key = value = batch*M x K x dim\n # softmax(QK^T) -> batch*M x 1 x K\n # softmax(QK^T)V -> batch*M x 1 x dim\n mention_tensor = mention_tensor.reshape(\n batch_size * self.M, 1, self.hidden_size\n ).transpose(0, 1)\n\n # get sentence embedding; move batch to middle\n sent_tensor = sent_embedding.transpose(0, 1)\n\n # Resize the alias embeddings and the entity mask from B x M x K x D -> B x (M*K) x D\n entity_embedding = entity_embedding.contiguous().view(\n batch_size, self.M * self.K, self.hidden_size\n )\n entity_embedding = entity_embedding.transpose(0, 1) # reshape for attention\n key_padding_mask_entities = entity_embedding_mask.contiguous().view(\n batch_size, self.M * self.K\n )\n key_padding_mask_entities_mention = entity_embedding_mask.contiguous().view(\n batch_size * self.M, self.K\n )\n # Mask of aliases; key_padding_mask_entities_mention of True means mask.\n # We want to find aliases with all masked entities\n key_padding_mask_mentions = (\n torch.sum(~key_padding_mask_entities_mention, dim=-1) == 0\n )\n # Unmask these aliases to avoid nan in attention\n key_padding_mask_entities_mention[key_padding_mask_mentions] = False\n # Iterate through stages\n query_tensor = entity_embedding\n for stage_index in range(self.num_model_stages):\n # As we are adding a residual in the attention modules, we can make embs empty\n embs = []\n context_mat_dict = {}\n key_tensor_mention = (\n query_tensor.transpose(0, 1)\n .contiguous()\n .reshape(batch_size, self.M, self.K, self.hidden_size)\n .reshape(batch_size * self.M, self.K, self.hidden_size)\n .transpose(0, 1)\n )\n # ============================================================================\n # Phrase module: compute attention between entities and words\n # ============================================================================\n word_entity_attn_context, word_entity_attn_weights = self.attention_modules[\n f\"stage_{stage_index}_entity_word\"\n ](\n q=query_tensor,\n x=sent_tensor,\n key_mask=sent_embedding_mask,\n attn_mask=None,\n )\n # Add embeddings to be merged in the output\n embs.append(word_entity_attn_context)\n # Save the attention weights\n self.attention_weights[\n f\"stage_{stage_index}_entity_word\"\n ] = word_entity_attn_weights\n\n # ============================================================================\n # Co-occurrence module: compute self attention over entities\n # ============================================================================\n # Move entity mask to device\n # TODO: move to device in init?\n self.e2e_entity_mask = self.e2e_entity_mask.to(\n key_padding_mask_entities.device\n )\n\n entity_attn_context, entity_attn_weights = self.attention_modules[\n f\"stage_{stage_index}_self_entity\"\n ](\n x=query_tensor,\n key_mask=key_padding_mask_entities,\n attn_mask=self.e2e_entity_mask,\n )\n # Mask out MxK of single aliases, alias_indices is batch x M, mask is true when single alias\n non_null_aliases = (\n self.K\n - key_padding_mask_entities.reshape(batch_size, self.M, self.K).sum(-1)\n ) != 0\n entity_attn_post_mask = (\n (non_null_aliases.sum(1) == 1)\n .unsqueeze(1)\n .expand(batch_size, self.K * self.M)\n .transpose(0, 1)\n )\n entity_attn_post_mask = entity_attn_post_mask.unsqueeze(-1).expand_as(\n entity_attn_context\n )\n entity_attn_context = torch.where(\n entity_attn_post_mask,\n torch.zeros_like(entity_attn_context),\n entity_attn_context,\n )\n\n # Add embeddings to be merged in the output\n embs.append(entity_attn_context)\n # Save the attention weights\n self.attention_weights[\n f\"stage_{stage_index}_self_entity\"\n ] = entity_attn_weights\n\n # ============================================================================\n # Mention module: compute attention between entities and mentions\n # ============================================================================\n # output is 1 x batch*M x dim\n (\n mention_entity_attn_context,\n mention_entity_attn_weights,\n ) = self.attention_modules[f\"stage_{stage_index}_mention_entity\"](\n q=mention_tensor,\n x=key_tensor_mention,\n key_mask=key_padding_mask_entities_mention,\n attn_mask=None,\n )\n # key_padding_mask_mentions mentions have all padded candidates,\n # meaning their row in the context matrix are all nan\n mention_entity_attn_context[key_padding_mask_mentions.unsqueeze(0)] = 0\n mention_entity_attn_context = (\n mention_entity_attn_context.expand(\n self.K, batch_size * self.M, self.hidden_size\n )\n .transpose(0, 1)\n .reshape(batch_size, self.M * self.K, self.hidden_size)\n .transpose(0, 1)\n )\n # Add embeddings to be merged in the output\n embs.append(mention_entity_attn_context)\n # Save the attention weights\n self.attention_weights[\n f\"stage_{stage_index}_mention_entity\"\n ] = mention_entity_attn_weights\n\n # Combine module output\n context_matrix_nokg = self.combine_modules[f\"stage_{stage_index}_combine\"](\n embs\n )\n context_mat_dict[self.no_kg_key] = context_matrix_nokg.transpose(\n 0, 1\n ).reshape(batch_size, self.M, self.K, self.hidden_size)\n # ============================================================================\n # KG module: add in KG connectivity bias\n # ============================================================================\n for key in self.kg_bias_keys:\n context_matrix_kg = torch.bmm(\n kg_bias_norms[key], context_matrix_nokg.transpose(0, 1)\n ).transpose(0, 1)\n context_matrix_kg = (context_matrix_nokg + context_matrix_kg) / 2\n context_mat_dict[f\"context_matrix_{key}\"] = context_matrix_kg.transpose(\n 0, 1\n ).reshape(batch_size, self.M, self.K, self.hidden_size)\n\n if stage_index < self.num_model_stages - 1:\n score = model_utils.max_score_context_matrix(\n context_mat_dict,\n self.predict_layers[DISAMBIG][\n bootleg.utils.model_utils.get_stage_head_name(stage_index)\n ],\n )\n out[DISAMBIG][\n f\"{bootleg.utils.model_utils.get_stage_head_name(stage_index)}\"\n ] = score\n\n # This will take the average of the context matrices that do not end in the key \"_nokg\";\n # if there are not kg bias terms, it will select the context_matrix_nokg\n # (as it's key, in this setting, will not end in _nokg)\n query_tensor = (\n model_utils.generate_final_context_matrix(\n context_mat_dict, ending_key_to_exclude=\"_nokg\"\n )\n .reshape(batch_size, self.M * self.K, self.hidden_size)\n .transpose(0, 1)\n )\n return {\n \"intermed_scores\": out,\n \"ent_embs\": context_mat_dict,\n \"final_scores\": None,\n }\n\n\nclass BERTNED(AttnNetwork):\n \"\"\"NED Baseline model using BERT.\n\n Args:\n args: args\n entity_symbols: entity symbols\n \"\"\"\n\n def __init__(self, args, entity_symbols):\n super(BERTNED, self).__init__(args, entity_symbols)\n self.dropout = args.train_config.dropout\n self.span_proj = MLP(\n input_size=2 * BERT_WORD_DIM,\n num_hidden_units=None,\n output_size=self.hidden_size,\n num_layers=1,\n )\n # Prediction layers\n disambig_task = nn.ModuleDict()\n disambig_task[\"final\"] = MLP(\n self.hidden_size, self.hidden_size, 1, self.num_fc_layers, self.dropout\n )\n self.predict_layers = {DISAMBIG: disambig_task}\n self.predict_layers = nn.ModuleDict(self.predict_layers)\n\n def forward(\n self,\n sent_embedding,\n sent_embedding_mask,\n entity_embedding,\n entity_embedding_mask,\n start_span_idx,\n end_span_idx,\n batch_on_the_fly_data,\n ):\n \"\"\"Model forward.\n\n Args:\n sent_embedding: sentence embedding (B x N x L)\n sent_embedding_mask: sentence embedding mask (B x N)\n entity_embedding: entity embedding (B x M x K x H)\n entity_embedding_mask: entity embedding mask (B x M x K)\n start_span_idx: start mention index into sentence (B x M)\n end_span_idx: end mention index into sentence (B x M)\n batch_on_the_fly_data: batch on the fly dictionary with values (B x (M*K) x (M*K)) of KG adjacency matrices\n\n Returns: Dict of Dict of intermediate output layer scores (will be empty for this model),\n Output entity embeddings (B x M x K x H),\n Candidate scores (B x M x K)\n \"\"\"\n out = {DISAMBIG: {}}\n context_mat_dict = {}\n\n batch_size, M, K, emb_dim = entity_embedding.shape\n alias_start_idx_sent = start_span_idx\n alias_end_idx_sent = end_span_idx\n assert (\n emb_dim == self.hidden_size\n ), f\"BERT NED requires the learned entity embedding dim be the same as the hidden size\"\n assert alias_start_idx_sent.shape == alias_end_idx_sent.shape\n\n # Get alias words from sent embedding then cat and proj\n alias_start_word_tensor = model_utils.select_alias_word_sent(\n alias_start_idx_sent, sent_embedding\n )\n alias_end_word_tensor = model_utils.select_alias_word_sent(\n alias_end_idx_sent, sent_embedding\n )\n alias_pair_word_tensor = torch.cat(\n [alias_start_word_tensor, alias_end_word_tensor], dim=-1\n )\n alias_emb = (\n self.span_proj(alias_pair_word_tensor)\n .unsqueeze(2)\n .expand(batch_size, M, self.K, self.hidden_size)\n )\n alias_emb = (\n alias_emb.contiguous()\n .reshape((batch_size * M * self.K), self.hidden_size)\n .unsqueeze(1)\n )\n\n # entity_embedding_mask: if I don't have 30 candidates, use a mask to fill the rest of the\n # matrix for empty candidates\n entity_embedding_zeroed = torch.where(\n entity_embedding_mask.unsqueeze(-1),\n torch.zeros_like(entity_embedding),\n entity_embedding,\n )\n entity_embedding_tensor = (\n entity_embedding_zeroed.contiguous()\n .reshape((batch_size * M * self.K), self.hidden_size)\n .unsqueeze(-1)\n )\n\n # Performs batch wise dot produce across each dim=0 dimension\n score = (\n torch.bmm(alias_emb, entity_embedding_tensor)\n .unsqueeze(-1)\n .reshape(batch_size, M, self.K)\n )\n context_mat_dict[DISAMBIG] = entity_embedding_tensor.reshape(\n batch_size, M, self.K, self.hidden_size\n )\n return {\n \"intermed_scores\": out,\n \"ent_embs\": context_mat_dict,\n \"final_scores\": score,\n }\n"
] | [
[
"torch.sum",
"torch.bmm",
"torch.nn.Softmax",
"torch.zeros_like",
"torch.tensor",
"torch.eye",
"torch.zeros",
"torch.nn.ModuleDict",
"torch.cat"
]
] |
lightbooster/models | [
"833900b085a353712010c26c66ae9111246b5ac7"
] | [
"official/nlp/modeling/models/bert_classifier_test.py"
] | [
"# Copyright 2021 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\"\"\"Tests for BERT trainer network.\"\"\"\n\nfrom absl.testing import parameterized\nimport tensorflow as tf\n\nfrom tensorflow.python.keras import keras_parameterized # pylint: disable=g-direct-tensorflow-import\nfrom official.nlp.modeling import networks\nfrom official.nlp.modeling.models import bert_classifier\n\n\n# This decorator runs the test in V1, V2-Eager, and V2-Functional mode. It\n# guarantees forward compatibility of this code for the V2 switchover.\n@keras_parameterized.run_all_keras_modes\nclass BertClassifierTest(keras_parameterized.TestCase):\n\n @parameterized.named_parameters(('single_cls', 1, False), ('3_cls', 3, False),\n ('3_cls_dictoutputs', 3, True))\n def test_bert_trainer(self, num_classes, dict_outputs):\n \"\"\"Validate that the Keras object can be created.\"\"\"\n # Build a transformer network to use within the BERT trainer.\n vocab_size = 100\n sequence_length = 512\n test_network = networks.BertEncoder(\n vocab_size=vocab_size, num_layers=2, dict_outputs=dict_outputs)\n\n # Create a BERT trainer with the created network.\n bert_trainer_model = bert_classifier.BertClassifier(\n test_network, num_classes=num_classes)\n\n # Create a set of 2-dimensional inputs (the first dimension is implicit).\n word_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32)\n mask = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32)\n type_ids = tf.keras.Input(shape=(sequence_length,), dtype=tf.int32)\n\n # Invoke the trainer model on the inputs. This causes the layer to be built.\n cls_outs = bert_trainer_model([word_ids, mask, type_ids])\n\n # Validate that the outputs are of the expected shape.\n expected_classification_shape = [None, num_classes]\n self.assertAllEqual(expected_classification_shape, cls_outs.shape.as_list())\n\n @parameterized.parameters(1, 2)\n def test_bert_trainer_tensor_call(self, num_classes):\n \"\"\"Validate that the Keras object can be invoked.\"\"\"\n # Build a transformer network to use within the BERT trainer. (Here, we use\n # a short sequence_length for convenience.)\n test_network = networks.BertEncoder(vocab_size=100, num_layers=2)\n\n # Create a BERT trainer with the created network.\n bert_trainer_model = bert_classifier.BertClassifier(\n test_network, num_classes=num_classes)\n\n # Create a set of 2-dimensional data tensors to feed into the model.\n word_ids = tf.constant([[1, 1], [2, 2]], dtype=tf.int32)\n mask = tf.constant([[1, 1], [1, 0]], dtype=tf.int32)\n type_ids = tf.constant([[1, 1], [2, 2]], dtype=tf.int32)\n\n # Invoke the trainer model on the tensors. In Eager mode, this does the\n # actual calculation. (We can't validate the outputs, since the network is\n # too complex: this simply ensures we're not hitting runtime errors.)\n _ = bert_trainer_model([word_ids, mask, type_ids])\n\n def test_serialize_deserialize(self):\n \"\"\"Validate that the BERT trainer can be serialized and deserialized.\"\"\"\n # Build a transformer network to use within the BERT trainer. (Here, we use\n # a short sequence_length for convenience.)\n test_network = networks.BertEncoder(\n vocab_size=100, num_layers=2, sequence_length=5)\n\n # Create a BERT trainer with the created network. (Note that all the args\n # are different, so we can catch any serialization mismatches.)\n bert_trainer_model = bert_classifier.BertClassifier(\n test_network, num_classes=4, initializer='zeros')\n\n # Create another BERT trainer via serialization and deserialization.\n config = bert_trainer_model.get_config()\n new_bert_trainer_model = bert_classifier.BertClassifier.from_config(config)\n\n # Validate that the config can be forced to JSON.\n _ = new_bert_trainer_model.to_json()\n\n # If the serialization was successful, the new config should match the old.\n self.assertAllEqual(bert_trainer_model.get_config(),\n new_bert_trainer_model.get_config())\n\n\nif __name__ == '__main__':\n tf.test.main()\n"
] | [
[
"tensorflow.constant",
"tensorflow.test.main",
"tensorflow.keras.Input"
]
] |
MathMachado/tensorflow | [
"56afda20b15f234c23e8393f7e337e7dd2659c2d"
] | [
"tensorflow/python/ops/math_grad.py"
] | [
"# Copyright 2015 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\"\"\"Gradients for operators defined in math_ops.py.\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport numpy as np\n\nfrom tensorflow.python import pywrap_tensorflow as c_api\nfrom tensorflow.python.compat import compat\nfrom tensorflow.python.eager import context\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.ops import array_ops\nfrom tensorflow.python.ops import gen_array_ops\nfrom tensorflow.python.ops import gen_math_ops\nfrom tensorflow.python.ops import math_ops\nfrom tensorflow.python.util import object_identity\n\n\ndef _safe_shape_div(x, y):\n \"\"\"Divides `x / y` assuming `x, y >= 0`, treating `0 / 0 = 0`.\"\"\"\n return x // math_ops.maximum(y, 1)\n\n\[email protected](\"ArgMax\")\ndef _ArgMaxGrad(op, grad):\n del op, grad\n return [None, None]\n\n\[email protected](\"ArgMin\")\ndef _ArgMinGrad(op, grad):\n del op, grad\n return [None, None]\n\n\n# TODO(rmlarsen): Implement gradient.\nops.NotDifferentiable(\"EuclideanNorm\")\n\n\ndef SmartBroadcastGradientArgs(x, y, grad):\n \"\"\"Optimized version of `broadcast_gradient_args` that caches results.\n\n This implementation avoids creating `broadcast_gradient_args` ops in the case\n that the input shapes are fully defined, and provides hints to the calling\n code that can be used to avoid creating reduction and reshaping ops.\n\n Args:\n x: The left input tensor to a broadcasting binary op.\n y: The right input tensor to a broadcasting binary op.\n grad: The incoming gradient tensor for a broadcasting binary op.\n\n Returns:\n A pair of tuples, containing:\n * A 3-tuple of broadcast information for x, containing:\n * The shape of x (as a tuple or Tensor).\n * The reduction indices for x (as a tuple or Tensor).\n * A boolean, which if True, indicates that x's shape differs from grad's\n shape (and so x's gradient must be reduced and/or reshaped).\n * A 3-tuple of broadcast information for y, containing the respective\n details for y.\n \"\"\"\n # NOTE: It may be productive to apply these optimizations in the eager case\n # as well.\n if context.executing_eagerly() or not (\n isinstance(x, ops.Tensor) and isinstance(y, ops.Tensor)\n and isinstance(grad, ops.Tensor)):\n sx = array_ops.shape(x)\n sy = array_ops.shape(y)\n rx, ry = gen_array_ops.broadcast_gradient_args(sx, sy)\n return (sx, rx, True), (sy, ry, True)\n\n # pylint: disable=protected-access\n x_shape_tuple = x._shape_tuple()\n y_shape_tuple = y._shape_tuple()\n grad_shape_tuple = grad._shape_tuple()\n # pylint: enable=protected-access\n\n if (x_shape_tuple is None or None in x_shape_tuple or\n y_shape_tuple is None or None in y_shape_tuple):\n sx = array_ops.shape_internal(x, optimize=False)\n sy = array_ops.shape_internal(y, optimize=False)\n rx, ry = gen_array_ops.broadcast_gradient_args(sx, sy)\n return (sx, rx, True), (sy, ry, True)\n\n x_needs_reduction = x_shape_tuple != grad_shape_tuple\n y_needs_reduction = y_shape_tuple != grad_shape_tuple\n\n # Get the default graph rather than relying on `x.graph`, `y.graph`, or\n # `grad.graph`, because these may be eager tensors.\n g = ops.get_default_graph()\n\n try:\n rx, ry = g._bcast_grad_args_cache[(x_shape_tuple, y_shape_tuple)] # pylint: disable=protected-access\n return (x_shape_tuple, rx, x_needs_reduction), (\n y_shape_tuple, ry, y_needs_reduction)\n except KeyError:\n rx, ry = array_ops.broadcast_gradient_args(x_shape_tuple, y_shape_tuple)\n # TODO(mrry): If this becomes a bottleneck, add a multi-output version of\n # `TF_TryEvaluateConstant()`.\n rx_value = tuple(c_api.TF_TryEvaluateConstant_wrapper(\n rx.graph._c_graph, rx._as_tf_output())) # pylint: disable=protected-access\n assert rx_value is not None\n ry_value = tuple(c_api.TF_TryEvaluateConstant_wrapper(\n ry.graph._c_graph, ry._as_tf_output())) # pylint: disable=protected-access\n assert ry_value is not None\n g._bcast_grad_args_cache[(x_shape_tuple, y_shape_tuple)] = ( # pylint: disable=protected-access\n rx_value, ry_value)\n\n return (x_shape_tuple, rx_value, x_needs_reduction), (\n y_shape_tuple, ry_value, y_needs_reduction)\n\n\n_empty_tuple = ()\n\n\ndef _IsScalar(x):\n return x._shape_tuple() is _empty_tuple # pylint: disable=protected-access\n\n\[email protected](\"Sum\")\ndef _SumGrad(op, grad):\n \"\"\"Gradient for Sum.\"\"\"\n # Fast path for when reducing to a scalar and ndims is known: adds only\n # Reshape and Tile ops (and possibly a Shape).\n input_0_shape = op.inputs[0]._shape_tuple() # pylint: disable=protected-access\n if input_0_shape is not None:\n axes = tensor_util.constant_value(op.inputs[1])\n if axes is not None:\n rank = len(input_0_shape)\n if np.array_equal(axes, np.arange(rank)): # Reduce all dims.\n if context.executing_eagerly():\n ctx = context.context()\n new_shape = ctx.ones_rank_cache().get(rank)\n if new_shape is None:\n new_shape = constant_op.constant([1] * rank, dtype=dtypes.int32)\n ctx.ones_rank_cache().put(rank, new_shape)\n else:\n new_shape = [1] * rank\n grad = array_ops.reshape(grad, new_shape)\n # If shape is not fully defined (but rank is), we use Shape.\n if None not in input_0_shape:\n input_shape = constant_op.constant(input_0_shape, dtype=dtypes.int32)\n else:\n input_shape = array_ops.shape(op.inputs[0])\n return [array_ops.tile(grad, input_shape), None]\n elif None not in input_0_shape and not context.executing_eagerly():\n # The shape and reduction indices are statically known, so we use a\n # graph-level cache to avoid recomputing `reduced_shape()` for each\n # invocation.\n graph = ops.get_default_graph()\n\n # Canonicalize `axes` to be a tuple of indices. The incoming\n # value may be a scalar or a vector, and may include negative indices.\n axes = tuple(axes.reshape(-1))\n\n try:\n output_shape_kept_dims, tile_scaling = graph._reduced_shape_cache[ # pylint: disable=protected-access\n (input_0_shape, axes)]\n except KeyError:\n\n # Compute and cache `output_shape_kept_dims` and `tile_scaling`.\n def EvaluateAsTuple(t):\n value = c_api.TF_TryEvaluateConstant_wrapper(\n t.graph._c_graph, t._as_tf_output()) # pylint: disable=protected-access\n assert value is not None\n return tuple(value)\n\n output_shape_kept_dims = EvaluateAsTuple(\n math_ops.reduced_shape(input_0_shape, axes))\n tile_scaling = EvaluateAsTuple(\n _safe_shape_div(input_0_shape, output_shape_kept_dims))\n graph._reduced_shape_cache[(input_0_shape, axes)] = ( # pylint:disable=protected-access\n output_shape_kept_dims, tile_scaling)\n\n grad = array_ops.reshape(grad, output_shape_kept_dims)\n return [array_ops.tile(grad, tile_scaling), None]\n\n input_shape = array_ops.shape(op.inputs[0])\n\n if compat.forward_compatible(2019, 9, 23):\n if not op.get_attr(\"keep_dims\"):\n with ops.colocate_with(input_shape):\n # TODO(apassos) remove this once device placement for eager ops makes\n # more sense.\n output_shape_kept_dims = math_ops.reduced_shape(input_shape,\n op.inputs[1])\n grad = array_ops.reshape(grad, output_shape_kept_dims)\n return [array_ops.broadcast_to(grad, input_shape), None]\n with ops.colocate_with(input_shape):\n output_shape_kept_dims = math_ops.reduced_shape(input_shape, op.inputs[1])\n tile_scaling = _safe_shape_div(input_shape, output_shape_kept_dims)\n grad = array_ops.reshape(grad, output_shape_kept_dims)\n return [array_ops.tile(grad, tile_scaling), None]\n\n\ndef _MinOrMaxGrad(op, grad):\n \"\"\"Gradient for Min or Max. Amazingly it's precisely the same code.\"\"\"\n input_shape = array_ops.shape(op.inputs[0])\n y = op.outputs[0]\n if not op.get_attr(\"keep_dims\"):\n output_shape_kept_dims = math_ops.reduced_shape(input_shape, op.inputs[1])\n y = array_ops.reshape(y, output_shape_kept_dims)\n grad = array_ops.reshape(grad, output_shape_kept_dims)\n else:\n output_shape_kept_dims = array_ops.shape(y)\n\n # Compute the number of selected (maximum or minimum) elements in each\n # reduction dimension. If there are multiple minimum or maximum elements\n # then the gradient will be divided between them.\n indicators = math_ops.cast(math_ops.equal(y, op.inputs[0]), grad.dtype)\n num_selected = array_ops.reshape(\n math_ops.reduce_sum(indicators, op.inputs[1]), output_shape_kept_dims)\n\n return [math_ops.divide(indicators, num_selected) * grad, None]\n\n\[email protected](\"Max\")\ndef _MaxGrad(op, grad):\n \"\"\"Gradient for Max.\"\"\"\n return _MinOrMaxGrad(op, grad)\n\n\[email protected](\"Min\")\ndef _MinGrad(op, grad):\n return _MinOrMaxGrad(op, grad)\n\n\[email protected](\"Mean\")\ndef _MeanGrad(op, grad):\n \"\"\"Gradient for Mean.\"\"\"\n sum_grad = _SumGrad(op, grad)[0]\n input_shape = op.inputs[0]._shape_tuple() # pylint: disable=protected-access\n output_shape = op.outputs[0]._shape_tuple() # pylint: disable=protected-access\n if (input_shape is not None and output_shape is not None and\n None not in input_shape and None not in output_shape):\n input_size = np.prod(input_shape)\n output_size = np.prod(output_shape)\n factor = input_size // max(output_size, 1)\n factor = constant_op.constant(factor, dtype=sum_grad.dtype)\n else:\n input_shape = array_ops.shape(op.inputs[0])\n output_shape = array_ops.shape(op.outputs[0])\n factor = _safe_shape_div(\n math_ops.reduce_prod(input_shape), math_ops.reduce_prod(output_shape))\n return math_ops.truediv(sum_grad, math_ops.cast(factor, sum_grad.dtype)), None\n\n\[email protected](\"Prod\")\ndef _ProdGrad(op, grad):\n \"\"\"Gradient for Prod.\"\"\"\n # The gradient can be expressed by dividing the product by each entry of the\n # input tensor, but this approach can't deal with zeros in the input.\n # Here, we avoid this problem by composing the output as a product of two\n # cumprod operations.\n\n input_shape = array_ops.shape(op.inputs[0])\n # Reshape reduction indices for the case where the parameter is a scalar\n reduction_indices = array_ops.reshape(op.inputs[1], [-1])\n\n if compat.forward_compatible(2019, 9, 23):\n # Expand grad to full input shape\n if not op.get_attr(\"keep_dims\"):\n output_shape_kept_dims = math_ops.reduced_shape(input_shape, op.inputs[1])\n grad = array_ops.reshape(grad, output_shape_kept_dims)\n\n grad = array_ops.broadcast_to(grad, input_shape)\n else:\n output_shape_kept_dims = math_ops.reduced_shape(input_shape, op.inputs[1])\n tile_scaling = _safe_shape_div(input_shape, output_shape_kept_dims)\n grad = array_ops.reshape(grad, output_shape_kept_dims)\n grad = array_ops.tile(grad, tile_scaling)\n\n # Pack all reduced dimensions into a single one, so we can perform the\n # cumprod ops. If the reduction dims list is empty, it defaults to float32,\n # so we need to cast here. We put all the shape-related ops on CPU to avoid\n # copying back and forth, and since listdiff is CPU only.\n with ops.device(\"/cpu:0\"):\n rank = array_ops.rank(op.inputs[0])\n reduction_indices = (reduction_indices + rank) % rank\n reduced = math_ops.cast(reduction_indices, dtypes.int32)\n idx = math_ops.range(0, rank)\n other, _ = array_ops.setdiff1d(idx, reduced)\n perm = array_ops.concat([reduced, other], 0)\n reduced_num = math_ops.reduce_prod(array_ops.gather(input_shape, reduced))\n other_num = math_ops.reduce_prod(array_ops.gather(input_shape, other))\n permuted = array_ops.transpose(op.inputs[0], perm)\n permuted_shape = array_ops.shape(permuted)\n reshaped = array_ops.reshape(permuted, (reduced_num, other_num))\n\n # Calculate product, leaving out the current entry\n left = math_ops.cumprod(reshaped, axis=0, exclusive=True)\n right = math_ops.cumprod(reshaped, axis=0, exclusive=True, reverse=True)\n # For complex inputs, the gradient is in the conjugate direction.\n y = array_ops.reshape(\n math_ops.conj(left) * math_ops.conj(right), permuted_shape)\n\n # Invert the transpose and reshape operations.\n # Make sure to set the statically known shape information through a reshape.\n out = grad * array_ops.transpose(y, array_ops.invert_permutation(perm))\n return array_ops.reshape(out, input_shape), None\n\n\[email protected](\"SegmentSum\")\ndef _SegmentSumGrad(op, grad):\n \"\"\"Gradient for SegmentSum.\"\"\"\n return array_ops.gather(grad, op.inputs[1]), None\n\n\[email protected](\"SegmentMean\")\ndef _SegmentMeanGrad(op, grad):\n \"\"\"Gradient for SegmentMean.\"\"\"\n input_rank = array_ops.rank(op.inputs[0])\n ones_shape = array_ops.concat([\n array_ops.shape(op.inputs[1]),\n array_ops.fill(array_ops.expand_dims(input_rank - 1, 0), 1)\n ], 0)\n ones = array_ops.fill(ones_shape, constant_op.constant(1, dtype=grad.dtype))\n scaled_grad = math_ops.divide(grad, math_ops.segment_sum(ones, op.inputs[1]))\n return array_ops.gather(scaled_grad, op.inputs[1]), None\n\n\[email protected](\"SparseSegmentSum\")\ndef _SparseSegmentSumGrad(op, grad):\n \"\"\"Gradient for SparseSegmentSum.\"\"\"\n input_rows = array_ops.shape(op.inputs[0])[0]\n return (math_ops.unsorted_segment_sum(\n array_ops.gather(grad, op.inputs[2]), op.inputs[1], input_rows), None,\n None)\n\n\[email protected](\"SparseSegmentSumWithNumSegments\")\ndef _SparseSegmentSumWithNumSegmentsGrad(op, grad):\n \"\"\"Gradient for SparseSegmentSumWithNumSegments.\"\"\"\n input_rows = array_ops.shape(op.inputs[0])[0]\n return (math_ops.unsorted_segment_sum(\n array_ops.gather(grad, op.inputs[2]), op.inputs[1], input_rows), None,\n None, None)\n\n\[email protected](\"SparseSegmentMean\")\ndef _SparseSegmentMeanGrad(op, grad):\n \"\"\"Gradient for SparseSegmentMean.\"\"\"\n dim0 = array_ops.shape(op.inputs[0])[0]\n return (math_ops.sparse_segment_mean_grad(grad, op.inputs[1], op.inputs[2],\n dim0), None, None)\n\n\[email protected](\"SparseSegmentMeanWithNumSegments\")\ndef _SparseSegmentMeanWithNumSegmentsGrad(op, grad):\n \"\"\"Gradient for SparseSegmentMeanWithNumSegments.\"\"\"\n dim0 = array_ops.shape(op.inputs[0])[0]\n return (math_ops.sparse_segment_mean_grad(grad, op.inputs[1], op.inputs[2],\n dim0), None, None, None)\n\n\[email protected](\"SparseSegmentSqrtN\")\ndef _SparseSegmentSqrtNGrad(op, grad):\n \"\"\"Gradient for SparseSegmentSqrtN.\"\"\"\n dim0 = array_ops.shape(op.inputs[0])[0]\n return (math_ops.sparse_segment_sqrt_n_grad(grad, op.inputs[1], op.inputs[2],\n dim0), None, None)\n\n\[email protected](\"SparseSegmentSqrtNWithNumSegments\")\ndef _SparseSegmentSqrtNWithNumSegmentsGrad(op, grad):\n \"\"\"Gradient for SparseSegmentSqrtNWithNumSegments.\"\"\"\n dim0 = array_ops.shape(op.inputs[0])[0]\n return (math_ops.sparse_segment_sqrt_n_grad(grad, op.inputs[1], op.inputs[2],\n dim0), None, None, None)\n\n\ndef _SegmentMinOrMaxGrad(op, grad):\n \"\"\" Gradient for SegmentMin and SegmentMax. \"\"\"\n zeros = array_ops.zeros_like(op.inputs[0], dtype=op.inputs[0].dtype)\n # Get the number of selected (minimum or maximum) elements in each segment.\n gathered_outputs = array_ops.gather(op.outputs[0], op.inputs[1])\n is_selected = math_ops.equal(op.inputs[0], gathered_outputs)\n num_selected = math_ops.segment_sum(\n math_ops.cast(is_selected, grad.dtype), op.inputs[1])\n # Compute the gradient for each segment. The gradient for the ith segment is\n # divided evenly among the selected elements in that segment.\n weighted_grads = math_ops.divide(grad, num_selected)\n gathered_grads = array_ops.gather(weighted_grads, op.inputs[1])\n return array_ops.where(is_selected, gathered_grads, zeros), None\n\n\[email protected](\"SegmentMin\")\ndef _SegmentMinGrad(op, grad):\n \"\"\"Gradient for SegmentMin.\"\"\"\n return _SegmentMinOrMaxGrad(op, grad)\n\n\[email protected](\"SegmentMax\")\ndef _SegmentMaxGrad(op, grad):\n \"\"\"Gradient for SegmentMax.\"\"\"\n return _SegmentMinOrMaxGrad(op, grad)\n\n\ndef _GatherDropNegatives(params,\n ids,\n zero_clipped_indices=None,\n is_positive=None):\n \"\"\" Helper function for unsorted segment ops.\n\n Gathers params for\n positive segment ids and gathers 0 for inputs with negative segment id.\n Also returns the clipped indices and a boolean mask with the same shape\n as ids where a positive id is masked as true. With this, the latter two\n can be passed as arguments to this function to reuse them.\n \"\"\"\n if zero_clipped_indices is None:\n zero_clipped_indices = math_ops.maximum(ids, array_ops.zeros_like(ids))\n gathered = array_ops.gather(params, zero_clipped_indices)\n if is_positive is None:\n is_positive = math_ops.greater_equal(ids, 0)\n # tf.where(condition, x, y) requires condition to have the same shape as x\n # and y.\n # todo(philjd): remove this if tf.where supports broadcasting (#9284)\n for _ in range(gathered.shape.ndims - is_positive.shape.ndims):\n is_positive = array_ops.expand_dims(is_positive, -1)\n is_positive = (\n is_positive & array_ops.ones_like(gathered, dtype=dtypes.bool))\n # replace gathered params of negative indices with 0\n zero_slice = array_ops.zeros_like(gathered)\n return (array_ops.where(is_positive, gathered, zero_slice),\n zero_clipped_indices, is_positive)\n\n\ndef _UnsortedSegmentMinOrMaxGrad(op, grad):\n \"\"\" Gradient for UnsortedSegmentMin and UnsortedSegmentMax. \"\"\"\n # Get the number of selected (minimum or maximum) elements in each segment.\n gathered_outputs, zero_clipped_indices, is_positive = \\\n _GatherDropNegatives(op.outputs[0], op.inputs[1])\n is_selected = math_ops.equal(op.inputs[0], gathered_outputs)\n is_selected = math_ops.logical_and(is_selected, is_positive)\n num_selected = math_ops.unsorted_segment_sum(\n math_ops.cast(is_selected, grad.dtype), op.inputs[1], op.inputs[2])\n # Compute the gradient for each segment. The gradient for the ith segment is\n # divided evenly among the selected elements in that segment.\n weighted_grads = math_ops.divide(grad, num_selected)\n gathered_grads, _, _ = _GatherDropNegatives(weighted_grads, None,\n zero_clipped_indices, is_positive)\n zeros = array_ops.zeros_like(gathered_grads)\n return array_ops.where(is_selected, gathered_grads, zeros), None, None\n\n\[email protected](\"UnsortedSegmentSum\")\ndef _UnsortedSegmentSumGrad(op, grad):\n \"\"\"Gradient for UnsortedSegmentSum.\"\"\"\n return _GatherDropNegatives(grad, op.inputs[1])[0], None, None\n\n\[email protected](\"UnsortedSegmentMax\")\ndef _UnsortedSegmentMaxGrad(op, grad):\n \"\"\" Gradient for UnsortedSegmentMax. \"\"\"\n return _UnsortedSegmentMinOrMaxGrad(op, grad)\n\n\[email protected](\"UnsortedSegmentMin\")\ndef _UnsortedSegmentMinGrad(op, grad):\n \"\"\" Gradient for UnsortedSegmentMin. \"\"\"\n return _UnsortedSegmentMinOrMaxGrad(op, grad)\n\n\[email protected](\"UnsortedSegmentProd\")\ndef _UnsortedSegmentProdGrad(op, grad):\n \"\"\" Gradient for UnsortedSegmentProd.\n\n The gradient can be expressed for each segment by dividing the segment's\n product by each element of the segment input tensor, but this approach can't\n deal with zeros in the input.\n Unlike reduce_prod we can't use cumsum here as individual segments may have\n a different number of elements. Therefore we consider three cases:\n 1) A segment input contains no zeros and we can safely divide by the input\n tensor.\n 2) A segment contains exactly one zero. Then the gradient of each input of\n the segment is zero except for the 0-input, there the gradient is\n the product of the remaining segment entries.\n 3) A segment contains at least two zeros. The gradient is zero for all\n segment inputs.\n \"\"\"\n # Note that unsorted_segment_sum will filter out the negative indices,\n # so we don't need to do a logical_and with is_positive here\n is_zero = math_ops.equal(op.inputs[0], 0)\n num_zeros = gen_math_ops.unsorted_segment_sum(\n math_ops.cast(is_zero, dtype=dtypes.int32), op.inputs[1], op.inputs[2])\n # handle case 3 and set the gradient to 0 for segments with more than one\n # 0 as input\n grad = array_ops.where(\n math_ops.greater(num_zeros, 1), array_ops.zeros_like(grad), grad)\n # replace all zeros with ones and compute the unsorted_segment_prod\n non_zero_data = array_ops.where(is_zero, array_ops.ones_like(op.inputs[0]),\n op.inputs[0])\n non_zero_prod = gen_math_ops.unsorted_segment_prod(non_zero_data,\n op.inputs[1], op.inputs[2])\n # clip the indices for gather to be positive\n zero_clipped_indices = math_ops.maximum(op.inputs[1],\n array_ops.zeros_like(op.inputs[1]))\n gathered_prod = array_ops.gather(op.outputs[0], zero_clipped_indices)\n gathered_non_zero_prod = array_ops.gather(non_zero_prod, zero_clipped_indices)\n prod_divided_by_el = gathered_prod / op.inputs[0] # May contain nan/inf.\n # Now fetch the individual results for segments containing 0 and those that\n # don't. is_zero will also fetch results for entries with negative index\n # but the following gather_drop_negatives sets the corresponding entry in\n # grad to 0 for these\n partial_derivative = array_ops.where(is_zero, gathered_non_zero_prod,\n prod_divided_by_el)\n gathered_grad = _GatherDropNegatives(grad, op.inputs[1],\n zero_clipped_indices)[0]\n return gathered_grad * partial_derivative, None, None\n\n\[email protected](\"Abs\")\ndef _AbsGrad(op, grad):\n x = op.inputs[0]\n return grad * math_ops.sign(x)\n\n\[email protected](\"Neg\")\ndef _NegGrad(_, grad):\n \"\"\"Returns -grad.\"\"\"\n return -grad\n\n\[email protected](\"Inv\")\ndef _InvGrad(op, grad):\n \"\"\"Returns -grad * (1 / x^2).\"\"\"\n y = op.outputs[0] # y = 1 / x\n return gen_math_ops.reciprocal_grad(y, grad)\n\n\[email protected](\"Reciprocal\")\ndef _ReciprocalGrad(op, grad):\n \"\"\"Returns -grad * (1 / x^2).\"\"\"\n y = op.outputs[0] # y = 1 / x\n return gen_math_ops.reciprocal_grad(y, grad)\n\n\[email protected](\"InvGrad\")\ndef _InvGradGrad(op, grad):\n b = op.inputs[1]\n # op.output[0]: y = -b * conj(a)^2\n with ops.control_dependencies([grad]):\n ca = math_ops.conj(op.inputs[0])\n cg = math_ops.conj(grad)\n return cg * -2.0 * b * ca, gen_math_ops.reciprocal_grad(ca, grad)\n\n\[email protected](\"ReciprocalGrad\")\ndef _ReciprocalGradGrad(op, grad):\n b = op.inputs[1]\n # op.output[0]: y = -b * conj(a)^2\n with ops.control_dependencies([grad]):\n ca = math_ops.conj(op.inputs[0])\n cg = math_ops.conj(grad)\n return cg * -2.0 * b * ca, gen_math_ops.reciprocal_grad(ca, grad)\n\n\[email protected](\"Square\")\ndef _SquareGrad(op, grad):\n x = op.inputs[0]\n # Added control dependencies to prevent 2*x from being computed too early.\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n y = constant_op.constant(2.0, dtype=x.dtype)\n return math_ops.multiply(grad, math_ops.multiply(x, y))\n\n\[email protected](\"Sqrt\")\ndef _SqrtGrad(op, grad):\n y = op.outputs[0] # y = x^(1/2)\n return gen_math_ops.sqrt_grad(y, grad)\n\n\[email protected](\"SqrtGrad\")\ndef _SqrtGradGrad(op, grad):\n a = op.inputs[0]\n y = op.outputs[0] # y = 0.5 * b / conj(a)\n with ops.control_dependencies([grad]):\n if compat.forward_compatible(2019, 9, 14):\n ga = gen_math_ops.xdivy(grad, a)\n return -gen_math_ops.mul_no_nan(y, math_ops.conj(ga)), 0.5 * ga\n else:\n ga = grad / a\n return -math_ops.conj(ga) * y, 0.5 * ga\n\n\[email protected](\"Rsqrt\")\ndef _RsqrtGrad(op, grad):\n \"\"\"Returns -0.5 * grad * conj(y)^3.\"\"\"\n y = op.outputs[0] # y = x^(-1/2)\n return gen_math_ops.rsqrt_grad(y, grad)\n\n\[email protected](\"RsqrtGrad\")\ndef _RsqrtGradGrad(op, grad):\n \"\"\"Returns backprop gradient for f(a,b) = -0.5 * b * conj(a)^3.\"\"\"\n a = op.inputs[0] # a = x^{-1/2}\n b = op.inputs[1] # backprop gradient for a\n with ops.control_dependencies([grad]):\n ca = math_ops.conj(a)\n cg = math_ops.conj(grad)\n grad_a = -1.5 * cg * b * math_ops.square(ca)\n grad_b = gen_math_ops.rsqrt_grad(ca, grad)\n return grad_a, grad_b\n\n\[email protected](\"Exp\")\ndef _ExpGrad(op, grad):\n \"\"\"Returns grad * exp(x).\"\"\"\n y = op.outputs[0] # y = e^x\n with ops.control_dependencies([grad]):\n y = math_ops.conj(y)\n if compat.forward_compatible(2019, 9, 14):\n return math_ops.mul_no_nan(y, grad)\n else:\n return grad * y\n\n\[email protected](\"Expm1\")\ndef _Expm1Grad(op, grad):\n \"\"\"Returns grad * exp(x).\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n y = math_ops.exp(x)\n if compat.forward_compatible(2019, 9, 14):\n return math_ops.mul_no_nan(y, grad)\n else:\n return grad * y\n\n\[email protected](\"Log\")\ndef _LogGrad(op, grad):\n \"\"\"Returns grad * (1/x).\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n if compat.forward_compatible(2019, 9, 14):\n return gen_math_ops.xdivy(grad, x)\n else:\n return grad * math_ops.reciprocal(x)\n\n\[email protected](\"Log1p\")\ndef _Log1pGrad(op, grad):\n \"\"\"Returns grad * (1/(1 + x)).\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n if compat.forward_compatible(2019, 9, 14):\n return gen_math_ops.xdivy(grad, 1 + x)\n else:\n return grad * math_ops.reciprocal(1 + x)\n\n\[email protected](\"Xlogy\")\ndef _XLogyGrad(op, grad):\n \"\"\"Returns gradient of xlogy(x, y) with respect to x and y.\"\"\"\n x = op.inputs[0]\n y = op.inputs[1]\n sx = array_ops.shape(x)\n sy = array_ops.shape(y)\n rx, ry = gen_array_ops.broadcast_gradient_args(sx, sy)\n with ops.control_dependencies([grad]):\n not_zero_x = math_ops.cast(\n math_ops.not_equal(x, math_ops.cast(0., dtype=x.dtype)), dtype=x.dtype)\n partial_x = gen_math_ops.xlogy(not_zero_x, y)\n partial_y = gen_math_ops.xdivy(x, y)\n return (array_ops.reshape(math_ops.reduce_sum(partial_x * grad, rx), sx),\n array_ops.reshape(math_ops.reduce_sum(partial_y * grad, ry), sy))\n\n\[email protected](\"Xdivy\")\ndef _XDivyGrad(op, grad):\n \"\"\"Returns gradient of xdivy(x, y) with respect to x and y.\"\"\"\n x = op.inputs[0]\n y = op.inputs[1]\n sx = array_ops.shape(x)\n sy = array_ops.shape(y)\n rx, ry = gen_array_ops.broadcast_gradient_args(sx, sy)\n with ops.control_dependencies([grad]):\n not_zero_x = math_ops.cast(\n math_ops.not_equal(x, math_ops.cast(0., dtype=x.dtype)), dtype=x.dtype)\n partial_x = gen_math_ops.xdivy(not_zero_x, y)\n partial_y = gen_math_ops.xdivy(math_ops.negative(x), y**2)\n return (array_ops.reshape(math_ops.reduce_sum(partial_x * grad, rx), sx),\n array_ops.reshape(math_ops.reduce_sum(partial_y * grad, ry), sy))\n\n\[email protected](\"Sinh\")\ndef _SinhGrad(op, grad):\n \"\"\"Returns grad * cosh(x).\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n return grad * math_ops.cosh(x)\n\n\[email protected](\"Cosh\")\ndef _CoshGrad(op, grad):\n \"\"\"Returns grad * sinh(x).\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n return grad * math_ops.sinh(x)\n\n\[email protected](\"Tanh\")\ndef _TanhGrad(op, grad):\n \"\"\"Returns grad * (1 - tanh(x) * tanh(x)).\"\"\"\n y = op.outputs[0] # y = tanh(x)\n with ops.control_dependencies([grad]):\n y = math_ops.conj(y)\n return gen_math_ops.tanh_grad(y, grad)\n\n\[email protected](\"Asinh\")\ndef _AsinhGrad(op, grad):\n \"\"\"Returns grad * 1/cosh(y).\"\"\"\n y = op.outputs[0]\n with ops.control_dependencies([grad]):\n y = math_ops.conj(y)\n return grad / math_ops.cosh(y)\n\n\[email protected](\"Acosh\")\ndef _AcoshGrad(op, grad):\n \"\"\"Returns grad * 1/sinh(y).\"\"\"\n y = op.outputs[0]\n with ops.control_dependencies([grad]):\n y = math_ops.conj(y)\n if compat.forward_compatible(2019, 9, 14):\n return math_ops.xdivy(grad, math_ops.sinh(y))\n else:\n return grad / math_ops.sinh(y)\n\n\[email protected](\"Atanh\")\ndef _AtanhGrad(op, grad):\n \"\"\"Returns grad * 1/ (1 - x^2).\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n x2 = math_ops.square(x)\n one = constant_op.constant(1, dtype=grad.dtype)\n inv = math_ops.reciprocal(math_ops.subtract(one, x2))\n return grad * inv\n\n\[email protected](\"TanhGrad\")\ndef _TanhGradGrad(op, grad):\n with ops.control_dependencies([grad]):\n a = math_ops.conj(op.inputs[0])\n b = math_ops.conj(op.inputs[1])\n return grad * -2.0 * b * a, gen_math_ops.tanh_grad(a, grad)\n\n\[email protected](\"Erf\")\ndef _ErfGrad(op, grad):\n \"\"\"Returns grad * 2/sqrt(pi) * exp(-x**2).\"\"\"\n x = op.inputs[0]\n two_over_root_pi = constant_op.constant(2 / np.sqrt(np.pi), dtype=grad.dtype)\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n return grad * two_over_root_pi * math_ops.exp(-math_ops.square(x))\n\n\[email protected](\"Erfc\")\ndef _ErfcGrad(op, grad):\n \"\"\"Returns -grad * 2/sqrt(pi) * exp(-x**2).\"\"\"\n x = op.inputs[0]\n minus_two_over_root_pi = constant_op.constant(\n -2 / np.sqrt(np.pi), dtype=grad.dtype)\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n return grad * minus_two_over_root_pi * math_ops.exp(-math_ops.square(x))\n\n\[email protected](\"Lgamma\")\ndef _LgammaGrad(op, grad):\n \"\"\"Returns grad * digamma(x).\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n if compat.forward_compatible(2019, 9, 14):\n return math_ops.mul_no_nan(math_ops.digamma(x), grad)\n else:\n return grad * math_ops.digamma(x)\n\n\[email protected](\"Digamma\")\ndef _DigammaGrad(op, grad):\n \"\"\"Compute gradient of the digamma function with respect to its argument.\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n partial_x = math_ops.polygamma(array_ops.constant(1, dtype=x.dtype), x)\n if compat.forward_compatible(2019, 9, 14):\n return math_ops.mul_no_nan(partial_x, grad)\n else:\n return grad * partial_x\n\n\[email protected](\"BesselI0e\")\ndef _BesselI0eGrad(op, grad):\n \"\"\"Compute gradient of bessel_i0e(x) with respect to its argument.\"\"\"\n x = op.inputs[0]\n y = op.outputs[0]\n with ops.control_dependencies([grad]):\n partial_x = (math_ops.bessel_i1e(x) - math_ops.sign(x) * y)\n if compat.forward_compatible(2019, 9, 14):\n return math_ops.mul_no_nan(partial_x, grad)\n else:\n return grad * partial_x\n\n\[email protected](\"BesselI1e\")\ndef _BesselI1eGrad(op, grad):\n \"\"\"Compute gradient of bessel_i1e(x) with respect to its argument.\"\"\"\n x = op.inputs[0]\n y = op.outputs[0]\n with ops.control_dependencies([grad]):\n # For x = 0, the correct gradient is 0.5.\n # However, the main branch gives NaN because of the division by x, so\n # we impute the gradient manually.\n # An alternative solution is to express the gradient via bessel_i0e and\n # bessel_i2e, but the latter is not yet implemented in Eigen.\n eps = np.finfo(x.dtype.as_numpy_dtype).eps\n zeros = array_ops.zeros_like(x)\n x_is_not_tiny = math_ops.abs(x) > eps\n safe_x = array_ops.where(x_is_not_tiny, x, eps + zeros)\n dy_dx = math_ops.bessel_i0e(safe_x) - y * (\n math_ops.sign(safe_x) + math_ops.reciprocal(safe_x))\n dy_dx = array_ops.where(x_is_not_tiny, dy_dx, 0.5 + zeros)\n if compat.forward_compatible(2019, 9, 14):\n return math_ops.mul_no_nan(dy_dx, grad)\n else:\n return grad * dy_dx\n\n\[email protected](\"Igamma\")\ndef _IgammaGrad(op, grad):\n \"\"\"Returns gradient of igamma(a, x) with respect to a and x.\"\"\"\n a = op.inputs[0]\n x = op.inputs[1]\n sa = array_ops.shape(a)\n sx = array_ops.shape(x)\n ra, rx = gen_array_ops.broadcast_gradient_args(sa, sx)\n\n with ops.control_dependencies([grad]):\n partial_a = gen_math_ops.igamma_grad_a(a, x)\n # Perform operations in log space before summing, because Gamma(a)\n # and Gamma'(a) can grow large.\n partial_x = math_ops.exp(-x + (a - 1) * math_ops.log(x) -\n math_ops.lgamma(a))\n if compat.forward_compatible(2019, 9, 14):\n return (array_ops.reshape(\n math_ops.reduce_sum(math_ops.mul_no_nan(partial_a, grad), ra), sa),\n array_ops.reshape(\n math_ops.reduce_sum(math_ops.mul_no_nan(partial_x, grad), rx),\n sx))\n else:\n return (array_ops.reshape(math_ops.reduce_sum(partial_a * grad, ra), sa),\n array_ops.reshape(math_ops.reduce_sum(partial_x * grad, rx), sx))\n\n\[email protected](\"Igammac\")\ndef _IgammacGrad(op, grad):\n \"\"\"Returns gradient of igammac(a, x) = 1 - igamma(a, x) w.r.t. a and x.\"\"\"\n igamma_grad_a, igamma_grad_x = _IgammaGrad(op, grad)\n return (-igamma_grad_a, -igamma_grad_x)\n\n\[email protected](\"Betainc\")\ndef _BetaincGrad(op, grad):\n \"\"\"Returns gradient of betainc(a, b, x) with respect to x.\"\"\"\n # TODO(ebrevdo): Perhaps add the derivative w.r.t. a, b\n a, b, x = op.inputs\n\n # two cases: x is a scalar and a/b are same-shaped tensors, or vice\n # versa; so its sufficient to check against shape(a).\n sa = array_ops.shape(a)\n sx = array_ops.shape(x)\n _, rx = gen_array_ops.broadcast_gradient_args(sa, sx)\n\n # Perform operations in log space before summing, because terms\n # can grow large.\n log_beta = (\n gen_math_ops.lgamma(a) + gen_math_ops.lgamma(b) -\n gen_math_ops.lgamma(a + b))\n partial_x = math_ops.exp((b - 1) * math_ops.log(1 - x) +\n (a - 1) * math_ops.log(x) - log_beta)\n\n # TODO(b/36815900): Mark None return values as NotImplemented\n if compat.forward_compatible(2019, 9, 14):\n return (\n None, # da\n None, # db\n array_ops.reshape(\n math_ops.reduce_sum(math_ops.mul_no_nan(partial_x, grad), rx), sx))\n else:\n return (\n None, # da\n None, # db\n array_ops.reshape(math_ops.reduce_sum(partial_x * grad, rx), sx))\n\n\[email protected](\"Zeta\")\ndef _ZetaGrad(op, grad):\n \"\"\"Returns gradient of zeta(x, q) with respect to x and q.\"\"\"\n # TODO(tillahoffmann): Add derivative with respect to x\n x = op.inputs[0]\n q = op.inputs[1]\n # Broadcast gradients\n sx = array_ops.shape(x)\n sq = array_ops.shape(q)\n unused_rx, rq = gen_array_ops.broadcast_gradient_args(sx, sq)\n # Evaluate gradient\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n q = math_ops.conj(q)\n partial_q = -x * math_ops.zeta(x + 1, q)\n # TODO(b/36815900): Mark None return values as NotImplemented\n if compat.forward_compatible(2019, 9, 14):\n return (None,\n array_ops.reshape(\n math_ops.reduce_sum(math_ops.mul_no_nan(partial_q, grad), rq),\n sq))\n else:\n return (None,\n array_ops.reshape(math_ops.reduce_sum(partial_q * grad, rq), sq))\n\n\[email protected](\"Polygamma\")\ndef _PolygammaGrad(op, grad):\n \"\"\"Returns gradient of psi(n, x) with respect to n and x.\"\"\"\n # TODO(tillahoffmann): Add derivative with respect to n\n n = op.inputs[0]\n x = op.inputs[1]\n # Broadcast gradients\n sn = array_ops.shape(n)\n sx = array_ops.shape(x)\n unused_rn, rx = gen_array_ops.broadcast_gradient_args(sn, sx)\n # Evaluate gradient\n with ops.control_dependencies([grad]):\n n = math_ops.conj(n)\n x = math_ops.conj(x)\n partial_x = math_ops.polygamma(n + 1, x)\n # TODO(b/36815900): Mark None return values as NotImplemented\n if compat.forward_compatible(2019, 9, 14):\n return (None,\n array_ops.reshape(\n math_ops.reduce_sum(math_ops.mul_no_nan(partial_x, grad), rx),\n sx))\n else:\n return (None,\n array_ops.reshape(math_ops.reduce_sum(partial_x * grad, rx), sx))\n\n\[email protected](\"Sigmoid\")\ndef _SigmoidGrad(op, grad):\n \"\"\"Returns grad * sigmoid(x) * (1 - sigmoid(x)).\"\"\"\n y = op.outputs[0] # y = sigmoid(x)\n with ops.control_dependencies([grad]):\n y = math_ops.conj(y)\n return gen_math_ops.sigmoid_grad(y, grad)\n\n\[email protected](\"SigmoidGrad\")\ndef _SigmoidGradGrad(op, grad):\n with ops.control_dependencies([grad]):\n a = math_ops.conj(op.inputs[0])\n b = math_ops.conj(op.inputs[1])\n gb = grad * b\n return gb - 2.0 * gb * a, gen_math_ops.sigmoid_grad(a, grad)\n\n\[email protected](\"Sign\")\ndef _SignGrad(op, _):\n \"\"\"Returns 0.\"\"\"\n x = op.inputs[0]\n return array_ops.zeros(array_ops.shape(x), dtype=x.dtype)\n\n\[email protected](\"Sin\")\ndef _SinGrad(op, grad):\n \"\"\"Returns grad * cos(x).\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n return grad * math_ops.cos(x)\n\n\[email protected](\"Cos\")\ndef _CosGrad(op, grad):\n \"\"\"Returns grad * -sin(x).\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n return -grad * math_ops.sin(x)\n\n\[email protected](\"Tan\")\ndef _TanGrad(op, grad):\n \"\"\"Returns grad * 1/sec^2(x).\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n secx = math_ops.reciprocal(math_ops.cos(x))\n secx2 = math_ops.square(secx)\n if compat.forward_compatible(2019, 9, 14):\n return math_ops.mul_no_nan(secx2, grad)\n else:\n return secx2 * grad\n\n\[email protected](\"Asin\")\ndef _AsinGrad(op, grad):\n \"\"\"Returns grad * 1/sqrt(1-x^2).\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n x2 = math_ops.square(x)\n one = constant_op.constant(1, dtype=grad.dtype)\n den = math_ops.sqrt(math_ops.subtract(one, x2))\n if compat.forward_compatible(2019, 9, 14):\n return math_ops.xdivy(grad, den)\n else:\n inv = math_ops.reciprocal(den)\n return grad * inv\n\n\[email protected](\"Acos\")\ndef _AcosGrad(op, grad):\n \"\"\"Returns grad * -1/sqrt(1-x^2).\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n x2 = math_ops.square(x)\n one = constant_op.constant(1, dtype=grad.dtype)\n den = math_ops.sqrt(math_ops.subtract(one, x2))\n if compat.forward_compatible(2019, 9, 14):\n return -math_ops.xdivy(grad, den)\n else:\n inv = math_ops.reciprocal(den)\n return -grad * inv\n\n\[email protected](\"Atan\")\ndef _AtanGrad(op, grad):\n \"\"\"Returns grad * 1/ (1 + x^2).\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n x = math_ops.conj(x)\n x2 = math_ops.square(x)\n one = constant_op.constant(1, dtype=grad.dtype)\n inv = math_ops.reciprocal(math_ops.add(one, x2))\n return grad * inv\n\n\[email protected](\"Atan2\")\ndef _Atan2Grad(op, grad):\n \"\"\"Returns grad * x / (x^2 + y^2), grad * -y / (x^2 + y^2).\"\"\"\n y = op.inputs[0]\n x = op.inputs[1]\n with ops.control_dependencies([grad]):\n if compat.forward_compatible(2019, 9, 14):\n grad_inv = math_ops.xdivy(grad, (math_ops.square(x) + math_ops.square(y)))\n else:\n grad_inv = grad / (math_ops.square(x) + math_ops.square(y))\n return x * grad_inv, -y * grad_inv\n\n\[email protected](\"AddN\")\ndef _AddNGrad(op, grad):\n \"\"\"Copies the gradient to all inputs.\"\"\"\n # Not broadcasting.\n return [grad] * len(op.inputs)\n\n\ndef _ShapesFullySpecifiedAndEqual(x, y, grad):\n # pylint: disable=protected-access\n x_shape = x._shape_tuple()\n y_shape = y._shape_tuple()\n grad_shape = grad._shape_tuple()\n # pylint: enable=protected-access\n return (x_shape == y_shape and x_shape == grad_shape and\n x_shape is not None and None not in x_shape)\n\n\[email protected](\"Add\")\[email protected](\"AddV2\")\ndef _AddGrad(op, grad):\n \"\"\"Gradient for Add.\"\"\"\n y = op.inputs[1]\n skip_input_indices = None\n try:\n skip_input_indices = op.skip_input_indices\n if skip_input_indices is not None and 1 in skip_input_indices and _IsScalar(\n y):\n return grad, None\n except AttributeError:\n # No gradient skipping, so do the full gradient computation\n pass\n x = op.inputs[0]\n if (isinstance(grad, ops.Tensor) and\n _ShapesFullySpecifiedAndEqual(x, y, grad)):\n return grad, grad\n (sx, rx, must_reduce_x), (sy, ry, must_reduce_y) = (\n SmartBroadcastGradientArgs(x, y, grad))\n if skip_input_indices is not None and 0 in skip_input_indices:\n gx = None\n elif not must_reduce_x:\n gx = grad\n else:\n gx = array_ops.reshape(math_ops.reduce_sum(grad, rx), sx)\n if skip_input_indices is not None and 1 in skip_input_indices:\n gy = None\n elif not must_reduce_y:\n gy = grad\n else:\n gy = array_ops.reshape(math_ops.reduce_sum(grad, ry), sy)\n return (gx, gy)\n\n\[email protected](\"Sub\")\ndef _SubGrad(op, grad):\n \"\"\"Gradient for Sub.\"\"\"\n y = op.inputs[1]\n skip_input_indices = None\n try:\n skip_input_indices = op.skip_input_indices\n if skip_input_indices is not None and 1 in skip_input_indices and _IsScalar(\n y):\n return grad, None\n except AttributeError:\n # No gradient skipping, so do the full gradient computation\n pass\n x = op.inputs[0]\n if (isinstance(grad, ops.Tensor) and\n _ShapesFullySpecifiedAndEqual(x, y, grad)):\n return grad, -grad\n (sx, rx, must_reduce_x), (sy, ry, must_reduce_y) = (\n SmartBroadcastGradientArgs(x, y, grad))\n if skip_input_indices is not None and 0 in skip_input_indices:\n gx = None\n elif not must_reduce_x:\n gx = grad\n else:\n gx = array_ops.reshape(math_ops.reduce_sum(grad, rx), sx)\n if skip_input_indices is not None and 1 in skip_input_indices:\n gy = None\n elif not must_reduce_y:\n gy = -grad\n else:\n gy = array_ops.reshape(math_ops.reduce_sum(-grad, ry), sy)\n return (gx, gy)\n\n\[email protected](\"Mul\")\ndef _MulGrad(op, grad):\n \"\"\"The gradient of scalar multiplication.\"\"\"\n y = op.inputs[1]\n skip_input_indices = None\n try:\n skip_input_indices = op.skip_input_indices\n if skip_input_indices is not None and 1 in skip_input_indices and _IsScalar(\n y):\n return gen_math_ops.mul(grad, math_ops.conj(y)), None\n except AttributeError:\n # No gradient skipping, so do the full gradient computation\n pass\n x = op.inputs[0]\n if (isinstance(grad, ops.Tensor) and\n _ShapesFullySpecifiedAndEqual(x, y, grad) and\n grad.dtype in (dtypes.int32, dtypes.float32)):\n return gen_math_ops.mul(grad, y), gen_math_ops.mul(grad, x)\n assert x.dtype.base_dtype == y.dtype.base_dtype, (x.dtype, \" vs. \", y.dtype)\n\n (sx, rx, must_reduce_x), (sy, ry, must_reduce_y) = (\n SmartBroadcastGradientArgs(x, y, grad))\n x = math_ops.conj(x)\n y = math_ops.conj(y)\n if skip_input_indices is not None and 0 in skip_input_indices:\n gx = None\n elif not must_reduce_x:\n gx = gen_math_ops.mul(grad, y)\n else:\n gx = array_ops.reshape(\n math_ops.reduce_sum(gen_math_ops.mul(grad, y), rx), sx)\n if skip_input_indices is not None and 1 in skip_input_indices:\n gy = None\n elif not must_reduce_y:\n gy = gen_math_ops.mul(x, grad)\n else:\n gy = array_ops.reshape(\n math_ops.reduce_sum(gen_math_ops.mul(x, grad), ry), sy)\n return (gx, gy)\n\n\[email protected](\"MulNoNan\")\ndef _MulNoNanGrad(op, grad):\n \"\"\"The gradient of scalar multiplication with NaN-suppression.\"\"\"\n x = op.inputs[0]\n y = op.inputs[1]\n if (isinstance(grad, ops.Tensor) and\n _ShapesFullySpecifiedAndEqual(x, y, grad)):\n return gen_math_ops.mul_no_nan(grad, y), gen_math_ops.mul_no_nan(x, grad)\n assert x.dtype.base_dtype == y.dtype.base_dtype, (x.dtype, \" vs. \", y.dtype)\n sx = array_ops.shape(x)\n sy = array_ops.shape(y)\n rx, ry = gen_array_ops.broadcast_gradient_args(sx, sy)\n return (array_ops.reshape(\n math_ops.reduce_sum(gen_math_ops.mul_no_nan(grad, y), rx), sx),\n array_ops.reshape(\n math_ops.reduce_sum(gen_math_ops.mul_no_nan(x, grad), ry), sy))\n\n\[email protected](\"Div\")\ndef _DivGrad(op, grad):\n \"\"\"The gradient for the Div operator.\"\"\"\n x = op.inputs[0]\n y = op.inputs[1]\n sx = array_ops.shape(x)\n sy = array_ops.shape(y)\n rx, ry = gen_array_ops.broadcast_gradient_args(sx, sy)\n x = math_ops.conj(x)\n y = math_ops.conj(y)\n if compat.forward_compatible(2019, 9, 14):\n return (array_ops.reshape(\n math_ops.reduce_sum(math_ops.xdivy(grad, y), rx), sx),\n array_ops.reshape(\n math_ops.reduce_sum(\n math_ops.mul_no_nan(\n math_ops.divide(math_ops.divide(-x, y), y), grad), ry),\n sy))\n else:\n return (array_ops.reshape(\n math_ops.reduce_sum(math_ops.divide(grad, y), rx), sx),\n array_ops.reshape(\n math_ops.reduce_sum(\n grad * math_ops.divide(math_ops.divide(-x, y), y), ry), sy))\n\n\[email protected](\"FloorDiv\")\ndef _FloorDivGrad(_, unused_grad):\n \"\"\"The gradient for the FloorDiv operator.\"\"\"\n return None, None\n\n\[email protected](\"FloorMod\")\ndef _FloorModGrad(op, grad):\n \"\"\"Returns grad * (1, -floor(x/y)).\"\"\"\n x = math_ops.conj(op.inputs[0])\n y = math_ops.conj(op.inputs[1])\n\n sx = array_ops.shape(x)\n sy = array_ops.shape(y)\n rx, ry = gen_array_ops.broadcast_gradient_args(sx, sy)\n floor_xy = math_ops.floor_div(x, y)\n gx = array_ops.reshape(math_ops.reduce_sum(grad, rx), sx)\n gy = array_ops.reshape(\n math_ops.reduce_sum(grad * math_ops.negative(floor_xy), ry), sy)\n return gx, gy\n\n\[email protected](\"TruncateDiv\")\ndef _TruncateDivGrad(_, unused_grad):\n return None, None\n\n\[email protected](\"RealDiv\")\ndef _RealDivGrad(op, grad):\n \"\"\"RealDiv op gradient.\"\"\"\n x = op.inputs[0]\n y = op.inputs[1]\n sx = array_ops.shape(x)\n sy = array_ops.shape(y)\n rx, ry = gen_array_ops.broadcast_gradient_args(sx, sy)\n x = math_ops.conj(x)\n y = math_ops.conj(y)\n if compat.forward_compatible(2019, 9, 14):\n return (array_ops.reshape(\n math_ops.reduce_sum(math_ops.xdivy(grad, y), rx), sx),\n array_ops.reshape(\n math_ops.reduce_sum(\n math_ops.mul_no_nan(\n math_ops.realdiv(math_ops.realdiv(-x, y), y), grad),\n ry), sy))\n else:\n return (array_ops.reshape(\n math_ops.reduce_sum(math_ops.realdiv(grad, y), rx), sx),\n array_ops.reshape(\n math_ops.reduce_sum(\n grad * math_ops.realdiv(math_ops.realdiv(-x, y), y), ry),\n sy))\n\n\[email protected](\"DivNoNan\")\ndef _DivNoNanGrad(op, grad):\n \"\"\"DivNoNan op gradient.\"\"\"\n x = op.inputs[0]\n y = op.inputs[1]\n sx = array_ops.shape(x)\n sy = array_ops.shape(y)\n rx, ry = gen_array_ops.broadcast_gradient_args(sx, sy)\n x = math_ops.conj(x)\n y = math_ops.conj(y)\n if compat.forward_compatible(2019, 9, 14):\n return (array_ops.reshape(\n math_ops.reduce_sum(math_ops.div_no_nan(grad, y), rx), sx),\n array_ops.reshape(\n math_ops.reduce_sum(\n math_ops.mul_no_nan(\n math_ops.div_no_nan(math_ops.div_no_nan(-x, y), y),\n grad), ry), sy))\n else:\n return (array_ops.reshape(\n math_ops.reduce_sum(math_ops.div_no_nan(grad, y), rx), sx),\n array_ops.reshape(\n math_ops.reduce_sum(\n grad * math_ops.div_no_nan(math_ops.div_no_nan(-x, y), y),\n ry), sy))\n\n\[email protected](\"Pow\")\ndef _PowGrad(op, grad):\n \"\"\"Returns grad * (y*x^(y-1), z*log(x)).\"\"\"\n x = op.inputs[0]\n y = op.inputs[1]\n use_mul_no_nan = compat.forward_compatible(2019, 9, 14)\n skip_input_indices = None\n try:\n skip_input_indices = op.skip_input_indices\n # TODO(mrry): If `y` is a constant, we can combine `tf.sub()` and the\n # constant `1` into a single constant op.\n if skip_input_indices is not None and 1 in skip_input_indices and _IsScalar(\n y):\n x = math_ops.conj(x)\n y = math_ops.conj(y)\n if use_mul_no_nan:\n return gen_math_ops.mul_no_nan(y * math_ops.pow(x, y - 1), grad), None\n else:\n return grad * y * math_ops.pow(x, y - 1), None\n\n except AttributeError:\n # No gradient skipping, so do the full gradient computation\n pass\n\n (sx, rx, must_reduce_x), (sy, ry, must_reduce_y) = (\n SmartBroadcastGradientArgs(x, y, grad))\n x = math_ops.conj(x)\n y = math_ops.conj(y)\n\n if skip_input_indices is None or 0 not in skip_input_indices:\n if use_mul_no_nan:\n gx = gen_math_ops.mul_no_nan(y * math_ops.pow(x, y - 1), grad)\n else:\n gx = grad * y * math_ops.pow(x, y - 1)\n if must_reduce_x:\n gx = array_ops.reshape(math_ops.reduce_sum(gx, rx), sx)\n else:\n gx = None\n\n if skip_input_indices is None or 1 not in skip_input_indices:\n z = math_ops.conj(op.outputs[0])\n\n # Avoid false singularity at x = 0\n if x.dtype.is_complex:\n # real(x) < 0 is fine for the complex case\n mask = math_ops.not_equal(x, 0)\n else:\n # There's no sensible real value to return if x < 0, so return 0\n mask = x > 0\n safe_x = array_ops.where(mask, x, array_ops.ones_like(x))\n log_x = array_ops.where(mask, math_ops.log(safe_x), array_ops.zeros_like(x))\n if use_mul_no_nan:\n gy = gen_math_ops.mul_no_nan(z * log_x, grad)\n else:\n gy = grad * z * log_x\n if must_reduce_y:\n gy = array_ops.reshape(math_ops.reduce_sum(gy, ry), sy)\n else:\n gy = None\n\n return gx, gy\n\n\ndef _MaximumMinimumGradInputOnly(op, grad, selector_op):\n x = op.inputs[0]\n y = op.inputs[1]\n zeros = array_ops.zeros_like(grad)\n xmask = selector_op(x, y)\n xgrad = array_ops.where(xmask, grad, zeros)\n ygrad = None # Return None for ygrad since the config allows that.\n return (xgrad, ygrad)\n\n\ndef _MaximumMinimumGrad(op, grad, selector_op):\n \"\"\"Factor out the code for the gradient of Maximum or Minimum.\"\"\"\n y = op.inputs[1]\n skip_input_indices = None\n try:\n skip_input_indices = op.skip_input_indices\n if skip_input_indices is not None and 1 in skip_input_indices and _IsScalar(\n y):\n # When we want to get gradients for the first input only, and the second\n # input tensor is a scalar, we can do a much simpler calculation\n return _MaximumMinimumGradInputOnly(op, grad, selector_op)\n except AttributeError:\n # No gradient skipping, so do the full gradient computation\n pass\n x = op.inputs[0]\n gdtype = grad.dtype\n sx = array_ops.shape(x)\n sy = array_ops.shape(y)\n gradshape = array_ops.shape(grad)\n zeros = array_ops.zeros(gradshape, gdtype)\n xmask = selector_op(x, y)\n rx, ry = gen_array_ops.broadcast_gradient_args(sx, sy)\n if skip_input_indices is not None and 0 in skip_input_indices:\n gx = None\n else:\n xgrad = array_ops.where(xmask, grad, zeros)\n gx = array_ops.reshape(math_ops.reduce_sum(xgrad, rx), sx)\n\n if skip_input_indices is not None and 1 in skip_input_indices:\n gy = None\n else:\n ygrad = array_ops.where(xmask, zeros, grad)\n gy = array_ops.reshape(math_ops.reduce_sum(ygrad, ry), sy)\n\n return (gx, gy)\n\n\[email protected](\"Maximum\")\ndef _MaximumGrad(op, grad):\n \"\"\"Returns grad*(x > y, x <= y) with type of grad.\"\"\"\n return _MaximumMinimumGrad(op, grad, math_ops.greater_equal)\n\n\[email protected](\"Minimum\")\ndef _MinimumGrad(op, grad):\n \"\"\"Returns grad*(x < y, x >= y) with type of grad.\"\"\"\n return _MaximumMinimumGrad(op, grad, math_ops.less_equal)\n\n\[email protected](\"SquaredDifference\")\ndef _SquaredDifferenceGrad(op, grad):\n \"\"\"Returns the gradient for (x-y)^2.\"\"\"\n x = op.inputs[0]\n y = op.inputs[1]\n skip_input_indices = None\n try:\n skip_input_indices = op.skip_input_indices\n except AttributeError:\n # No gradient skipping, so do the full gradient computation\n pass\n\n with ops.control_dependencies([grad]):\n # The parens ensure that if grad is IndexedSlices, it'll get multiplied by\n # Tensor (not a number like 2.0) which causes it to convert to Tensor.\n x_grad = math_ops.scalar_mul(2.0, grad) * (x - y)\n\n if (isinstance(grad, ops.Tensor) and\n _ShapesFullySpecifiedAndEqual(x, y, grad)):\n return x_grad, -x_grad\n\n (sx, rx, must_reduce_x), (sy, ry, must_reduce_y) = (\n SmartBroadcastGradientArgs(x, y, grad))\n\n if skip_input_indices is not None and 0 in skip_input_indices:\n gx = None\n elif must_reduce_x:\n gx = array_ops.reshape(math_ops.reduce_sum(x_grad, rx), sx)\n else:\n gx = x_grad\n\n if skip_input_indices is not None and 1 in skip_input_indices:\n gy = None\n elif must_reduce_y:\n gy = -array_ops.reshape(math_ops.reduce_sum(x_grad, ry), sy)\n else:\n gy = -x_grad\n return (gx, gy)\n\n\n# Logical operations have no gradients.\nops.NotDifferentiable(\"Less\")\nops.NotDifferentiable(\"LessEqual\")\nops.NotDifferentiable(\"Greater\")\nops.NotDifferentiable(\"GreaterEqual\")\nops.NotDifferentiable(\"Equal\")\nops.NotDifferentiable(\"ApproximateEqual\")\nops.NotDifferentiable(\"NotEqual\")\nops.NotDifferentiable(\"LogicalAnd\")\nops.NotDifferentiable(\"LogicalOr\")\nops.NotDifferentiable(\"LogicalNot\")\n\n\[email protected](\"Select\")\ndef _SelectGrad(op, grad):\n c = op.inputs[0]\n x = op.inputs[1]\n zeros = array_ops.zeros_like(x)\n return (None, array_ops.where(c, grad, zeros), array_ops.where(\n c, zeros, grad))\n\n\[email protected](\"SelectV2\")\ndef _SelectGradV2(op, grad):\n c = op.inputs[0]\n x = op.inputs[1]\n y = op.inputs[2]\n zeros = array_ops.zeros([], dtype=grad.dtype.base_dtype)\n gx = array_ops.where_v2(c, grad, zeros)\n x_shape = array_ops.shape(x)\n output_shape = array_ops.shape(op.outputs[0])\n # Reduce away broadcasted leading dims.\n reduce_x, _ = gen_array_ops.broadcast_gradient_args(x_shape, output_shape)\n gx = math_ops.reduce_sum(gx, keepdims=True, axis=reduce_x)\n gx = array_ops.reshape(gx, x_shape)\n\n gy = array_ops.where_v2(c, zeros, grad)\n y_shape = array_ops.shape(y)\n # Reduce away broadcasted leading dims.\n reduce_y, _ = gen_array_ops.broadcast_gradient_args(y_shape, output_shape)\n gy = math_ops.reduce_sum(gy, keepdims=True, axis=reduce_y)\n gy = array_ops.reshape(gy, y_shape)\n\n return (None, gx, gy)\n\n\ndef _MatMulGradAgainstFirstOnly(op, grad):\n \"\"\"Gradient for MatMul, only for the first input.\"\"\"\n t_a = op.get_attr(\"transpose_a\")\n t_b = op.get_attr(\"transpose_b\")\n b = math_ops.conj(op.inputs[1])\n if not t_a and not t_b:\n grad_a = gen_math_ops.mat_mul(grad, b, transpose_b=True)\n elif not t_a and t_b:\n grad_a = gen_math_ops.mat_mul(grad, b)\n elif t_a and not t_b:\n grad_a = gen_math_ops.mat_mul(b, grad, transpose_b=True)\n elif t_a and t_b:\n grad_a = gen_math_ops.mat_mul(b, grad, transpose_a=True, transpose_b=True)\n return grad_a, None\n\n\ndef _MatMulGradAgainstSecondOnly(op, grad):\n \"\"\"Gradient for MatMul, only for the second input.\"\"\"\n t_a = op.get_attr(\"transpose_a\")\n t_b = op.get_attr(\"transpose_b\")\n a = math_ops.conj(op.inputs[0])\n if not t_a and not t_b:\n grad_b = gen_math_ops.mat_mul(a, grad, transpose_a=True)\n elif not t_a and t_b:\n grad_b = gen_math_ops.mat_mul(grad, a, transpose_a=True)\n elif t_a and not t_b:\n grad_b = gen_math_ops.mat_mul(a, grad)\n elif t_a and t_b:\n grad_b = gen_math_ops.mat_mul(grad, a, transpose_a=True, transpose_b=True)\n return None, grad_b\n\n\[email protected](\"MatMul\")\ndef _MatMulGrad(op, grad):\n \"\"\"Gradient for MatMul.\"\"\"\n try:\n skip_input_indices = op.skip_input_indices\n if skip_input_indices is not None:\n if 1 in skip_input_indices:\n return _MatMulGradAgainstFirstOnly(op, grad)\n elif 0 in skip_input_indices:\n return _MatMulGradAgainstSecondOnly(op, grad)\n except AttributeError:\n # No gradient skipping, so do the full gradient computation\n pass\n\n t_a = op.get_attr(\"transpose_a\")\n t_b = op.get_attr(\"transpose_b\")\n a = math_ops.conj(op.inputs[0])\n b = math_ops.conj(op.inputs[1])\n if not t_a and not t_b:\n grad_a = gen_math_ops.mat_mul(grad, b, transpose_b=True)\n grad_b = gen_math_ops.mat_mul(a, grad, transpose_a=True)\n elif not t_a and t_b:\n grad_a = gen_math_ops.mat_mul(grad, b)\n grad_b = gen_math_ops.mat_mul(grad, a, transpose_a=True)\n elif t_a and not t_b:\n grad_a = gen_math_ops.mat_mul(b, grad, transpose_b=True)\n grad_b = gen_math_ops.mat_mul(a, grad)\n elif t_a and t_b:\n grad_a = gen_math_ops.mat_mul(b, grad, transpose_a=True, transpose_b=True)\n grad_b = gen_math_ops.mat_mul(grad, a, transpose_a=True, transpose_b=True)\n return grad_a, grad_b\n\n\[email protected](\"SparseMatMul\")\ndef _SparseMatMulGrad(op, grad):\n \"\"\"Gradient for SparseMatMul.\"\"\"\n\n t_a = op.get_attr(\"transpose_a\")\n t_b = op.get_attr(\"transpose_b\")\n is_sparse = object_identity.ObjectIdentityDictionary()\n is_sparse[op.inputs[0]] = op.get_attr(\"a_is_sparse\")\n is_sparse[op.inputs[1]] = op.get_attr(\"b_is_sparse\")\n # Use heuristic to figure out if grad might be sparse\n is_sparse[grad] = not context.executing_eagerly() and (\n grad.op.type == \"ReluGrad\")\n\n def _SparseMatMul(t1, t2, out_dtype, transpose_a=False, transpose_b=False):\n \"\"\"Helper function to create SparseMatMul op.\"\"\"\n\n assert t1 in is_sparse and t2 in is_sparse\n t1_sparse = is_sparse[t1]\n t2_sparse = is_sparse[t2]\n if transpose_b:\n t2 = array_ops.transpose(t2)\n transpose_b = False\n prod = math_ops.matmul(\n t1,\n t2,\n transpose_a=transpose_a,\n transpose_b=transpose_b,\n a_is_sparse=t1_sparse,\n b_is_sparse=t2_sparse)\n if prod.dtype != out_dtype:\n prod = math_ops.cast(prod, out_dtype)\n return prod\n\n dtype_a = op.inputs[0].dtype\n dtype_b = op.inputs[1].dtype\n if not t_a and not t_b:\n return (_SparseMatMul(grad, op.inputs[1], dtype_a, transpose_b=True),\n _SparseMatMul(op.inputs[0], grad, dtype_b, transpose_a=True))\n elif not t_a and t_b:\n return (_SparseMatMul(grad, op.inputs[1], dtype_a),\n _SparseMatMul(grad, op.inputs[0], dtype_b, transpose_a=True))\n elif t_a and not t_b:\n return (_SparseMatMul(op.inputs[1], grad, dtype_a, transpose_b=True),\n _SparseMatMul(op.inputs[0], grad, dtype_b))\n elif t_a and t_b:\n return (_SparseMatMul(\n op.inputs[1], grad, dtype_a, transpose_a=True, transpose_b=True),\n _SparseMatMul(\n grad, op.inputs[0], dtype_b, transpose_a=True,\n transpose_b=True))\n\n\[email protected](\"Floor\")\ndef _FloorGrad(_, unused_grad):\n return [None]\n\n\[email protected](\"Ceil\")\ndef _CeilGrad(_, unused_grad):\n return [None]\n\n\[email protected](\"Round\")\ndef _RoundGrad(_, unused_grad):\n return [None]\n\n\[email protected](\"Rint\")\ndef _RintGrad(_, unused_grad):\n # the gradient of Rint is zero\n return [None]\n\n\[email protected](\"BatchMatMul\")\ndef _BatchMatMul(op, grad):\n \"\"\"Returns the gradient of x and y given the gradient of x * y.\"\"\"\n x = op.inputs[0]\n y = op.inputs[1]\n adj_x = op.get_attr(\"adj_x\")\n adj_y = op.get_attr(\"adj_y\")\n\n if not adj_x:\n if not adj_y:\n grad_x = math_ops.matmul(grad, y, adjoint_a=False, adjoint_b=True)\n grad_y = math_ops.matmul(x, grad, adjoint_a=True, adjoint_b=False)\n else:\n grad_x = math_ops.matmul(grad, y, adjoint_a=False, adjoint_b=False)\n grad_y = math_ops.matmul(grad, x, adjoint_a=True, adjoint_b=False)\n else:\n if not adj_y:\n grad_x = math_ops.matmul(y, grad, adjoint_a=False, adjoint_b=True)\n grad_y = math_ops.matmul(x, grad, adjoint_a=False, adjoint_b=False)\n else:\n grad_x = math_ops.matmul(y, grad, adjoint_a=True, adjoint_b=True)\n grad_y = math_ops.matmul(grad, x, adjoint_a=True, adjoint_b=True)\n\n return grad_x, grad_y\n\n\[email protected](\"BatchMatMulV2\")\ndef _BatchMatMulV2(op, grad):\n \"\"\"Returns the gradient of x and y given the gradient of x * y.\"\"\"\n x = op.inputs[0]\n y = op.inputs[1]\n adj_x = op.get_attr(\"adj_x\")\n adj_y = op.get_attr(\"adj_y\")\n\n if not adj_x:\n if not adj_y:\n grad_x = math_ops.matmul(grad, y, adjoint_a=False, adjoint_b=True)\n grad_y = math_ops.matmul(x, grad, adjoint_a=True, adjoint_b=False)\n else:\n grad_x = math_ops.matmul(grad, y, adjoint_a=False, adjoint_b=False)\n grad_y = math_ops.matmul(grad, x, adjoint_a=True, adjoint_b=False)\n else:\n if not adj_y:\n grad_x = math_ops.matmul(y, grad, adjoint_a=False, adjoint_b=True)\n grad_y = math_ops.matmul(x, grad, adjoint_a=False, adjoint_b=False)\n else:\n grad_x = math_ops.matmul(y, grad, adjoint_a=True, adjoint_b=True)\n grad_y = math_ops.matmul(grad, x, adjoint_a=True, adjoint_b=True)\n\n # Reduce along the broadcasted batch dimensions, if broadcasting is required.\n shape_x_static = x.get_shape()\n shape_y_static = y.get_shape()\n if not (shape_x_static.is_fully_defined() and\n shape_y_static.is_fully_defined() and\n shape_x_static == shape_y_static):\n sx = array_ops.shape(x)\n sy = array_ops.shape(y)\n rx, ry = gen_array_ops.broadcast_gradient_args(sx[:-2], sy[:-2])\n grad_x = array_ops.reshape(math_ops.reduce_sum(grad_x, rx), sx)\n grad_y = array_ops.reshape(math_ops.reduce_sum(grad_y, ry), sy)\n\n return grad_x, grad_y\n\n\nops.NotDifferentiable(\"Range\")\nops.NotDifferentiable(\"LinSpace\")\n\n\[email protected](\"Complex\")\ndef _ComplexGrad(op, grad):\n \"\"\"Returns the real and imaginary components of 'grad', respectively.\"\"\"\n x = op.inputs[0]\n y = op.inputs[1]\n sx = array_ops.shape(x)\n sy = array_ops.shape(y)\n rx, ry = gen_array_ops.broadcast_gradient_args(sx, sy)\n return (array_ops.reshape(math_ops.reduce_sum(math_ops.real(grad), rx), sx),\n array_ops.reshape(math_ops.reduce_sum(math_ops.imag(grad), ry), sy))\n\n\[email protected](\"Real\")\ndef _RealGrad(_, grad):\n \"\"\"Returns 'grad' as the real part and set the imaginary part 0.\"\"\"\n zero = constant_op.constant(0, dtype=grad.dtype)\n return math_ops.complex(grad, zero)\n\n\[email protected](\"Imag\")\ndef _ImagGrad(_, grad):\n \"\"\"Returns 'grad' as the imaginary part and set the real part 0.\"\"\"\n zero = constant_op.constant(0, dtype=grad.dtype)\n return math_ops.complex(zero, grad)\n\n\[email protected](\"Angle\")\ndef _AngleGrad(op, grad):\n \"\"\"Returns -grad / (Im(x) + iRe(x))\"\"\"\n x = op.inputs[0]\n with ops.control_dependencies([grad]):\n re = math_ops.real(x)\n im = math_ops.imag(x)\n z = math_ops.reciprocal(math_ops.complex(im, re))\n zero = constant_op.constant(0, dtype=grad.dtype)\n complex_grad = math_ops.complex(grad, zero)\n return -complex_grad * z\n\n\[email protected](\"Conj\")\ndef _ConjGrad(_, grad):\n \"\"\"Returns the complex conjugate of grad.\"\"\"\n return math_ops.conj(grad)\n\n\[email protected](\"ComplexAbs\")\ndef _ComplexAbsGrad(op, grad):\n \"\"\"Returns the gradient of ComplexAbs.\"\"\"\n return math_ops.div_no_nan(\n math_ops.complex(\n grad, array_ops.zeros_like(grad)) * op.inputs[0],\n math_ops.complex(\n op.outputs[0], array_ops.zeros_like(op.outputs[0])))\n\n\[email protected](\"Cast\")\ndef _CastGrad(op, grad):\n t = [\n dtypes.float16, dtypes.float32, dtypes.float64, dtypes.bfloat16,\n dtypes.complex64, dtypes.complex128\n ]\n src_type = op.inputs[0].dtype.base_dtype\n dst_type = grad.dtype.base_dtype\n if src_type in t and dst_type in t:\n return math_ops.cast(grad, src_type)\n else:\n return None\n\n\[email protected](\"Cross\")\ndef _CrossGrad(op, grad):\n u = op.inputs[0]\n v = op.inputs[1]\n return (math_ops.cross(v, grad), math_ops.cross(grad, u))\n\n\[email protected](\"Cumsum\")\ndef _CumsumGrad(op, grad):\n axis = op.inputs[1]\n exclusive = op.get_attr(\"exclusive\")\n reverse = op.get_attr(\"reverse\")\n return [\n math_ops.cumsum(grad, axis, exclusive=exclusive, reverse=not reverse),\n None\n ]\n\n\[email protected](\"Cumprod\")\ndef _CumprodGrad(op, grad):\n x = op.inputs[0]\n axis = op.inputs[1]\n exclusive = op.get_attr(\"exclusive\")\n reverse = op.get_attr(\"reverse\")\n\n # TODO This fails when x contains 0 and should be fixed\n prod = math_ops.cumprod(x, axis, exclusive=exclusive, reverse=reverse)\n out = math_ops.cumsum(\n prod * grad, axis, exclusive=exclusive, reverse=not reverse)\n return [out / x, None]\n\n\[email protected](\"CumulativeLogsumexp\")\ndef _CumulativeLogsumexpGrad(op, grad):\n x = op.inputs[0]\n axis = op.inputs[1]\n cumulative_logsumexp = op.outputs[0]\n\n exclusive = op.get_attr(\"exclusive\")\n reverse = op.get_attr(\"reverse\")\n\n # Split the incoming gradient into positive and negative part\n # in order to take logs. This is required for stable results.\n log_grad_positive = array_ops.where_v2(\n math_ops.greater(grad, 0),\n math_ops.log(grad),\n grad.dtype.min)\n\n log_grad_negative = array_ops.where_v2(\n math_ops.less(grad, 0),\n math_ops.log(-grad),\n grad.dtype.min)\n\n output_pos = math_ops.exp(\n math_ops.cumulative_logsumexp(\n log_grad_positive - cumulative_logsumexp,\n axis=axis, reverse=not reverse, exclusive=exclusive) + x)\n\n output_neg = math_ops.exp(\n math_ops.cumulative_logsumexp(\n log_grad_negative - cumulative_logsumexp,\n axis=axis, reverse=not reverse, exclusive=exclusive) + x)\n\n return [output_pos - output_neg, None]\n\n\[email protected](\"NextAfter\")\ndef _NextAfterGrad(op, grad):\n \"\"\"Returns gradient of nextafter(x1, x2) with respect to x1 and x2.\"\"\"\n x1 = op.inputs[0]\n x2 = op.inputs[1]\n s_x1 = array_ops.shape(x1)\n s_x2 = array_ops.shape(x2)\n r_x1, r_x2 = gen_array_ops.broadcast_gradient_args(s_x1, s_x2)\n with ops.control_dependencies([grad]):\n partial_x1 = array_ops.ones(s_x1, dtype=x1.dtype)\n partial_x2 = array_ops.zeros(s_x2, dtype=x2.dtype)\n return (array_ops.reshape(\n math_ops.reduce_sum(partial_x1 * grad, r_x1), s_x1),\n array_ops.reshape(\n math_ops.reduce_sum(partial_x2 * grad, r_x2), s_x2))\n"
] | [
[
"tensorflow.python.ops.gen_math_ops.xlogy",
"tensorflow.python.ops.math_ops.lgamma",
"tensorflow.python.ops.gen_math_ops.reciprocal_grad",
"tensorflow.python.ops.math_ops.negative",
"tensorflow.python.ops.math_ops.zeta",
"tensorflow.python.ops.array_ops.tile",
"tensorflow.python.ops.math_ops.floor_div",
"tensorflow.python.ops.math_ops.imag",
"tensorflow.python.compat.compat.forward_compatible",
"tensorflow.python.framework.ops.device",
"tensorflow.python.ops.math_ops.cross",
"tensorflow.python.ops.array_ops.shape",
"tensorflow.python.framework.ops.control_dependencies",
"tensorflow.python.ops.array_ops.broadcast_gradient_args",
"tensorflow.python.ops.math_ops.sparse_segment_sqrt_n_grad",
"tensorflow.python.ops.math_ops.complex",
"tensorflow.python.framework.ops.NotDifferentiable",
"tensorflow.python.eager.context.executing_eagerly",
"tensorflow.python.ops.math_ops.conj",
"tensorflow.python.ops.array_ops.transpose",
"tensorflow.python.ops.math_ops.equal",
"tensorflow.python.ops.gen_math_ops.mul",
"tensorflow.python.ops.gen_math_ops.lgamma",
"tensorflow.python.ops.array_ops.broadcast_to",
"tensorflow.python.ops.gen_math_ops.tanh_grad",
"tensorflow.python.framework.constant_op.constant",
"tensorflow.python.ops.gen_math_ops.igamma_grad_a",
"tensorflow.python.ops.array_ops.rank",
"tensorflow.python.ops.math_ops.bessel_i1e",
"tensorflow.python.ops.math_ops.reduce_sum",
"tensorflow.python.ops.array_ops.constant",
"tensorflow.python.ops.math_ops.divide",
"numpy.finfo",
"tensorflow.python.ops.array_ops.ones",
"tensorflow.python.ops.array_ops.gather",
"tensorflow.python.ops.math_ops.realdiv",
"tensorflow.python.framework.ops.RegisterGradient",
"tensorflow.python.ops.math_ops.abs",
"tensorflow.python.util.object_identity.ObjectIdentityDictionary",
"tensorflow.python.ops.array_ops.shape_internal",
"tensorflow.python.ops.math_ops.cumsum",
"tensorflow.python.ops.math_ops.cosh",
"tensorflow.python.ops.array_ops.ones_like",
"tensorflow.python.ops.math_ops.sparse_segment_mean_grad",
"numpy.sqrt",
"tensorflow.python.ops.math_ops.bessel_i0e",
"tensorflow.python.ops.gen_math_ops.sqrt_grad",
"tensorflow.python.ops.array_ops.expand_dims",
"tensorflow.python.ops.math_ops.cumulative_logsumexp",
"tensorflow.python.ops.math_ops.cos",
"tensorflow.python.ops.math_ops.greater",
"tensorflow.python.ops.math_ops.sign",
"tensorflow.python.ops.math_ops.add",
"tensorflow.python.ops.math_ops.range",
"tensorflow.python.framework.tensor_util.constant_value",
"tensorflow.python.ops.math_ops.square",
"tensorflow.python.ops.math_ops.logical_and",
"tensorflow.python.ops.gen_math_ops.mat_mul",
"tensorflow.python.ops.array_ops.setdiff1d",
"tensorflow.python.ops.gen_math_ops.rsqrt_grad",
"tensorflow.python.eager.context.context",
"numpy.arange",
"tensorflow.python.ops.math_ops.cumprod",
"tensorflow.python.ops.math_ops.cast",
"numpy.prod",
"tensorflow.python.ops.math_ops.digamma",
"tensorflow.python.ops.gen_math_ops.xdivy",
"tensorflow.python.framework.ops.get_default_graph",
"tensorflow.python.ops.array_ops.zeros_like",
"tensorflow.python.ops.math_ops.reciprocal",
"tensorflow.python.ops.math_ops.div_no_nan",
"tensorflow.python.ops.array_ops.concat",
"tensorflow.python.ops.array_ops.where",
"tensorflow.python.ops.array_ops.reshape",
"tensorflow.python.ops.gen_array_ops.broadcast_gradient_args",
"tensorflow.python.framework.ops.colocate_with",
"tensorflow.python.ops.math_ops.maximum",
"tensorflow.python.ops.math_ops.sinh",
"tensorflow.python.ops.math_ops.pow",
"tensorflow.python.ops.gen_math_ops.sigmoid_grad",
"tensorflow.python.ops.array_ops.invert_permutation",
"tensorflow.python.ops.math_ops.segment_sum",
"tensorflow.python.ops.gen_math_ops.unsorted_segment_prod",
"tensorflow.python.ops.math_ops.xdivy",
"tensorflow.python.ops.math_ops.matmul",
"tensorflow.python.ops.math_ops.reduce_prod",
"tensorflow.python.ops.math_ops.mul_no_nan",
"tensorflow.python.ops.math_ops.scalar_mul",
"tensorflow.python.ops.math_ops.multiply",
"tensorflow.python.ops.math_ops.less",
"tensorflow.python.ops.array_ops.zeros",
"tensorflow.python.ops.math_ops.sin",
"tensorflow.python.ops.gen_math_ops.mul_no_nan",
"tensorflow.python.ops.math_ops.real",
"tensorflow.python.ops.math_ops.reduced_shape",
"tensorflow.python.ops.array_ops.where_v2",
"tensorflow.python.ops.math_ops.subtract",
"tensorflow.python.ops.math_ops.log",
"tensorflow.python.ops.math_ops.not_equal",
"tensorflow.python.ops.math_ops.polygamma",
"tensorflow.python.ops.math_ops.greater_equal",
"tensorflow.python.ops.math_ops.exp"
]
] |
shunsvineyard/shunsvineyard | [
"5ef44847da95e8ad881622d2c3571a3aceb1b20c"
] | [
"pocket-learning-algorithm-and-feature-engineering/iris_example.py"
] | [
"# Copyright © 2017, 2019 by Shun Huang. All rights reserved.\n# Licensed under MIT License.\n# See LICENSE in the project root for license information.\n\n\"\"\"An example of supervised learning uses the Iris data set.\nhttps://archive.ics.uci.edu/ml/datasets/Iris\nAttribute Information:\n0. sepal length in cm \n1. sepal width in cm \n2. petal length in cm \n3. petal width in cm \n4. class: \n-- Iris Setosa \n-- Iris Versicolour \n-- Iris Virginica\n\"\"\"\n\nimport urllib.request\n\n# matplotlib is a python 2D plotting library which produces publication\n# quality. Figures in a variety of hardcopy formats and interactive\n# environments across platforms.\n# http://matplotlib.org/2.0.0/index.html\nimport matplotlib.pyplot as plt\n\n# NumPy is the fundamental package for scientific computing with\n# Python. http://www.numpy.org/\nimport numpy as np\n\n# pandas is an open source library providing high-performance, \n# easy-to-use data structures and data analysis tools.\n# http://pandas.pydata.org/\nimport pandas as pd\n\n# Seaborn is a Python data visualization library based on matplotlib.\n# It provides a high-level interface for drawing attractive and\n# informative statistical graphics.\n# http://seaborn.pydata.org/index.html\nimport seaborn as sns\n\nsns.set() # set the default seaborn theme, scaling, and color palette.\n\nimport perceptron_classifier\n\n# Download Iris Data Set from \n# http://archive.ics.uci.edu/ml/datasets/Iris\nURL = \"http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data\"\nurllib.request.urlretrieve(URL, \"iris.data\")\n# use pandas\" read_csv function to read iris.data into a python array.\n# Note: the iris.data is headerless, so header is None.\nIRIS_DATA = pd.read_csv(\"iris.data\", header=None)\n\n# Plot the versicolor and virginica.\nVERSICOLOR = IRIS_DATA.iloc[50:100, [0, 2]].values\nVIRGINICA = IRIS_DATA.iloc[100:150, [0, 2]].values\n\nplt.scatter(VERSICOLOR[:, 0], VERSICOLOR[:, 1],\n color=\"blue\", marker=\"x\", label=\"versicolor\")\nplt.scatter(VIRGINICA[:, 0], VIRGINICA[:, 1],\n color=\"green\", marker=\"v\", label=\"virginica\")\n\nplt.xlabel(\"sepal length\")\nplt.ylabel(\"petal length\")\nplt.legend(loc=\"upper left\")\nplt.show()\n\n# Use Perceptron Learning Algorithm onto the versicolor and virginica\n# of the Iris Data Set.\nVERSICOLOR_LABEL = IRIS_DATA.iloc[50:100, 4].values\nVIRGINICA_LABEL = IRIS_DATA.iloc[100:150, 4].values\nLABELS = np.append(VERSICOLOR_LABEL, VIRGINICA_LABEL)\nSAMPLES = np.append(VERSICOLOR, VIRGINICA, axis=0)\n\nperceptron_classifier = perceptron_classifier.PerceptronClassifier(\n number_of_attributes=2, class_labels=('Iris-versicolor', 'Iris-virginica'))\n\nperceptron_classifier.train(SAMPLES, LABELS, 100)\nplt.plot(perceptron_classifier.misclassify_record, color=\"purple\")\n\n# Plot the error rate and show it never converges.\nplt.xlabel(\"number of iteration\")\nplt.ylabel(\"number of misclassification\")\nplt.legend(loc=\"lower right\")\nplt.show()"
] | [
[
"matplotlib.pyplot.legend",
"numpy.append",
"pandas.read_csv",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.scatter"
]
] |
changgoo/pyathena-1 | [
"c461ac3390d773537ce52393e3ebf68a3282aa46"
] | [
"pyathena/tigress_xco/plt_tigress_xco.py"
] | [
"#!/usr/bin/env python\n\nimport os\nimport sys\nimport time\n\nimport os.path as osp\nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\nfrom matplotlib import gridspec\nimport numpy as np\nimport xarray as xr\nfrom mpi4py import MPI\n\nfrom .load_sim_tigress_xco import LoadSimTIGRESSXCOAll\nfrom ..util.split_container import split_container\nfrom ..plt_tools.plt_joint_pdf import plt_joint_pdf\n\n#field_def = ['density', 'xH2', 'CR_ionization_rate']\n\nfield_def = ['density', 'xH2', 'CR_ionization_rate',\n 'rad_energy_density0', 'rad_energy_density_PE',\n 'rad_energy_density2', 'rad_energy_density3', 'rad_energy_density4',\n 'rad_energy_density_LW', 'rad_energy_density_PE_unatt']\n\ndef read_data(sa, model, num,\n field=field_def, zmin=-256.0, zmax=256.0):\n sa.set_model(model)\n s = sa.sim\n ds = s.load_vtk(num=num)\n # Read data\n dat = ds.get_field(field=field, as_xarray=True)\n dat['nH2'] = 2.0*dat.xH2*dat.density\n dat = dat.where(np.logical_and(dat.z < zmax, dat.z > zmin), drop=True)\n\n #dat = dict(dat)\n\n # dat['taueff'] = -np.log(dat.rad_energy_density_PE/dat.rad_energy_density_PE_unatt)\n # Mask where taueff = inf with tau_eff_max\n # taueff_max = 10.0\n # dat['taueff'] = xr.where(dat['taueff'] == np.inf, taueff_max, dat['taueff'])\n \n return s, ds, dat\n\ndef plt_pdf_density_CRIR(sa, model, num, dat=None, gs=None, savfig=True):\n\n if dat is None:\n s, ds, dat = read_data(sa, model, num)\n\n s = sa.set_model(model)\n ds = s.load_vtk(num=num)\n \n x = dat['density'].values.flatten()\n y = dat['CR_ionization_rate'].values.flatten()\n hexbin_args = dict(xscale='log', yscale='log', mincnt=1, gridsize=30)\n ax1, ax2, ax3 = plt_joint_pdf(x, y, hexbin_args, weights=x, gs=gs)\n ax1.set_xlabel(r'$n_{\\rm H}$')\n ax1.set_ylabel(r'$\\xi_{\\rm CR}$')\n ax1.set_xlim(1e-3, 1e4)\n ax2.set_xlim(1e-3, 1e4)\n\n # Set CRIR range\n h = s.read_hst()\n ylim = (h.xi_CR0.iloc[0]*1e-2, h.xi_CR0.iloc[0]*2.0)\n ax1.set_ylim(*ylim)\n ax3.set_ylim(*ylim)\n #ax1.set_ylim(3e-17, 1e-15)\n #ax3.set_ylim(3e-17, 1e-15)\n plt.suptitle('{0:s}, time: {1:.1f}'.format(s.basename, ds.domain['time']))\n \n if savfig:\n savdir = osp.join('./figures-pdf')\n if not os.path.exists(savdir):\n os.makedirs(savdir)\n plt.savefig(osp.join(savdir, 'pdf-density-CRIR.{0:s}.{1:04d}.png'.format(model, ds.num)))\n \n return plt.gcf()\n\ndef plt_pdf_density_xH2(sa, model, num, dat=None, gs=None, savfig=True):\n\n if dat is None:\n s, ds, dat = read_data(sa, model, num)\n \n s = sa.set_model(model)\n ds = s.load_vtk(num=num)\n\n x = dat['density'].values.flatten()\n y = dat['xH2'].values.flatten()\n hexbin_args = dict(xscale='log', yscale='linear', mincnt=1, gridsize=50,\n norm=mpl.colors.LogNorm())\n ax1, ax2, ax3 = plt_joint_pdf(x, y, hexbin_args, weights=x, gs=gs)\n ax1.set_xlabel(r'$n_{\\rm H}$')\n ax1.set_ylabel(r'$x_{\\rm H_2}$')\n ax1.set_xlim(1e-3, 1e4)\n ax2.set_xlim(1e-3, 1e4)\n ax1.set_ylim(0, 0.55)\n ax3.set_ylim(0, 0.55)\n \n def calc_xH2_equil(n, xi_H=2.0e-16, R_gr=3.0e-17, zeta=5.7e-11):\n a = 2.31*xi_H\n b = -2.0*R_gr*n - 4.95*xi_H - zeta\n c = n*R_gr\n return (-b - np.sqrt(b*b - 4.0*a*c))/(2.0*a)\n \n n = np.logspace(-3, 4)\n h = s.read_hst()\n xH2eq = calc_xH2_equil(n, h.xi_CR0.iloc[num-1], # num-1 because the first row is delted\n R_gr=3.0e-17*s.par['problem']['R_gr_amp'], zeta=0.0)\n \n ax1.semilogx(n, xH2eq, 'r--')\n plt.suptitle('{0:s}, time: {1:.1f}'.format(s.basename,ds.domain['time']))\n \n if savfig:\n savdir = osp.join('./figures-pdf')\n if not os.path.exists(savdir):\n os.makedirs(savdir)\n plt.savefig(osp.join(savdir, 'pdf-density-xH2.{0:s}.{1:04d}.png'.format(model, ds.num)))\n \n return plt.gcf()\n\n\ndef plt_hst_mass(mhd_model='R2_2pc'):\n\n sa = LoadSimTIGRESSXCOAll()\n \n fig, axes = plt.subplots(3, 1, figsize=(12, 15),\n sharex=True)\n\n i = 0\n for mdl in sa.models:\n if not mdl.startswith(mhd_model):\n continue\n \n s = sa.set_model(mdl, verbose=False)\n h = s.read_hst(merge_mhd=True, force_override=True)\n hmhd = s.read_hst_mhd()\n plt.sca(axes[0])\n if i == 0:\n label = 'total'\n plt.plot(h.time, h.Sigma_gas, 'k-', lw=2, label=label)\n else:\n label = '_nolegend_'\n plt.plot(h.time, h.Sigma_H - h.Sigma_H2, 'o-', label=mdl)\n plt.sca(axes[1])\n plt.plot(h.time, h.Sigma_H2/h.Sigma_H, 'o-', label=mdl)\n plt.sca(axes[2])\n plt.plot(h.time, h.xi_CR0, 'o-')\n \n i += 1\n\n plt.sca(axes[0])\n plt.ylabel(r'$\\Sigma_{\\rm HI} [Msun/pc^2]$')\n plt.legend(loc=1)\n plt.yscale('log')\n plt.title('Gas surface density')\n plt.grid()\n plt.gca().grid(which='minor', alpha=0.2)\n plt.gca().grid(which='major', alpha=0.5)\n\n # H2 fraction\n plt.sca(axes[1])\n plt.ylim(3e-2, 1)\n plt.yscale('log')\n plt.title('H2 mass fraction')\n plt.ylabel(r'$M_{\\rm H_2}/M_{\\rm H,tot}$')\n plt.grid()\n plt.gca().grid(which='minor', alpha=0.2)\n plt.gca().grid(which='major', alpha=0.5)\n\n # CRIR\n plt.sca(axes[2])\n plt.yscale('log')\n plt.title('CRIR')\n plt.xlabel('time [Myr]')\n plt.ylabel(r'$\\xi_{\\rm CR,0}\\;[{\\rm s}^{-1}]$')\n plt.grid()\n plt.gca().grid(which='minor', alpha=0.2)\n plt.gca().grid(which='major', alpha=0.5)\n \n dtime = h.time.iloc[-1] - h.time.iloc[0]\n plt.xlim(h.time.iloc[0]*0.9, h.time.iloc[-1] + 0.8*dtime)\n \n return fig\n \ndef plt_two_joint_pdfs(sa, model, num, savfig=True):\n\n fig = plt.figure(figsize=(14, 6))\n gs0 = gridspec.GridSpec(1, 2, wspace=0.25)\n gs00 = gridspec.GridSpecFromSubplotSpec(4, 4, subplot_spec=gs0[0])\n gs01 = gridspec.GridSpecFromSubplotSpec(4, 4, subplot_spec=gs0[1])\n\n s, ds, dat = read_data(sa, model, num)\n plt_pdf_density_xH2(sa, model, num, dat, gs=gs00, savfig=False)\n fig = plt_pdf_density_CRIR(sa, model, num, dat, gs=gs01, savfig=savfig)\n if savfig:\n plt.close(fig)\n else:\n return fig\n \nif __name__ == '__main__':\n\n COMM = MPI.COMM_WORLD\n sa = LoadSimTIGRESSXCOAll()\n\n models = sa.models\n\n # Measure execution time\n time0 = time.time()\n for model in models:\n if not model.startswith('R8'):\n continue\n s = sa.set_model(model, verbose=False)\n nums = s.nums\n \n if COMM.rank == 0:\n print('model, nums', model, nums)\n nums = split_container(nums, COMM.size)\n else:\n nums = None\n \n mynums = COMM.scatter(nums, root=0)\n print('[rank, mynums]:', COMM.rank, mynums)\n\n for num in mynums:\n print(num, end=' ')\n plt_two_joint_pdfs(sa, model, num)\n # break\n \n COMM.barrier()\n if COMM.rank == 0:\n print('')\n print('################################################')\n print('# Done with model', model)\n print('# Execution time [sec]: {:.1f}'.format(time.time()-time0))\n print('################################################')\n print('')\n"
] | [
[
"matplotlib.pyplot.yscale",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.plot",
"matplotlib.gridspec.GridSpecFromSubplotSpec",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.gcf",
"numpy.logical_and",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.title",
"matplotlib.colors.LogNorm",
"matplotlib.gridspec.GridSpec",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.close",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.sca",
"numpy.logspace",
"numpy.sqrt",
"matplotlib.pyplot.xlabel"
]
] |
kkleidal/GatedPixelCNNPyTorch | [
"286298a0cd81ed2f6cb918fd39ce4da2c0e92802"
] | [
"models/components/pixelcnn.py"
] | [
"# Loosely derived from https://github.com/jzbontar/pixelcnn-pytorch/blob/master/main.py\n# and moreso derived from https://github.com/rampage644/wavenet/blob/master/wavenet/models.py\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torch.autograd import Variable\nimport numpy as np\nimport tqdm\n\n#owidth = floor((width + 2*padW - kW) / dW + 1)\n#oheight = floor((height + 2*padH - kH) / dH + 1)\n#dW is stride, assuming 1:\n# kW // 2 = padW\ndef same_padding(kernel_size):\n # assumming stride 1\n if isinstance(kernel_size, int):\n return kernel_size // 2\n else:\n return (kernel_size[0] // 2, kernel_size[1] // 2)\n\n# PyTorch port of\nclass MaskedConvolution2D(nn.Conv2d):\n def __init__(self, in_channels, out_channels, kernel_size, \n *args, mask='B', vertical=False, mask_mode=\"noblind\", **kwargs):\n if \"padding\" not in kwargs:\n assert \"stride\" not in kwargs\n kwargs[\"padding\"] = same_padding(kernel_size)\n remove = {\"conditional_features\", \"conditional_image_channels\"}\n for feature in remove:\n if feature in kwargs:\n del kwargs[feature]\n super(MaskedConvolution2D, self).__init__(in_channels,\n out_channels, kernel_size, *args, **kwargs)\n Cout, Cin, kh, kw = self.weight.size()\n pre_mask = np.ones_like(self.weight.data.cpu().numpy()).astype(np.float32)\n yc, xc = kh // 2, kw // 2\n\n assert mask_mode in {\"noblind\", \"turukin\", \"fig1-van-den-oord\"}\n if mask_mode == \"noblind\":\n # context masking - subsequent pixels won't hav access\n # to next pixels (spatial dim)\n if vertical:\n if mask == 'A':\n # In the first layer, can ONLY access pixels above it\n pre_mask[:, :, yc:, :] = 0.0\n else:\n # In the second layer, can access pixels above or even with it.\n # Reason being that the pixels to the right or left of the current pixel\n # only have a receptive field of the layer above the current layer and up.\n pre_mask[:, :, yc+1:, :] = 0.0\n else:\n # All rows after center must be zero\n pre_mask[:, :, yc+1:, :] = 0.0\n ### All rows before center must be zero # XXX: not actually necessary\n ##pre_mask[:, :, :yc, :] = 0.0\n # All columns after center in center row must be zero\n pre_mask[:, :, yc, xc+1:] = 0.0\n\n if mask == 'A':\n # Center must be zero in first layer\n pre_mask[:, :, yc, xc] = 0.0\n # same pixel masking - pixel won't access next color (conv filter dim)\n #def bmask(i_out, i_in):\n # cout_idx = np.expand_dims(np.arange(Cout) % 3 == i_out, 1)\n # cin_idx = np.expand_dims(np.arange(Cin) % 3 == i_in, 0)\n # a1, a2 = np.broadcast_arrays(cout_idx, cin_idx)\n # return a1 * a2\n\n #for j in range(3):\n # pre_mask[bmask(j, j), yc, xc] = 0.0 if mask == 'A' else 1.0\n\n #pre_mask[bmask(0, 1), yc, xc] = 0.0\n #pre_mask[bmask(0, 2), yc, xc] = 0.0\n #pre_mask[bmask(1, 2), yc, xc] = 0.0\n elif mask_mode == \"fig1-van-den-oord\":\n if vertical:\n pre_mask[:, :, yc:, :] = 0.0\n else:\n # All rows after center must be zero\n pre_mask[:, :, yc+1:, :] = 0.0\n ### All rows before center must be zero # XXX: not actually necessary\n ##pre_mask[:, :, :yc, :] = 0.0\n # All columns after center in center row must be zero\n pre_mask[:, :, yc, xc+1:] = 0.0\n\n if mask == 'A':\n # Center must be zero in first layer\n pre_mask[:, :, yc, xc] = 0.0\n elif mask_mode == \"turukin\":\n pre_mask[:, :, yc+1:, :] = 0.0\n pre_mask[:, :, yc, xc+1:] = 0.0\n if mask == 'A':\n pre_mask[:, :, yc, xc] = 0.0\n\n print(\"%s %s MASKED CONV: %d x %d. Mask:\" % (mask, \"VERTICAL\" if vertical else \"HORIZONTAL\", kh, kw))\n print(pre_mask[0, 0, :, :])\n\n self.register_buffer(\"mask\", torch.from_numpy(pre_mask))\n\n def __call__(self, x):\n self.weight.data = self.weight.data * self.mask\n return super(MaskedConvolution2D, self).forward(x)\n\nclass CroppedConvolution(nn.Conv2d):\n def __init__(self, in_channels, out_channels, kernel_size,\n *args, **kwargs):\n if \"padding\" not in kwargs:\n assert \"stride\" not in kwargs\n kwargs[\"padding\"] = same_padding(kernel_size)\n super().__init__(in_channels, out_channels, kernel_size,\n *args, **kwargs)\n\n def __call__(self, x):\n ret = super().__call__(x)\n _, _, kh, kw = self.weight.size()\n pad_h, pad_w = self.padding\n h_crop = -(kh + 1) if pad_h == kh else None\n w_crop = -(kw + 1) if pad_w == kw else None\n return ret[:, :, :h_crop, :w_crop]\n\nclass PixelCNNGatedLayer(nn.Module):\n def __init__(self, primary, in_channels, out_channels, filter_size,\n mask='B', nobias=False, conditional_features=None,\n conditional_image_channels=None, residual_vertical=False,\n residual_horizontal=True, skips=False, gated=True,\n relu_out=False, horizontal_2d_convs=False, mask_mode=\"noblind\"):\n super().__init__()\n self.primary = primary\n if primary:\n assert mask == 'A'\n assert not residual_vertical\n assert not residual_horizontal\n else:\n assert mask == 'B'\n self.out_channels = out_channels\n self.gated = gated\n gm = 2 if gated else 1\n self.vertical_conv = MaskedConvolution2D(\n in_channels, gm * out_channels, (filter_size, filter_size),\n mask=mask, vertical=True, mask_mode=mask_mode)\n self.v_to_h_conv = nn.Conv2d(gm * out_channels, gm * out_channels, 1)\n\n self.horizontal_conv = MaskedConvolution2D(\n in_channels, gm * out_channels,\n (filter_size if horizontal_2d_convs else 1, filter_size), # XXX: traditionally (1, filter_size),\n mask=mask, vertical=False, mask_mode=mask_mode)\n\n self.residual_vertical = None\n if residual_vertical:\n self.residual_vertical = nn.Conv2d(in_channels, gm * out_channels, 1)\n\n self.horizontal_output = nn.Conv2d(out_channels, out_channels, 1)\n self.horizontal_skip = None\n if skips:\n self.horizontal_skip = nn.Conv2d(out_channels, out_channels, 1)\n self.conditional_vector = conditional_features is not None\n self.conditional_image = conditional_image_channels is not None\n if self.conditional_image:\n self.cond_conv_h = nn.Conv2d(conditional_image_channels, gm * out_channels, 1, bias=False)\n self.cond_conv_v = nn.Conv2d(conditional_image_channels, gm * out_channels, 1, bias=False)\n if self.conditional_vector:\n self.cond_fc_h = nn.Linear(conditional_features, gm * out_channels, bias=False)\n self.cond_fc_v = nn.Linear(conditional_features, gm * out_channels, bias=False)\n self.residual_horizontal = residual_horizontal\n self.relu_out = relu_out\n\n @classmethod\n def primary(cls, in_channels, out_channels, filter_size,\n nobias=False, conditional_features=None,\n conditional_image_channels=None, \n skips=False, gated=True,\n relu_out=False, horizontal_2d_convs=False, mask_mode=\"noblind\"):\n return cls(True, in_channels, out_channels, filter_size, nobias=nobias,\n mask='A', conditional_features=conditional_features,\n conditional_image_channels=conditional_image_channels,\n residual_vertical=False, residual_horizontal=False,\n skips=skips, gated=gated,\n relu_out=relu_out, horizontal_2d_convs=horizontal_2d_convs,\n mask_mode=mask_mode)\n \n @classmethod\n def secondary(cls, in_channels, out_channels, filter_size,\n nobias=False, conditional_features=None,\n conditional_image_channels=None, residual_vertical=True,\n residual_horizontal=True, skips=False, gated=True,\n relu_out=False, horizontal_2d_convs=False, mask_mode=\"noblind\"):\n return cls(False, in_channels, out_channels, filter_size, nobias=nobias,\n mask='B', conditional_features=conditional_features,\n conditional_image_channels=conditional_image_channels,\n residual_vertical=residual_vertical, residual_horizontal=residual_horizontal,\n skips=skips, gated=gated, relu_out=relu_out,\n horizontal_2d_convs=horizontal_2d_convs, mask_mode=mask_mode)\n\n def _gate(self, x):\n if self.gated:\n return F.tanh(x[:,:self.out_channels]) * F.sigmoid(x[:,self.out_channels:])\n else:\n return x\n\n def __call__(self, v, h, conditional_image=None, conditional_vector=None):\n horizontal_preactivation = self.horizontal_conv(h) # 1xN\n vertical_preactivation = self.vertical_conv(v) # NxN\n v_to_h = self.v_to_h_conv(vertical_preactivation) # 1x1\n if self.residual_vertical is not None:\n vertical_preactivation = vertical_preactivation + self.residual_vertical(v) # 1x1 to residual\n horizontal_preactivation = horizontal_preactivation + v_to_h\n if self.conditional_image and conditional_image is not None:\n horizontal_preactivation = horizontal_preactivation + \\\n self.cond_conv_h(conditional_image)\n vertical_preactivation = vertical_preactivation + \\\n self.cond_conv_v(conditional_image)\n if self.conditional_vector and conditional_vector is not None:\n horizontal_preactivation = horizontal_preactivation + \\\n self.cond_fc_h(conditional_vector).unsqueeze(-1).unsqueeze(-1)\n vertical_preactivation = vertical_preactivation + \\\n self.cond_fc_v(conditional_vector).unsqueeze(-1).unsqueeze(-1)\n v_out = self._gate(vertical_preactivation)\n h_activated = self._gate(horizontal_preactivation)\n h_skip = None\n if self.horizontal_skip is not None:\n h_skip = self.horizontal_skip(h_activated)\n h_preres = self.horizontal_output(h_activated)\n if self.residual_horizontal:\n h_out = h + h_preres\n else:\n h_out = h_preres\n if self.relu_out:\n v_out = F.relu(v_out)\n h_out = F.relu(h_out)\n if h_skip is not None:\n h_skip = F.relu(h_skip)\n return v_out, h_out, h_skip\n\nclass PixelCNNGatedStack(nn.Module):\n def __init__(self, *args):\n super().__init__()\n layers = list(args)\n for i, layer in enumerate(layers):\n assert isinstance(layer, PixelCNNGatedLayer)\n if i == 0:\n assert layer.primary\n else:\n assert not layer.primary\n self.layers = nn.ModuleList(layers)\n\n def __call__(self, v, h, skips=None, conditional_image=None, conditional_vector=None):\n if skips is None:\n skips = []\n else:\n skips = [skips]\n for layer in self.layers:\n v, h, skip = layer(v, h, conditional_image=conditional_image, conditional_vector=conditional_vector)\n if skip is not None:\n skips.append(skip)\n if len(skips) == 0:\n skips = None\n else:\n skips = torch.cat(skips, 1)\n return v, h, skips\n\nclass PixelCNN(nn.Module):\n def _sample_from(self, probas):\n N, level_count = probas.size()\n val = torch.rand(N, 1)\n if probas.is_cuda:\n val = val.cuda()\n cutoffs = torch.cumsum(probas, dim=1)\n _, idx = torch.max(cutoffs > val, dim=1)\n out = idx.float() / (level_count - 1)\n return out \n\n def sample_pixel(self, canvas, row, col, channel, **kwargs):\n probs = F.softmax(self(canvas, **kwargs)[:, :, channel, row, col], dim=1)\n return self._sample_from(probs.data)\n\n def generate_samples(self, height, width,\n channels, count, show_prog=False, **kwargs):\n samples = torch.zeros(count, channels, height, width).float()\n if next(self.parameters()).data.is_cuda:\n samples = samples.cuda()\n samples = Variable(samples, requires_grad=False)\n \n def generate(prog=None):\n for i in range(height):\n for j in range(width):\n for k in range(channels):\n samples.data[:, k, i, j] = self.sample_pixel(samples,\n i, j, k, **kwargs)\n if prog is not None:\n prog.update()\n if show_prog:\n with tqdm.tqdm(total=height * width * channels) as prog:\n generate(prog=prog)\n else:\n generate()\n return samples\n\nif __name__ == \"__main__\":\n x = PixelCNN(3, 128, 5, 16, 8, conditional_features=10,\n conditional_image_channels=8)\n print(x)\n inp = Variable(torch.randn(128, 3, 28, 28))\n cv = Variable(torch.randn(128, 10))\n ci = Variable(torch.randn(128, 8, 28, 28))\n print(x(inp, conditional_vector=cv, conditional_image=ci))\n print(x.generate_samples(28, 28, 3, 4, conditional_vector=cv, conditional_image=ci, show_prog=True))\n"
] | [
[
"torch.nn.Linear",
"torch.nn.functional.tanh",
"torch.nn.functional.sigmoid",
"torch.randn",
"torch.rand",
"torch.autograd.Variable",
"torch.nn.functional.relu",
"torch.cumsum",
"torch.from_numpy",
"torch.nn.Conv2d",
"torch.nn.ModuleList",
"torch.max",
"torch.zeros",
"torch.cat"
]
] |
zhengye1995/datafountain_siweituxin_autodriver_det | [
"2c2df76fb9942ddc334730cc5bc447be66440e22"
] | [
"tools/convert_datasets/trans_txt2json.py"
] | [
"# *utf-8*\nimport os\nimport json\nimport numpy as np\nfrom tqdm import tqdm\nimport cv2\n\ndefect_name2label = {\n 'red': 1, 'green': 2, 'yellow': 3, 'red_left': 4, 'red_right': 5, 'yellow_left': 6, 'yellow_right': 7,\n 'green_left': 8, 'green_right': 9, 'red_forward': 10, 'green_forward': 11, 'yellow_forward': 12,\n 'horizon_red': 13, 'horizon_green': 14, 'horizon_yellow': 15, 'off': 16, 'traffic_sign': 17,\n 'car': 18, 'motor': 19, 'bike': 20, 'bus': 21, 'truck': 22, 'suv': 23, 'express': 24, 'person': 25,\n}\n\n\nclass Siwei2COCO:\n\n def __init__(self, mode=\"train\"):\n self.images = []\n self.annotations = []\n self.categories = []\n self.img_id = 0\n self.ann_id = 0\n self.mode = mode\n\n\n def to_coco(self, anno_file, img_dir):\n self._init_categories()\n with open(anno_file, 'r') as f:\n annos = f.readlines()\n\n for anno in tqdm(annos):\n try:\n img_name, seg_name, bboxs = anno.strip().split(' ', 2)\n except:\n img_name, seg_name = anno.strip().split(' ', 2)\n print(img_name)\n continue\n\n bboxs = bboxs.split(' ')\n # print(bboxs)\n\n img_path = os.path.join(img_dir, img_name)\n # img = cv2.imread(img_path)\n # h, w, _ = img.shape\n h, w = 720, 1280\n self.images.append(self._image(img_path, h, w))\n for bbox in zip(bboxs):\n # print(list(bbox)[0])\n xmin, ymin, xmax, ymax, class_id, _ = list(bbox)[0].split(',')\n # print(xmin, ymin, xmax, ymax, class_id)\n annotation = self._annotation(class_id, [float(xmin), float(ymin), float(xmax), float(ymax)], h, w)\n self.annotations.append(annotation)\n self.ann_id += 1\n self.img_id += 1\n instance = {}\n instance['info'] = 'fabric defect'\n instance['license'] = ['none']\n instance['images'] = self.images\n instance['annotations'] = self.annotations\n instance['categories'] = self.categories\n return instance\n\n def _init_categories(self):\n # for v in range(1, 16):\n # print(v)\n # category = {}\n # category['id'] = v\n # category['name'] = str(v)\n # category['supercategory'] = 'defect_name'\n # self.categories.append(category)\n for k, v in defect_name2label.items():\n category = {}\n category['id'] = v\n category['name'] = k\n category['supercategory'] = 'siweituxin_name'\n self.categories.append(category)\n\n def _image(self, path, h, w):\n image = {}\n image['height'] = h\n image['width'] = w\n image['id'] = self.img_id\n image['file_name'] = os.path.basename(path)\n return image\n\n def _annotation(self, label, bbox, h, w):\n area = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])\n # area=abs(bbox[2]-bbox[0])*abs(bbox[3]-bbox[1])\n if area <= 0:\n print(bbox)\n input()\n points = [[bbox[0], bbox[1]], [bbox[2], bbox[1]], [bbox[2], bbox[3]], [bbox[0], bbox[3]]]\n annotation = {}\n annotation['id'] = self.ann_id\n annotation['image_id'] = self.img_id\n annotation['category_id'] = int(label)\n annotation['segmentation'] = [np.asarray(points).flatten().tolist()]\n annotation['bbox'] = self._get_box(points, h, w)\n annotation['iscrowd'] = 0\n annotation['area'] = area\n return annotation\n\n def _get_box(self, points, img_h, img_w):\n min_x = min_y = np.inf\n max_x = max_y = 0\n for x, y in points:\n min_x = min(min_x, x)\n min_y = min(min_y, y)\n max_x = max(max_x, x)\n max_y = max(max_y, y)\n '''coco,[x,y,w,h]'''\n w = max_x - min_x\n h = max_y - min_y\n if w > img_w:\n w = img_w\n if h > img_h:\n h = img_h\n return [min_x, min_y, w, h]\n\n def save_coco_json(self, instance, save_path):\n with open(save_path, 'w') as fp:\n json.dump(instance, fp, indent=1, separators=(',', ': '))\n\n\n'''转换有瑕疵的样本为coco格式'''\nimg_dir = \"data/siweituxin/train_image\"\nanno_dir = \"data/siweituxin/Annotations/train.txt\"\nsiwei2coco = Siwei2COCO()\ntrain_instance = siwei2coco.to_coco(anno_dir, img_dir)\n\nsiwei2coco.save_coco_json(train_instance,\n \"data/siweituxin/annotations/\"\n + 'instances_{}.json'.format(\"train\"))"
] | [
[
"numpy.asarray"
]
] |
Mrpatekful/supervised-translation | [
"d03db6a0fc25900fd42b8057a12adad0b8d025f8"
] | [
"src/model.py"
] | [
"\"\"\"\n@author: Patrik Purgai\n@copyright: Copyright 2019, supervised-translation\n@license: MIT\n@email: [email protected]\n@date: 2019.04.04.\n\"\"\"\n\n# pylint: disable=no-member\n# pylint: disable=not-callable\n\nimport torch\nimport random\n\nfrom torch.nn.modules import (\n Module, ModuleList)\n\nfrom torch.nn.functional import (\n log_softmax, softmax, linear,\n embedding)\n\nfrom torch.nn import (\n Linear, Softmax, Parameter, \n GRU, Dropout, Embedding)\n\n\ndef setup_model_args(parser):\n \"\"\"\n Sets up the model arguments.\n \"\"\"\n parser.add_argument(\n '--hidden_size',\n type=int,\n default=256,\n help='Hidden size of the model.')\n parser.add_argument(\n '--embedding_size',\n type=int,\n default=128,\n help='Embedding dimension for the tokens.')\n\n\ndef create_model(args, tokenizers, device):\n \"\"\"\n Creates the sequence to sequence model.\n \"\"\"\n source_tokenizer, target_tokenizer = tokenizers\n\n special_ids = target_tokenizer.bos_id(), \\\n target_tokenizer.eos_id(), source_tokenizer.pad_id(), \\\n target_tokenizer.pad_id(), source_tokenizer.unk_id()\n\n tensor_indices = [\n torch.tensor(i).to(device) for i in special_ids]\n\n model = Seq2Seq(\n source_vocab_size=len(source_tokenizer),\n target_vocab_size=len(target_tokenizer),\n indices=tensor_indices,\n **vars(args)).to(device)\n\n return model\n\n\ndef neginf(dtype):\n \"\"\"\n Return a representable finite \n number near -inf for a dtype.\n \"\"\"\n if dtype is torch.float16:\n return -65504\n else:\n return -1e20\n\n\n# NOTE currently unused function\ndef embeddeding_dropout(embed, inputs, training, mask=None, p=0.1):\n \"\"\"\n Applies dropout to the embedding layer based on\n https://arxiv.org/pdf/1512.05287.pdf. The code is\n based on salesforce/awd-lstm-lm.\n \"\"\"\n if not training:\n masked_embed_weight = embed.weight\n if mask is not None:\n # masks might be provided, which is useful for shared\n # dropout masks over the whole sequence of inputs\n masked_embed_weight = mask * embed.weight\n elif p:\n mask = embed.weight.new_empty((embed.weight.size(0), 1))\n mask.bernoulli_(1 - p).expand_as(embed.weight) / (1 - p)\n masked_embed_weight = mask * embed.weight\n else:\n masked_embed_weight = embed.weight\n\n return embedding(\n inputs, masked_embed_weight, embed.padding_idx, \n embed.max_norm, embed.norm_type,\n embed.scale_grad_by_freq, embed.sparse)\n\n\nclass Seq2Seq(Module):\n \"\"\"\n The sequence-to-sequence model.\n \"\"\"\n\n def __init__(self, embedding_size, hidden_size, indices,\n source_vocab_size, target_vocab_size, **kwargs):\n super().__init__()\n\n self.start_idx, self.end_idx, \\\n self.pad_idx, _, self.unk_idx = indices\n\n self.encoder = Encoder(\n input_size=embedding_size,\n hidden_size=hidden_size,\n pad_idx=self.pad_idx,\n vocab_size=source_vocab_size)\n\n self.decoder = Decoder(\n input_size=embedding_size,\n hidden_size=hidden_size,\n vocab_size=target_vocab_size)\n\n def forward(self, inputs, attn_mask=None, targets=None, \n max_len=50):\n \"\"\"\n Runs the inputs through the encoder-decoder model.\n \"\"\"\n # inputs are expexted in sequence-first format\n batch_size = inputs.size(0)\n max_len = targets.size(1) if targets is not None \\\n else max_len\n\n if attn_mask is None:\n attn_mask = inputs.eq(self.pad_idx)\n\n # the number of layers in the decoder must be equal\n # to the number of layers in the encoder because of\n # the initial hidden states from the encoder\n encoder_outputs, hidden_states = self.encoder(inputs)\n\n scores = []\n preds = self.start_idx.detach().expand(batch_size, 1)\n\n for idx in range(max_len):\n # if targets are provided and training then apply\n # teacher forcing 50% of the time\n if targets is not None and self.training and \\\n random.random() > 0.5:\n prev_output = targets[:, idx].unsqueeze(1)\n else:\n prev_output = preds[:, -1:]\n\n step_scores, hidden_states = self.decoder(\n inputs=prev_output,\n encoder_outputs=encoder_outputs,\n prev_hiddens=hidden_states,\n attn_mask=attn_mask)\n\n _, step_preds = step_scores.max(dim=-1)\n\n preds = torch.cat([preds, step_preds], dim=-1)\n scores.append(step_scores)\n\n scores = torch.cat(scores, dim=1)\n preds = preds.narrow(1, 1, preds.size(1) - 1)\n\n return scores, preds\n\n\nclass Encoder(Module):\n \"\"\"\n Encoder module for the seq2seq model.\n \"\"\"\n\n def __init__(self, input_size, hidden_size, pad_idx,\n vocab_size):\n super().__init__()\n\n self.embedding = Embedding(\n num_embeddings=vocab_size,\n embedding_dim=input_size,\n padding_idx=pad_idx)\n\n self.dropout = Dropout(p=0.1)\n\n self.merge = Linear(\n in_features=hidden_size * 2,\n out_features=hidden_size,\n bias=False)\n\n # creating rnn layer as module list so locked\n # dropout can be applied between each layer\n # NOTE: currently not using weight drop, because\n # it is incompatible with apex\n self.rnn = ModuleList([\n GRU(input_size=input_size,\n hidden_size=hidden_size,\n bidirectional=True,\n batch_first=True)] + [\n GRU(input_size=hidden_size,\n hidden_size=hidden_size,\n batch_first=True)\n for _ in range(2)\n ])\n\n def forward(self, inputs):\n \"\"\"\n Computes the embeddings and runs them through an RNN.\n \"\"\"\n embedded = self.embedding(inputs)\n embedded = self.dropout(embedded)\n\n outputs, hidden_state = self.rnn[0](embedded)\n\n # merging the two directions of bidirectional layer\n # by summing along the first axis\n hidden_states = [hidden_state.sum(0, keepdim=True)]\n outputs = self.merge(outputs)\n\n for layer in self.rnn[1:]:\n outputs, hidden_state = layer(outputs)\n outputs = self.dropout(outputs)\n hidden_states.append(hidden_state)\n\n return outputs, hidden_states\n\n\nclass Decoder(Module):\n \"\"\"\n Decoder module for the seq2seq.\n \"\"\"\n\n def __init__(self, input_size, hidden_size, vocab_size):\n super().__init__()\n\n self.embedding = Embedding(\n num_embeddings=vocab_size,\n embedding_dim=input_size)\n\n self.dropout = Dropout(p=0.1)\n\n self.rnn = ModuleList([\n GRU(input_size=input_size,\n hidden_size=hidden_size,\n batch_first=True)] + [\n GRU(input_size=hidden_size,\n hidden_size=hidden_size,\n batch_first=True)\n for _ in range(2)\n ])\n\n self.attn = Attention(hidden_size=hidden_size)\n\n self.out_bias = Parameter(torch.zeros((vocab_size, )))\n self.out_weight = self.embedding.weight\n\n def forward(self, inputs, encoder_outputs, prev_hiddens,\n attn_mask=None, embed_mask=None):\n \"\"\"\n Applies decoding with attention mechanism, mixture\n of sofmaxes and multi dropout during training.\n MoS implementation is taken from \n \"\"\"\n embedded = self.embedding(inputs)\n output = self.dropout(embedded)\n\n hidden_states = []\n for idx, layer in enumerate(self.rnn):\n output, hidden_state = layer(\n output, prev_hiddens[idx])\n output = self.dropout(output)\n hidden_states.append(hidden_state)\n\n # NOTE attention weights are not used currently\n # (they could be exported for visualization)\n output, _ = self.attn(\n decoder_output=output,\n hidden_state=hidden_state,\n encoder_outputs=encoder_outputs,\n attn_mask=attn_mask)\n\n logits = linear(\n output, self.out_weight, self.out_bias)\n\n log_probs = log_softmax(logits, dim=-1)\n\n return log_probs, hidden_states\n\n\nclass Attention(Module):\n \"\"\"\n Luong style general attention from \n https://arxiv.org/pdf/1508.04025.pdf.\n \"\"\"\n\n def __init__(self, hidden_size):\n super().__init__()\n\n self.project = Linear(\n in_features=hidden_size,\n out_features=hidden_size,\n bias=False)\n\n self.combine = Linear(\n in_features=hidden_size * 2,\n out_features=hidden_size,\n bias=False)\n\n def forward(self, decoder_output, hidden_state, \n encoder_outputs, attn_mask=None):\n \"\"\"\n Applies attention by creating the weighted \n context vector. Implementation is based on \n `IBM/pytorch-seq2seq`.\n \"\"\"\n hidden_state = self.project(hidden_state)\n hidden_state = hidden_state.transpose(0, 1)\n \n encoder_outputs_t = encoder_outputs.transpose(1, 2)\n attn_scores = torch.bmm(\n hidden_state, encoder_outputs_t)\n\n # applying mask on padded values of the input\n # NOTE during beam search mask might not be provided\n if attn_mask is not None:\n attn_scores = attn_scores.squeeze(1)\n attn_scores.masked_fill_(\n attn_mask, neginf(attn_scores.dtype))\n attn_scores = attn_scores.unsqueeze(1)\n\n attn_weights = softmax(attn_scores, dim=-1)\n attn_applied = torch.bmm(\n attn_weights, encoder_outputs)\n\n stacked = torch.cat(\n [decoder_output, attn_applied], dim=-1)\n outputs = self.combine(stacked)\n\n return outputs, attn_weights\n"
] | [
[
"torch.nn.functional.log_softmax",
"torch.nn.Linear",
"torch.nn.functional.embedding",
"torch.nn.functional.linear",
"torch.bmm",
"torch.nn.functional.softmax",
"torch.tensor",
"torch.nn.Embedding",
"torch.nn.GRU",
"torch.zeros",
"torch.cat",
"torch.nn.Dropout"
]
] |
jiruifu-jerry0219/UpperLimbEstimator | [
"d62deef93419934dcb33e43707dd0634a235fb9a"
] | [
"ArtificialNeuralNetwork/model.py"
] | [
"import torch\nimport torch.nn as nn\nfrom torch.autograd import Variable\nimport torch.nn.functional as F\nimport torch.utils.data as Data\nimport torch.optim as optim\nfrom torch.utils.data import Dataset, DataLoader, WeightedRandomSampler\n\nclass MultipleRegression(nn.Module):\n def __init__(self, num_features):\n super(MultipleRegression, self).__init__()\n self.fc1 = nn.Linear(num_features, 64)\n self.fc2 = nn.Linear(64, 128)\n# self.fc3 = nn.Linear(128, 64)\n self.output = nn.Linear(128, 1)\n\n self.act = nn.Sigmoid()\n\n def forward(self, inputs):\n x = self.act(self.fc1(inputs))\n x = self.act(self.fc2(x))\n# x = self.act(self.fc3(x))\n x = self.output(x)\n\n return x\n\n def predict(self, test_inputs):\n x = self.act(self.fc1(test_inputs))\n x = self.act(self.fc2(x))\n# x = self.act(self.fc3(x))\n x = self.output(x)\n\n return x\n"
] | [
[
"torch.nn.Sigmoid",
"torch.nn.Linear"
]
] |
anonymousGithub2023/ECCV | [
"7c4b862c898aa6a591bc7f32f95c5900e0492490"
] | [
"collect_latency.py"
] | [
"import torch\nimport os\nimport numpy as np\n\nfrom utils import *\n\nl2_res = np.zeros([6, 7])\nlinf_res = np.zeros([6, 7])\n\nresDir = 'res'\nif not os.path.isdir(resDir):\n os.mkdir(resDir)\nfor model_file in MODEL_FILE_LIST:\n task_name = model_file.split('.')[0]\n for attack_name in ['L2', 'Linf']:\n avg_res = np.zeros([3, 7])\n max_res = np.zeros([3, 7])\n for attack_type in [1,2,3,4,5,6,0]:\n latency_file = os.path.join('latency', str(attack_type) + '_' + attack_name + '_' + task_name + '.latency')\n latency_res = torch.load(latency_file)\n ori_res, adv_res = latency_res\n cpu_inc, gpu_inc, loop_inc = [], [], []\n for ori, adv in zip(ori_res, adv_res):\n cpu_inc.append(adv[1] / ori[1] - 1)\n gpu_inc.append(adv[0] / ori[0] - 1)\n loop_inc.append(adv[2] / ori[2] - 1)\n cpu_inc, gpu_inc, loop_inc = np.array(cpu_inc), np.array(gpu_inc), np.array(loop_inc)\n\n avg_res[0, attack_type] = loop_inc.mean()\n avg_res[1, attack_type] = cpu_inc.mean()\n avg_res[2, attack_type] = gpu_inc.mean()\n\n max_res[0, attack_type] = loop_inc.max()\n max_res[1, attack_type] = cpu_inc.max()\n max_res[2, attack_type] = gpu_inc.max()\n final_res = np.concatenate([avg_res, max_res], axis=0)\n file_name = os.path.join(resDir, task_name + '_' + attack_name + '.csv')\n final_res = np.concatenate([final_res[:,1:], final_res[:, 0:1]], axis=1)\n np.savetxt(file_name, final_res, delimiter=',')\n print(file_name, 'success')\n"
] | [
[
"torch.load",
"numpy.zeros",
"numpy.savetxt",
"numpy.array",
"numpy.concatenate"
]
] |
youqingxiaozhua/OpenSelfSup | [
"ab8fc27c6b43679317eaf312b85461ba490606af"
] | [
"openselfsup/models/backbones/resnet.py"
] | [
"import torch.nn as nn\nimport torch.utils.checkpoint as cp\nfrom mmcv.cnn import constant_init, kaiming_init\nfrom mmcv.runner import load_checkpoint\nfrom torch.nn.modules.batchnorm import _BatchNorm\n\nfrom openselfsup.utils import get_root_logger\nfrom ..registry import BACKBONES\nfrom ..utils import build_conv_layer, build_norm_layer\n\n\nclass BasicBlock(nn.Module):\n expansion = 1\n\n def __init__(self,\n inplanes,\n planes,\n stride=1,\n dilation=1,\n downsample=None,\n style='pytorch',\n with_cp=False,\n conv_cfg=None,\n norm_cfg=dict(type='BN')):\n super(BasicBlock, self).__init__()\n\n self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1)\n self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2)\n\n self.conv1 = build_conv_layer(\n conv_cfg,\n inplanes,\n planes,\n 3,\n stride=stride,\n padding=dilation,\n dilation=dilation,\n bias=False)\n self.add_module(self.norm1_name, norm1)\n self.conv2 = build_conv_layer(\n conv_cfg, planes, planes, 3, padding=1, bias=False)\n self.add_module(self.norm2_name, norm2)\n\n self.relu = nn.ReLU(inplace=True)\n self.downsample = downsample\n self.stride = stride\n self.dilation = dilation\n assert not with_cp\n\n @property\n def norm1(self):\n return getattr(self, self.norm1_name)\n\n @property\n def norm2(self):\n return getattr(self, self.norm2_name)\n\n def forward(self, x):\n identity = x\n\n out = self.conv1(x)\n out = self.norm1(out)\n out = self.relu(out)\n\n out = self.conv2(out)\n out = self.norm2(out)\n\n if self.downsample is not None:\n identity = self.downsample(x)\n\n out += identity\n out = self.relu(out)\n\n return out\n\n\nclass Bottleneck(nn.Module):\n expansion = 4\n\n def __init__(self,\n inplanes,\n planes,\n stride=1,\n dilation=1,\n downsample=None,\n style='pytorch',\n with_cp=False,\n conv_cfg=None,\n norm_cfg=dict(type='BN')):\n \"\"\"Bottleneck block for ResNet.\n If style is \"pytorch\", the stride-two layer is the 3x3 conv layer,\n if it is \"caffe\", the stride-two layer is the first 1x1 conv layer.\n \"\"\"\n super(Bottleneck, self).__init__()\n assert style in ['pytorch', 'caffe']\n\n self.inplanes = inplanes\n self.planes = planes\n self.stride = stride\n self.dilation = dilation\n self.style = style\n self.with_cp = with_cp\n self.conv_cfg = conv_cfg\n self.norm_cfg = norm_cfg\n\n if self.style == 'pytorch':\n self.conv1_stride = 1\n self.conv2_stride = stride\n else:\n self.conv1_stride = stride\n self.conv2_stride = 1\n\n self.norm1_name, norm1 = build_norm_layer(norm_cfg, planes, postfix=1)\n self.norm2_name, norm2 = build_norm_layer(norm_cfg, planes, postfix=2)\n self.norm3_name, norm3 = build_norm_layer(\n norm_cfg, planes * self.expansion, postfix=3)\n\n self.conv1 = build_conv_layer(\n conv_cfg,\n inplanes,\n planes,\n kernel_size=1,\n stride=self.conv1_stride,\n bias=False)\n self.add_module(self.norm1_name, norm1)\n self.conv2 = build_conv_layer(\n conv_cfg,\n planes,\n planes,\n kernel_size=3,\n stride=self.conv2_stride,\n padding=dilation,\n dilation=dilation,\n bias=False)\n self.add_module(self.norm2_name, norm2)\n self.conv3 = build_conv_layer(\n conv_cfg,\n planes,\n planes * self.expansion,\n kernel_size=1,\n bias=False)\n self.add_module(self.norm3_name, norm3)\n\n self.relu = nn.ReLU(inplace=True)\n self.downsample = downsample\n\n @property\n def norm1(self):\n return getattr(self, self.norm1_name)\n\n @property\n def norm2(self):\n return getattr(self, self.norm2_name)\n\n @property\n def norm3(self):\n return getattr(self, self.norm3_name)\n\n def forward(self, x):\n\n def _inner_forward(x):\n identity = x\n\n out = self.conv1(x)\n out = self.norm1(out)\n out = self.relu(out)\n\n out = self.conv2(out)\n out = self.norm2(out)\n out = self.relu(out)\n\n out = self.conv3(out)\n out = self.norm3(out)\n\n if self.downsample is not None:\n identity = self.downsample(x)\n\n out += identity\n\n return out\n\n if self.with_cp and x.requires_grad:\n out = cp.checkpoint(_inner_forward, x)\n else:\n out = _inner_forward(x)\n\n out = self.relu(out)\n\n return out\n\n\ndef make_res_layer(block,\n inplanes,\n planes,\n blocks,\n stride=1,\n dilation=1,\n style='pytorch',\n with_cp=False,\n conv_cfg=None,\n norm_cfg=dict(type='BN')):\n downsample = None\n if stride != 1 or inplanes != planes * block.expansion:\n downsample = nn.Sequential(\n build_conv_layer(\n conv_cfg,\n inplanes,\n planes * block.expansion,\n kernel_size=1,\n stride=stride,\n bias=False),\n build_norm_layer(norm_cfg, planes * block.expansion)[1],\n )\n\n layers = []\n layers.append(\n block(\n inplanes=inplanes,\n planes=planes,\n stride=stride,\n dilation=dilation,\n downsample=downsample,\n style=style,\n with_cp=with_cp,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg))\n inplanes = planes * block.expansion\n for i in range(1, blocks):\n layers.append(\n block(\n inplanes=inplanes,\n planes=planes,\n stride=1,\n dilation=dilation,\n style=style,\n with_cp=with_cp,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg))\n\n return nn.Sequential(*layers)\n\n\[email protected]_module\nclass ResNet(nn.Module):\n \"\"\"ResNet backbone.\n\n Args:\n depth (int): Depth of resnet, from {18, 34, 50, 101, 152}.\n in_channels (int): Number of input image channels. Normally 3.\n num_stages (int): Resnet stages, normally 4.\n strides (Sequence[int]): Strides of the first block of each stage.\n dilations (Sequence[int]): Dilation of each stage.\n out_indices (Sequence[int]): Output from which stages.\n style (str): `pytorch` or `caffe`. If set to \"pytorch\", the stride-two\n layer is the 3x3 conv layer, otherwise the stride-two layer is\n the first 1x1 conv layer.\n frozen_stages (int): Stages to be frozen (stop grad and set eval mode).\n -1 means not freezing any parameters.\n norm_cfg (dict): dictionary to construct and config norm layer.\n norm_eval (bool): Whether to set norm layers to eval mode, namely,\n freeze running stats (mean and var). Note: Effect on Batch Norm\n and its variants only.\n with_cp (bool): Use checkpoint or not. Using checkpoint will save some\n memory while slowing down the training speed.\n zero_init_residual (bool): whether to use zero init for last norm layer\n in resblocks to let them behave as identity.\n\n Example:\n >>> from openselfsup.models import ResNet\n >>> import torch\n >>> self = ResNet(depth=18)\n >>> self.eval()\n >>> inputs = torch.rand(1, 3, 32, 32)\n >>> level_outputs = self.forward(inputs)\n >>> for level_out in level_outputs:\n ... print(tuple(level_out.shape))\n (1, 64, 8, 8)\n (1, 128, 4, 4)\n (1, 256, 2, 2)\n (1, 512, 1, 1)\n \"\"\"\n\n arch_settings = {\n 18: (BasicBlock, (2, 2, 2, 2)),\n 34: (BasicBlock, (3, 4, 6, 3)),\n 50: (Bottleneck, (3, 4, 6, 3)),\n 101: (Bottleneck, (3, 4, 23, 3)),\n 152: (Bottleneck, (3, 8, 36, 3))\n }\n\n def __init__(self,\n depth,\n in_channels=3,\n num_stages=4,\n strides=(1, 2, 2, 2),\n dilations=(1, 1, 1, 1),\n out_indices=(0, 1, 2, 3, 4),\n style='pytorch',\n frozen_stages=-1,\n conv_cfg=None,\n norm_cfg=dict(type='BN', requires_grad=True),\n norm_eval=False,\n with_cp=False,\n zero_init_residual=False):\n super(ResNet, self).__init__()\n if depth not in self.arch_settings:\n raise KeyError('invalid depth {} for resnet'.format(depth))\n self.depth = depth\n self.num_stages = num_stages\n assert num_stages >= 1 and num_stages <= 4\n self.strides = strides\n self.dilations = dilations\n assert len(strides) == len(dilations) == num_stages\n self.out_indices = out_indices\n assert max(out_indices) < num_stages + 1\n self.style = style\n self.frozen_stages = frozen_stages\n self.conv_cfg = conv_cfg\n self.norm_cfg = norm_cfg\n self.with_cp = with_cp\n self.norm_eval = norm_eval\n self.zero_init_residual = zero_init_residual\n self.block, stage_blocks = self.arch_settings[depth]\n self.stage_blocks = stage_blocks[:num_stages]\n self.inplanes = 64\n\n self._make_stem_layer(in_channels)\n\n self.res_layers = []\n for i, num_blocks in enumerate(self.stage_blocks):\n stride = strides[i]\n dilation = dilations[i]\n planes = 64 * 2**i\n res_layer = make_res_layer(\n self.block,\n self.inplanes,\n planes,\n num_blocks,\n stride=stride,\n dilation=dilation,\n style=self.style,\n with_cp=with_cp,\n conv_cfg=conv_cfg,\n norm_cfg=norm_cfg)\n self.inplanes = planes * self.block.expansion\n layer_name = 'layer{}'.format(i + 1)\n self.add_module(layer_name, res_layer)\n self.res_layers.append(layer_name)\n\n self._freeze_stages()\n\n self.feat_dim = self.block.expansion * 64 * 2**(\n len(self.stage_blocks) - 1)\n\n @property\n def norm1(self):\n return getattr(self, self.norm1_name)\n\n def _make_stem_layer(self, in_channels):\n self.conv1 = build_conv_layer(\n self.conv_cfg,\n in_channels,\n 64,\n kernel_size=7,\n stride=2,\n padding=3,\n bias=False)\n self.norm1_name, norm1 = build_norm_layer(self.norm_cfg, 64, postfix=1)\n self.add_module(self.norm1_name, norm1)\n self.relu = nn.ReLU(inplace=True)\n self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)\n\n def _freeze_stages(self):\n if self.frozen_stages >= 0:\n self.norm1.eval()\n for m in [self.conv1, self.norm1]:\n for param in m.parameters():\n param.requires_grad = False\n\n for i in range(1, self.frozen_stages + 1):\n m = getattr(self, 'layer{}'.format(i))\n m.eval()\n for param in m.parameters():\n param.requires_grad = False\n\n def init_weights(self, pretrained=None):\n if isinstance(pretrained, str):\n logger = get_root_logger()\n load_checkpoint(self, pretrained, strict=True, logger=logger)\n elif pretrained is None:\n for m in self.modules():\n if isinstance(m, nn.Conv2d):\n kaiming_init(m, mode='fan_in', nonlinearity='relu')\n elif isinstance(m, (_BatchNorm, nn.GroupNorm)):\n constant_init(m, 1)\n\n if self.zero_init_residual:\n for m in self.modules():\n if isinstance(m, Bottleneck):\n constant_init(m.norm3, 0)\n elif isinstance(m, BasicBlock):\n constant_init(m.norm2, 0)\n else:\n raise TypeError('pretrained must be a str or None')\n\n def forward(self, x):\n outs = []\n x = self.conv1(x)\n x = self.norm1(x)\n x = self.relu(x) # r50: 64x128x128\n if 0 in self.out_indices:\n outs.append(x)\n x = self.maxpool(x) # r50: 64x56x56\n for i, layer_name in enumerate(self.res_layers):\n res_layer = getattr(self, layer_name)\n x = res_layer(x)\n if i + 1 in self.out_indices:\n outs.append(x)\n # r50: 1-256x56x56; 2-512x28x28; 3-1024x14x14; 4-2048x7x7\n return tuple(outs)\n\n def train(self, mode=True):\n super(ResNet, self).train(mode)\n self._freeze_stages()\n if mode and self.norm_eval:\n for m in self.modules():\n # trick: eval have effect on BatchNorm only\n if isinstance(m, _BatchNorm):\n m.eval()\n"
] | [
[
"torch.nn.MaxPool2d",
"torch.utils.checkpoint.checkpoint",
"torch.nn.ReLU",
"torch.nn.Sequential"
]
] |
unhold/game-and-watch-patch | [
"dc33f2228d7c791a746502aef27a5331c0076503"
] | [
"patches/tileset.py"
] | [
"from io import BytesIO\nfrom math import ceil\n\nimport numpy as np\nfrom PIL import Image\n\nfrom .exception import ParsingError\n\n_BLOCK_SIZE = 16\n_BLOCK_PIXEL = _BLOCK_SIZE * _BLOCK_SIZE\n\nPALETTE_OFFSETS = [\n 0xB_EC68,\n 0xB_EDA8,\n 0xB_EEE8,\n 0xB_F028,\n 0xB_F168,\n]\n\n\ndef bytes_to_tilemap(data, palette=None, bpp=8, width=256):\n \"\"\"\n Parameters\n ----------\n palette : bytes\n 320 long RGBA (80 colors). Alpha is ignored.\n\n Returns\n -------\n PIL.Image\n Rendered RGB image.\n \"\"\"\n\n # assert bpp in [4, 8]\n\n if bpp < 8:\n nibbles = bytearray()\n # offset = 0x0\n for b in data:\n shift = 8 - bpp\n while shift >= 0:\n nibbles.append(b >> shift & (2 ** bpp - 1))\n shift -= bpp\n # nibbles.append((b >> 4) | (offset << 4))\n # nibbles.append((b & 0xF) | (offset << 4))\n data = bytes(nibbles)\n del nibbles\n\n # Assemble bytes into an index-image\n h, w = int(ceil(len(data) / width / _BLOCK_SIZE) * _BLOCK_SIZE), width\n canvas = np.zeros((h, w), dtype=np.uint8)\n i_sprite = 0\n for i in range(0, len(data), _BLOCK_PIXEL):\n sprite = data[i : i + _BLOCK_PIXEL]\n\n x = i_sprite * _BLOCK_SIZE % w\n y = _BLOCK_SIZE * (i_sprite * _BLOCK_SIZE // w)\n view = canvas[y : y + _BLOCK_SIZE, x : x + _BLOCK_SIZE]\n sprite_block = np.frombuffer(sprite, dtype=np.uint8).reshape(\n _BLOCK_SIZE, _BLOCK_SIZE\n )\n view[:] = sprite_block\n\n i_sprite += 1\n\n if palette is None:\n return Image.fromarray(canvas, \"L\")\n\n # Apply palette to index-image\n p = np.frombuffer(palette, dtype=np.uint8).reshape((80, 4))\n p = p[:, :3]\n p = np.fliplr(p) # BGR->RGB\n\n im = Image.fromarray(canvas, \"P\")\n im.putpalette(p)\n\n return im\n\n\ndef rgb_to_index(tilemap, palette):\n if isinstance(tilemap, Image.Image):\n tilemap = tilemap.convert(\"RGB\")\n tilemap = np.array(tilemap)\n elif isinstance(tilemap, np.ndarray):\n pass\n else:\n raise TypeError(f\"Don't know how to handle tilemap type {type(tilemap)}\")\n\n # Convert rgb tilemap to index image\n p = np.frombuffer(palette, dtype=np.uint8).reshape((80, 4))\n p = p[:, :3]\n p = np.fliplr(p) # BGR->RGB\n p = p[None, None].transpose(0, 1, 3, 2) # (1, 1, 3, 80)\n\n # Find closest color\n diff = tilemap[..., None] - p\n dist = np.linalg.norm(diff, axis=2)\n tilemap = np.argmin(dist, axis=-1).astype(np.uint8)\n\n return tilemap\n\n\ndef tilemap_to_bytes(tilemap, palette=None, bpp=8):\n \"\"\"\n Parameters\n ----------\n tilemap : PIL.Image.Image or numpy.ndarray\n RGB data\n palette : bytes\n 320 long RGBA (80 colors). Alpha is ignored.\n\n Returns\n -------\n bytes\n Bytes representation of index image\n \"\"\"\n\n if isinstance(tilemap, Image.Image):\n tilemap = tilemap.convert(\"RGB\")\n tilemap = np.array(tilemap)\n elif isinstance(tilemap, np.ndarray):\n pass\n else:\n raise TypeError(f\"Don't know how to handle tilemap type {type(tilemap)}\")\n\n if palette is not None:\n tilemap = rgb_to_index(tilemap, palette)\n\n # Need to undo the tiling now.\n out = []\n for i in range(0, tilemap.shape[0], _BLOCK_SIZE):\n for j in range(0, tilemap.shape[1], _BLOCK_SIZE):\n sprite = tilemap[i : i + _BLOCK_SIZE, j : j + _BLOCK_SIZE]\n sprite_bytes = sprite.tobytes()\n out.append(sprite_bytes)\n out = b\"\".join(out)\n\n if bpp == 4:\n out_packed = bytearray()\n assert len(out) % 2 == 0\n for i in range(0, len(out), 2):\n b1, b2 = out[i], out[i + 1]\n b1 &= 0xF\n b2 &= 0xF\n out_packed.append((b1 << 4) | b2)\n out = bytes(out_packed)\n\n return out\n\n\ndef decode_backdrop(data):\n \"\"\"Convert easter egg images to GIF\n\n Based on:\n https://gist.github.com/GMMan/c1f0b516afdbb71769752ee06adbbd9a\n\n Returns\n -------\n PIL.Image.Image\n Decoded image\n int\n Number of bytes consumed to create image.\n \"\"\"\n\n def rgb565_to_rgba32(pix):\n r = int(((pix >> 11) * 255 + 15) / 31)\n g = int((((pix >> 5) & 0x3F) * 255 + 31) / 63)\n b = int(((pix & 0x1F) * 255 + 15) / 31)\n return r, g, b\n\n idx = 0\n out = []\n\n # Header\n out.append(b\"GIF89a\")\n\n width = int.from_bytes(data[idx : idx + 2], \"little\")\n idx += 2\n\n height = int.from_bytes(data[idx : idx + 2], \"little\")\n idx += 2\n\n palette_size = data[idx]\n idx += 1\n idx += 1 # padding\n\n palette = []\n for _ in range(palette_size):\n palette.append(int.from_bytes(data[idx : idx + 2], \"little\"))\n idx += 2\n\n gct_size = 0\n calc_gct_size = 2\n while calc_gct_size < palette_size:\n gct_size += 1\n calc_gct_size <<= 1\n\n # Logical screen descriptor\n out.append(width.to_bytes(2, \"little\"))\n out.append(height.to_bytes(2, \"little\"))\n out.append(((1 << 7) | gct_size).to_bytes(1, \"little\"))\n out.append(b\"\\x00\")\n out.append(b\"\\x00\")\n\n # Global Color Table\n for i in range(calc_gct_size):\n if i < len(palette):\n r, g, b = rgb565_to_rgba32(palette[i])\n out.append(r.to_bytes(1, \"little\"))\n out.append(g.to_bytes(1, \"little\"))\n out.append(b.to_bytes(1, \"little\"))\n else:\n out.append(b\"\\x00\")\n out.append(b\"\\x00\")\n out.append(b\"\\x00\")\n\n # Image descriptor\n out.append(b\"\\x2c\")\n out.append(b\"\\x00\\x00\") # x\n out.append(b\"\\x00\\x00\") # y\n out.append(width.to_bytes(2, \"little\"))\n out.append(height.to_bytes(2, \"little\"))\n out.append(b\"\\x00\")\n\n # Frame\n min_code_size = data[idx]\n idx += 1\n out.append(min_code_size.to_bytes(1, \"little\"))\n\n while True:\n block_size = data[idx]\n idx += 1\n out.append(block_size.to_bytes(1, \"little\"))\n if block_size == 0:\n break\n out.append(data[idx : idx + block_size])\n idx += block_size\n\n trailer = data[idx]\n idx += 1\n\n if trailer != 0x3B:\n raise ParsingError(\"Invalid GIF Trailer\")\n out.append(trailer.to_bytes(1, \"little\"))\n out = b\"\".join(out)\n\n im = Image.open(BytesIO(out))\n\n return im, idx\n"
] | [
[
"numpy.zeros",
"numpy.argmin",
"numpy.fliplr",
"numpy.array",
"numpy.linalg.norm",
"numpy.frombuffer"
]
] |
JeanOlivier/Labber-PSICT | [
"f6d831823ec7c8373fd562b6d1247f7e438f1ee5"
] | [
"PSICT_extras/PSICT_MultiPulse/PSICT_MultiPulse.py"
] | [
"#!/usr/bin/env python\n\nimport InstrumentDriver\nimport numpy as np\n\nimport os\nimport logging\nfrom datetime import datetime\n\nfrom PSICT_MultiPulse_tools import delistifyPulseDefs\nfrom waveforms_handling import generatePulse, calculateWaveform, gen_pulse_sequence\n\n\nclass Driver(InstrumentDriver.InstrumentWorker):\n \"\"\" This class implements the PSICT-MultiPulse pulse generator\"\"\"\n\n def performOpen(self, options = {}):\n '''Open the instrument connection'''\n ## Start logging object\n self.initLogger()\n ## Number of traces - corresponds to number of outputs\n self.nTrace = 4\n ## Waveform and time containers\n self.lWaveforms = [np.array([], dtype=float)] * self.nTrace\n self.lQuadratures = [np.array([], dtype=float)] * self.nTrace\n self.vTime = np.array([], dtype=float)\n ## Pulse definition and sequence containers\n self.lDefKeyOrder = []\n self.lPulseDefinitions = []\n self.lPulseSequences = []\n ## Log completion of opening operation\n self._logger.info('Instrument opened successfully.')\n\n def initLogger(self):\n ## Dir and file setup\n log_dir = os.path.expanduser('~/MultiPulse_logs/')\n log_file = 'MultiPulse_{:%y%m%d_%H%M%S}'.format(datetime.now())+'.log'\n ## Create log dir if it does not exist\n if not os.path.exists(log_dir):\n os.makedirs(log_dir)\n log_path = os.path.join(log_dir, log_file)\n ## logger object config and init\n logging.basicConfig(filename = log_path, filemode = 'a', \\\n level = logging.DEBUG,\\\n format = '%(asctime)s %(name)-8s: %(message)s', \\\n datefmt = '%y-%m-%d %H:%M:%S')\n self._logger = logging.getLogger('MultiPulse')\n self._logger.info('Logging initialized to {}'.format(log_path))\n\n def performSetValue(self, quant, value, sweepRate = 0.0, options = {}):\n '''\n Set the specified quantity to the given value\n\n Should return the actual value set by the instrument.\n '''\n self._logger.debug('SetValue: {} {} {}'.format(quant.name, value, type(value)))\n ## If the value is a pulse definitions or sequences file path, pull the contents of the file\n if quant.name == 'Pulse definitions file':\n ## Only fetch if input string is not empty\n if value is not '':\n self._logger.debug('Pulling pulse definitions from file: {}'.format(value))\n ## Get pulse definitions from file\n with open(value, 'r') as pdfile:\n self.lDefKeyOrder = pdfile.readline().strip().split(',')\n lRawPulseDefinitions = [[float(yy) for yy in xx.strip().split(',')] \\\n for xx in pdfile.readlines()]\n ## Parse raw pulse definitions\n self.lPulseDefinitions = delistifyPulseDefs(lRawPulseDefinitions, self.lDefKeyOrder)\n self._logger.debug('Pulse definitions: {}'.format(self.lPulseDefinitions))\n elif quant.name == 'Pulse sequences file':\n ## Only fetch if input string is not empty\n if value is not '':\n self._logger.debug('Pulling pulse sequences from file: {}'.format(value))\n ## Get pulse definitions from file\n with open(value, 'r') as psfile:\n self.lPulseSequences = [[int(yy) for yy in xx.strip().split(',')] \\\n for xx in psfile.readlines()]\n self._logger.debug('Imported pulse sequences: {}'.format(self.lPulseSequences))\n ## Return value, regardless of quant\n return value\n\n def performGetValue(self, quant, options = {}):\n '''\n Get the value of the specified quantity from the instrument\n '''\n ## Ensure that vector waveforms are updated before returning value\n if quant.name[:5] == 'Trace':\n ## Recalculate waveform if necessary\n if self.isConfigUpdated():\n self.calculateWaveform()\n vData = self.getWaveformFromMemory(quant)\n dt = 1/self.getValue('Sample rate')\n value = quant.getTraceDict(vData, dt=dt)\n elif quant.name[:10] == 'Quadrature':\n ## Recalculate waveform if necessary\n if self.isConfigUpdated():\n self.calculateWaveform()\n vData = self.getWaveformFromMemory(quant)\n dt = 1/self.getValue('Sample rate')\n value = quant.getTraceDict(vData, dt=dt)\n else:\n ## All other values can be returned as-is\n value = quant.getValue()\n ## Log GetValue operation\n self._logger.debug('GetValue: {} {} {}'.format(quant.name, value, type(value)))\n return value\n\n def getWaveformFromMemory(self, quant):\n '''Return data from calculated waveforms'''\n if quant.name[:5] == 'Trace':\n iDataIndex = int(quant.name[-1]) - 1\n self._logger.debug('Fetching waveform for output {}'.format(iDataIndex))\n vData = self.lWaveforms[iDataIndex]\n elif quant.name[:10] == 'Quadrature':\n iDataIndex = int(quant.name[-1]) - 1\n self._logger.debug('Fetching quadrature for output {}'.format(iDataIndex))\n vData = self.lQuadratures[iDataIndex]\n else:\n raise RuntimeError('Invalid specification for getting waveform: {}'.format(quant.name))\n return vData\n\n def calculateTotalSeqTime(self, pulseSeq, truncRange):\n '''\n Calculate the total time required for the specified pulse sequence with the given truncation range\n '''\n ## Get pulse definitions\n lPulseDefs = self.lPulseDefinitions\n ## Calculate total time\n totalTime = 0.0\n for pulseIndex in pulseSeq:\n oPulseDef = lPulseDefs[pulseIndex]\n totalTime += oPulseDef['w'] + oPulseDef['v'] + oPulseDef['s']\n ## Add decay time for last pulse in sequence\n totalTime += lPulseDefs[pulseSeq[-1]]['w'] * (truncRange - 1)/2\n ## Return final value\n return totalTime\n\n def updateHeadTime(self, dOldHeadTime, oPulseDef, bReversed = False):\n ## Get edge-to-edge length of pulse (including spacing)\n dPulseLength = oPulseDef['w'] + oPulseDef['v'] + oPulseDef['s']\n ## Increment head time and return new value\n if bReversed:\n dNewHeadTime = dOldHeadTime - dPulseLength\n else:\n dNewHeadTime = dOldHeadTime + dPulseLength\n return dNewHeadTime\n\n calculateWaveform = calculateWaveform\n generatePulse = generatePulse\n gen_pulse_sequence = gen_pulse_sequence\n\nif __name__ == '__main__':\n pass\n"
] | [
[
"numpy.array"
]
] |
keklarup/POET_AiPoetry | [
"ff197564ab13d0e2001093bc2b803d538dd52f59"
] | [
"app.py"
] | [
"# -*- coding: utf-8 -*-\n# app.py\n\nfrom flask import Flask, request, render_template\nimport pickle\nimport gzip\nimport numpy as np\nimport AiPoems\n\n#start up cell -- import necessary metadata for model\nwith open('tokenizer.pickle', 'rb') as handle:\n tokenizer = pickle.load(handle)\nwith gzip.GzipFile('predictors.npy.gz', \"r\") as f:\n predictors=np.load(f)\nwith gzip.GzipFile('label.npy.gz', \"r\") as f:\n label=np.load(f)\ntotal_words=len(label[0])\nmax_sequence_len=len(predictors[0])+1\nfilename='word_model_love_poems_composite_100.h5'\n\n#start up cell -- initialize model\nmodel = AiPoems.initialize_model(predictors, label, max_sequence_len, \n total_words, device='/cpu:0')\nmodel=AiPoems.load_model(model, filename)\n\ntext=AiPoems.generate_text_random(model, tokenizer, 10, max_sequence_len, seed_text=\"starttoken\", top_n=10)\n\napp = Flask(__name__)\n\[email protected](\"/example\")\ndef get_numbers():\n #return ExampleService().supply_numbers(1,2)\n return str(1+2)\n #return ExampleModel().add_numbers(5,5)\n\[email protected](\"/\")\ndef home():\n return render_template(\"home.html\")\n \[email protected](\"/about\")\ndef about():\n return render_template(\"about.html\")\n\[email protected](\"/make\")\ndef make(): \n return render_template(\"make.html\")\n\[email protected](\"/generatedPoem\")\ndef generatedPoem():\n #choices=['this is string 1', 'this is string 2', 'a cat is a cat is a cat', 'the rain is spain']\n #import random\n AiPoem=AiPoems.generate_text_random(model, tokenizer, 50, max_sequence_len, seed_text=\"starttoken\", top_n=10)\n AiPoem=AiPoem.replace('starttoken','').replace('returntoken','\\n').split('endtoken2')[0]\n AiPoem=AiPoem.strip()\n #text=str(max_sequence_len)\n \n #text=random.choice(choices)\n return render_template(\"generatedPoem.html\", text=AiPoem)\n\n\nif __name__ == \"__main__\":\n app.run(debug=False)"
] | [
[
"numpy.load"
]
] |
AntonYermilov/progue | [
"7f382208c9efc904cff9d8df4750606039801d45"
] | [
"game/model/entity/character/hero.py"
] | [
"from dataclasses import dataclass\nfrom typing import Dict\n\nimport numpy as np\n\nfrom game import Position\nfrom game.model.entity.damage import Damageable, Damage, DamageType\nfrom game.model.entity.inventory.inventory_keeper import InventoryKeeper\nfrom game.model.entity.item.item import Item\nfrom .character import Character, CharacterStats\n\n\n@dataclass\nclass HeroStats(CharacterStats):\n max_experience: int\n experience: int\n confuse_ratio: float\n\n def __init__(self, max_experience: int, experience: int, confuse_ratio: float, confuse_turns: int, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.max_experience = max_experience\n self.experience = experience\n self.confuse_ratio = confuse_ratio\n self.confuse_turns = confuse_turns\n\n@dataclass\nclass LevelUpStats:\n health_inc_value: int\n strength_inc_value: int\n experience_inc_ratio: float\n\nclass Hero(Character, InventoryKeeper):\n \"\"\"\n Hero is the character controlled by the player.\n \"\"\"\n\n def __init__(self, name: str, id: str, position: Position, description: Dict):\n stats = HeroStats(level=1,\n max_health=description['initial_stats']['max_health'],\n health=description['initial_stats']['health'],\n attack_damage=description['initial_stats']['max_strength'],\n max_experience=description['initial_stats']['max_experience'],\n experience=description['initial_stats']['experience'],\n confuse_ratio=description['initial_stats']['confuse_ratio'],\n confuse_turns=description['initial_stats']['confuse_turns'],\n reward=description['reward'])\n Character.__init__(self, position=position, stats=stats)\n InventoryKeeper.__init__(self, limit=description['initial_stats']['inventory_size'])\n self.level_up_stats = LevelUpStats(health_inc_value=description['on_new_level']['max_health_increase_value'],\n strength_inc_value=description['on_new_level']['max_strength_increase_value'],\n experience_inc_ratio=description['on_new_level']['max_experience_increase_ratio'])\n self.name = name\n self.id = id\n\n def deal_damage(self, target: Damageable) -> Damage:\n confuse_turns = 0\n confuse = np.random.choice([True, False], p=[self.stats.confuse_ratio, 1 - self.stats.confuse_ratio])\n if confuse:\n confuse_turns = self.stats.confuse_turns\n return Damage(damage_type=DamageType.PHYSICAL,\n damage_amount=self.stats.attack_damage,\n confuse_turns=confuse_turns)\n\n def accept_damage(self, damage: Damage):\n self.update_health(-damage.damage_amount)\n\n def use_item(self, item: Item):\n item.apply(self)\n self.inventory.remove(item)\n\n def on_destroy(self, model):\n model.players.pop(self.id)\n\n def is_alive(self) -> bool:\n return self.stats.health > 0\n\n def update_health(self, health):\n self.stats.health += health\n if self.stats.health > self.stats.max_health:\n self.stats.health = self.stats.max_health\n if self.stats.health < 0:\n self.stats.health = 0\n\n def update_experience(self, experience):\n self.stats.experience += experience\n if self.stats.experience > self.stats.max_experience:\n self.stats.level += 1\n self.stats.experience -= self.stats.max_experience\n self.stats.health += self.level_up_stats.health_inc_value\n self.stats.max_health += self.level_up_stats.health_inc_value\n self.stats.attack_damage += self.level_up_stats.strength_inc_value\n self.stats.max_experience = int(self.stats.max_experience * self.level_up_stats.experience_inc_ratio)\n if self.stats.experience < 0:\n self.stats.experience = 0\n"
] | [
[
"numpy.random.choice"
]
] |
qureshinomaan/habitat-sim | [
"df2540b658d0444e84bbc7a0c3fb995f8d523b52"
] | [
"tests/test_controls.py"
] | [
"#!/usr/bin/env python3\n\n# Copyright (c) Facebook, Inc. and its affiliates.\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\nimport attr\nimport hypothesis\nimport magnum as mn\nimport numpy as np\nimport pytest\nimport quaternion # noqa: F401\nfrom hypothesis import strategies as st\n\nimport habitat_sim\nimport habitat_sim.errors\nfrom habitat_sim.utils.common import angle_between_quats, quat_from_angle_axis\n\n\ndef test_no_action():\n scene_graph = habitat_sim.SceneGraph()\n agent_config = habitat_sim.AgentConfiguration()\n agent_config.action_space = dict(\n move_backward=habitat_sim.ActionSpec(\n \"move_backward\", habitat_sim.ActuationSpec(amount=0.25)\n )\n )\n agent = habitat_sim.Agent(scene_graph.get_root_node().create_child(), agent_config)\n\n with pytest.raises(AssertionError):\n agent.act(\"move_forward\")\n\n\ndef test_no_move_fun():\n scene_graph = habitat_sim.SceneGraph()\n agent_config = habitat_sim.AgentConfiguration()\n agent_config.action_space = dict(\n move_forward=habitat_sim.ActionSpec(\n \"DNF\", habitat_sim.ActuationSpec(amount=0.25)\n )\n )\n agent = habitat_sim.Agent(scene_graph.get_root_node().create_child(), agent_config)\n\n with pytest.raises(AssertionError):\n agent.act(\"move_forward\")\n\n\[email protected](auto_attribs=True, cmp=False)\nclass ExpectedDelta:\n delta_pos: np.ndarray = attr.Factory(lambda: np.array([0, 0, 0]))\n delta_rot: np.quaternion = attr.Factory(lambda: np.quaternion(1, 0, 0, 0))\n\n\ndef _check_state_same(s1, s2):\n assert np.allclose(s1.position, s2.position)\n assert angle_between_quats(s1.rotation, s2.rotation) < 1e-5\n\n\ndef _check_state_expected(s1, s2, expected: ExpectedDelta):\n assert np.linalg.norm(s2.position - s1.position - expected.delta_pos) < 1e-5\n assert (\n angle_between_quats(s2.rotation * expected.delta_rot.inverse(), s1.rotation)\n < 1e-5\n )\n\n\ndefault_body_control_testdata = [\n (\"move_backward\", ExpectedDelta(delta_pos=0.25 * habitat_sim.geo.BACK)),\n (\"move_forward\", ExpectedDelta(delta_pos=0.25 * habitat_sim.geo.FRONT)),\n (\"move_right\", ExpectedDelta(delta_pos=0.25 * habitat_sim.geo.RIGHT)),\n (\"move_left\", ExpectedDelta(delta_pos=0.25 * habitat_sim.geo.LEFT)),\n (\n \"turn_right\",\n ExpectedDelta(\n delta_rot=quat_from_angle_axis(np.deg2rad(10.0), habitat_sim.geo.GRAVITY)\n ),\n ),\n (\n \"turn_left\",\n ExpectedDelta(\n delta_rot=quat_from_angle_axis(np.deg2rad(10.0), habitat_sim.geo.UP)\n ),\n ),\n]\n\n\[email protected](\"action,expected\", default_body_control_testdata)\ndef test_default_body_contorls(action, expected):\n scene_graph = habitat_sim.SceneGraph()\n agent_config = habitat_sim.AgentConfiguration()\n agent_config.action_space = dict(\n move_backward=habitat_sim.ActionSpec(\n \"move_backward\", habitat_sim.ActuationSpec(amount=0.25)\n ),\n move_forward=habitat_sim.ActionSpec(\n \"move_forward\", habitat_sim.ActuationSpec(amount=0.25)\n ),\n move_left=habitat_sim.ActionSpec(\n \"move_left\", habitat_sim.ActuationSpec(amount=0.25)\n ),\n move_right=habitat_sim.ActionSpec(\n \"move_right\", habitat_sim.ActuationSpec(amount=0.25)\n ),\n turn_left=habitat_sim.ActionSpec(\n \"turn_left\", habitat_sim.ActuationSpec(amount=10.0)\n ),\n turn_right=habitat_sim.ActionSpec(\n \"turn_right\", habitat_sim.ActuationSpec(amount=10.0)\n ),\n )\n agent = habitat_sim.Agent(scene_graph.get_root_node().create_child(), agent_config)\n\n state = agent.state\n agent.act(action)\n new_state = agent.state\n\n _check_state_expected(state, new_state, expected)\n for k, v in state.sensor_states.items():\n assert k in new_state.sensor_states\n _check_state_expected(v, new_state.sensor_states[k], expected)\n\n\ndefault_sensor_control_testdata = [\n (\"move_up\", ExpectedDelta(delta_pos=0.25 * habitat_sim.geo.UP)),\n (\"move_down\", ExpectedDelta(delta_pos=0.25 * habitat_sim.geo.GRAVITY)),\n (\n \"look_right\",\n ExpectedDelta(\n delta_rot=quat_from_angle_axis(np.deg2rad(-10.0), habitat_sim.geo.UP)\n ),\n ),\n (\n \"look_left\",\n ExpectedDelta(\n delta_rot=quat_from_angle_axis(np.deg2rad(10.0), habitat_sim.geo.UP)\n ),\n ),\n (\n \"look_up\",\n ExpectedDelta(\n delta_rot=quat_from_angle_axis(np.deg2rad(10.0), habitat_sim.geo.RIGHT)\n ),\n ),\n (\n \"look_down\",\n ExpectedDelta(\n delta_rot=quat_from_angle_axis(np.deg2rad(-10.0), habitat_sim.geo.RIGHT)\n ),\n ),\n (\n \"rotate_sensor_clockwise\",\n ExpectedDelta(\n delta_rot=quat_from_angle_axis(np.deg2rad(-10.0), habitat_sim.geo.FRONT)\n ),\n ),\n (\n \"rotate_sensor_anti_clockwise\",\n ExpectedDelta(\n delta_rot=quat_from_angle_axis(np.deg2rad(10.0), habitat_sim.geo.FRONT)\n ),\n ),\n]\n\n\[email protected](\"action,expected\", default_sensor_control_testdata)\ndef test_default_sensor_contorls(action, expected):\n scene_graph = habitat_sim.SceneGraph()\n agent_config = habitat_sim.AgentConfiguration()\n agent_config.action_space = dict(\n move_up=habitat_sim.ActionSpec(\n \"move_up\", habitat_sim.ActuationSpec(amount=0.25)\n ),\n move_down=habitat_sim.ActionSpec(\n \"move_down\", habitat_sim.ActuationSpec(amount=0.25)\n ),\n look_left=habitat_sim.ActionSpec(\n \"look_left\", habitat_sim.ActuationSpec(amount=10.0)\n ),\n look_right=habitat_sim.ActionSpec(\n \"look_right\", habitat_sim.ActuationSpec(amount=10.0)\n ),\n look_up=habitat_sim.ActionSpec(\n \"look_up\", habitat_sim.ActuationSpec(amount=10.0)\n ),\n look_down=habitat_sim.ActionSpec(\n \"look_down\", habitat_sim.ActuationSpec(amount=10.0)\n ),\n rotate_sensor_clockwise=habitat_sim.ActionSpec(\n \"rotate_sensor_clockwise\", habitat_sim.ActuationSpec(amount=10.0)\n ),\n rotate_sensor_anti_clockwise=habitat_sim.ActionSpec(\n \"rotate_sensor_anti_clockwise\", habitat_sim.ActuationSpec(amount=10.0)\n ),\n )\n agent = habitat_sim.Agent(scene_graph.get_root_node().create_child(), agent_config)\n\n state = agent.state\n agent.act(action)\n new_state = agent.state\n\n _check_state_same(state, new_state)\n for k, v in state.sensor_states.items():\n assert k in new_state.sensor_states\n _check_state_expected(v, new_state.sensor_states[k], expected)\n\n\[email protected]()\ndef scene_graph():\n return habitat_sim.SceneGraph()\n\n\[email protected](\n \"control_name,control_axis\",\n [(\"look_up\", 0), (\"look_down\", 0), (\"look_left\", 1), (\"look_right\", 1)],\n)\[email protected](\n actuation_amount=st.floats(0, 60), actuation_constraint=st.floats(0, 60)\n)\ndef test_constrainted(\n scene_graph, control_name, control_axis, actuation_amount, actuation_constraint\n):\n initial_look_angle = mn.Deg(\n np.random.uniform(-actuation_constraint, actuation_constraint)\n )\n rotation_vector = mn.Vector3()\n rotation_vector[control_axis] = 1\n initial_rotation = mn.Quaternion.rotation(\n mn.Rad(initial_look_angle), rotation_vector\n )\n\n node = scene_graph.get_root_node().create_child()\n node.rotation = initial_rotation\n\n spec = habitat_sim.agent.controls.ActuationSpec(\n actuation_amount, actuation_constraint\n )\n habitat_sim.registry.get_move_fn(control_name)(node, spec)\n\n expected_angle = initial_look_angle + mn.Deg(\n -actuation_amount\n if control_name in {\"look_down\", \"look_right\"}\n else actuation_amount\n )\n\n if expected_angle > mn.Deg(actuation_constraint):\n expected_angle = mn.Deg(actuation_constraint)\n elif expected_angle < mn.Deg(-actuation_constraint):\n expected_angle = mn.Deg(-actuation_constraint)\n\n final_rotation = node.rotation\n\n look_vector = final_rotation.transform_vector(habitat_sim.geo.FRONT)\n if control_axis == 0:\n look_angle = mn.Deg(mn.Rad(np.arctan2(look_vector[1], -look_vector[2])))\n elif control_axis == 1:\n look_angle = -mn.Deg(mn.Rad(np.arctan2(look_vector[0], -look_vector[2])))\n\n assert np.abs(float(expected_angle - look_angle)) < 1e-1\n"
] | [
[
"numpy.random.uniform",
"numpy.allclose",
"numpy.arctan2",
"numpy.quaternion",
"numpy.array",
"numpy.linalg.norm",
"numpy.deg2rad"
]
] |
readthedocs-assistant/tabmat | [
"c2d82db1901afb0ea79806f26ee66068d553b3e6"
] | [
"src/tabmat/dense_matrix.py"
] | [
"from typing import List, Optional, Union\n\nimport numpy as np\n\nfrom .ext.dense import (\n dense_matvec,\n dense_rmatvec,\n dense_sandwich,\n transpose_square_dot_weights,\n)\nfrom .matrix_base import MatrixBase\nfrom .util import (\n check_matvec_out_shape,\n check_transpose_matvec_out_shape,\n setup_restrictions,\n)\n\n\nclass DenseMatrix(np.ndarray, MatrixBase):\n \"\"\"\n A ``numpy.ndarray`` subclass with several additional functions that allow\n it to share the MatrixBase API with SparseMatrix and CategoricalMatrix.\n\n In particular, we have added:\n\n - The ``sandwich`` product\n - ``getcol`` to support the same interface as SparseMatrix for retrieving a\n single column\n - ``toarray``\n - ``matvec``\n\n \"\"\"\n\n def __new__(cls, input_array): # noqa\n \"\"\"\n Details of how to subclass np.ndarray are explained here:\n\n https://docs.scipy.org/doc/numpy/user/basics.subclassing.html\\\n #slightly-more-realistic-example-attribute-added-to-existing-array\n \"\"\"\n obj = np.asarray(input_array).view(cls)\n if not np.issubdtype(obj.dtype, np.floating):\n raise NotImplementedError(\"DenseMatrix is only implemented for float data\")\n return obj\n\n def __array_finalize__(self, obj):\n if obj is None:\n return\n\n def getcol(self, i):\n \"\"\"Return matrix column at specified index.\"\"\"\n return self[:, [i]]\n\n def toarray(self):\n \"\"\"Return array representation of matrix.\"\"\"\n return np.asarray(self)\n\n def sandwich(\n self, d: np.ndarray, rows: np.ndarray = None, cols: np.ndarray = None\n ) -> np.ndarray:\n \"\"\"Perform a sandwich product: X.T @ diag(d) @ X.\"\"\"\n d = np.asarray(d)\n rows, cols = setup_restrictions(self.shape, rows, cols)\n return dense_sandwich(self, d, rows, cols)\n\n def _cross_sandwich(\n self,\n other: MatrixBase,\n d: np.ndarray,\n rows: Optional[np.ndarray] = None,\n L_cols: Optional[np.ndarray] = None,\n R_cols: Optional[np.ndarray] = None,\n ):\n from .categorical_matrix import CategoricalMatrix\n from .sparse_matrix import SparseMatrix\n\n if isinstance(other, SparseMatrix) or isinstance(other, CategoricalMatrix):\n return other._cross_sandwich(self, d, rows, R_cols, L_cols).T\n raise TypeError\n\n def _get_col_stds(self, weights: np.ndarray, col_means: np.ndarray) -> np.ndarray:\n \"\"\"Get standard deviations of columns.\"\"\"\n sqrt_arg = transpose_square_dot_weights(self, weights) - col_means ** 2\n # Minor floating point errors above can result in a very slightly\n # negative sqrt_arg (e.g. -5e-16). We just set those values equal to\n # zero.\n sqrt_arg[sqrt_arg < 0] = 0\n return np.sqrt(sqrt_arg)\n\n def _matvec_helper(\n self,\n vec: Union[List, np.ndarray],\n rows: Optional[np.ndarray],\n cols: Optional[np.ndarray],\n out: Optional[np.ndarray],\n transpose: bool,\n ):\n # Because the dense_rmatvec takes a row array and col array, it has\n # added overhead compared to a raw matrix vector product. So, when\n # we're not filtering at all, let's just use default numpy dot product.\n #\n # TODO: related to above, it could be nice to have a version that only\n # filters rows and a version that only filters columns. How do we do\n # this without an explosion of code?\n X = self.T if transpose else self\n vec = np.asarray(vec)\n\n # NOTE: We assume that rows and cols are unique\n unrestricted_rows = rows is None or len(rows) == self.shape[0]\n unrestricted_cols = cols is None or len(cols) == self.shape[1]\n\n if unrestricted_rows and unrestricted_cols:\n if out is None:\n out = X.dot(vec)\n else:\n out += X.dot(vec)\n return out\n else:\n rows, cols = setup_restrictions(self.shape, rows, cols)\n # TODO: should take 'out' parameter\n fast_fnc = dense_rmatvec if transpose else dense_matvec\n if vec.ndim == 1:\n res = fast_fnc(self, vec, rows, cols)\n elif vec.ndim == 2 and vec.shape[1] == 1:\n res = fast_fnc(self, vec[:, 0], rows, cols)[:, None]\n else:\n subset = self[np.ix_(rows, cols)]\n res = subset.T.dot(vec[rows]) if transpose else subset.dot(vec[cols])\n if out is None:\n return res\n if transpose:\n out[cols] += res\n else:\n # Note that currently 'rows' will always be all rows\n out[rows] += res\n return out\n\n def transpose_matvec(\n self,\n vec: Union[np.ndarray, List],\n rows: np.ndarray = None,\n cols: np.ndarray = None,\n out: np.ndarray = None,\n ) -> np.ndarray:\n \"\"\"Perform: self[rows, cols].T @ vec.\"\"\"\n check_transpose_matvec_out_shape(self, out)\n return self._matvec_helper(vec, rows, cols, out, True)\n\n def matvec(\n self,\n vec: Union[np.ndarray, List],\n cols: np.ndarray = None,\n out: np.ndarray = None,\n ) -> np.ndarray:\n \"\"\"Perform self[:, cols] @ other.\"\"\"\n check_matvec_out_shape(self, out)\n return self._matvec_helper(vec, None, cols, out, False)\n"
] | [
[
"numpy.sqrt",
"numpy.ix_",
"numpy.issubdtype",
"numpy.asarray"
]
] |
vishalbelsare/RLScore | [
"713f0a402f7a09e41a609f2ddcaf849b2021a0a7"
] | [
"rlscore/test/test_learner/test_query_rankrls.py"
] | [
"import numpy as np\nimport numpy.linalg as la\nfrom numpy.testing import assert_allclose\nimport unittest\n\nfrom rlscore.learner import QueryRankRLS\nfrom rlscore.kernel import GaussianKernel, PolynomialKernel\n\n\ndef mapQids(qids):\n \"\"\"Maps qids to running numbering starting from zero, and partitions\n the training data indices so that each partition corresponds to one\n query\"\"\"\n qid_dict = {}\n folds = {}\n counter = 0\n for index, qid in enumerate(qids):\n if not qid in qid_dict:\n qid_dict[qid] = counter\n folds[qid] = []\n counter += 1\n folds[qid].append(index)\n indslist = []\n for f in folds.values():\n indslist.append(f)\n return indslist\n\ndef generate_qids(m):\n qids = []\n qsize = int(m / 10)\n for i in range(int(m / qsize)):\n qids = qids + [i] * qsize\n qids = qids + [i + 1] * (m % qsize)\n objcount = np.max(qids)+1\n P = np.zeros((m, objcount))\n for i in range(m):\n qid = qids[i]\n P[i, qid] = 1.\n labelcounts = np.sum(P, axis=0)\n P = np.divide(P, np.sqrt(labelcounts))\n D = np.ones((1, m))\n L = np.multiply(np.eye(m), D) - np.dot(P, P.T)\n return qids, L\n\nclass Test(unittest.TestCase):\n \n def setUp(self):\n np.random.seed(100)\n m= 30\n self.Xtrain1 = np.random.rand(m, 20)\n self.Xtrain2 = np.random.rand(m, 40)\n self.Ytrain1 = np.random.randn(m)\n self.Ytrain2 = np.random.randn(m, 5)\n self.bvectors = [0,3,5,22]\n \n #@unittest.skip(\"does not work\") \n def test_linear_subset(self):\n X = self.Xtrain1\n Y = self.Ytrain1\n m = X.shape[0]\n qids, L = generate_qids(m)\n #reduced set approximation\n primal_rls = QueryRankRLS(X, Y, qids, basis_vectors = X[self.bvectors], regparam=0.001)\n W = primal_rls.predictor.W\n K = np.dot(X, X.T)\n Kr = K[:, self.bvectors]\n Krr = K[np.ix_(self.bvectors, self.bvectors)]\n A = np.linalg.solve(np.dot(Kr.T, np.dot(L, Kr))+ 0.001 * Krr, np.dot(Kr.T, np.dot(L, Y)))\n #W_reduced = np.dot(X[self.bvectors].T, A)\n W_reduced = np.dot(X[self.bvectors].T, A)\n assert_allclose(W, W_reduced)\n \n def test_linear(self):\n #Test that learning with linear kernel works correctly both\n #with low and high-dimensional data\n for X in [self.Xtrain1, self.Xtrain2]:\n for Y in [self.Ytrain1, self.Ytrain2]:\n #Basic case\n m = X.shape[0]\n qids, L = generate_qids(m)\n primal_rls = QueryRankRLS(X, Y, qids, regparam=1.0, bias=0.)\n W = primal_rls.predictor.W\n d = X.shape[1]\n W2 = np.linalg.solve(np.dot(X.T, np.dot(L, X)) + np.eye(d), np.dot(X.T, np.dot(L, Y)))\n assert_allclose(W, W2)\n #For RankRLS, bias should have no effect\n primal_rls = QueryRankRLS(X, Y, qids, regparam=1.0, bias=5.)\n W2 = primal_rls.predictor.W\n assert_allclose(W, W2)\n #Fast regularization\n primal_rls.solve(10)\n W = primal_rls.predictor.W\n W2 = np.linalg.solve(np.dot(X.T, np.dot(L, X)) + 10 * np.eye(d), np.dot(X.T, np.dot(L, Y)))\n assert_allclose(W, W2)\n #reduced set approximation\n primal_rls = QueryRankRLS(X, Y, qids, basis_vectors = X[self.bvectors], regparam=5.0)\n W = primal_rls.predictor.W\n K = np.dot(X, X.T)\n Kr = K[:, self.bvectors]\n Krr = K[np.ix_(self.bvectors, self.bvectors)]\n A = np.linalg.solve(np.dot(Kr.T, np.dot(L, Kr))+ 5.0 * Krr, np.dot(Kr.T, np.dot(L, Y)))\n W_reduced = np.dot(X[self.bvectors].T, A)\n #assert_allclose(W, W_reduced)\n #Pre-computed linear kernel, reduced set approximation\n dual_rls = QueryRankRLS(Kr, Y, qids, kernel=\"PrecomputedKernel\", basis_vectors = Krr, regparam=5.0)\n W = np.dot(X[self.bvectors].T, dual_rls.predictor.W)\n assert_allclose(W, W_reduced)\n# #Precomputed kernel matrix\n# dual_rls = GlobalRankRLS(K, Y, kernel = \"PrecomputedKernel\", regparam=0.01)\n# W = np.dot(X.T, dual_rls.predictor.W)\n# W2 = np.linalg.solve(np.dot(X.T, np.dot(L, X)) + 0.01 * np.eye(d), np.dot(X.T, np.dot(L, Y)))\n# assert_allclose(W, W2)\n\n def test_kernel(self):\n #tests that learning with kernels works\n for X in [self.Xtrain1, self.Xtrain2]:\n for Y in [self.Ytrain1, self.Ytrain2]:\n m = X.shape[0]\n qids, L = generate_qids(m)\n #Basic case\n dual_rls = QueryRankRLS(X, Y, qids, kernel= \"GaussianKernel\", regparam=5.0, gamma=0.01)\n kernel = GaussianKernel(X, gamma = 0.01)\n K = kernel.getKM(X)\n m = K.shape[0]\n A = dual_rls.predictor.A\n A2 = np.linalg.solve(np.dot(L, K) +5.0*np.eye(m), np.dot(L, Y) )\n assert_allclose(A, A2)\n #Fast regularization\n dual_rls.solve(1000)\n A = dual_rls.predictor.A\n A2 = np.linalg.solve(np.dot(L, K) + 1000 * np.eye(m), np.dot(L, Y))\n assert_allclose(A, A2)\n #Precomputed kernel\n dual_rls = QueryRankRLS(K, Y, qids, kernel=\"PrecomputedKernel\", regparam = 1000)\n assert_allclose(dual_rls.predictor.W, A2)\n #Reduced set approximation\n kernel = PolynomialKernel(X[self.bvectors], gamma=0.5, coef0 = 1.2, degree = 2) \n Kr = kernel.getKM(X)\n Krr = kernel.getKM(X[self.bvectors])\n dual_rls = QueryRankRLS(X, Y, qids, kernel=\"PolynomialKernel\", basis_vectors = X[self.bvectors], regparam = 200, gamma=0.5, coef0=1.2, degree = 2)\n A = dual_rls.predictor.A\n A2 = np.linalg.solve(np.dot(Kr.T, np.dot(L, Kr))+ 200 * Krr, np.dot(Kr.T, np.dot(L, Y)))\n assert_allclose(A, A2)\n dual_rls = QueryRankRLS(Kr, Y, qids, kernel=\"PrecomputedKernel\", basis_vectors = Krr, regparam=200)\n A = dual_rls.predictor.W\n assert_allclose(A, A2)\n \n def test_holdout(self):\n for X in [self.Xtrain1, self.Xtrain2]:\n for Y in [self.Ytrain1, self.Ytrain2]:\n m = X.shape[0]\n qids, L = generate_qids(m)\n qids = np.array(qids)\n hoindices = np.where(qids == 1)[0]\n hocompl = list(set(range(m)) - set(hoindices))\n #Holdout with linear kernel\n rls1 = QueryRankRLS(X, Y, qids)\n rls2 = QueryRankRLS(X[hocompl], Y[hocompl], qids[hocompl])\n P1 = rls1.holdout(hoindices)\n P2 = rls2.predict(X[hoindices])\n assert_allclose(P1, P2)\n #Holdout with bias\n rls1 = QueryRankRLS(X, Y, qids, bias = 3.0)\n rls2 = QueryRankRLS(X[hocompl], Y[hocompl], qids[hocompl], bias = 3.0)\n P1 = rls1.holdout(hoindices)\n P2 = rls2.predict(X[hoindices])\n assert_allclose(P1, P2)\n #Fast regularization\n for i in range(-5, 5):\n rls1.solve(2**i)\n rls2.solve(2**i)\n P1 = rls1.holdout(hoindices)\n P2 = rls2.predict(X[hoindices])\n assert_allclose(P1, P2)\n #Kernel holdout\n rls1 = QueryRankRLS(X, Y, qids, kernel = \"GaussianKernel\", gamma = 0.01)\n rls2 = QueryRankRLS(X[hocompl], Y[hocompl], qids[hocompl], kernel = \"GaussianKernel\", gamma = 0.01)\n P1 = rls1.holdout(hoindices)\n P2 = rls2.predict(X[hoindices])\n assert_allclose(P1, P2)\n for i in range(-15, 15):\n rls1.solve(2**i)\n rls2.solve(2**i)\n P1 = rls1.holdout(hoindices)\n P2 = rls2.predict(X[hoindices])\n assert_allclose(P1, P2)\n #Incorrect indices\n I = [0, 3, 100]\n self.assertRaises(IndexError, rls1.holdout, I)\n I = [-1, 0, 2]\n self.assertRaises(IndexError, rls1.holdout, I)\n I = [1,1,2]\n self.assertRaises(IndexError, rls1.holdout, I)\n I = [0,4,8]\n self.assertRaises(IndexError, rls1.holdout, I)\n \n def testLabelRankRLS(self):\n \n print(\"Testing the cross-validation routines of the QueryRankRLS module.\\n\")\n \n np.random.seed(100)\n floattype = np.float64\n \n m, n = 100, 400 #data, features\n Xtrain = np.mat(np.random.rand(m, n))\n K = Xtrain * Xtrain.T\n ylen = 1\n Y = np.mat(np.zeros((m, ylen), dtype=floattype))\n Y[:, 0] = np.sum(Xtrain, 1)\n \n \n labelcount = 5\n \n hoindices = range(labelcount)\n hocompl = list(set(range(m)) - set(hoindices))\n \n qidlist = [0 for i in range(100)]\n for h in range(5, 12):\n qidlist[h] = 1\n for h in range(12, 32):\n qidlist[h] = 2\n for h in range(32, 34):\n qidlist[h] = 3\n for h in range(34, 85):\n qidlist[h] = 4\n for h in range(85, 100):\n qidlist[h] = 5\n qidlist_cv = qidlist[5: len(qidlist)]\n \n objcount = max(qidlist) + 1\n P = np.mat(np.zeros((m, objcount), dtype=np.float64))\n for i in range(m):\n qid = qidlist[i]\n P[i, qid] = 1.\n labelcounts = np.sum(P, axis=0)\n P = np.divide(P, np.sqrt(labelcounts))\n D = np.mat(np.ones((1, m), dtype=np.float64))\n L = np.multiply(np.eye(m), D) - P * P.T\n \n Kcv = K[np.ix_(hocompl, hocompl)]\n Lcv = L[np.ix_(hocompl, hocompl)]\n \n Xcv = Xtrain[hocompl]\n Xtest = Xtrain[hoindices]\n Yho = Y[hocompl]\n \n rpool = {}\n rpool[\"X\"] = Xtrain\n rpool[\"Y\"] = Y\n rpool[\"qids\"] = qidlist\n primalrls = QueryRankRLS(**rpool) \n \n rpool = {}\n rpool[\"X\"] = K\n rpool['kernel'] = 'PrecomputedKernel'\n rpool[\"Y\"] = Y\n rpool[\"qids\"] = qidlist \n dualrls = QueryRankRLS(**rpool)\n \n rpool = {}\n rpool['X'] = Xcv\n rpool['Y'] = Yho\n rpool['qids'] = qidlist_cv\n primalrls_naive = QueryRankRLS(**rpool)\n\n rpool = {}\n rpool['X'] = Kcv\n rpool['kernel'] = 'PrecomputedKernel' \n rpool['Y'] = Yho\n #rpool['X'] = Xcv\n rpool['qids'] = qidlist_cv\n dualrls_naive = QueryRankRLS(**rpool)\n \n testkm = K[np.ix_(hocompl, hoindices)]\n \n loglambdas = range(-5, 5)\n for j in range(0, len(loglambdas)):\n regparam = 2. ** loglambdas[j]\n print\n print(\"Regparam 2^%1d\" % loglambdas[j])\n \n \n print(str(np.squeeze(np.array((testkm.T * la.inv(Lcv * Kcv + regparam * np.eye(Lcv.shape[0])) * Lcv * Yho).T))) + ' Dumb HO')\n \n predhos = []\n primalrls_naive.solve(regparam)\n predho = primalrls_naive.predictor.predict(Xtest)\n print(str(predho.T) + ' Naive HO (primal)')\n predhos.append(predho)\n \n dualrls_naive.solve(regparam)\n predho = dualrls_naive.predictor.predict(testkm.T)\n print(str(predho.T) + ' Naive HO (dual)')\n predhos.append(predho)\n \n primalrls.solve(regparam)\n predho = np.squeeze(primalrls.holdout(hoindices))\n print(str(predho.T) + ' Fast HO (primal)')\n predhos.append(predho)\n \n dualrls.solve(regparam)\n predho = np.squeeze(dualrls.holdout(hoindices))\n print(str(predho.T) + ' Fast HO (dual)')\n predhos.append(predho)\n \n predho0 = predhos.pop(0)\n for predho in predhos:\n self.assertEqual(predho0.shape, predho.shape)\n for row in range(predho.shape[0]):\n #for col in range(predho.shape[1]):\n # self.assertAlmostEqual(predho0[row,col],predho[row,col], places=5)\n self.assertAlmostEqual(predho0[row],predho[row], places=5)\n"
] | [
[
"numpy.sum",
"numpy.ones",
"numpy.eye",
"numpy.ix_",
"numpy.zeros",
"numpy.random.seed",
"numpy.random.randn",
"numpy.where",
"numpy.max",
"numpy.random.rand",
"numpy.testing.assert_allclose",
"numpy.sqrt",
"numpy.dot",
"numpy.array"
]
] |
marwahaha/QTensor | [
"936d078825a6418f9d32d2c176332422d8a4c137"
] | [
"qtensor/tests/test_simulators.py"
] | [
"import qtensor\nfrom qtensor import CirqQAOAComposer, QtreeQAOAComposer\nfrom qtensor import QAOAQtreeSimulator\nfrom qtensor.Simulate import CirqSimulator, QtreeSimulator\nfrom qtensor.FeynmanSimulator import FeynmanSimulator\nimport numpy as np\nimport networkx as nx\n\nnp.random.seed(42)\n\n\ndef get_test_problem(n=14, p=2, d=3):\n w = np.array([[0,1,1,0],[1,0,1,1],[1,1,0,1],[0,1,1,0]])\n G = nx.from_numpy_matrix(w)\n\n G = nx.random_regular_graph(d, n)\n gamma, beta = [np.pi/3]*p, [np.pi/2]*p\n return G, gamma, beta\n\ndef test_qtree():\n G, gamma, beta = get_test_problem()\n\n composer = QtreeQAOAComposer(\n graph=G, gamma=gamma, beta=beta)\n composer.ansatz_state()\n\n print(composer.circuit)\n sim = QtreeSimulator()\n result = sim.simulate(composer.circuit)\n print(result)\n qtree_amp = result\n\n composer = CirqQAOAComposer(\n graph=G, gamma=gamma, beta=beta)\n composer.ansatz_state()\n\n print(composer.circuit)\n sim = CirqSimulator()\n result = sim.simulate(composer.circuit)\n print(result)\n final_cirq = result.final_state\n assert final_cirq[0] - qtree_amp < 1e-5\n\n assert result\n\n\ndef test_parallel_batched():\n G, gamma, beta = get_test_problem(14, 3, d=4)\n batch_vars = 3\n\n composer = QtreeQAOAComposer(\n graph=G, gamma=gamma, beta=beta)\n composer.ansatz_state()\n\n sim = QtreeSimulator()\n amp = sim.simulate(composer.circuit)\n amps = sim.simulate_batch(composer.circuit, batch_vars=2)\n print('ordinary qtree amp', amp)\n print('ordinary qtree 2 amps', amps)\n assert abs( amp - amps[0]) < 1e-6\n\n sim = FeynmanSimulator()\n result = sim.simulate(composer.circuit, batch_vars=batch_vars, tw_bias=7)\n print(result)\n\n batch_amps = 2**batch_vars\n assert len(result) == batch_amps\n assert abs( amp - result[0]) < 1e-6\n\n\ndef test_qtree_energy():\n G, gamma, beta = get_test_problem(16, 2, d=3)\n\n sim = QAOAQtreeSimulator(QtreeQAOAComposer)\n E = sim.energy_expectation(\n G=G, gamma=gamma, beta=beta)\n\n print('Energy', E)\n assert np.imag(E)<1e-6\n\n E = np.real(E)\n\n Ed = G.number_of_edges()\n C = (Ed - E)/2\n\n print(\"Edges\", Ed)\n print(\"Cost\", C)\n assert E\n\nif __name__ == \"__main__\":\n #test_qtree_energy()\n test_parallel_batched()\n"
] | [
[
"numpy.array",
"numpy.random.seed",
"numpy.real",
"numpy.imag"
]
] |
Prakadeeswaran05/Simple-Tf-ObjectDetection-SemanticSegmentation-ROS | [
"f119f0f8394c324c8453d540f4dfa495e34ee001"
] | [
"notcv_bridge.py"
] | [
"#! /usr/bin/env python\nimport sys\nimport numpy as np\nfrom sensor_msgs.msg import Image\n\ndef imgmsg_to_cv2(img_msg):\n if img_msg.encoding != \"bgr8\":\n rospy.logerr(\"This Coral detect node has been hardcoded to the 'bgr8' encoding. Come change the code if you're actually trying to implement a new camera\")\n dtype = np.dtype(\"uint8\") # Hardcode to 8 bits...\n dtype = dtype.newbyteorder('>' if img_msg.is_bigendian else '<')\n image_opencv = np.ndarray(shape=(img_msg.height, img_msg.width, 3), # and three channels of data. Since OpenCV works with bgr natively, we don't need to reorder the channels.\n dtype=dtype, buffer=img_msg.data)\n # If the byt order is different between the message and the system.\n if img_msg.is_bigendian == (sys.byteorder == 'little'):\n image_opencv = image_opencv.byteswap().newbyteorder()\n return image_opencv\n\ndef cv2_to_imgmsg(cv_image):\n img_msg = Image()\n img_msg.height = cv_image.shape[0]\n img_msg.width = cv_image.shape[1]\n img_msg.encoding = \"bgr8\"\n img_msg.is_bigendian = 0\n img_msg.data = cv_image.tostring()\n img_msg.step = len(img_msg.data) // img_msg.height # That double line is actually integer division, not a comment\n return img_msg\n"
] | [
[
"numpy.ndarray",
"numpy.dtype"
]
] |
ipanepen/sagemaker-scikit-learn-container | [
"3214b0d36955fed0b6338b997b26bcc883f7b883"
] | [
"test/unit/test_serving.py"
] | [
"# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\"). You\n# may not use this file except in compliance with the License. A copy of\n# the License is located at\n#\n# http://aws.amazon.com/apache2.0/\n#\n# or in the \"license\" file accompanying this file. This file is\n# distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF\n# ANY KIND, either express or implied. See the License for the specific\n# language governing permissions and limitations under the License.\nfrom __future__ import absolute_import\n\nfrom mock import patch, MagicMock\nimport numpy as np\nimport pytest\nimport os\n\nfrom sklearn.base import BaseEstimator\n\nfrom sagemaker_containers.beta.framework import (content_types, encoders, errors)\nfrom sagemaker_sklearn_container import serving\nfrom sagemaker_sklearn_container.serving import default_model_fn, import_module\n\n\[email protected](scope='module', name='np_array')\ndef fixture_np_array():\n return np.ones((2, 2))\n\n\nclass FakeEstimator(BaseEstimator):\n def __init__(self):\n pass\n\n @staticmethod\n def predict(input):\n return\n\n\ndef dummy_execution_parameters_fn():\n return {'dummy': 'dummy'}\n\n\nclass DummyUserModule:\n def __init__(self):\n self.execution_parameters_fn = dummy_execution_parameters_fn\n\n def model_fn(self, model_dir):\n pass\n\n\[email protected](\n 'json_data, expected', [\n ('[42, 6, 9]', np.array([42, 6, 9])),\n ('[42.0, 6.0, 9.0]', np.array([42., 6., 9.])),\n ('[\"42\", \"6\", \"9\"]', np.array(['42', '6', '9'], dtype=np.float32)),\n (u'[\"42\", \"6\", \"9\"]', np.array([u'42', u'6', u'9'], dtype=np.float32))])\ndef test_input_fn_json(json_data, expected):\n actual = serving.default_input_fn(json_data, content_types.JSON)\n np.testing.assert_equal(actual, expected)\n\n\[email protected](\n 'csv_data, expected', [\n ('42\\n6\\n9\\n', np.array([42, 6, 9], dtype=np.float32)),\n ('42.0\\n6.0\\n9.0\\n', np.array([42., 6., 9.], dtype=np.float32)),\n ('42\\n6\\n9\\n', np.array([42, 6, 9], dtype=np.float32))])\ndef test_input_fn_csv(csv_data, expected):\n deserialized_np_array = serving.default_input_fn(csv_data, content_types.CSV)\n assert np.array_equal(expected, deserialized_np_array)\n\n\[email protected]('np_array', ([42, 6, 9], [42., 6., 9.]))\ndef test_input_fn_npz(np_array):\n input_data = encoders.array_to_npy(np_array)\n deserialized_np_array = serving.default_input_fn(input_data, content_types.NPY)\n\n assert np.array_equal(np_array, deserialized_np_array)\n\n float_32_array = np.array(np_array, dtype=np.float32)\n input_data = encoders.array_to_npy(float_32_array)\n deserialized_np_array = serving.default_input_fn(input_data, content_types.NPY)\n\n assert np.array_equal(float_32_array, deserialized_np_array)\n\n float_64_array = np.array(np_array, dtype=np.float64)\n input_data = encoders.array_to_npy(float_64_array)\n deserialized_np_array = serving.default_input_fn(input_data, content_types.NPY)\n\n assert np.array_equal(float_64_array, deserialized_np_array)\n\n\ndef test_input_fn_bad_content_type():\n with pytest.raises(errors.UnsupportedFormatError):\n serving.default_input_fn('', 'application/not_supported')\n\n\ndef test_default_model_fn():\n with pytest.raises(NotImplementedError):\n default_model_fn('model_dir')\n\n\ndef test_predict_fn(np_array):\n mock_estimator = FakeEstimator()\n with patch.object(mock_estimator, 'predict') as mock:\n serving.default_predict_fn(np_array, mock_estimator)\n mock.assert_called_once()\n\n\ndef test_output_fn_json(np_array):\n response = serving.default_output_fn(np_array, content_types.JSON)\n\n assert response.get_data(as_text=True) == encoders.array_to_json(np_array.tolist())\n assert response.content_type == content_types.JSON\n\n\ndef test_output_fn_csv(np_array):\n response = serving.default_output_fn(np_array, content_types.CSV)\n\n assert response.get_data(as_text=True) == '1.0,1.0\\n1.0,1.0\\n'\n assert content_types.CSV in response.content_type\n\n\ndef test_output_fn_npz(np_array):\n response = serving.default_output_fn(np_array, content_types.NPY)\n\n assert response.get_data() == encoders.array_to_npy(np_array)\n assert response.content_type == content_types.NPY\n\n\ndef test_input_fn_bad_accept():\n with pytest.raises(errors.UnsupportedFormatError):\n serving.default_output_fn('', 'application/not_supported')\n\n\n@patch('importlib.import_module')\ndef test_import_module_execution_parameters(importlib_module_mock):\n importlib_module_mock.return_value = DummyUserModule()\n _, execution_parameters_fn = import_module('dummy_module', 'dummy_dir')\n\n assert execution_parameters_fn == dummy_execution_parameters_fn\n\n\n@patch('sagemaker_sklearn_container.serving.server')\ndef test_serving_entrypoint_start_gunicorn(mock_server):\n mock_server.start = MagicMock()\n serving.serving_entrypoint()\n mock_server.start.assert_called_once()\n\n\[email protected](os.environ, {'SAGEMAKER_MULTI_MODEL': 'True', })\n@patch('sagemaker_sklearn_container.serving.start_model_server')\ndef test_serving_entrypoint_start_mms(mock_start_model_server):\n serving.serving_entrypoint()\n mock_start_model_server.assert_called_once()\n"
] | [
[
"numpy.testing.assert_equal",
"numpy.ones",
"numpy.array",
"numpy.array_equal"
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.