repo_name
stringlengths 6
130
| hexsha
list | file_path
list | code
list | apis
list |
|---|---|---|---|---|
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.nn.Dropout",
"torch.arange",
"torch.ones_like",
"torch.zeros_like",
"torch.nn.Embedding"
]
]
|
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.device",
"torch.nn.Identity",
"torch.cat",
"torch.nn.BatchNorm2d",
"torch.nn.ConvTranspose2d",
"torch.abs",
"torch.randn",
"torch.nn.Conv2d",
"torch.set_grad_enabled",
"torch.nn.ELU"
]
]
|
mrzhuzhe/mmdetection | [
"c04ca2c2a65500bc248a5d2ab6ace5b15f00064d",
"c04ca2c2a65500bc248a5d2ab6ace5b15f00064d"
]
| [
"mmdet/models/losses/ae_loss.py",
"mmdet/models/necks/bfp.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",
"# Copyright (c) OpenMMLab. All rights reserved.\r\nimport torch.nn.functional as F\r\nfrom mmcv.cnn import ConvModule\r\nfrom mmcv.cnn.bricks import NonLocal2d\r\nfrom mmcv.runner import BaseModule\r\n\r\nfrom ..builder import NECKS\r\n\r\n\r\[email protected]_module()\r\nclass BFP(BaseModule):\r\n \"\"\"BFP (Balanced Feature Pyramids)\r\n\r\n BFP takes multi-level features as inputs and gather them into a single one,\r\n then refine the gathered feature and scatter the refined results to\r\n multi-level features. This module is used in Libra R-CNN (CVPR 2019), see\r\n the paper `Libra R-CNN: Towards Balanced Learning for Object Detection\r\n <https://arxiv.org/abs/1904.02701>`_ for details.\r\n\r\n Args:\r\n in_channels (int): Number of input channels (feature maps of all levels\r\n should have the same channels).\r\n num_levels (int): Number of input feature levels.\r\n conv_cfg (dict): The config dict for convolution layers.\r\n norm_cfg (dict): The config dict for normalization layers.\r\n refine_level (int): Index of integration and refine level of BSF in\r\n multi-level features from bottom to top.\r\n refine_type (str): Type of the refine op, currently support\r\n [None, 'conv', 'non_local'].\r\n init_cfg (dict or list[dict], optional): Initialization config dict.\r\n \"\"\"\r\n\r\n def __init__(self,\r\n in_channels,\r\n num_levels,\r\n refine_level=2,\r\n refine_type=None,\r\n conv_cfg=None,\r\n norm_cfg=None,\r\n init_cfg=dict(\r\n type='Xavier', layer='Conv2d', distribution='uniform')):\r\n super(BFP, self).__init__(init_cfg)\r\n assert refine_type in [None, 'conv', 'non_local']\r\n\r\n self.in_channels = in_channels\r\n self.num_levels = num_levels\r\n self.conv_cfg = conv_cfg\r\n self.norm_cfg = norm_cfg\r\n\r\n self.refine_level = refine_level\r\n self.refine_type = refine_type\r\n assert 0 <= self.refine_level < self.num_levels\r\n\r\n if self.refine_type == 'conv':\r\n self.refine = ConvModule(\r\n self.in_channels,\r\n self.in_channels,\r\n 3,\r\n padding=1,\r\n conv_cfg=self.conv_cfg,\r\n norm_cfg=self.norm_cfg)\r\n elif self.refine_type == 'non_local':\r\n self.refine = NonLocal2d(\r\n self.in_channels,\r\n reduction=1,\r\n use_scale=False,\r\n conv_cfg=self.conv_cfg,\r\n norm_cfg=self.norm_cfg)\r\n\r\n def forward(self, inputs):\r\n \"\"\"Forward function.\"\"\"\r\n assert len(inputs) == self.num_levels\r\n\r\n # step 1: gather multi-level features by resize and average\r\n feats = []\r\n gather_size = inputs[self.refine_level].size()[2:]\r\n for i in range(self.num_levels):\r\n if i < self.refine_level:\r\n gathered = F.adaptive_max_pool2d(\r\n inputs[i], output_size=gather_size)\r\n else:\r\n gathered = F.interpolate(\r\n inputs[i], size=gather_size, mode='nearest')\r\n feats.append(gathered)\r\n\r\n bsf = sum(feats) / len(feats)\r\n\r\n # step 2: refine gathered features\r\n if self.refine_type is not None:\r\n bsf = self.refine(bsf)\r\n\r\n # step 3: scatter refined features to multi-levels by a residual path\r\n outs = []\r\n for i in range(self.num_levels):\r\n out_size = inputs[i].size()[2:]\r\n if i < self.refine_level:\r\n residual = F.interpolate(bsf, size=out_size, mode='nearest')\r\n else:\r\n residual = F.adaptive_max_pool2d(bsf, output_size=out_size)\r\n outs.append(residual + inputs[i])\r\n\r\n return tuple(outs)\r\n"
]
| [
[
"torch.nn.functional.relu",
"torch.cat",
"torch.eye"
],
[
"torch.nn.functional.adaptive_max_pool2d",
"torch.nn.functional.interpolate"
]
]
|
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.show",
"numpy.geomspace",
"matplotlib.pyplot.plot",
"numpy.random.rand"
]
]
|
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.max",
"numpy.zeros",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.title",
"numpy.min",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.show"
]
]
|
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.concatenate",
"numpy.array",
"numpy.random.choice",
"numpy.zeros",
"numpy.argmin",
"numpy.copy",
"numpy.split",
"numpy.random.shuffle",
"numpy.any",
"numpy.invert",
"numpy.where",
"numpy.arange",
"numpy.argmax"
]
]
|
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.to_datetime",
"pandas.read_csv"
]
]
|
blester125/baseline | [
"4ad4147d4a88a42b309c6784a95b0b9f1faa2c60",
"4ad4147d4a88a42b309c6784a95b0b9f1faa2c60"
]
| [
"baseline/tf/seq2seq/training/datasets.py",
"layers/eight_mile/tf/embeddings.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",
"import math\nimport copy\nimport logging\nimport numpy as np\nimport tensorflow as tf\nfrom eight_mile.utils import write_json, Offsets, is_sequence, calc_nfeats\nfrom eight_mile.tf.layers import *\n\n\nFLOAT32 = 4\nGB2 = 1024 * 1024 * 1024 * 2\nlogger = logging.getLogger(\"baseline\")\n\n\nclass TensorFlowEmbeddings(tf.keras.layers.Layer):\n \"\"\"This provides a base for TensorFlow embeddings sub-graphs\n\n \"\"\"\n\n def __init__(self, trainable=True, name=None, dtype=tf.float32, **kwargs):\n # tf.kers.layers.Layer has a validation step that only allows certain kwargs\n # to be passed into it. These are not documented and you need to look into the\n # code to find this. For now just don't pass in out kwargs\n super().__init__(trainable=trainable, name=name, dtype=dtype)\n self.W = None\n\n def get_dsz(self):\n \"\"\"Get the number of output dimension of this operation\n\n :return:\n \"\"\"\n pass\n\n def get_vsz(self):\n \"\"\"Get the number of words (including <PAD>) in the vocabulary\n\n :return:\n \"\"\"\n pass\n\n def get_weights(self):\n raise NotImplementedError\n\n def encode(self, *x):\n \"\"\"This defines the computation of the sub-graph for this object and returns the output node\n\n :return:\n \"\"\"\n pass\n\n @property\n def output_dim(self):\n return self.get_dsz()\n\n def call(self, x):\n return self.encode(x)\n\n def get_feed_dict(self):\n \"\"\"Return a feed dict that is needed to initialize this embeddings.\"\"\"\n return {}\n\n\nclass LookupTableEmbeddings(TensorFlowEmbeddings):\n def __init__(self, trainable=True, name=None, dtype=tf.float32, cpu_placement=False, **kwargs):\n \"\"\"Create a lookup-table based embedding.\n\n :param name: The name of the feature/placeholder, and a key for the scope\n :param kwargs:\n\n :Keyword Arguments: See below\n * *vsz* -- (``int``) this is the vocabulary (input) size of the lookup table\n * *dsz* -- (``int``) the output dimension size of this embedding\n * *finetune* -- (``bool``) (default is `True`) should we allow the sub-graph to learn updated weights\n * *weights* -- (``numpy.ndarray``) Optional `vsz x dsz` weight matrix for initialization\n * *unif* -- (``float``) (defaults to `0.1`) If the weights should be created, what is the random initialization range\n \"\"\"\n trainable = kwargs.get(\"finetune\", trainable)\n # The layers have a filter of allowed keywords and the docs don't list what they are\n # you need to look in code. We are just not passing kwargs for now.\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\n self.vsz = kwargs.get(\"vsz\")\n self.padding_idx = kwargs.get('padding_idx', Offsets.PAD)\n self.dsz = kwargs.get(\"dsz\")\n self.finetune = kwargs.get(\"finetune\", trainable)\n self.scope = kwargs.get(\"scope\", \"LUT\")\n self.dropin = kwargs.get(\"dropin\", 0.0)\n self._weights = kwargs.get(\"weights\")\n self.drop = tf.keras.layers.Dropout(rate=self.dropin, noise_shape=(self.get_vsz(), 1))\n self.cpu_placement = cpu_placement\n if self._weights is None:\n unif = kwargs.get(\"unif\", 0.1)\n self._weights = np.random.uniform(-unif, unif, (self.vsz, self.dsz))\n else:\n self.vsz, self.dsz = self._weights.shape\n\n def build(self, input_shape):\n\n if self.cpu_placement:\n with tf.device(\"cpu:0\"):\n self.W = self.add_weight(\n name=f\"{self.scope}/Weight\",\n shape=(self.vsz, self.dsz),\n initializer=tf.constant_initializer(self._weights),\n trainable=self.finetune,\n )\n else:\n self.W = self.add_weight(\n name=f\"{self.scope}/Weight\",\n shape=(self.vsz, self.dsz),\n initializer=tf.constant_initializer(self._weights),\n trainable=self.finetune,\n )\n super().build(input_shape)\n\n def _embed_w_dropout(self, x):\n # The ablation table (4) in https://arxiv.org/pdf/1708.02182.pdf shows this has a massive impact\n embedding_w_dropout = self.drop(self.W, training=TRAIN_FLAG())\n word_embeddings = tf.nn.embedding_lookup(embedding_w_dropout, x)\n return word_embeddings\n\n def encode(self, *x):\n \"\"\"Build a simple Lookup Table and set as input `x` if it exists, or `self.x` otherwise.\n\n :param x: An optional input sub-graph to bind to this operation or use `self.x` if `None`\n :return: The sub-graph output\n \"\"\"\n self.x = x[0]\n if self.padding_idx is not None:\n e0 = tf.tensor_scatter_nd_update(\n self.W, tf.constant(self.padding_idx, dtype=tf.int32, shape=[1, 1]), tf.zeros(shape=[1, self.dsz])\n )\n with tf.control_dependencies([e0]):\n return self._embed_w_dropout(self.x)\n else:\n return self._embed_w_dropout(self.x)\n\n def get_vsz(self):\n return self.vsz\n\n def get_dsz(self):\n return self.dsz\n\n def get_weights(self):\n return self.W\n\n\nclass CharConvEmbeddings(TensorFlowEmbeddings):\n \"\"\"dos Santos embeddings extended to parallel filters (AKA Kim character-aware neural language model inputs)\n\n \"\"\"\n\n def __init__(self, trainable=True, name=None, dtype=tf.float32, **kwargs):\n trainable = kwargs.get(\"finetune\", trainable)\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\n self.cpu_placement = bool(kwargs.get('cpu_placement', False))\n self.scope = kwargs.get(\"scope\", \"CharConv\")\n self.finetune = kwargs.get(\"finetune\", trainable)\n self.nfeat_factor = kwargs.get(\"nfeat_factor\", None)\n self.cfiltsz = kwargs.get(\"cfiltsz\", kwargs.get(\"filtsz\", [3]))\n self.max_feat = kwargs.get(\"max_feat\", 30)\n gating = kwargs.get(\"gating\", \"skip\")\n num_gates = kwargs.get(\"num_gates\", 1)\n activation = kwargs.get(\"activation\", \"tanh\")\n self.wsz = kwargs.get(\"wsz\", 30)\n self.projsz = kwargs.get(\"projsz\")\n self.x = None\n # These are the actual final filter sizes and num features\n filtsz, nfeats = calc_nfeats(self.cfiltsz, self.nfeat_factor, self.max_feat, self.wsz)\n\n self.embed = LookupTableEmbeddings(name=f\"{self.name}/CharLUT\", finetune=self.finetune, **kwargs)\n dsz = self.embed.output_dim\n self.parallel_conv = ParallelConv(dsz, nfeats, filtsz, activation)\n self.gating_fns = tf.keras.Sequential()\n for _ in range(num_gates):\n if gating == 'skip':\n self.gating_fns.add(SkipConnection(self.parallel_conv.output_dim, activation))\n else:\n self.gating_fns.add(Highway(self.parallel_conv.output_dim))\n\n self.outsz = self.parallel_conv.output_dim\n if self.projsz is not None:\n self.outsz = self.projsz\n self.proj = tf.keras.layers.Dense(self.outsz, bias_initializer=tf.constant_initializer(0.0))\n\n\n\n @property\n def dsz(self):\n return self.outsz\n\n def encode(self, *x):\n self.x = x[0]\n\n mxlen = tf.shape(self.x)[1]\n mxwlen = tf.shape(self.x)[-1]\n char_bt_x_w = tf.reshape(self.x, [-1, mxwlen])\n cembed = self.embed(char_bt_x_w)\n cmot = self.parallel_conv(cembed)\n cmot = self.gating_fns(cmot)\n if self.projsz:\n cmot = self.proj(cmot)\n word_char = tf.reshape(cmot, [-1, mxlen, self.outsz])\n return word_char\n\n def get_vsz(self):\n return self.embed.get_vsz()\n\n def get_dsz(self):\n return self.outsz\n\n\nclass CharLSTMEmbeddings(TensorFlowEmbeddings):\n def __init__(self, trainable=True, name=None, dtype=tf.float32, **kwargs):\n trainable = kwargs.get(\"finetune\", trainable)\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\n self.scope = kwargs.get(\"scope\", \"CharLUT\")\n self.finetune = kwargs.get(\"finetune\", trainable)\n self.lstmsz = kwargs.get(\"lstmsz\", 50)\n self.lstm_layers = kwargs.get(\"layers\", 1)\n self.pdrop = kwargs.get(\"pdrop\", 0.5)\n self.rnn_type = kwargs.get(\"rnn_type\", \"blstm\")\n self.x = None\n self.embed = LookupTableEmbeddings(name=f\"{self.name}/CharLUT\", finetune=self.finetune, **kwargs)\n self.lstm = BiLSTMEncoderHidden(\n self.embed.output_dim,\n self.lstmsz,\n self.lstm_layers,\n pdrop=self.pdrop,\n requires_length=True,\n name=f\"{self.name}/blstm\",\n )\n\n def encode(self, *x):\n self.x = x[0]\n shape = tf.shape(self.x)\n B = shape[0]\n T = shape[1]\n W = shape[2]\n flat_chars = tf.reshape(x, [-1, W])\n embed_chars = self.embed(flat_chars)\n\n # Calculate the lengths of each word\n word_lengths = tf.reduce_sum(tf.cast(tf.not_equal(flat_chars, Offsets.PAD), tf.int32), axis=1)\n\n # cuDNN throws an error if there is an input with a length of 0, this happens when the \"word\"\n # is actually a \"<PAD>\" so there are no characters to run the LSTM over. Here we just say\n # that the lengths is 1. This will make cudnn happy and we will just get junk in that spot\n patched_lengths = tf.math.maximum(word_lengths, 1)\n\n # Run the LSTM\n result = self.lstm((embed_chars, patched_lengths))\n\n # Create a mask that is true when the length is 0 (where the word was a pad) so that\n # we can mask out the junk that the lstm created because we needed a length of 1\n result = tf.multiply(result, tf.expand_dims(tf.cast(tf.not_equal(word_lengths, 0), tf.float32), -1))\n\n return tf.reshape(result, (B, T, self.lstmsz))\n\n def call(self, inputs):\n return self.encode(inputs)\n\n def get_dsz(self):\n return self.lstmsz\n\n def get_vsz(self):\n return self.embed.get_vsz()\n\n\nclass CharTransformerEmbeddings(TensorFlowEmbeddings):\n def __init__(self, trainable=True, name=None, dtype=tf.float32, **kwargs):\n trainable = kwargs.get(\"finetune\", trainable)\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\n self.scope = kwargs.get(\"scope\", \"CharLUT\")\n self.finetune = kwargs.get(\"finetune\", trainable)\n self.embed = LookupTableEmbeddings(name=f\"{self.name}/CharLUT\", finetune=self.finetune, **kwargs)\n self.d_model = kwargs.get(\"wsz\", 30)\n self.num_heads = kwargs.get(\"num_heads\", 3)\n self.rpr_k = kwargs.get(\"rpr_k\", 10)\n layers = kwargs.get(\"layers\", 1)\n pdrop = kwargs.get(\"pdrop\", 0.5)\n self.char_comp = TransformerEncoderStackWithLengths(\n self.num_heads,\n self.d_model,\n pdrop,\n False,\n layers,\n rpr_k=self.rpr_k,\n input_sz=self.embed.output_dim,\n name=f\"{self.name}/transformer\",\n )\n\n def encode(self, *x):\n self.x = x[0]\n shape = tf.shape(self.x)\n B = shape[0]\n T = shape[1]\n W = shape[2]\n flat_chars = tf.reshape(x, [-1, W])\n embed_chars = self.embed(flat_chars)\n\n # Calculate the lengths of each word\n lengths = tf.reduce_sum(tf.cast(tf.not_equal(flat_chars, Offsets.PAD), tf.int32), axis=1)\n\n # Run the LSTM\n result = self.char_comp((embed_chars, lengths))\n\n pooled = tf.reduce_max(result, -2, keepdims=False)\n\n return tf.reshape(pooled, (B, T, self.d_model))\n\n def call(self, inputs):\n return self.encode(inputs)\n\n def get_dsz(self):\n return self.d_model\n\n def get_vsz(self):\n return self.embed.get_vsz()\n\n\nclass PositionalMixin(tf.keras.layers.Layer):\n def positional(self, length):\n pass\n\n\nclass SinusoidalPositionalMixin(PositionalMixin):\n def __init__(self, trainable=True, name=None, dtype=tf.float32, **kwargs):\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\n\n max_timescale = kwargs.get(\"max_timescale\", 1.0e4)\n # Match the mxlen pytorch has because it precomputes the timing signal\n mxlen = kwargs.get('mxlen', 10000)\n\n word_dsz = self.get_dsz()\n log_timescale_increment = math.log(max_timescale) / float(word_dsz)\n inv_timescales = np.exp(np.arange(0, word_dsz, 2, dtype=np.float32) * -log_timescale_increment)\n\n pe = np.zeros((mxlen, word_dsz), dtype=np.float32)\n position = np.expand_dims(np.arange(0, mxlen, dtype=np.float32), 1)\n\n pe[:, 0::2] = np.sin(position * inv_timescales)\n pe[:, 1::2] = np.cos(position * inv_timescales)\n\n self.pe = tf.expand_dims(pe, 0)\n\n def positional(self, length):\n return self.pe[:, :length]\n\n\nclass LearnedPositionalMixin(PositionalMixin):\n def __init__(self, trainable=True, name=None, dtype=tf.float32, **kwargs):\n trainable = kwargs.get(\"finetune\", trainable)\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\n self.mxlen = int(kwargs.get(\"mxlen\", 512))\n self.pos_weights = kwargs.get(\"pos_weights\")\n if self.pos_weights is None:\n unif = float(kwargs.get(\"unif\", 0.1))\n self.pos_weights = np.random.uniform(-unif, unif, (self.mxlen, self.get_dsz()))\n\n def build(self, input_shape):\n self.pos = self.add_weight(\n name=\"pos\",\n initializer=tf.constant_initializer(self.pos_weights),\n shape=[self.mxlen, self.get_dsz()],\n trainable=self.finetune,\n )\n super().build(input_shape)\n\n def positional(self, length):\n return tf.expand_dims(tf.nn.embedding_lookup(self.pos, tf.range(length, dtype=tf.int32)), 0)\n\n\nclass PositionalLookupTableEmbeddings(SinusoidalPositionalMixin, LookupTableEmbeddings):\n def __init__(self, trainable=True, name=None, dtype=tf.float32, **kwargs):\n super().__init__(name=name, **kwargs)\n self.scale = math.sqrt(self.get_dsz())\n self.dropout = tf.keras.layers.Dropout(kwargs.get(\"dropout\", 0.0))\n\n def encode(self, *x):\n y = super().encode(*x) * tf.constant(self.scale)\n T = tf.shape(y)[1]\n pos = self.positional(T)\n return self.dropout(y + pos, training=TRAIN_FLAG())\n\n\nclass LearnedPositionalLookupTableEmbeddings(LearnedPositionalMixin, LookupTableEmbeddings):\n def __init__(self, trainable=True, name=None, dtype=tf.float32, **kwargs):\n super().__init__(name=name, **kwargs)\n self.dropout = tf.keras.layers.Dropout(kwargs.get(\"dropout\", 0.0))\n\n def encode(self, *x):\n y = super().encode(*x)\n T = tf.shape(y)[1]\n pos = self.positional(T)\n return self.dropout(y + pos, training=TRAIN_FLAG())\n\n\nclass LearnedPositionalLookupTableEmbeddingsWithBias(LearnedPositionalMixin, LookupTableEmbeddings):\n \"\"\"Learned positional lookup table embeddings wih a bias and layer norm\n\n This is just a typical learned positional embedding but with a learnable\n bias and a layer norm. This is equivalent to BERT embeddings when the\n token_type is not set\n\n \"\"\"\n def __init__(self, trainable=True, name=None, dtype=tf.float32, **kwargs):\n super().__init__(name=name, **kwargs)\n\n def build(self, input_shape):\n super().build(input_shape)\n self.bias = self.add_weight(\n name=\"bias\",\n initializer=tf.constant_initializer(0.0),\n shape=[1, self.get_dsz()],\n trainable=self.finetune,\n )\n\n def encode(self, *x):\n y = super().encode(*x)\n T = tf.shape(y)[1]\n pos = self.positional(T)\n y = y + pos + self.bias\n return y\n\n\nclass PositionalCharConvEmbeddings(SinusoidalPositionalMixin, CharConvEmbeddings):\n def __init__(self, trainable=True, name=None, dtype=tf.float32, **kwargs):\n super().__init__(name=name, **kwargs)\n self.scale = math.sqrt(self.get_dsz())\n self.dropout = tf.keras.layers.Dropout(kwargs.get(\"dropout\", 0.0))\n\n def encode(self, *x):\n y = super().encode(*x) * tf.constant(self.scale)\n T = tf.shape(y)[1]\n pos = self.positional(T)\n return self.dropout(y + pos, training=TRAIN_FLAG())\n\n\nclass LearnedPositionalCharConvEmbeddings(LearnedPositionalMixin, CharConvEmbeddings):\n def __init__(self, trainable=True, name=None, dtype=tf.float32, **kwargs):\n super().__init__(name=name, **kwargs)\n self.dropout = tf.keras.layers.Dropout(kwargs.get(\"dropout\", 0.0))\n\n def encode(self, *x):\n y = super().encode(*x)\n T = tf.shape(y)[1]\n pos = self.positional(T)\n return self.dropout(y + pos, training=TRAIN_FLAG())\n\n\nclass PositionalCharLSTMEmbeddings(SinusoidalPositionalMixin, CharLSTMEmbeddings):\n def __init__(self, trainable=True, name=None, dtype=tf.float32, **kwargs):\n trainable = kwargs.get(\"finetune\", trainable)\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\n self.scale = math.sqrt(self.get_dsz())\n self.dropout = tf.keras.layers.Dropout(kwargs.get(\"dropout\", 0.0))\n\n def encode(self, *x):\n y = super().encode(*x) * tf.constant(self.scale)\n T = tf.shape(y)[1]\n pos = self.positional(T)\n return self.dropout(y + pos, training=TRAIN_FLAG())\n\n\nclass LearnedPositionalCharLSTMEmbeddings(LearnedPositionalMixin, CharLSTMEmbeddings):\n def __init__(self, trainable=True, name=None, dtype=tf.float32, **kwargs):\n trainable = kwargs.get(\"finetune\", trainable)\n super().__init__(trainable=trainable, name=name, dtype=dtype, **kwargs)\n self.dropout = tf.keras.layers.Dropout(kwargs.get(\"dropout\", 0.0))\n\n def encode(self, *x):\n y = super().encode(*x)\n T = tf.shape(y)[1]\n pos = self.positional(T)\n return self.dropout(y + pos, training=TRAIN_FLAG())\n"
]
| [
[
"tensorflow.compat.v1.data.get_output_shapes",
"tensorflow.reduce_max",
"tensorflow.compat.v1.data.get_output_types"
],
[
"tensorflow.constant_initializer",
"tensorflow.reshape",
"tensorflow.keras.Sequential",
"tensorflow.nn.embedding_lookup",
"tensorflow.control_dependencies",
"numpy.cos",
"numpy.sin",
"tensorflow.shape",
"tensorflow.constant",
"numpy.arange",
"tensorflow.zeros",
"tensorflow.range",
"numpy.zeros",
"tensorflow.expand_dims",
"tensorflow.math.maximum",
"tensorflow.not_equal",
"tensorflow.reduce_max",
"numpy.random.uniform",
"tensorflow.device"
]
]
|
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.mean",
"numpy.where",
"numpy.array_equiv",
"tensorflow.compat.v1.placeholder",
"numpy.zeros_like",
"matplotlib.colors.hsv_to_rgb",
"numpy.logical_and",
"numpy.prod",
"numpy.transpose",
"numpy.arange",
"tensorflow.compat.v1.train.latest_checkpoint",
"numpy.square",
"numpy.array",
"numpy.zeros",
"tensorflow.compat.v1.train.Saver",
"tensorflow.compat.v1.Session",
"numpy.argsort",
"numpy.dstack",
"numpy.logical_not",
"scipy.ndimage.label",
"tensorflow.compat.v1.disable_eager_execution"
]
]
|
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.linalg.norm",
"numpy.cross"
]
]
|
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.cat",
"torch.cuda.manual_seed_all",
"torch.nn.ModuleList",
"torch.nn.Conv1d",
"torch.nn.init.constant_",
"torch.manual_seed",
"torch.nn.Conv2d",
"torch.randn",
"torch.sum"
]
]
|
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"
]
| [
[
"tensorflow.ConfigProto",
"numpy.squeeze",
"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"
]
| [
[
"scipy.interpolate.interp1d",
"scipy.interpolate._fitpack._bspleval",
"numpy.empty_like"
]
]
|
noelevans/playground | [
"da529e967a15bcb217fff091ac0ec5c4dc1821ce",
"da529e967a15bcb217fff091ac0ec5c4dc1821ce",
"da529e967a15bcb217fff091ac0ec5c4dc1821ce"
]
| [
"kaggle/sf-crime/logistic_regressions.py",
"kaggle/washington_bike_share/svm_simple.py",
"iris/classification_report.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",
"import numpy as np\nfrom sklearn.svm import SVR\nimport matplotlib.pyplot as plt\n\n###############################################################################\n# Generate sample data\nX = np.sort(5 * np.random.rand(40, 1), axis=0)\ny = np.sin(X).ravel()\n\n###############################################################################\n# Add noise to targets\ny[::5] += 3 * (0.5 - np.random.rand(8))\n\n###############################################################################\n# Fit regression model\nsvr_rbf = SVR(kernel='rbf', C=1e3, gamma=0.1)\ny_rbf = svr_rbf.fit(X, y).predict(X)\n\n###############################################################################\n# look at the results\nplt.scatter(X, y, c='k', label='data')\nplt.hold('on')\nplt.plot(X, y_rbf, c='g', label='RBF model')\nplt.xlabel('data')\nplt.ylabel('target')\nplt.title('Support Vector Regression')\nplt.legend()\nplt.show()\n",
"from sklearn import datasets\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.metrics import classification_report\nfrom sklearn.cross_validation import train_test_split\n\n\ndef main():\n iris = datasets.load_iris()\n X = iris.data\n y = iris.target\n X_train, X_test, y_train, y_test = train_test_split(\n X, y, test_size=0.25, random_state=2)\n\n clf = RandomForestClassifier(n_estimators=10)\n clf.fit(X_train, y_train)\n y_hat = clf.predict(X_test)\n\n print(y_test == y_hat)\n print(classification_report(\n y_test, y_hat, target_names=iris.target_names))\n\n\n\nif __name__ == '__main__':\n main()\n"
]
| [
[
"sklearn.linear_model.LogisticRegression"
],
[
"numpy.sin",
"numpy.random.rand",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.hold",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.title",
"matplotlib.pyplot.legend",
"sklearn.svm.SVR",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.scatter"
],
[
"sklearn.ensemble.RandomForestClassifier",
"sklearn.cross_validation.train_test_split",
"sklearn.metrics.classification_report",
"sklearn.datasets.load_iris"
]
]
|
Onkar627/cupy | [
"8eef1ad5393c0a92c5065bc05137bf997f37044a",
"8eef1ad5393c0a92c5065bc05137bf997f37044a",
"8eef1ad5393c0a92c5065bc05137bf997f37044a",
"8eef1ad5393c0a92c5065bc05137bf997f37044a"
]
| [
"cupyx/scipy/ndimage/_measurements.py",
"tests/cupy_tests/core_tests/test_ndarray_elementwise_op.py",
"cupyx/scipy/sparse/_compressed.py",
"tests/cupyx_tests/scipy_tests/sparse_tests/test_coo.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",
"import operator\n\nimport numpy\nimport pytest\n\nimport cupy\nfrom cupy import testing\n\n\nclass TestArrayElementwiseOp:\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(rtol=1e-6, accept_error=TypeError)\n def check_array_scalar_op(self, op, xp, x_type, y_type, swap=False,\n no_bool=False, no_complex=False):\n x_dtype = numpy.dtype(x_type)\n y_dtype = numpy.dtype(y_type)\n if no_bool and x_dtype == '?' and y_dtype == '?':\n return xp.array(True)\n if no_complex and (x_dtype.kind == 'c' or y_dtype.kind == 'c'):\n return xp.array(True)\n a = xp.array([[1, 2, 3], [4, 5, 6]], x_type)\n if swap:\n return op(y_type(3), a)\n else:\n return op(a, y_type(3))\n\n def test_add_scalar(self):\n self.check_array_scalar_op(operator.add)\n\n def test_radd_scalar(self):\n self.check_array_scalar_op(operator.add, swap=True)\n\n def test_iadd_scalar(self):\n self.check_array_scalar_op(operator.iadd)\n\n def test_sub_scalar(self):\n self.check_array_scalar_op(operator.sub, no_bool=True)\n\n def test_rsub_scalar(self):\n self.check_array_scalar_op(operator.sub, swap=True, no_bool=True)\n\n def test_isub_scalar(self):\n self.check_array_scalar_op(operator.isub, no_bool=True)\n\n def test_mul_scalar(self):\n self.check_array_scalar_op(operator.mul)\n\n def test_rmul_scalar(self):\n self.check_array_scalar_op(operator.mul, swap=True)\n\n def test_imul_scalar(self):\n self.check_array_scalar_op(operator.imul)\n\n def test_truediv_scalar(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_scalar_op(operator.truediv)\n\n def test_rtruediv_scalar(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_scalar_op(operator.truediv, swap=True)\n\n def test_itruediv_scalar(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_scalar_op(operator.itruediv)\n\n def test_floordiv_scalar(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_scalar_op(operator.floordiv, no_complex=True)\n\n def test_rfloordiv_scalar(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_scalar_op(operator.floordiv, swap=True,\n no_complex=True)\n\n def test_ifloordiv_scalar(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_scalar_op(operator.ifloordiv, no_complex=True)\n\n def test_pow_scalar(self):\n self.check_array_scalar_op(operator.pow)\n\n def test_rpow_scalar(self):\n self.check_array_scalar_op(operator.pow, swap=True)\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(atol=1.0, accept_error=TypeError)\n def check_ipow_scalar(self, xp, x_type, y_type):\n a = xp.array([[1, 2, 3], [4, 5, 6]], x_type)\n return operator.ipow(a, y_type(3))\n\n def test_ipow_scalar(self):\n self.check_ipow_scalar()\n\n def test_divmod0_scalar(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_scalar_op(lambda x, y: divmod(x, y)[0],\n no_complex=True)\n\n def test_divmod1_scalar(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_scalar_op(lambda x, y: divmod(x, y)[1],\n no_complex=True)\n\n def test_rdivmod0_scalar(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_scalar_op(lambda x, y: divmod(x, y)[0], swap=True,\n no_complex=True)\n\n def test_rdivmod1_scalar(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_scalar_op(lambda x, y: divmod(x, y)[1], swap=True,\n no_complex=True)\n\n def test_lt_scalar(self):\n self.check_array_scalar_op(operator.lt, no_complex=False)\n\n def test_le_scalar(self):\n self.check_array_scalar_op(operator.le, no_complex=False)\n\n def test_gt_scalar(self):\n self.check_array_scalar_op(operator.gt, no_complex=False)\n\n def test_ge_scalar(self):\n self.check_array_scalar_op(operator.ge, no_complex=False)\n\n def test_eq_scalar(self):\n self.check_array_scalar_op(operator.eq)\n\n def test_ne_scalar(self):\n self.check_array_scalar_op(operator.ne)\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(accept_error=TypeError)\n def check_array_array_op(self, op, xp, x_type, y_type,\n no_bool=False, no_complex=False):\n x_dtype = numpy.dtype(x_type)\n y_dtype = numpy.dtype(y_type)\n if no_bool and x_dtype == '?' and y_dtype == '?':\n return xp.array(True)\n if no_complex and (x_dtype.kind == 'c' or y_dtype.kind == 'c'):\n return xp.array(True)\n a = xp.array([[1, 2, 3], [4, 5, 6]], x_type)\n b = xp.array([[6, 5, 4], [3, 2, 1]], y_type)\n return op(a, b)\n\n def test_add_array(self):\n self.check_array_array_op(operator.add)\n\n def test_iadd_array(self):\n self.check_array_array_op(operator.iadd)\n\n def test_sub_array(self):\n self.check_array_array_op(operator.sub, no_bool=True)\n\n def test_isub_array(self):\n self.check_array_array_op(operator.isub, no_bool=True)\n\n def test_mul_array(self):\n self.check_array_array_op(operator.mul)\n\n def test_imul_array(self):\n self.check_array_array_op(operator.imul)\n\n def test_truediv_array(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_array_op(operator.truediv)\n\n def test_itruediv_array(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_array_op(operator.itruediv)\n\n def test_floordiv_array(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_array_op(operator.floordiv, no_complex=True)\n\n def test_ifloordiv_array(self):\n if '1.16.1' <= numpy.lib.NumpyVersion(numpy.__version__) < '1.18.0':\n self.skipTest(\"NumPy Issue #12927\")\n with numpy.errstate(divide='ignore'):\n self.check_array_array_op(operator.ifloordiv, no_complex=True)\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(atol=1e-5, rtol=1e-6, accept_error=TypeError)\n def check_pow_array(self, xp, x_type, y_type):\n a = xp.array([[1, 2, 3], [4, 5, 6]], x_type)\n b = xp.array([[6, 5, 4], [3, 2, 1]], y_type)\n return operator.pow(a, b)\n\n def test_pow_array(self):\n # There are some precission issues in HIP that prevent\n # checking with atol=0\n if cupy.cuda.runtime.is_hip:\n self.check_pow_array()\n else:\n self.check_array_array_op(operator.pow)\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(atol=1.0, accept_error=TypeError)\n def check_ipow_array(self, xp, x_type, y_type):\n a = xp.array([[1, 2, 3], [4, 5, 6]], x_type)\n b = xp.array([[6, 5, 4], [3, 2, 1]], y_type)\n return operator.ipow(a, b)\n\n def test_ipow_array(self):\n self.check_ipow_array()\n\n def test_divmod0_array(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_array_op(lambda x, y: divmod(x, y)[0])\n\n def test_divmod1_array(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_array_op(lambda x, y: divmod(x, y)[1])\n\n def test_lt_array(self):\n self.check_array_array_op(operator.lt, no_complex=True)\n\n def test_le_array(self):\n self.check_array_array_op(operator.le, no_complex=True)\n\n def test_gt_array(self):\n self.check_array_array_op(operator.gt, no_complex=True)\n\n def test_ge_array(self):\n self.check_array_array_op(operator.ge, no_complex=True)\n\n def test_eq_array(self):\n self.check_array_array_op(operator.eq)\n\n def test_ne_array(self):\n self.check_array_array_op(operator.ne)\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(accept_error=TypeError)\n def check_array_broadcasted_op(self, op, xp, x_type, y_type,\n no_bool=False, no_complex=False):\n x_dtype = numpy.dtype(x_type)\n y_dtype = numpy.dtype(y_type)\n if no_bool and x_dtype == '?' and y_dtype == '?':\n return xp.array(True)\n if no_complex and (x_dtype.kind == 'c' or y_dtype.kind == 'c'):\n return xp.array(True)\n a = xp.array([[1, 2, 3], [4, 5, 6]], x_type)\n b = xp.array([[1], [2]], y_type)\n return op(a, b)\n\n def test_broadcasted_add(self):\n self.check_array_broadcasted_op(operator.add)\n\n def test_broadcasted_iadd(self):\n self.check_array_broadcasted_op(operator.iadd)\n\n def test_broadcasted_sub(self):\n # TODO(unno): sub for boolean array is deprecated in numpy>=1.13\n self.check_array_broadcasted_op(operator.sub, no_bool=True)\n\n def test_broadcasted_isub(self):\n # TODO(unno): sub for boolean array is deprecated in numpy>=1.13\n self.check_array_broadcasted_op(operator.isub, no_bool=True)\n\n def test_broadcasted_mul(self):\n self.check_array_broadcasted_op(operator.mul)\n\n def test_broadcasted_imul(self):\n self.check_array_broadcasted_op(operator.imul)\n\n def test_broadcasted_truediv(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_broadcasted_op(operator.truediv)\n\n def test_broadcasted_itruediv(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_broadcasted_op(operator.itruediv)\n\n def test_broadcasted_floordiv(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_broadcasted_op(operator.floordiv, no_complex=True)\n\n def test_broadcasted_ifloordiv(self):\n if '1.16.1' <= numpy.lib.NumpyVersion(numpy.__version__) < '1.18.0':\n self.skipTest(\"NumPy Issue #12927\")\n with numpy.errstate(divide='ignore'):\n self.check_array_broadcasted_op(operator.ifloordiv,\n no_complex=True)\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(atol=1e-5, rtol=1e-6, accept_error=TypeError)\n def check_broadcasted_pow(self, xp, x_type, y_type):\n a = xp.array([[1, 2, 3], [4, 5, 6]], x_type)\n b = xp.array([[1], [2]], y_type)\n return operator.pow(a, b)\n\n def test_broadcasted_pow(self):\n # There are some precission issues in HIP that prevent\n # checking with atol=0\n if cupy.cuda.runtime.is_hip:\n self.check_broadcasted_pow()\n else:\n self.check_array_broadcasted_op(operator.pow)\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(atol=1.0, accept_error=TypeError)\n def check_broadcasted_ipow(self, xp, x_type, y_type):\n a = xp.array([[1, 2, 3], [4, 5, 6]], x_type)\n b = xp.array([[1], [2]], y_type)\n return operator.ipow(a, b)\n\n def test_broadcasted_ipow(self):\n self.check_broadcasted_ipow()\n\n def test_broadcasted_divmod0(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_broadcasted_op(lambda x, y: divmod(x, y)[0],\n no_complex=True)\n\n def test_broadcasted_divmod1(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_broadcasted_op(lambda x, y: divmod(x, y)[1],\n no_complex=True)\n\n def test_broadcasted_lt(self):\n self.check_array_broadcasted_op(operator.lt, no_complex=True)\n\n def test_broadcasted_le(self):\n self.check_array_broadcasted_op(operator.le, no_complex=True)\n\n def test_broadcasted_gt(self):\n self.check_array_broadcasted_op(operator.gt, no_complex=True)\n\n def test_broadcasted_ge(self):\n self.check_array_broadcasted_op(operator.ge, no_complex=True)\n\n def test_broadcasted_eq(self):\n self.check_array_broadcasted_op(operator.eq)\n\n def test_broadcasted_ne(self):\n self.check_array_broadcasted_op(operator.ne)\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(rtol=1e-6)\n def check_array_doubly_broadcasted_op(self, op, xp, x_type, y_type,\n no_bool=False, no_complex=False):\n x_dtype = numpy.dtype(x_type)\n y_dtype = numpy.dtype(y_type)\n if no_bool and x_dtype == '?' and y_dtype == '?':\n return xp.array(True)\n if no_complex and (x_dtype.kind == 'c' or y_dtype.kind == 'c'):\n return xp.array(True)\n a = xp.array([[[1, 2, 3]], [[4, 5, 6]]], x_type)\n b = xp.array([[1], [2], [3]], y_type)\n return op(a, b)\n\n def test_doubly_broadcasted_add(self):\n self.check_array_doubly_broadcasted_op(operator.add)\n\n def test_doubly_broadcasted_sub(self):\n self.check_array_doubly_broadcasted_op(operator.sub, no_bool=True)\n\n def test_doubly_broadcasted_mul(self):\n self.check_array_doubly_broadcasted_op(operator.mul)\n\n def test_doubly_broadcasted_truediv(self):\n with numpy.errstate(divide='ignore', invalid='ignore'):\n self.check_array_doubly_broadcasted_op(operator.truediv)\n\n def test_doubly_broadcasted_floordiv(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_doubly_broadcasted_op(operator.floordiv,\n no_complex=True)\n\n def test_doubly_broadcasted_pow(self):\n self.check_array_doubly_broadcasted_op(operator.pow)\n\n def test_doubly_broadcasted_divmod0(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_doubly_broadcasted_op(\n lambda x, y: divmod(x, y)[0],\n no_complex=True)\n\n def test_doubly_broadcasted_divmod1(self):\n with numpy.errstate(divide='ignore'):\n self.check_array_doubly_broadcasted_op(\n lambda x, y: divmod(x, y)[1],\n no_complex=True)\n\n def test_doubly_broadcasted_lt(self):\n self.check_array_doubly_broadcasted_op(operator.lt, no_complex=True)\n\n def test_doubly_broadcasted_le(self):\n self.check_array_doubly_broadcasted_op(operator.le, no_complex=True)\n\n def test_doubly_broadcasted_gt(self):\n self.check_array_doubly_broadcasted_op(operator.gt, no_complex=True)\n\n def test_doubly_broadcasted_ge(self):\n self.check_array_doubly_broadcasted_op(operator.ge, no_complex=True)\n\n def test_doubly_broadcasted_eq(self):\n self.check_array_doubly_broadcasted_op(operator.eq)\n\n def test_doubly_broadcasted_ne(self):\n self.check_array_doubly_broadcasted_op(operator.ne)\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose()\n def check_array_reversed_op(self, op, xp, x_type, y_type, no_bool=False):\n if no_bool and x_type == numpy.bool_ and y_type == numpy.bool_:\n return xp.array(True)\n a = xp.array([1, 2, 3, 4, 5], x_type)\n b = xp.array([1, 2, 3, 4, 5], y_type)\n return op(a, b[::-1])\n\n def test_array_reversed_add(self):\n self.check_array_reversed_op(operator.add)\n\n def test_array_reversed_sub(self):\n self.check_array_reversed_op(operator.sub, no_bool=True)\n\n def test_array_reversed_mul(self):\n self.check_array_reversed_op(operator.mul)\n\n @testing.for_all_dtypes(no_bool=True)\n def check_typecast(self, val, dtype):\n operators = [\n operator.add, operator.sub, operator.mul, operator.truediv]\n\n for op in operators:\n with numpy.errstate(divide='ignore', invalid='ignore'):\n a = op(val, (testing.shaped_arange((5,), numpy, dtype) - 2))\n b = op(val, (testing.shaped_arange((5,), cupy, dtype) - 2))\n assert a.dtype == b.dtype\n\n def test_typecast_bool1(self):\n self.check_typecast(True)\n\n def test_typecast_bool2(self):\n self.check_typecast(False)\n\n def test_typecast_int1(self):\n self.check_typecast(0)\n\n def test_typecast_int2(self):\n self.check_typecast(-127)\n\n def test_typecast_int3(self):\n self.check_typecast(255)\n\n def test_typecast_int4(self):\n self.check_typecast(-32768)\n\n def test_typecast_int5(self):\n self.check_typecast(65535)\n\n def test_typecast_int6(self):\n self.check_typecast(-2147483648)\n\n def test_typecast_int7(self):\n self.check_typecast(4294967295)\n\n def test_typecast_float1(self):\n self.check_typecast(0.0)\n\n def test_typecast_float2(self):\n self.check_typecast(100000.0)\n\n # Skip float16 because of NumPy #19514\n @testing.for_all_dtypes(name='x_type', no_float16=True)\n @testing.numpy_cupy_allclose()\n def check_array_boolarray_op(self, op, xp, x_type):\n a = xp.array([[2, 7, 1], [8, 2, 8]], x_type)\n # Cast from np.bool8 array should not read bytes\n b = xp.array([[3, 1, 4], [-1, -5, -9]], numpy.int8).view(bool)\n return op(a, b)\n\n def test_add_array_boolarray(self):\n self.check_array_boolarray_op(operator.add)\n\n def test_iadd_array_boolarray(self):\n self.check_array_boolarray_op(operator.iadd)\n\n\nclass TestArrayIntElementwiseOp:\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(accept_error=TypeError)\n def check_array_scalar_op(self, op, xp, x_type, y_type, swap=False):\n a = xp.array([[0, 1, 2], [1, 0, 2]], dtype=x_type)\n if swap:\n return op(y_type(2), a)\n else:\n return op(a, y_type(2))\n\n def test_lshift_scalar(self):\n self.check_array_scalar_op(operator.lshift)\n\n def test_rlshift_scalar(self):\n self.check_array_scalar_op(operator.lshift, swap=True)\n\n def test_rshift_scalar(self):\n self.check_array_scalar_op(operator.rshift)\n\n def test_rrshift_scalar(self):\n self.check_array_scalar_op(operator.rshift, swap=True)\n\n def test_and_scalar(self):\n self.check_array_scalar_op(operator.and_)\n\n def test_rand_scalar(self):\n self.check_array_scalar_op(operator.and_, swap=True)\n\n def test_or_scalar(self):\n self.check_array_scalar_op(operator.or_)\n\n def test_ror_scalar(self):\n self.check_array_scalar_op(operator.or_, swap=True)\n\n def test_xor_scalar(self):\n self.check_array_scalar_op(operator.xor)\n\n def test_rxor_scalar(self):\n self.check_array_scalar_op(operator.xor, swap=True)\n\n def test_mod_scalar(self):\n with numpy.errstate(divide='ignore', invalid='ignore'):\n self.check_array_scalar_op(operator.mod)\n\n def test_rmod_scalar(self):\n with numpy.errstate(divide='ignore', invalid='ignore'):\n self.check_array_scalar_op(operator.mod, swap=True)\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(accept_error=TypeError)\n def check_array_scalarzero_op(self, op, xp, x_type, y_type, swap=False):\n a = xp.array([[0, 1, 2], [1, 0, 2]], dtype=x_type)\n if swap:\n return op(y_type(0), a)\n else:\n return op(a, y_type(0))\n\n def test_lshift_scalarzero(self):\n self.check_array_scalarzero_op(operator.lshift)\n\n def test_rlshift_scalarzero(self):\n self.check_array_scalarzero_op(operator.lshift, swap=True)\n\n def test_rshift_scalarzero(self):\n self.check_array_scalarzero_op(operator.rshift)\n\n def test_rrshift_scalarzero(self):\n self.check_array_scalarzero_op(operator.rshift, swap=True)\n\n def test_and_scalarzero(self):\n self.check_array_scalarzero_op(operator.and_)\n\n def test_rand_scalarzero(self):\n self.check_array_scalarzero_op(operator.and_, swap=True)\n\n def test_or_scalarzero(self):\n self.check_array_scalarzero_op(operator.or_)\n\n def test_ror_scalarzero(self):\n self.check_array_scalarzero_op(operator.or_, swap=True)\n\n def test_xor_scalarzero(self):\n self.check_array_scalarzero_op(operator.xor)\n\n def test_rxor_scalarzero(self):\n self.check_array_scalarzero_op(operator.xor, swap=True)\n\n def test_mod_scalarzero(self):\n with numpy.errstate(divide='ignore', invalid='ignore'):\n self.check_array_scalarzero_op(operator.mod)\n\n def test_rmod_scalarzero(self):\n with numpy.errstate(divide='ignore', invalid='ignore'):\n self.check_array_scalarzero_op(operator.mod, swap=True)\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(accept_error=TypeError)\n def check_array_array_op(self, op, xp, x_type, y_type):\n a = xp.array([[0, 1, 2], [1, 0, 2]], dtype=x_type)\n b = xp.array([[0, 0, 1], [0, 1, 2]], dtype=y_type)\n return op(a, b)\n\n def test_lshift_array(self):\n self.check_array_array_op(operator.lshift)\n\n def test_ilshift_array(self):\n self.check_array_array_op(operator.ilshift)\n\n def test_rshift_array(self):\n self.check_array_array_op(operator.rshift)\n\n def test_irshift_array(self):\n self.check_array_array_op(operator.irshift)\n\n def test_and_array(self):\n self.check_array_array_op(operator.and_)\n\n def test_iand_array(self):\n self.check_array_array_op(operator.iand)\n\n def test_or_array(self):\n self.check_array_array_op(operator.or_)\n\n def test_ior_array(self):\n self.check_array_array_op(operator.ior)\n\n def test_xor_array(self):\n self.check_array_array_op(operator.xor)\n\n def test_ixor_array(self):\n self.check_array_array_op(operator.ixor)\n\n def test_mod_array(self):\n with numpy.errstate(divide='ignore', invalid='ignore'):\n self.check_array_array_op(operator.mod)\n\n def test_imod_array(self):\n with numpy.errstate(divide='ignore', invalid='ignore'):\n self.check_array_array_op(operator.imod)\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(accept_error=TypeError)\n def check_array_broadcasted_op(self, op, xp, x_type, y_type):\n a = xp.array([[0, 1, 2], [1, 0, 2], [2, 1, 0]], dtype=x_type)\n b = xp.array([[0, 0, 1]], dtype=y_type)\n return op(a, b)\n\n def test_broadcasted_lshift(self):\n self.check_array_broadcasted_op(operator.lshift)\n\n def test_broadcasted_ilshift(self):\n self.check_array_broadcasted_op(operator.ilshift)\n\n def test_broadcasted_rshift(self):\n self.check_array_broadcasted_op(operator.rshift)\n\n def test_broadcasted_irshift(self):\n self.check_array_broadcasted_op(operator.irshift)\n\n def test_broadcasted_and(self):\n self.check_array_broadcasted_op(operator.and_)\n\n def test_broadcasted_iand(self):\n self.check_array_broadcasted_op(operator.iand)\n\n def test_broadcasted_or(self):\n self.check_array_broadcasted_op(operator.or_)\n\n def test_broadcasted_ior(self):\n self.check_array_broadcasted_op(operator.ior)\n\n def test_broadcasted_xor(self):\n self.check_array_broadcasted_op(operator.xor)\n\n def test_broadcasted_ixor(self):\n self.check_array_broadcasted_op(operator.ixor)\n\n def test_broadcasted_mod(self):\n with numpy.errstate(divide='ignore', invalid='ignore'):\n self.check_array_broadcasted_op(operator.mod)\n\n def test_broadcasted_imod(self):\n with numpy.errstate(divide='ignore', invalid='ignore'):\n self.check_array_broadcasted_op(operator.imod)\n\n @testing.for_all_dtypes_combination(names=['x_type', 'y_type'])\n @testing.numpy_cupy_allclose(accept_error=TypeError)\n def check_array_doubly_broadcasted_op(self, op, xp, x_type, y_type):\n a = xp.array([[[0, 1, 2]], [[1, 0, 2]]], dtype=x_type)\n b = xp.array([[0], [0], [1]], dtype=y_type)\n return op(a, b)\n\n def test_doubly_broadcasted_lshift(self):\n self.check_array_doubly_broadcasted_op(operator.lshift)\n\n def test_doubly_broadcasted_rshift(self):\n self.check_array_doubly_broadcasted_op(operator.rshift)\n\n def test_doubly_broadcasted_and(self):\n self.check_array_doubly_broadcasted_op(operator.and_)\n\n def test_doubly_broadcasted_or(self):\n self.check_array_doubly_broadcasted_op(operator.or_)\n\n def test_doubly_broadcasted_xor(self):\n self.check_array_doubly_broadcasted_op(operator.xor)\n\n def test_doubly_broadcasted_mod(self):\n with numpy.errstate(divide='ignore', invalid='ignore'):\n self.check_array_doubly_broadcasted_op(operator.mod)\n\n\[email protected]('value', [\n None,\n Ellipsis,\n object(),\n numpy._NoValue,\n])\nclass TestArrayObjectComparison:\n\n @pytest.mark.parametrize('swap', [False, True])\n @testing.for_all_dtypes()\n @testing.numpy_cupy_array_equal()\n def test_eq_object(self, xp, dtype, value, swap):\n a = xp.array([[1, 2, 3], [4, 5, 6]], dtype=dtype)\n if swap:\n return value == a\n else:\n return a == value\n\n @pytest.mark.parametrize('swap', [False, True])\n @testing.for_all_dtypes()\n @testing.numpy_cupy_array_equal()\n def test_ne_object(self, xp, dtype, value, swap):\n a = xp.array([[1, 2, 3], [4, 5, 6]], dtype=dtype)\n if swap:\n return value != a\n else:\n return a != value\n\n\nclass HasEq:\n def __eq__(self, other):\n return (other == 2) | (other == 4)\n\n\nclass HasNe:\n def __ne__(self, other):\n return (other == 2) | (other == 4)\n\n\nclass HasEqSub(HasEq):\n pass\n\n\nclass CustomInt(int):\n pass\n\n\[email protected]('dtype', ['int32', 'float64'])\[email protected]('value', [\n HasEq(),\n HasNe(), # eq test passes because `==` does not fall back to `__ne__`.\n HasEqSub(),\n CustomInt(3),\n])\nclass TestArrayObjectComparisonDifficult:\n\n # OK to raise TypeError.\n # If CuPy returns a result, it should match with NumPy's result.\n\n def test_eq_object(self, dtype, value):\n expected = numpy.array([[1, 2, 3], [4, 5, 6]], dtype=dtype) == value\n\n a = cupy.array([[1, 2, 3], [4, 5, 6]], dtype=dtype)\n try:\n res = a == value\n except TypeError:\n pytest.skip()\n\n cupy.testing.assert_array_equal(res, expected)\n\n def test_ne_object(self, dtype, value):\n expected = numpy.array([[1, 2, 3], [4, 5, 6]], dtype=dtype) != value\n\n a = cupy.array([[1, 2, 3], [4, 5, 6]], dtype=dtype)\n try:\n res = a != value\n except TypeError:\n pytest.skip()\n\n cupy.testing.assert_array_equal(res, expected)\n",
"import string\nimport warnings\n\nimport numpy\ntry:\n import scipy.sparse\n scipy_available = True\nexcept ImportError:\n scipy_available = False\n\nimport cupy\nimport cupyx\n\nfrom cupy import _core\nfrom cupy._core import _scalar\nfrom cupy._creation import basic\nfrom cupy import cusparse\nfrom cupyx.scipy.sparse import _base\nfrom cupyx.scipy.sparse import _coo\nfrom cupyx.scipy.sparse import _data as sparse_data\nfrom cupyx.scipy.sparse import _sputils\nfrom cupyx.scipy.sparse import _util\n\nfrom cupyx.scipy.sparse import _index\n\n\nclass _compressed_sparse_matrix(sparse_data._data_matrix,\n sparse_data._minmax_mixin,\n _index.IndexMixin):\n\n _max_min_reduction_code = r'''\n extern \"C\" __global__\n void ${func}(double* data, int* x, int* y, int length,\n double* z) {\n // Get the index of the block\n int tid = blockIdx.x * blockDim.x + threadIdx.x;\n\n // Calculate the block length\n int block_length = y[tid] - x[tid];\n\n // Select initial value based on the block density\n double running_value = 0;\n if (${cond}){\n running_value = data[x[tid]];\n } else {\n running_value = 0;\n }\n\n // Iterate over the block and update\n for (int entry = x[tid]; entry < y[tid]; entry++){\n if (data[entry] != data[entry]){\n // Check for NaN\n running_value = nan(\"\");\n break;\n } else {\n // Check for a value update\n if (data[entry] ${op} running_value){\n running_value = data[entry];\n }\n }\n }\n\n // Store in the return function\n z[tid] = running_value;\n }'''\n\n _max_reduction_kern = _core.RawKernel(\n string.Template(_max_min_reduction_code).substitute(\n func='max_reduction', op='>', cond='block_length == length'),\n 'max_reduction')\n\n _max_nonzero_reduction_kern = _core.RawKernel(\n string.Template(_max_min_reduction_code).substitute(\n func='max_nonzero_reduction', op='>', cond='block_length > 0'),\n 'max_nonzero_reduction')\n\n _min_reduction_kern = _core.RawKernel(\n string.Template(_max_min_reduction_code).substitute(\n func='min_reduction', op='<', cond='block_length == length'),\n 'min_reduction')\n\n _min_nonzero_reduction_kern = _core.RawKernel(\n string.Template(_max_min_reduction_code).substitute(\n func='min_nonzero_reduction', op='<', cond='block_length > 0'),\n 'min_nonzero_reduction')\n\n # For _max_arg_reduction_mod and _min_arg_reduction_mod below, we pick\n # the right template specialization according to input dtypes at runtime.\n # The distinction in int types (T2) is important for portability in OS.\n\n _argmax_argmin_code = r'''\n template<typename T1, typename T2> __global__ void\n ${func}_arg_reduction(T1* data, int* indices, int* x, int* y,\n int length, T2* z) {\n // Get the index of the block\n int tid = blockIdx.x * blockDim.x + threadIdx.x;\n\n // Calculate the block length\n int block_length = y[tid] - x[tid];\n\n // Select initial value based on the block density\n int data_index = 0;\n double data_value = 0;\n\n if (block_length == length){\n // Block is dense. Fill the first value\n data_value = data[x[tid]];\n data_index = indices[x[tid]];\n } else if (block_length > 0) {\n // Block has at least one zero. Assign first occurrence as the\n // starting reference\n data_value = 0;\n for (data_index = 0; data_index < length; data_index++){\n if (data_index != indices[x[tid] + data_index] ||\n x[tid] + data_index >= y[tid]){\n break;\n }\n }\n } else {\n // Zero valued array\n data_value = 0;\n data_index = 0;\n }\n\n // Iterate over the section of the sparse matrix\n for (int entry = x[tid]; entry < y[tid]; entry++){\n if (data[entry] != data[entry]){\n // Check for NaN\n data_value = nan(\"\");\n data_index = 0;\n break;\n } else {\n // Check for a value update\n if (data[entry] ${op} data_value){\n data_index = indices[entry];\n data_value = data[entry];\n }\n }\n }\n\n // Store in the return function\n z[tid] = data_index;\n }'''\n\n _max_arg_reduction_mod = _core.RawModule(\n code=string.Template(_argmax_argmin_code).substitute(\n func='max', op='>'),\n options=('-std=c++11',),\n name_expressions=['max_arg_reduction<float, int>',\n 'max_arg_reduction<float, long long>',\n 'max_arg_reduction<double, int>',\n 'max_arg_reduction<double, long long>'])\n\n _min_arg_reduction_mod = _core.RawModule(\n code=string.Template(_argmax_argmin_code).substitute(\n func='min', op='<'),\n options=('-std=c++11',),\n name_expressions=['min_arg_reduction<float, int>',\n 'min_arg_reduction<float, long long>',\n 'min_arg_reduction<double, int>',\n 'min_arg_reduction<double, long long>'])\n\n # TODO(leofang): rewrite a more load-balanced approach than this naive one?\n _has_sorted_indices_kern = _core.ElementwiseKernel(\n 'raw T indptr, raw T indices',\n 'bool diff',\n '''\n bool diff_out = true;\n for (T jj = indptr[i]; jj < indptr[i+1] - 1; jj++) {\n if (indices[jj] > indices[jj+1]){\n diff_out = false;\n }\n }\n diff = diff_out;\n ''', 'cupyx_scipy_sparse_has_sorted_indices')\n\n # TODO(leofang): rewrite a more load-balanced approach than this naive one?\n _has_canonical_format_kern = _core.ElementwiseKernel(\n 'raw T indptr, raw T indices',\n 'bool diff',\n '''\n bool diff_out = true;\n if (indptr[i] > indptr[i+1]) {\n diff = false;\n return;\n }\n for (T jj = indptr[i]; jj < indptr[i+1] - 1; jj++) {\n if (indices[jj] >= indices[jj+1]) {\n diff_out = false;\n }\n }\n diff = diff_out;\n ''', 'cupyx_scipy_sparse_has_canonical_format')\n\n def __init__(self, arg1, shape=None, dtype=None, copy=False):\n if shape is not None:\n if not _util.isshape(shape):\n raise ValueError('invalid shape (must be a 2-tuple of int)')\n shape = int(shape[0]), int(shape[1])\n\n if _base.issparse(arg1):\n x = arg1.asformat(self.format)\n data = x.data\n indices = x.indices\n indptr = x.indptr\n\n if arg1.format != self.format:\n # When formats are differnent, all arrays are already copied\n copy = False\n\n if shape is None:\n shape = arg1.shape\n\n elif _util.isshape(arg1):\n m, n = arg1\n m, n = int(m), int(n)\n data = basic.zeros(0, dtype if dtype else 'd')\n indices = basic.zeros(0, 'i')\n indptr = basic.zeros(self._swap(m, n)[0] + 1, dtype='i')\n # shape and copy argument is ignored\n shape = (m, n)\n copy = False\n\n elif scipy_available and scipy.sparse.issparse(arg1):\n # Convert scipy.sparse to cupyx.scipy.sparse\n x = arg1.asformat(self.format)\n data = cupy.array(x.data)\n indices = cupy.array(x.indices, dtype='i')\n indptr = cupy.array(x.indptr, dtype='i')\n copy = False\n\n if shape is None:\n shape = arg1.shape\n\n elif isinstance(arg1, tuple) and len(arg1) == 2:\n # Note: This implementation is not efficeint, as it first\n # constructs a sparse matrix with coo format, then converts it to\n # compressed format.\n sp_coo = _coo.coo_matrix(arg1, shape=shape, dtype=dtype, copy=copy)\n sp_compressed = sp_coo.asformat(self.format)\n data = sp_compressed.data\n indices = sp_compressed.indices\n indptr = sp_compressed.indptr\n\n elif isinstance(arg1, tuple) and len(arg1) == 3:\n data, indices, indptr = arg1\n if not (_base.isdense(data) and data.ndim == 1 and\n _base.isdense(indices) and indices.ndim == 1 and\n _base.isdense(indptr) and indptr.ndim == 1):\n raise ValueError(\n 'data, indices, and indptr should be 1-D')\n\n if len(data) != len(indices):\n raise ValueError('indices and data should have the same size')\n\n elif _base.isdense(arg1):\n if arg1.ndim > 2:\n raise TypeError('expected dimension <= 2 array or matrix')\n elif arg1.ndim == 1:\n arg1 = arg1[None]\n elif arg1.ndim == 0:\n arg1 = arg1[None, None]\n data, indices, indptr = self._convert_dense(arg1)\n copy = False\n if shape is None:\n shape = arg1.shape\n\n else:\n raise ValueError(\n 'Unsupported initializer format')\n\n if dtype is None:\n dtype = data.dtype\n else:\n dtype = numpy.dtype(dtype)\n\n if dtype.char not in '?fdFD':\n raise ValueError(\n 'Only bool, float32, float64, complex64 and complex128 '\n 'are supported')\n\n data = data.astype(dtype, copy=copy)\n sparse_data._data_matrix.__init__(self, data)\n\n self.indices = indices.astype('i', copy=copy)\n self.indptr = indptr.astype('i', copy=copy)\n\n if shape is None:\n shape = self._swap(len(indptr) - 1, int(indices.max()) + 1)\n\n major, minor = self._swap(*shape)\n if len(indptr) != major + 1:\n raise ValueError('index pointer size (%d) should be (%d)'\n % (len(indptr), major + 1))\n\n self._descr = cusparse.MatDescriptor.create()\n self._shape = shape\n\n def _with_data(self, data, copy=True):\n if copy:\n return self.__class__(\n (data, self.indices.copy(), self.indptr.copy()),\n shape=self.shape,\n dtype=data.dtype)\n else:\n return self.__class__(\n (data, self.indices, self.indptr),\n shape=self.shape,\n dtype=data.dtype)\n\n def _convert_dense(self, x):\n raise NotImplementedError\n\n def _swap(self, x, y):\n raise NotImplementedError\n\n def _add_sparse(self, other, alpha, beta):\n raise NotImplementedError\n\n def _add(self, other, lhs_negative, rhs_negative):\n if cupy.isscalar(other):\n if other == 0:\n if lhs_negative:\n return -self\n else:\n return self.copy()\n else:\n raise NotImplementedError(\n 'adding a nonzero scalar to a sparse matrix is not '\n 'supported')\n elif _base.isspmatrix(other):\n alpha = -1 if lhs_negative else 1\n beta = -1 if rhs_negative else 1\n return self._add_sparse(other, alpha, beta)\n elif _base.isdense(other):\n if lhs_negative:\n if rhs_negative:\n return -self.todense() - other\n else:\n return other - self.todense()\n else:\n if rhs_negative:\n return self.todense() - other\n else:\n return self.todense() + other\n else:\n return NotImplemented\n\n def __add__(self, other):\n return self._add(other, False, False)\n\n def __radd__(self, other):\n return self._add(other, False, False)\n\n def __sub__(self, other):\n return self._add(other, False, True)\n\n def __rsub__(self, other):\n return self._add(other, True, False)\n\n def _get_intXint(self, row, col):\n major, minor = self._swap(row, col)\n data, indices, _ = _index._get_csr_submatrix_major_axis(\n self.data, self.indices, self.indptr, major, major + 1)\n dtype = data.dtype\n res = cupy.zeros((), dtype=dtype)\n if dtype.kind == 'c':\n _index._compress_getitem_complex_kern(\n data.real, data.imag, indices, minor, res.real, res.imag)\n else:\n _index._compress_getitem_kern(data, indices, minor, res)\n return res\n\n def _get_sliceXslice(self, row, col):\n major, minor = self._swap(row, col)\n copy = major.step in (1, None)\n return self._major_slice(major)._minor_slice(minor, copy=copy)\n\n def _get_arrayXarray(self, row, col, not_found_val=0):\n # inner indexing\n idx_dtype = self.indices.dtype\n M, N = self._swap(*self.shape)\n major, minor = self._swap(row, col)\n major = major.astype(idx_dtype, copy=False)\n minor = minor.astype(idx_dtype, copy=False)\n\n val = _index._csr_sample_values(\n M, N, self.indptr, self.indices, self.data,\n major.ravel(), minor.ravel(),\n not_found_val)\n\n if major.ndim == 1:\n # Scipy returns `matrix` here\n return cupy.expand_dims(val, 0)\n return self.__class__(val.reshape(major.shape))\n\n def _get_columnXarray(self, row, col):\n # outer indexing\n major, minor = self._swap(row, col)\n return self._major_index_fancy(major)._minor_index_fancy(minor)\n\n def _major_index_fancy(self, idx):\n \"\"\"Index along the major axis where idx is an array of ints.\n \"\"\"\n _, N = self._swap(*self.shape)\n M = idx.size\n new_shape = self._swap(M, N)\n if self.nnz == 0 or M == 0:\n return self.__class__(new_shape)\n\n return self.__class__(\n _index._csr_row_index(self.data, self.indices, self.indptr, idx),\n shape=new_shape, copy=False)\n\n def _minor_index_fancy(self, idx):\n \"\"\"Index along the minor axis where idx is an array of ints.\n \"\"\"\n M, _ = self._swap(*self.shape)\n N = idx.size\n new_shape = self._swap(M, N)\n if self.nnz == 0 or N == 0:\n return self.__class__(new_shape)\n\n if idx.size * M < self.nnz:\n # TODO (asi1024): Implement faster algorithm.\n pass\n\n return self._tocsx()._major_index_fancy(idx)._tocsx()\n\n def _major_slice(self, idx, copy=False):\n \"\"\"Index along the major axis where idx is a slice object.\n \"\"\"\n M, N = self._swap(*self.shape)\n start, stop, step = idx.indices(M)\n\n if start == 0 and stop == M and step == 1:\n return self.copy() if copy else self\n\n M = len(range(start, stop, step))\n new_shape = self._swap(M, N)\n\n if step == 1:\n if M == 0 or self.nnz == 0:\n return self.__class__(new_shape, dtype=self.dtype)\n return self.__class__(\n _index._get_csr_submatrix_major_axis(\n self.data, self.indices, self.indptr, start, stop),\n shape=new_shape, copy=copy)\n rows = cupy.arange(start, stop, step, dtype=self.indptr.dtype)\n return self._major_index_fancy(rows)\n\n def _minor_slice(self, idx, copy=False):\n \"\"\"Index along the minor axis where idx is a slice object.\n \"\"\"\n M, N = self._swap(*self.shape)\n start, stop, step = idx.indices(N)\n\n if start == 0 and stop == N and step == 1:\n return self.copy() if copy else self\n\n N = len(range(start, stop, step))\n new_shape = self._swap(M, N)\n\n if N == 0 or self.nnz == 0:\n return self.__class__(new_shape)\n if step == 1:\n return self.__class__(\n _index._get_csr_submatrix_minor_axis(\n self.data, self.indices, self.indptr, start, stop),\n shape=new_shape, copy=False)\n cols = cupy.arange(start, stop, step, dtype=self.indices.dtype)\n return self._minor_index_fancy(cols)\n\n def _set_intXint(self, row, col, x):\n i, j = self._swap(row, col)\n self._set_many(i, j, x)\n\n def _set_arrayXarray(self, row, col, x):\n i, j = self._swap(row, col)\n self._set_many(i, j, x)\n\n def _set_arrayXarray_sparse(self, row, col, x):\n # clear entries that will be overwritten\n self._zero_many(*self._swap(row, col))\n\n M, N = row.shape # matches col.shape\n broadcast_row = M != 1 and x.shape[0] == 1\n broadcast_col = N != 1 and x.shape[1] == 1\n r, c = x.row, x.col\n x = cupy.asarray(x.data, dtype=self.dtype)\n if broadcast_row:\n r = cupy.repeat(cupy.arange(M), r.size)\n c = cupy.tile(c, M)\n x = cupy.tile(x, M)\n if broadcast_col:\n r = cupy.repeat(r, N)\n c = cupy.tile(cupy.arange(N), c.size)\n x = cupy.repeat(x, N)\n # only assign entries in the new sparsity structure\n i, j = self._swap(row[r, c], col[r, c])\n self._set_many(i, j, x)\n\n def _prepare_indices(self, i, j):\n M, N = self._swap(*self.shape)\n\n def check_bounds(indices, bound):\n idx = indices.max()\n if idx >= bound:\n raise IndexError('index (%d) out of range (>= %d)' %\n (idx, bound))\n idx = indices.min()\n if idx < -bound:\n raise IndexError('index (%d) out of range (< -%d)' %\n (idx, bound))\n\n i = cupy.array(i, dtype=self.indptr.dtype,\n copy=True, ndmin=1).ravel()\n j = cupy.array(j, dtype=self.indices.dtype,\n copy=True, ndmin=1).ravel()\n check_bounds(i, M)\n check_bounds(j, N)\n return i, j, M, N\n\n def _set_many(self, i, j, x):\n \"\"\"Sets value at each (i, j) to x\n Here (i,j) index major and minor respectively, and must not contain\n duplicate entries.\n \"\"\"\n i, j, M, N = self._prepare_indices(i, j)\n x = cupy.array(x, dtype=self.dtype, copy=True, ndmin=1).ravel()\n\n new_sp = cupyx.scipy.sparse.csr_matrix(\n (cupy.arange(self.nnz, dtype=cupy.float32),\n self.indices, self.indptr), shape=(M, N))\n\n offsets = new_sp._get_arrayXarray(\n i, j, not_found_val=-1).astype(cupy.int32).ravel()\n\n if -1 not in offsets:\n # only affects existing non-zero cells\n self.data[offsets] = x\n return\n\n else:\n warnings.warn('Changing the sparsity structure of a '\n '{}_matrix is expensive.'\n ' lil_matrix is more efficient.'.format(self.format))\n # replace where possible\n mask = offsets > -1\n self.data[offsets[mask]] = x[mask]\n # only insertions remain\n mask = ~mask\n i = i[mask]\n i[i < 0] += M\n j = j[mask]\n j[j < 0] += N\n self._insert_many(i, j, x[mask])\n\n def _zero_many(self, i, j):\n \"\"\"Sets value at each (i, j) to zero, preserving sparsity structure.\n Here (i,j) index major and minor respectively.\n \"\"\"\n i, j, M, N = self._prepare_indices(i, j)\n\n new_sp = cupyx.scipy.sparse.csr_matrix(\n (cupy.arange(self.nnz, dtype=cupy.float32),\n self.indices, self.indptr), shape=(M, N))\n\n offsets = new_sp._get_arrayXarray(\n i, j, not_found_val=-1).astype(cupy.int32).ravel()\n\n # only assign zeros to the existing sparsity structure\n self.data[offsets[offsets > -1]] = 0\n\n def _perform_insert(self, indices_inserts, data_inserts,\n rows, row_counts, idx_dtype):\n \"\"\"Insert new elements into current sparse matrix in sorted order\"\"\"\n indptr_diff = cupy.diff(self.indptr)\n indptr_diff[rows] += row_counts\n\n new_indptr = cupy.empty(self.indptr.shape, dtype=idx_dtype)\n new_indptr[0] = idx_dtype(0)\n new_indptr[1:] = indptr_diff\n\n # Build output arrays\n cupy.cumsum(new_indptr, out=new_indptr)\n out_nnz = int(new_indptr[-1])\n\n new_indices = cupy.empty(out_nnz, dtype=idx_dtype)\n new_data = cupy.empty(out_nnz, dtype=self.data.dtype)\n\n # Build an indexed indptr that contains the offsets for each\n # row but only for in i, j, and x.\n new_indptr_lookup = cupy.zeros(new_indptr.size, dtype=idx_dtype)\n new_indptr_lookup[1:][rows] = row_counts\n cupy.cumsum(new_indptr_lookup, out=new_indptr_lookup)\n\n _index._insert_many_populate_arrays(\n indices_inserts, data_inserts, new_indptr_lookup,\n self.indptr, self.indices, self.data, new_indptr, new_indices,\n new_data, size=self.indptr.size-1)\n\n self.indptr = new_indptr\n self.indices = new_indices\n self.data = new_data\n\n def _insert_many(self, i, j, x):\n \"\"\"Inserts new nonzero at each (i, j) with value x\n Here (i,j) index major and minor respectively.\n i, j and x must be non-empty, 1d arrays.\n Inserts each major group (e.g. all entries per row) at a time.\n Maintains has_sorted_indices property.\n Modifies i, j, x in place.\n \"\"\"\n\n order = cupy.argsort(i) # stable for duplicates\n i = i.take(order)\n j = j.take(order)\n x = x.take(order)\n\n # Update index data type\n\n idx_dtype = _sputils.get_index_dtype(\n (self.indices, self.indptr), maxval=(\n self.nnz + x.size))\n\n self.indptr = self.indptr.astype(idx_dtype)\n self.indices = self.indices.astype(idx_dtype)\n self.data = self.data.astype(self.dtype)\n\n indptr_inserts, indices_inserts, data_inserts = \\\n _index._select_last_indices(i, j, x, idx_dtype)\n\n rows, ui_indptr = cupy.unique(indptr_inserts, return_index=True)\n\n to_add = cupy.empty(ui_indptr.size+1, ui_indptr.dtype)\n to_add[-1] = j.size\n to_add[:-1] = ui_indptr\n ui_indptr = to_add\n\n # Compute the counts for each row in the insertion array\n row_counts = cupy.zeros(ui_indptr.size-1, dtype=idx_dtype)\n cupyx.scatter_add(\n row_counts, cupy.searchsorted(rows, indptr_inserts), 1)\n\n self._perform_insert(indices_inserts, data_inserts,\n rows, row_counts, idx_dtype)\n\n def __get_has_canonical_format(self):\n \"\"\"Determine whether the matrix has sorted indices and no duplicates.\n\n Returns\n bool: ``True`` if the above applies, otherwise ``False``.\n\n .. note::\n :attr:`has_canonical_format` implies :attr:`has_sorted_indices`, so\n if the latter flag is ``False``, so will the former be; if the\n former is found ``True``, the latter flag is also set.\n\n .. warning::\n Getting this property might synchronize the device.\n\n \"\"\"\n # Modified from the SciPy counterpart.\n\n # In CuPy the implemented conversions do not exactly match those of\n # SciPy's, so it's hard to put this exactly as where it is in SciPy,\n # but this should do the job.\n if self.data.size == 0:\n self._has_canonical_format = True\n # check to see if result was cached\n elif not getattr(self, '_has_sorted_indices', True):\n # not sorted => not canonical\n self._has_canonical_format = False\n elif not hasattr(self, '_has_canonical_format'):\n is_canonical = self._has_canonical_format_kern(\n self.indptr, self.indices, size=self.indptr.size-1)\n self._has_canonical_format = bool(is_canonical.all())\n return self._has_canonical_format\n\n def __set_has_canonical_format(self, val):\n \"\"\"Taken from SciPy as is.\"\"\"\n self._has_canonical_format = bool(val)\n if val:\n self.has_sorted_indices = True\n\n has_canonical_format = property(fget=__get_has_canonical_format,\n fset=__set_has_canonical_format)\n\n def __get_sorted(self):\n \"\"\"Determine whether the matrix has sorted indices.\n\n Returns\n bool:\n ``True`` if the indices of the matrix are in sorted order,\n otherwise ``False``.\n\n .. warning::\n Getting this property might synchronize the device.\n\n \"\"\"\n # Modified from the SciPy counterpart.\n\n # In CuPy the implemented conversions do not exactly match those of\n # SciPy's, so it's hard to put this exactly as where it is in SciPy,\n # but this should do the job.\n if self.data.size == 0:\n self._has_sorted_indices = True\n # check to see if result was cached\n elif not hasattr(self, '_has_sorted_indices'):\n is_sorted = self._has_sorted_indices_kern(\n self.indptr, self.indices, size=self.indptr.size-1)\n self._has_sorted_indices = bool(is_sorted.all())\n return self._has_sorted_indices\n\n def __set_sorted(self, val):\n self._has_sorted_indices = bool(val)\n\n has_sorted_indices = property(fget=__get_sorted, fset=__set_sorted)\n\n def get_shape(self):\n \"\"\"Returns the shape of the matrix.\n\n Returns:\n tuple: Shape of the matrix.\n\n \"\"\"\n return self._shape\n\n def getnnz(self, axis=None):\n \"\"\"Returns the number of stored values, including explicit zeros.\n\n Args:\n axis: Not supported yet.\n\n Returns:\n int: The number of stored values.\n\n \"\"\"\n if axis is None:\n return self.data.size\n else:\n raise ValueError\n\n def sorted_indices(self):\n \"\"\"Return a copy of this matrix with sorted indices\n\n .. warning::\n Calling this function might synchronize the device.\n \"\"\"\n # Taken from SciPy as is.\n A = self.copy()\n A.sort_indices()\n return A\n\n def sort_indices(self):\n # Unlike in SciPy, here this is implemented in child classes because\n # each child needs to call its own sort function from cuSPARSE\n raise NotImplementedError\n\n def sum_duplicates(self):\n \"\"\"Eliminate duplicate matrix entries by adding them together.\n\n .. note::\n This is an *in place* operation.\n\n .. warning::\n Calling this function might synchronize the device.\n\n .. seealso::\n :meth:`scipy.sparse.csr_matrix.sum_duplicates`,\n :meth:`scipy.sparse.csc_matrix.sum_duplicates`\n \"\"\"\n if self.has_canonical_format:\n return\n # TODO(leofang): add a kernel for compressed sparse matrices without\n # converting to coo\n coo = self.tocoo()\n coo.sum_duplicates()\n self.__init__(coo.asformat(self.format))\n self.has_canonical_format = True\n\n #####################\n # Reduce operations #\n #####################\n\n def _minor_reduce(self, ufunc, axis, nonzero):\n \"\"\"Reduce nonzeros with a ufunc over the minor axis when non-empty\n\n Can be applied to a function of self.data by supplying data parameter.\n Warning: this does not call sum_duplicates()\n\n Args:\n ufunc (object): Function handle giving the operation to be\n conducted.\n axis (int): Matrix over which the reduction should be\n conducted.\n\n Returns:\n (cupy.ndarray): Reduce result for nonzeros in each\n major_index.\n\n \"\"\"\n out_shape = self.shape[1 - axis]\n # Call to the appropriate kernel function\n out = cupy.zeros(out_shape).astype(cupy.float64)\n if nonzero:\n kerns = {cupy.amax: self._max_nonzero_reduction_kern,\n cupy.amin: self._min_nonzero_reduction_kern}\n else:\n kerns = {cupy.amax: self._max_reduction_kern,\n cupy.amin: self._min_reduction_kern}\n\n kerns[ufunc]((out_shape,), (1,),\n (self.data.astype(cupy.float64),\n self.indptr[:len(self.indptr) - 1],\n self.indptr[1:], cupy.int64(self.shape[axis]),\n out))\n\n return out\n\n def _arg_minor_reduce(self, ufunc, axis):\n \"\"\"Reduce nonzeros with a ufunc over the minor axis when non-empty\n\n Can be applied to a function of self.data by supplying data parameter.\n Warning: this does not call sum_duplicates()\n\n Args:\n ufunc (object): Function handle giving the operation to be\n conducted.\n axis (int): Maxtrix over which the reduction should be conducted\n\n Returns:\n (cupy.ndarray): Reduce result for nonzeros in each\n major_index\n\n \"\"\"\n\n # Call to the appropriate kernel function\n # Create the vector to hold output\n # Note: it's important to set \"int\" here, following what SciPy\n # does, as the outcome dtype is platform dependent\n out_shape = self.shape[1 - axis]\n out = cupy.zeros(out_shape, dtype=int)\n\n # Perform the calculation\n ker_name = '_arg_reduction<{}, {}>'.format(\n _scalar.get_typename(self.data.dtype),\n _scalar.get_typename(out.dtype))\n\n if ufunc == cupy.argmax:\n ker = self._max_arg_reduction_mod.get_function('max' + ker_name)\n elif ufunc == cupy.argmin:\n ker = self._min_arg_reduction_mod.get_function('min' + ker_name)\n\n ker((out_shape,), (1,),\n (self.data, self.indices,\n self.indptr[:len(self.indptr) - 1],\n self.indptr[1:], cupy.int64(self.shape[axis]),\n out))\n\n return out\n",
"import pickle\n\nimport numpy\nimport pytest\ntry:\n import scipy.sparse\n scipy_available = True\nexcept ImportError:\n scipy_available = False\n\nimport cupy\nfrom cupy import testing\nfrom cupy.cuda import driver\nfrom cupy.cuda import runtime\nfrom cupyx.scipy import sparse\n\n\ndef _make(xp, sp, dtype):\n data = xp.array([0, 1, 2, 3], dtype)\n row = xp.array([0, 0, 1, 2], 'i')\n col = xp.array([0, 1, 3, 2], 'i')\n # 0, 1, 0, 0\n # 0, 0, 0, 2\n # 0, 0, 3, 0\n return sp.coo_matrix((data, (row, col)), shape=(3, 4))\n\n\ndef _make_complex(xp, sp, dtype):\n data = xp.array([0, 1, 2, 3], dtype)\n if dtype in [numpy.complex64, numpy.complex128]:\n data = data - 1j\n row = xp.array([0, 0, 1, 2], 'i')\n col = xp.array([0, 1, 3, 2], 'i')\n # 0, 1 - 1j, 0, 0\n # 0, 0, 0, 2 - 1j\n # 0, 0, 3 - 1j, 0\n return sp.coo_matrix((data, (row, col)), shape=(3, 4))\n\n\ndef _make2(xp, sp, dtype):\n data = xp.array([1, 2, 3, 4], dtype)\n row = xp.array([0, 1, 1, 2], 'i')\n col = xp.array([2, 1, 2, 2], 'i')\n # 0, 0, 1, 0\n # 0, 2, 3, 0\n # 0, 0, 4, 0\n return sp.coo_matrix((data, (row, col)), shape=(3, 4))\n\n\ndef _make3(xp, sp, dtype):\n data = xp.array([1, 2, 3, 4, 5], dtype)\n row = xp.array([0, 1, 1, 3, 3], 'i')\n col = xp.array([0, 2, 1, 0, 2], 'i')\n # 1, 0, 0\n # 0, 3, 2\n # 0, 0, 0\n # 4, 0, 5\n return sp.coo_matrix((data, (row, col)), shape=(4, 3))\n\n\ndef _make_unordered(xp, sp, dtype):\n data = xp.array([1, 4, 3, 2], dtype)\n row = xp.array([0, 2, 1, 0], 'i')\n col = xp.array([0, 2, 3, 1], 'i')\n # 1, 2, 0, 0\n # 0, 0, 0, 3\n # 0, 0, 4, 0\n return sp.coo_matrix((data, (row, col)), shape=(3, 4))\n\n\ndef _make_duplicate(xp, sp, dtype):\n data = xp.array([0, 1, 2, 3, 4, 5], dtype)\n row = xp.array([1, 1, 1, 1, 0, 1], 'i')\n col = xp.array([0, 0, 2, 0, 0, 2], 'i')\n # 4, 0, 0, 0\n # 4, 0, 7, 0\n # 0, 0, 0, 0\n return sp.coo_matrix((data, (row, col)), shape=(3, 4))\n\n\ndef _make_empty(xp, sp, dtype):\n data = xp.array([], dtype)\n row = xp.array([], 'i')\n col = xp.array([], 'i')\n return sp.coo_matrix((data, (row, col)), shape=(3, 4))\n\n\ndef _make_square(xp, sp, dtype):\n data = xp.array([0, 1, 2, 3], dtype)\n row = xp.array([0, 0, 1, 2], 'i')\n col = xp.array([0, 2, 0, 2], 'i')\n # 0, 1, 0\n # 2, 0, 0\n # 0, 0, 3\n return sp.coo_matrix((data, (row, col)), shape=(3, 3))\n\n\ndef _make_shape(xp, sp, dtype):\n return sp.coo_matrix((3, 4))\n\n\ndef _make_sum_dup(xp, sp, dtype):\n # 1 0 0\n # 1 1 0\n # 1 1 1\n data = xp.array([1, 1, 1, 1, 1, 1], dtype)\n row = xp.array([0, 1, 1, 2, 2, 2], 'i')\n col = xp.array([0, 0, 1, 0, 1, 2], 'i')\n return sp.coo_matrix((data, (row, col)), shape=(3, 3))\n\n\[email protected](*testing.product({\n 'dtype': [numpy.float32, numpy.float64, numpy.complex64, numpy.complex128],\n}))\nclass TestCooMatrix:\n\n @pytest.fixture(autouse=True)\n def setUp(self):\n self.m = _make(cupy, sparse, self.dtype)\n\n def test_dtype(self):\n assert self.m.dtype == self.dtype\n\n def test_data(self):\n assert self.m.data.dtype == self.dtype\n testing.assert_array_equal(\n self.m.data, cupy.array([0, 1, 2, 3], self.dtype))\n\n def test_row(self):\n assert self.m.row.dtype == numpy.int32\n testing.assert_array_equal(\n self.m.row, cupy.array([0, 0, 1, 2], self.dtype))\n\n def test_col(self):\n assert self.m.col.dtype == numpy.int32\n testing.assert_array_equal(\n self.m.col, cupy.array([0, 1, 3, 2], self.dtype))\n\n def test_init_copy(self):\n n = sparse.coo_matrix(self.m)\n assert n is not self.m\n cupy.testing.assert_array_equal(n.toarray(), self.m.toarray())\n\n def test_init_copy_other_sparse(self):\n n = sparse.coo_matrix(self.m.tocsr())\n cupy.testing.assert_array_equal(n.toarray(), self.m.toarray())\n\n @testing.with_requires('scipy')\n def test_init_copy_scipy_sparse(self):\n m = _make(numpy, scipy.sparse, self.dtype)\n n = sparse.coo_matrix(m)\n assert isinstance(n.data, cupy.ndarray)\n assert isinstance(n.row, cupy.ndarray)\n assert isinstance(n.col, cupy.ndarray)\n cupy.testing.assert_array_equal(n.data, m.data)\n cupy.testing.assert_array_equal(n.row, m.row)\n cupy.testing.assert_array_equal(n.col, m.col)\n assert n.shape == m.shape\n\n @testing.with_requires('scipy')\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_init_copy_other_scipy_sparse(self, xp, sp):\n m = _make(numpy, scipy.sparse, self.dtype)\n n = sp.coo_matrix(m.tocsc())\n assert len(n.data) == len(m.data)\n assert len(n.row) == len(m.row)\n assert len(n.col) == len(m.col)\n assert n.shape == m.shape\n return n\n\n def test_pickle_roundtrip(self):\n s = _make(cupy, sparse, self.dtype)\n s2 = pickle.loads(pickle.dumps(s))\n assert s.shape == s2.shape\n assert s.dtype == s2.dtype\n if scipy_available:\n assert (s.get() != s2.get()).count_nonzero() == 0\n\n def test_shape(self):\n assert self.m.shape == (3, 4)\n\n def test_ndim(self):\n assert self.m.ndim == 2\n\n def test_nnz(self):\n assert self.m.nnz == 4\n\n def test_conj(self):\n n = _make_complex(cupy, sparse, self.dtype)\n cupy.testing.assert_array_equal(n.conj().data, n.data.conj())\n\n def test_has_canonical_format(self):\n assert self.m.has_canonical_format is False\n\n @testing.with_requires('scipy')\n def test_get(self):\n m = self.m.get()\n assert isinstance(m, scipy.sparse.coo_matrix)\n expect = [\n [0, 1, 0, 0],\n [0, 0, 0, 2],\n [0, 0, 3, 0]\n ]\n numpy.testing.assert_allclose(m.toarray(), expect)\n\n @testing.with_requires('scipy')\n def test_str(self):\n if numpy.dtype(self.dtype).kind == 'f':\n expect = ''' (0, 0)\\t0.0\n (0, 1)\\t1.0\n (1, 3)\\t2.0\n (2, 2)\\t3.0'''\n elif numpy.dtype(self.dtype).kind == 'c':\n expect = ''' (0, 0)\\t0j\n (0, 1)\\t(1+0j)\n (1, 3)\\t(2+0j)\n (2, 2)\\t(3+0j)'''\n assert str(self.m) == expect\n\n def test_toarray(self):\n m = self.m.toarray()\n expect = [\n [0, 1, 0, 0],\n [0, 0, 0, 2],\n [0, 0, 3, 0]\n ]\n cupy.testing.assert_allclose(m, expect)\n\n # reshape\n def test_reshape_0(self):\n assert self.m.reshape((12, 1)).shape == (12, 1)\n\n def test_reshape_1(self):\n m = self.m.reshape((1, 12)).toarray()\n expect = [[0, 1, 0, 0, 0, 0, 0, 2, 0, 0, 3, 0]]\n cupy.testing.assert_allclose(m, expect)\n\n def test_reshape_2(self):\n m = self.m.reshape((1, 12), order='F').toarray()\n expect = [[1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0]]\n cupy.testing.assert_allclose(m, expect)\n\n\[email protected](*testing.product({\n 'dtype': [numpy.float32, numpy.float64, numpy.complex64, numpy.complex128],\n}))\[email protected]_requires('scipy')\nclass TestCooMatrixInit:\n\n @pytest.fixture(autouse=True)\n def setUp(self):\n self.shape = (3, 4)\n\n def data(self, xp):\n return xp.array([0, 1, 2, 3], self.dtype)\n\n def row(self, xp):\n return xp.array([0, 0, 1, 2], 'i')\n\n def col(self, xp):\n return xp.array([0, 1, 3, 2], 'i')\n\n @testing.numpy_cupy_equal(sp_name='sp')\n def test_shape_none(self, xp, sp):\n x = sp.coo_matrix(\n (self.data(xp), (self.row(xp), self.col(xp))), shape=None)\n assert x.shape == (3, 4)\n\n @testing.numpy_cupy_equal(sp_name='sp')\n def test_dtype(self, xp, sp):\n data = self.data(xp).real.astype('i')\n x = sp.coo_matrix(\n (data, (self.row(xp), self.col(xp))), dtype=self.dtype)\n assert x.dtype == self.dtype\n\n @testing.numpy_cupy_equal(sp_name='sp')\n def test_copy_true(self, xp, sp):\n data = self.data(xp)\n row = self.row(xp)\n col = self.col(xp)\n x = sp.coo_matrix((data, (row, col)), copy=True)\n\n assert data is not x.data\n assert row is not x.row\n assert col is not x.col\n\n def test_init_dense(self):\n m = cupy.array([[0, 1, 0, 2],\n [0, 0, 0, 0],\n [0, 0, 3, 0]], dtype=self.dtype)\n n = sparse.coo_matrix(m)\n assert n.nnz == 3\n assert n.shape == (3, 4)\n cupy.testing.assert_array_equal(n.data, [1, 2, 3])\n cupy.testing.assert_array_equal(n.row, [0, 0, 2])\n cupy.testing.assert_array_equal(n.col, [1, 3, 2])\n\n def test_init_dense_allzero(self):\n m = cupy.array([[0, 0, 0, 0],\n [0, 0, 0, 0],\n [0, 0, 0, 0]], dtype=self.dtype)\n n = sparse.coo_matrix(m)\n assert n.nnz == 0\n assert n.shape == (3, 4)\n cupy.testing.assert_array_equal(n.data, [])\n cupy.testing.assert_array_equal(n.row, [])\n cupy.testing.assert_array_equal(n.col, [])\n\n def test_init_dense_check_if_row_major(self):\n rows, cols = 10, 9\n for order in ('C', 'F'):\n d = testing.shaped_random((rows, cols), dtype=self.dtype,\n order=order)\n mask = testing.shaped_random((rows, cols), scale=1.0)\n d[mask > 0.5] = 0\n s = sparse.coo_matrix(d)\n for i in range(s.nnz):\n assert 0 <= s.row[i] < rows\n assert 0 <= s.col[i] < cols\n assert s.data[i] == d[s.row[i], s.col[i]]\n if i == 0:\n continue\n assert ((s.row[i-1] < s.row[i]) or\n (s.row[i-1] == s.row[i] and s.col[i-1] < s.col[i]))\n assert s.has_canonical_format\n\n def test_invalid_format(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n with pytest.raises(TypeError):\n sp.coo_matrix(\n (self.data(xp), self.row(xp)), shape=self.shape)\n\n @testing.numpy_cupy_allclose(sp_name='sp', atol=1e-5)\n def test_intlike_shape(self, xp, sp):\n s = sp.coo_matrix((self.data(xp), (self.row(xp), self.col(xp))),\n shape=(xp.array(self.shape[0]),\n xp.int32(self.shape[1])))\n assert isinstance(s.shape[0], int)\n assert isinstance(s.shape[1], int)\n return s\n\n def test_shape_invalid(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n with pytest.raises(ValueError):\n sp.coo_matrix(\n (self.data(xp), (self.row(xp), self.col(xp))),\n shape=(2,))\n\n def test_data_invalid(self):\n with pytest.raises(ValueError):\n sparse.coo_matrix(\n ('invalid', (self.row(cupy), self.col(cupy))),\n shape=self.shape)\n\n def test_data_invalid_ndim(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n with pytest.raises(ValueError):\n sp.coo_matrix(\n (self.data(xp)[None], (self.row(xp), self.col(xp))),\n shape=self.shape)\n\n def test_row_invalid(self):\n with pytest.raises(ValueError):\n sparse.coo_matrix(\n (self.data(cupy), ('invalid', self.col(cupy))),\n shape=self.shape)\n\n def test_row_invalid_ndim(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n with pytest.raises(ValueError):\n sp.coo_matrix(\n (self.data(xp), (self.row(xp)[None], self.col(xp))),\n shape=self.shape)\n\n def test_col_invalid(self):\n with pytest.raises(ValueError):\n sparse.coo_matrix(\n (self.data(cupy), (self.row(cupy), 'invalid')),\n shape=self.shape)\n\n def test_col_invalid_ndim(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n with pytest.raises(ValueError):\n sp.coo_matrix(\n (self.data(xp), (self.row(xp), self.col(xp)[None])),\n shape=self.shape)\n\n def test_data_different_length(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n data = xp.arange(5, dtype=self.dtype)\n with pytest.raises(TypeError):\n sp.coo_matrix(\n (data(xp), (self.row(xp), self.col(xp))),\n shape=self.shape)\n\n def test_row_different_length(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n row = xp.arange(5, dtype=self.dtype)\n with pytest.raises(TypeError):\n sp.coo_matrix(\n (self.data(xp), (row(xp), self.col(xp))),\n shape=self.shape)\n\n def test_col_different_length(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n col = xp.arange(5, dtype=self.dtype)\n with pytest.raises(TypeError):\n sp.coo_matrix(\n (self.data(xp), (self.row(xp), col(xp))),\n shape=self.shape)\n\n def test_fail_to_infer_shape(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n data = xp.array([], dtype=self.dtype)\n row = xp.array([], dtype='i')\n col = xp.array([], dtype='i')\n with pytest.raises(ValueError):\n sp.coo_matrix((data, (row, col)), shape=None)\n\n def test_row_too_large(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n row = xp.array([0, 0, 1, 3], 'i')\n with pytest.raises(ValueError):\n sp.coo_matrix(\n (self.data(xp), (row, self.col(xp))),\n shape=self.shape)\n\n def test_row_too_small(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n row = xp.array([0, -1, 1, 2], 'i')\n with pytest.raises(ValueError):\n sp.coo_matrix(\n (self.data(xp), (row, self.col(xp))),\n shape=self.shape)\n\n def test_col_too_large(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n col = xp.array([0, 1, 4, 2], 'i')\n with pytest.raises(ValueError):\n sp.coo_matrix(\n (self.data(xp), (self.row(xp), col)),\n shape=self.shape)\n\n def test_col_too_small(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n col = xp.array([0, -1, 3, 2], 'i')\n with pytest.raises(ValueError):\n sp.coo_matrix(\n (self.data(xp), (self.row(xp), col)),\n shape=self.shape)\n\n def test_unsupported_dtype(self):\n with pytest.raises(ValueError):\n sparse.coo_matrix(\n (self.data(cupy), (self.row(cupy), self.col(cupy))),\n shape=self.shape, dtype='i')\n\n @testing.numpy_cupy_equal(sp_name='sp')\n def test_conj(self, xp, sp):\n n = _make_complex(xp, sp, self.dtype)\n cupy.testing.assert_array_equal(n.conj().data, n.data.conj())\n\n\[email protected](*testing.product({\n 'make_method': [\n '_make', '_make_unordered', '_make_empty', '_make_duplicate',\n '_make_shape'],\n 'dtype': [numpy.float32, numpy.float64, numpy.complex64, numpy.complex128],\n}))\[email protected]_requires('scipy')\nclass TestCooMatrixScipyComparison:\n\n @property\n def make(self):\n return globals()[self.make_method]\n\n @testing.numpy_cupy_equal(sp_name='sp')\n def test_dtype(self, xp, sp):\n m = self.make(xp, sp, self.dtype)\n return m.dtype\n\n @testing.numpy_cupy_equal(sp_name='sp')\n def test_nnz(self, xp, sp):\n m = self.make(xp, sp, self.dtype)\n return m.getnnz()\n\n @testing.numpy_cupy_array_equal(sp_name='sp')\n def test_asfptype(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n return m.asfptype()\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_toarray(self, xp, sp):\n m = self.make(xp, sp, self.dtype)\n return m.toarray()\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_A(self, xp, sp):\n m = self.make(xp, sp, self.dtype)\n return m.A\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_tocoo(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n return m.tocoo()\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_tocoo_copy(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n n = m.tocoo(copy=True)\n assert m.data is not n.data\n assert m.row is not n.row\n assert m.col is not n.col\n return n\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_tocsc(self, xp, sp):\n m = self.make(xp, sp, self.dtype)\n out = m.tocsc()\n assert out.has_canonical_format\n return out\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_tocsc_copy(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n n = m.tocsc(copy=True)\n assert m.data is not n.data\n assert n.has_canonical_format\n return n\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_tocsr(self, xp, sp):\n m = self.make(xp, sp, self.dtype)\n out = m.tocsr()\n assert out.has_canonical_format\n return out\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_tocsr_copy(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n n = m.tocsr(copy=True)\n assert m.data is not n.data\n assert n.has_canonical_format\n return n\n\n # dot\n @testing.with_requires('scipy>=1.8.0rc1')\n def test_dot_scalar(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n with pytest.raises(ValueError):\n m.dot(2.0)\n\n @testing.with_requires('scipy>=1.8.0rc1')\n def test_dot_numpy_scalar(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n with pytest.raises(ValueError):\n m.dot(numpy.dtype(self.dtype).type(2.0))\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_dot_csr(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = _make3(xp, sp, self.dtype)\n return m.dot(x)\n\n def test_dot_csr_invalid_shape(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n x = sp.csr_matrix((5, 3), dtype=self.dtype)\n with pytest.raises(ValueError):\n m.dot(x)\n\n @pytest.mark.skipif(runtime.is_hip and driver.get_build_version() < 400,\n reason='no working implementation')\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_dot_csc(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = _make3(xp, sp, self.dtype).tocsc()\n return m.dot(x)\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_dot_sparse(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = _make3(xp, sp, self.dtype).tocoo()\n return m.dot(x)\n\n @testing.with_requires('scipy>=1.8.0rc1')\n def test_dot_zero_dim(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n x = xp.array(2, dtype=self.dtype)\n with pytest.raises(ValueError):\n m.dot(x)\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_dot_dense_vector(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = xp.arange(4).astype(self.dtype)\n return m.dot(x)\n\n def test_dot_dense_vector_invalid_shape(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n x = xp.arange(5).astype(self.dtype)\n with pytest.raises(ValueError):\n m.dot(x)\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_dot_dense_matrix(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = xp.arange(8).reshape(4, 2).astype(self.dtype)\n return m.dot(x)\n\n def test_dot_dense_matrix_invalid_shape(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n x = xp.arange(10).reshape(5, 2).astype(self.dtype)\n with pytest.raises(ValueError):\n m.dot(x)\n\n def test_dot_dense_ndim3(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n x = xp.arange(24).reshape(4, 2, 3).astype(self.dtype)\n with pytest.raises(ValueError):\n m.dot(x)\n\n def test_dot_unsupported(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n with pytest.raises(TypeError):\n m.dot(None)\n\n # __add__\n @testing.numpy_cupy_allclose(sp_name='sp', _check_sparse_format=False)\n def test_add_zero(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n return m + 0\n\n def test_add_scalar(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n with pytest.raises(NotImplementedError):\n m + 1\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_add_csr(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n n = _make2(xp, sp, self.dtype)\n return m + n\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_add_coo(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n n = _make2(xp, sp, self.dtype).tocoo()\n return m + n\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_add_dense(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n n = xp.arange(12).reshape(3, 4)\n return m + n\n\n # __radd__\n @testing.numpy_cupy_allclose(sp_name='sp', _check_sparse_format=False)\n def test_radd_zero(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n return 0 + m\n\n def test_radd_scalar(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n with pytest.raises(NotImplementedError):\n 1 + m\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_radd_dense(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n n = xp.arange(12).reshape(3, 4)\n return n + m\n\n # __sub__\n @testing.numpy_cupy_allclose(sp_name='sp', _check_sparse_format=False)\n def test_sub_zero(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n return m - 0\n\n def test_sub_scalar(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n with pytest.raises(NotImplementedError):\n m - 1\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_sub_csr(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n n = _make2(xp, sp, self.dtype)\n return m - n\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_sub_coo(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n n = _make2(xp, sp, self.dtype).tocoo()\n return m - n\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_sub_dense(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n n = xp.arange(12).reshape(3, 4)\n return m - n\n\n # __rsub__\n @testing.numpy_cupy_allclose(sp_name='sp', _check_sparse_format=False)\n def test_rsub_zero(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n return 0 - m\n\n def test_rsub_scalar(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n with pytest.raises(NotImplementedError):\n 1 - m\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_rsub_dense(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n n = xp.arange(12).reshape(3, 4)\n return n - m\n\n # __mul__\n @testing.numpy_cupy_allclose(sp_name='sp', _check_sparse_format=False)\n def test_mul_scalar(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n return m * 2.0\n\n @testing.numpy_cupy_allclose(sp_name='sp', _check_sparse_format=False)\n def test_mul_numpy_scalar(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n return m * numpy.dtype(self.dtype).type(2.0)\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_mul_csr(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = _make3(xp, sp, self.dtype)\n return m * x\n\n def test_mul_csr_invalid_shape(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n x = sp.csr_matrix((5, 3), dtype=self.dtype)\n with pytest.raises(ValueError):\n m * x\n\n @pytest.mark.skipif(runtime.is_hip and driver.get_build_version() < 400,\n reason='no working implementation')\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_mul_csc(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = _make3(xp, sp, self.dtype).tocsc()\n return m * x\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_mul_sparse(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = _make3(xp, sp, self.dtype).tocoo()\n return m * x\n\n @testing.numpy_cupy_allclose(sp_name='sp', _check_sparse_format=False)\n def test_mul_zero_dim(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = xp.array(2, dtype=self.dtype)\n return m * x\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_mul_dense_vector(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = xp.arange(4).astype(self.dtype)\n return m * x\n\n def test_mul_dense_vector_invalid_shape(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n x = xp.arange(5).astype(self.dtype)\n with pytest.raises(ValueError):\n m * x\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_mul_dense_matrix(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = xp.arange(8).reshape(4, 2).astype(self.dtype)\n return m * x\n\n def test_mul_dense_matrix_invalid_shape(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n x = xp.arange(10).reshape(5, 2).astype(self.dtype)\n with pytest.raises(ValueError):\n m * x\n\n def test_mul_dense_ndim3(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n x = xp.arange(24).reshape(4, 2, 3).astype(self.dtype)\n with pytest.raises(ValueError):\n m * x\n\n def test_mul_unsupported(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n with pytest.raises(TypeError):\n m * None\n\n # __rmul__\n @testing.numpy_cupy_allclose(sp_name='sp', _check_sparse_format=False)\n def test_rmul_scalar(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n return 2.0 * m\n\n @testing.numpy_cupy_allclose(sp_name='sp', _check_sparse_format=False)\n def test_rmul_numpy_scalar(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n return numpy.dtype(self.dtype).type(2.0) * m\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_rmul_csr(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = _make3(xp, sp, self.dtype)\n return x * m\n\n @pytest.mark.skipif(runtime.is_hip and driver.get_build_version() < 400,\n reason='no working implementation')\n @testing.numpy_cupy_allclose(sp_name='sp', _check_sparse_format=False)\n def test_rmul_csc(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = _make3(xp, sp, self.dtype).tocsc()\n return x * m\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_rmul_sparse(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = _make3(xp, sp, self.dtype).tocoo()\n return x * m\n\n @testing.numpy_cupy_allclose(sp_name='sp', _check_sparse_format=False)\n def test_rmul_zero_dim(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = xp.array(2, dtype=self.dtype)\n return x * m\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_rmul_dense_matrix(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n x = xp.arange(12).reshape(4, 3).astype(self.dtype)\n return x * m\n\n def test_rmul_dense_ndim3(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n x = xp.arange(24).reshape(4, 2, 3).astype(self.dtype)\n with pytest.raises(ValueError):\n x * m\n\n @pytest.mark.xfail(\n numpy.lib.NumpyVersion(scipy.__version__) >= '1.8.0rc1',\n reason='See scipy/15210')\n def test_rmul_unsupported(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n with pytest.raises(TypeError):\n None * m\n\n # Note: '@' operator is almost equivalent to '*' operator. Only test the\n # cases where '@' raises an exception and '*' does not.\n def test_matmul_scalar(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = self.make(xp, sp, self.dtype)\n x = 2.0\n with pytest.raises(ValueError):\n m @ x\n with pytest.raises(ValueError):\n x @ m\n\n def test_matmul_numpy_scalar(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = self.make(xp, sp, self.dtype)\n x = numpy.dtype(self.dtype).type(2.0)\n with pytest.raises(ValueError):\n m @ x\n with pytest.raises(ValueError):\n x @ m\n\n def test_matmul_scalar_like_array(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = self.make(xp, sp, self.dtype)\n x = xp.array(2.0, self.dtype)\n with pytest.raises(ValueError):\n m @ x\n with pytest.raises(ValueError):\n x @ m\n\n # __pow__\n @testing.numpy_cupy_allclose(sp_name='sp', _check_sparse_format=False)\n def test_pow_0(self, xp, sp):\n m = _make_square(xp, sp, self.dtype)\n return m ** 0\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_pow_1(self, xp, sp):\n m = _make_square(xp, sp, self.dtype)\n return m ** 1\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_pow_2(self, xp, sp):\n m = _make_square(xp, sp, self.dtype)\n return m ** 2\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_pow_3(self, xp, sp):\n m = _make_square(xp, sp, self.dtype)\n return m ** 3\n\n def test_pow_neg(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make_square(xp, sp, self.dtype)\n with pytest.raises(ValueError):\n m ** -1\n\n def test_sum_tuple_axis(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n with pytest.raises(TypeError):\n m.sum(axis=(0, 1))\n\n def test_sum_float_axis(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n with pytest.raises(TypeError):\n m.sum(axis=0.0)\n\n def test_sum_too_large_axis(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n with pytest.raises(ValueError):\n m.sum(axis=3)\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_transpose(self, xp, sp):\n m = self.make(xp, sp, self.dtype)\n return m.transpose()\n\n def test_transpose_axes_int(self):\n for xp, sp in ((numpy, scipy.sparse), (cupy, sparse)):\n m = _make(xp, sp, self.dtype)\n with pytest.raises(ValueError):\n m.transpose(axes=0)\n\n @testing.numpy_cupy_equal(sp_name='sp')\n def test_eliminate_zeros(self, xp, sp):\n m = self.make(xp, sp, self.dtype)\n m.eliminate_zeros()\n return m.nnz\n\n\[email protected](*testing.product({\n 'dtype': [numpy.float32, numpy.float64],\n 'ret_dtype': [None, numpy.float32, numpy.float64],\n 'axis': [None, 0, 1, -1, -2],\n}))\[email protected]_requires('scipy')\nclass TestCooMatrixSum:\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_sum(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n return m.sum(axis=self.axis, dtype=self.ret_dtype)\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_sum_with_out(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n if self.axis is None:\n shape = ()\n else:\n shape = list(m.shape)\n shape[self.axis] = 1\n shape = tuple(shape)\n out = xp.empty(shape, dtype=self.ret_dtype)\n if xp is numpy:\n # TODO(unno): numpy.matrix is used for scipy.sparse though\n # cupy.ndarray is used for cupyx.scipy.sparse.\n out = xp.asmatrix(out)\n return m.sum(axis=self.axis, dtype=self.ret_dtype, out=out)\n\n\[email protected](*testing.product({\n 'dtype': [numpy.float32, numpy.float64, numpy.complex64, numpy.complex128],\n}))\[email protected]_requires('scipy')\nclass TestCooMatrixSumDuplicates:\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_sum_duplicates(self, xp, sp):\n m = _make_duplicate(xp, sp, self.dtype)\n assert not m.has_canonical_format\n m.sum_duplicates()\n assert m.has_canonical_format\n assert m.nnz == 3\n\n m.sum_duplicates()\n assert m.has_canonical_format\n return m\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_sum_duplicates_canonical(self, xp, sp):\n m = _make(xp, sp, self.dtype)\n assert not m.has_canonical_format\n m.sum_duplicates()\n assert m.has_canonical_format\n assert m.nnz == 4\n return m\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_sum_duplicates_empty(self, xp, sp):\n m = _make_empty(xp, sp, self.dtype)\n assert not m.has_canonical_format\n m.sum_duplicates()\n assert m.has_canonical_format\n assert m.nnz == 0\n return m\n\n @testing.numpy_cupy_allclose(sp_name='sp')\n def test_sum_duplicates_incompatibility(self, xp, sp):\n # See #3620 and #3624. CuPy's and SciPy's COO indices could mismatch\n # due to the order of lexsort, but the matrix is correct.\n m = _make_sum_dup(xp, sp, self.dtype)\n if xp is cupy:\n sorted_first = m.row.copy()\n else:\n sorted_first = m.col.copy()\n assert not m.has_canonical_format\n m.sum_duplicates()\n assert m.has_canonical_format\n # Here we ensure this sorting order is not altered by future PRs...\n sorted_first.sort()\n if xp is cupy:\n assert (m.row == sorted_first).all()\n else:\n assert (m.col == sorted_first).all()\n assert m.has_canonical_format\n # ...and now we make sure the dense matrix is the same\n return m\n\n\[email protected](*testing.product({\n 'dtype': [numpy.float32, numpy.float64, numpy.complex64, numpy.complex128],\n 'ufunc': [\n 'arcsin', 'arcsinh', 'arctan', 'arctanh', 'ceil', 'deg2rad', 'expm1',\n 'floor', 'log1p', 'rad2deg', 'rint', 'sign', 'sin', 'sinh', 'sqrt',\n 'tan', 'tanh', 'trunc',\n ],\n}))\[email protected]_requires('scipy')\nclass TestUfunc:\n\n @testing.numpy_cupy_allclose(sp_name='sp', atol=1e-5)\n def test_ufun(self, xp, sp):\n x = _make(xp, sp, self.dtype)\n x.data *= 0.1\n func = getattr(x, self.ufunc)\n complex_unsupported = {'ceil', 'deg2rad', 'floor', 'rad2deg', 'trunc'}\n if (numpy.dtype(self.dtype).kind == 'c' and\n self.ufunc in complex_unsupported):\n with pytest.raises(TypeError):\n func()\n return xp.array(0)\n else:\n return func()\n\n\nclass TestIsspmatrixCoo:\n\n def test_coo(self):\n x = sparse.coo_matrix(\n (cupy.array([0], 'f'),\n (cupy.array([0], 'i'), cupy.array([0], 'i'))),\n shape=(1, 1), dtype='f')\n assert sparse.isspmatrix_coo(x) is True\n\n def test_csr(self):\n x = sparse.csr_matrix(\n (cupy.array([], 'f'),\n cupy.array([], 'i'),\n cupy.array([0], 'i')),\n shape=(0, 0), dtype='f')\n assert sparse.isspmatrix_coo(x) is False\n\n\[email protected](*testing.product({\n 'shape': [(8, 5), (5, 5), (5, 8)],\n}))\[email protected]_requires('scipy>=1.5.0')\[email protected]\nclass TestCooMatrixDiagonal:\n density = 0.5\n\n def _make_matrix(self, dtype):\n a = testing.shaped_random(self.shape, numpy, dtype=dtype)\n mask = testing.shaped_random(self.shape, numpy, dtype='f', scale=1.0)\n a[mask > self.density] = 0\n scipy_a = scipy.sparse.coo_matrix(a)\n cupyx_a = sparse.coo_matrix(cupy.array(a))\n return scipy_a, cupyx_a\n\n @testing.for_dtypes('fdFD')\n def test_diagonal(self, dtype):\n scipy_a, cupyx_a = self._make_matrix(dtype)\n m, n = self.shape\n for k in range(-m, n+1):\n scipy_diag = scipy_a.diagonal(k=k)\n cupyx_diag = cupyx_a.diagonal(k=k)\n testing.assert_allclose(scipy_diag, cupyx_diag)\n\n def _test_setdiag(self, scipy_a, cupyx_a, x, k):\n scipy_a = scipy_a.copy()\n cupyx_a = cupyx_a.copy()\n scipy_a.setdiag(x, k=k)\n cupyx_a.setdiag(cupy.array(x), k=k)\n testing.assert_allclose(scipy_a.data, cupyx_a.data)\n testing.assert_array_equal(scipy_a.row, cupyx_a.row)\n testing.assert_array_equal(scipy_a.col, cupyx_a.col)\n\n @testing.for_dtypes('fdFD')\n def test_setdiag(self, dtype):\n scipy_a, cupyx_a = self._make_matrix(dtype)\n m, n = self.shape\n for k in range(-m+1, n):\n m_st, n_st = max(0, -k), max(0, k)\n for d in (-1, 0, 1):\n x_len = min(m - m_st, n - n_st) + d\n if x_len <= 0:\n continue\n x = numpy.ones((x_len,), dtype=dtype)\n self._test_setdiag(scipy_a, cupyx_a, x, k)\n\n @testing.for_dtypes('fdFD')\n def test_setdiag_scalar(self, dtype):\n scipy_a, cupyx_a = self._make_matrix(dtype)\n x = numpy.array(1.0, dtype=dtype)\n m, n = self.shape\n for k in range(-m+1, n):\n self._test_setdiag(scipy_a, cupyx_a, x, k)\n\n def test_setdiag_invalid(self):\n dtype = 'f'\n scipy_a, cupyx_a = self._make_matrix(dtype)\n x = numpy.array(1.0, dtype=dtype)\n m, n = self.shape\n for k in (-m, n):\n with pytest.raises(ValueError):\n scipy_a.setdiag(x, k=k)\n with pytest.raises(ValueError):\n cupyx_a.setdiag(x, k=k)\n"
]
| [
[
"numpy.array",
"numpy.asarray",
"numpy.add.reduce",
"numpy.where",
"numpy.indices"
],
[
"numpy.lib.NumpyVersion",
"numpy.array",
"numpy.dtype",
"numpy.errstate"
],
[
"numpy.dtype"
],
[
"numpy.lib.NumpyVersion",
"numpy.array",
"numpy.ones",
"numpy.dtype"
]
]
|
bolcom/probability | [
"4a11efad1ecd8a1336e4c9fdb0105efbf2375ad7",
"4a11efad1ecd8a1336e4c9fdb0105efbf2375ad7",
"4a11efad1ecd8a1336e4c9fdb0105efbf2375ad7",
"4a11efad1ecd8a1336e4c9fdb0105efbf2375ad7",
"4a11efad1ecd8a1336e4c9fdb0105efbf2375ad7",
"4a11efad1ecd8a1336e4c9fdb0105efbf2375ad7",
"4a11efad1ecd8a1336e4c9fdb0105efbf2375ad7",
"4a11efad1ecd8a1336e4c9fdb0105efbf2375ad7"
]
| [
"tensorflow_probability/python/mcmc/replica_exchange_mc.py",
"tensorflow_probability/python/optimizer/sgld_test.py",
"tensorflow_probability/python/distributions/dirichlet_test.py",
"tensorflow_probability/python/internal/test_combinations.py",
"tensorflow_probability/python/distributions/mixture_same_family_test.py",
"tensorflow_probability/python/positive_semidefinite_kernels/__init__.py",
"tensorflow_probability/python/experimental/auto_batching/dsl_test.py",
"tensorflow_probability/python/bijectors/categorical_to_discrete.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",
"# 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# ============================================================================\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\n\n# Dependency imports\nimport numpy as np\nfrom scipy import special as sp_special\nfrom scipy import stats as sp_stats\n\nimport tensorflow.compat.v2 as tf\nimport tensorflow_probability as tfp\n\nfrom tensorflow_probability.python.internal import test_case\nfrom tensorflow_probability.python.internal import test_util as tfp_test_util\nfrom tensorflow.python.framework import test_util # pylint: disable=g-direct-tensorflow-import\n\ntfb = tfp.bijectors\ntfd = tfp.distributions\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass DirichletTest(test_case.TestCase):\n\n def testSimpleShapes(self):\n alpha = np.random.rand(3)\n dist = tfd.Dirichlet(alpha)\n self.assertEqual(3, self.evaluate(dist.event_shape_tensor()))\n self.assertAllEqual([], self.evaluate(dist.batch_shape_tensor()))\n self.assertEqual(tf.TensorShape([3]), dist.event_shape)\n self.assertEqual(tf.TensorShape([]), dist.batch_shape)\n\n def testComplexShapes(self):\n alpha = np.random.rand(3, 2, 2)\n dist = tfd.Dirichlet(alpha)\n self.assertEqual(2, self.evaluate(dist.event_shape_tensor()))\n self.assertAllEqual([3, 2], self.evaluate(dist.batch_shape_tensor()))\n self.assertEqual(tf.TensorShape([2]), dist.event_shape)\n self.assertEqual(tf.TensorShape([3, 2]), dist.batch_shape)\n\n def testConcentrationProperty(self):\n alpha = [[1., 2, 3]]\n dist = tfd.Dirichlet(alpha)\n self.assertEqual([1, 3], dist.concentration.shape)\n self.assertAllClose(alpha, self.evaluate(dist.concentration))\n\n def testPdfXProper(self):\n alpha = [[1., 2, 3]]\n dist = tfd.Dirichlet(alpha, validate_args=True)\n self.evaluate(dist.prob([.1, .3, .6]))\n self.evaluate(dist.prob([.2, .3, .5]))\n # Either condition can trigger.\n with self.assertRaisesOpError('samples must be positive'):\n self.evaluate(dist.prob([-1., 1.5, 0.5]))\n with self.assertRaisesOpError('samples must be positive'):\n self.evaluate(dist.prob([0., .1, .9]))\n with self.assertRaisesOpError('sample last-dimension must sum to `1`'):\n self.evaluate(dist.prob([.1, .2, .8]))\n\n def testLogPdfOnBoundaryIsFiniteWhenAlphaIsOne(self):\n # Test concentration = 1. for each dimension.\n concentration = 3 * np.ones((10, 10)).astype(np.float32)\n concentration[range(10), range(10)] = 1.\n x = 1 / 9. * np.ones((10, 10)).astype(np.float32)\n x[range(10), range(10)] = 0.\n dist = tfd.Dirichlet(concentration)\n log_prob = self.evaluate(dist.log_prob(x))\n self.assertAllEqual(\n np.ones_like(log_prob, dtype=np.bool), np.isfinite(log_prob))\n\n # Test when concentration[k] = 1., and x is zero at various dimensions.\n dist = tfd.Dirichlet(10 * [1.])\n log_prob = self.evaluate(dist.log_prob(x))\n self.assertAllEqual(\n np.ones_like(log_prob, dtype=np.bool), np.isfinite(log_prob))\n\n def testPdfZeroBatches(self):\n alpha = [1., 2]\n x = [.5, .5]\n dist = tfd.Dirichlet(alpha)\n pdf = dist.prob(x)\n self.assertAllClose(1., self.evaluate(pdf))\n self.assertEqual((), pdf.shape)\n\n def testPdfZeroBatchesNontrivialX(self):\n alpha = [1., 2]\n x = [.3, .7]\n dist = tfd.Dirichlet(alpha)\n pdf = dist.prob(x)\n self.assertAllClose(7. / 5, self.evaluate(pdf))\n self.assertEqual((), pdf.shape)\n\n def testPdfUniformZeroBatches(self):\n # Corresponds to a uniform distribution\n alpha = [1., 1, 1]\n x = [[.2, .5, .3], [.3, .4, .3]]\n dist = tfd.Dirichlet(alpha)\n pdf = dist.prob(x)\n self.assertAllClose([2., 2.], self.evaluate(pdf))\n self.assertEqual((2), pdf.shape)\n\n def testPdfAlphaStretchedInBroadcastWhenSameRank(self):\n alpha = [[1., 2]]\n x = [[.5, .5], [.3, .7]]\n dist = tfd.Dirichlet(alpha)\n pdf = dist.prob(x)\n self.assertAllClose([1., 7. / 5], self.evaluate(pdf))\n self.assertEqual((2), pdf.shape)\n\n def testPdfAlphaStretchedInBroadcastWhenLowerRank(self):\n alpha = [1., 2]\n x = [[.5, .5], [.2, .8]]\n pdf = tfd.Dirichlet(alpha).prob(x)\n self.assertAllClose([1., 8. / 5], self.evaluate(pdf))\n self.assertEqual((2), pdf.shape)\n\n def testPdfXStretchedInBroadcastWhenSameRank(self):\n alpha = [[1., 2], [2., 3]]\n x = [[.5, .5]]\n pdf = tfd.Dirichlet(alpha).prob(x)\n self.assertAllClose([1., 3. / 2], self.evaluate(pdf))\n self.assertEqual((2), pdf.shape)\n\n def testPdfXStretchedInBroadcastWhenLowerRank(self):\n alpha = [[1., 2], [2., 3]]\n x = [.5, .5]\n pdf = tfd.Dirichlet(alpha).prob(x)\n self.assertAllClose([1., 3. / 2], self.evaluate(pdf))\n self.assertEqual((2), pdf.shape)\n\n def testMean(self):\n alpha = [1., 2, 3]\n dirichlet = tfd.Dirichlet(concentration=alpha)\n self.assertEqual(dirichlet.mean().shape, [3])\n expected_mean = sp_stats.dirichlet.mean(alpha)\n self.assertAllClose(self.evaluate(dirichlet.mean()), expected_mean)\n\n def testCovarianceFromSampling(self):\n alpha = np.array([[1., 2, 3],\n [2.5, 4, 0.01]], dtype=np.float32)\n dist = tfd.Dirichlet(alpha) # batch_shape=[2], event_shape=[3]\n x = dist.sample(int(250e3), seed=tfp_test_util.test_seed())\n sample_mean = tf.reduce_mean(x, axis=0)\n x_centered = x - sample_mean[None, ...]\n sample_cov = tf.reduce_mean(\n tf.matmul(x_centered[..., None], x_centered[..., None, :]), axis=0)\n sample_var = tf.linalg.diag_part(sample_cov)\n sample_stddev = tf.sqrt(sample_var)\n\n [\n sample_mean_,\n sample_cov_,\n sample_var_,\n sample_stddev_,\n analytic_mean,\n analytic_cov,\n analytic_var,\n analytic_stddev,\n ] = self.evaluate([\n sample_mean,\n sample_cov,\n sample_var,\n sample_stddev,\n dist.mean(),\n dist.covariance(),\n dist.variance(),\n dist.stddev(),\n ])\n\n self.assertAllClose(sample_mean_, analytic_mean, atol=0.04, rtol=0.)\n self.assertAllClose(sample_cov_, analytic_cov, atol=0.06, rtol=0.)\n self.assertAllClose(sample_var_, analytic_var, atol=0.03, rtol=0.)\n self.assertAllClose(sample_stddev_, analytic_stddev, atol=0.02, rtol=0.)\n\n def testVariance(self):\n alpha = [1., 2, 3]\n denominator = np.sum(alpha)**2 * (np.sum(alpha) + 1)\n dirichlet = tfd.Dirichlet(concentration=alpha)\n self.assertEqual(dirichlet.covariance().shape, (3, 3))\n expected_covariance = np.diag(sp_stats.dirichlet.var(alpha))\n expected_covariance += [[0., -2, -3], [-2, 0, -6], [-3, -6, 0]\n ] / denominator\n self.assertAllClose(\n self.evaluate(dirichlet.covariance()), expected_covariance)\n\n def testMode(self):\n alpha = np.array([1.1, 2, 3])\n expected_mode = (alpha - 1) / (np.sum(alpha) - 3)\n dirichlet = tfd.Dirichlet(concentration=alpha)\n self.assertEqual(dirichlet.mode().shape, [3])\n self.assertAllClose(self.evaluate(dirichlet.mode()), expected_mode)\n\n def testModeInvalid(self):\n alpha = np.array([1., 2, 3])\n dirichlet = tfd.Dirichlet(\n concentration=alpha, allow_nan_stats=False)\n with self.assertRaisesOpError('Condition x < y.*'):\n self.evaluate(dirichlet.mode())\n\n def testModeEnableAllowNanStats(self):\n alpha = np.array([1., 2, 3])\n dirichlet = tfd.Dirichlet(\n concentration=alpha, allow_nan_stats=True)\n expected_mode = np.zeros_like(alpha) + np.nan\n\n self.assertEqual(dirichlet.mode().shape, [3])\n self.assertAllClose(self.evaluate(dirichlet.mode()), expected_mode)\n\n def testEntropy(self):\n alpha = [1., 2, 3]\n dirichlet = tfd.Dirichlet(concentration=alpha)\n self.assertEqual(dirichlet.entropy().shape, ())\n expected_entropy = sp_stats.dirichlet.entropy(alpha)\n self.assertAllClose(self.evaluate(dirichlet.entropy()), expected_entropy)\n\n def testSample(self):\n alpha = [1., 2]\n dirichlet = tfd.Dirichlet(alpha)\n n = tf.constant(100000)\n samples = dirichlet.sample(n)\n sample_values = self.evaluate(samples)\n self.assertEqual(sample_values.shape, (100000, 2))\n self.assertTrue(np.all(sample_values > 0.0))\n self.assertLess(\n sp_stats.kstest(\n # Beta is a univariate distribution.\n sample_values[:, 0],\n sp_stats.beta(a=1., b=2.).cdf)[0],\n 0.01)\n\n def testDirichletFullyReparameterized(self):\n alpha = tf.constant([1.0, 2.0, 3.0])\n _, grad_alpha = tfp.math.value_and_gradient(\n lambda a: tfd.Dirichlet(a).sample(100), alpha)\n self.assertIsNotNone(grad_alpha)\n\n def testDirichletDirichletKL(self):\n conc1 = np.array([[1., 2., 3., 1.5, 2.5, 3.5],\n [1.5, 2.5, 3.5, 4.5, 5.5, 6.5]])\n conc2 = np.array([[0.5, 1., 1.5, 2., 2.5, 3.]])\n\n d1 = tfd.Dirichlet(conc1)\n d2 = tfd.Dirichlet(conc2)\n x = d1.sample(int(1e4), seed=tfp_test_util.test_seed())\n kl_sample = tf.reduce_mean(d1.log_prob(x) - d2.log_prob(x), axis=0)\n kl_actual = tfd.kl_divergence(d1, d2)\n\n kl_sample_val = self.evaluate(kl_sample)\n kl_actual_val = self.evaluate(kl_actual)\n\n self.assertEqual(conc1.shape[:-1], kl_actual.shape)\n\n kl_expected = (\n sp_special.gammaln(np.sum(conc1, -1))\n - sp_special.gammaln(np.sum(conc2, -1))\n - np.sum(sp_special.gammaln(conc1) - sp_special.gammaln(conc2), -1)\n + np.sum((conc1 - conc2) * (sp_special.digamma(conc1) -\n sp_special.digamma(\n np.sum(conc1, -1, keepdims=True))), -1))\n\n self.assertAllClose(kl_expected, kl_actual_val, atol=0., rtol=1e-5)\n self.assertAllClose(kl_sample_val, kl_actual_val, atol=0., rtol=1e-1)\n\n # Make sure KL(d1||d1) is 0\n kl_same = self.evaluate(tfd.kl_divergence(d1, d1))\n self.assertAllClose(kl_same, np.zeros_like(kl_expected))\n\n def testDegenerateAlignedStridedSlice(self):\n # Corresponds to the TF fix in tensorflow/tensorflow#d9b3db0\n d = tfd.Dirichlet(tf.math.softplus(tf.zeros([2, 2, 2])))\n batch_shape = [2, 2]\n self.assertAllEqual(batch_shape, d.batch_shape)\n self.assertAllEqual(np.zeros(batch_shape)[1:0].shape,\n d[1:0].batch_shape)\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass DirichletFromVariableTest(test_case.TestCase):\n\n def testGradients(self):\n x = tf.Variable([1., 1.1, 1.2])\n d = tfd.Dirichlet(concentration=x, validate_args=True)\n with tf.GradientTape() as tape:\n loss = -d.log_prob([0.1, 0.2, 0.7])\n g = tape.gradient(loss, d.trainable_variables)\n self.assertLen(g, 1)\n self.assertAllNotNone(g)\n\n def testAssertions(self):\n x = tfp.util.TransformedVariable(0.3679, tfb.Exp(), shape=None)\n with self.assertRaisesRegexp(\n ValueError, 'Argument `concentration` must have rank at least 1.'):\n d = tfd.Dirichlet(concentration=x, validate_args=True)\n self.evaluate([v.initializer for v in d.variables])\n self.evaluate(d.entropy())\n\n\nif __name__ == '__main__':\n tf.test.main()\n",
"# Copyright 2019 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\"\"\"Decorators for testing TFP code under combinations of TF features.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport contextlib\nimport tensorflow.compat.v2 as tf\n\nfrom tensorflow.python.eager import def_function # pylint: disable=g-direct-tensorflow-import\nfrom tensorflow.python.framework import combinations # pylint: disable=g-direct-tensorflow-import\nfrom tensorflow.python.framework import test_combinations # pylint: disable=g-direct-tensorflow-import\n\n__all__ = [\n 'test_all_tf_execution_regimes',\n 'test_graph_and_eager_modes',\n]\n\n\[email protected]\ndef _tf_function_mode_context(tf_function_mode):\n \"\"\"Context manager controlling `tf.function` behavior (enabled/disabled).\n\n Before activating, the previously set mode is stored. Then the mode is changed\n to the given `tf_function_mode` and control yielded back to the caller. Upon\n exiting the context, the mode is returned to its original state.\n\n Args:\n tf_function_mode: a Python `str`, either 'disabled' or 'enabled'. If\n 'enabled', `@tf.function`-decorated code behaves as usual (ie, a background\n graph is created). If 'disabled', `@tf.function`-decorated code will behave\n as if it had not been `@tf.function`-decorated. Since users will be able to\n do this (e.g., to debug library code that has been\n `@tf.function`-decorated), we need to ensure our tests cover the behavior\n when this is the case.\n\n Yields:\n None\n \"\"\"\n if tf_function_mode not in ['enabled', 'disabled']:\n raise ValueError(\n 'Only allowable values for tf_function_mode_context are `enabled` and '\n '`disabled`; but got `{}`'.format(tf_function_mode))\n original_mode = def_function.RUN_FUNCTIONS_EAGERLY\n try:\n tf.config.experimental_run_functions_eagerly(tf_function_mode == 'disabled')\n yield\n finally:\n tf.config.experimental_run_functions_eagerly(original_mode)\n\n\nclass ExecuteFunctionsEagerlyCombination(test_combinations.TestCombination):\n \"\"\"A `TestCombinationi` for enabling/disabling `tf.function` execution modes.\n\n For more on `TestCombination`, check out\n 'tensorflow/python/framework/test_combinations.py' in the TensorFlow code\n base.\n\n This `TestCombination` supports two values for the `tf_function`\n combination argument: 'disabled' and 'enabled'. The mode switching is\n performed using `tf.experimental_run_functions_eagerly(mode)`.\n \"\"\"\n\n def context_managers(self, kwargs):\n mode = kwargs.pop('tf_function', 'enabled')\n return [_tf_function_mode_context(mode)]\n\n def parameter_modifiers(self):\n return [test_combinations.OptionalParameter('tf_function')]\n\n\ndef test_all_tf_execution_regimes(test_class_or_method=None):\n \"\"\"Decorator for generating a collection of tests in various contexts.\n\n Must be applied to subclasses of `parameterized.TestCase` (from\n `absl/testing`), or a method of such a subclass.\n\n When applied to a test method, this decorator results in the replacement of\n that method with a collection of new test methods, each executed under a\n different set of context managers that control some aspect of the execution\n model. This decorator generates three test scenario combinations:\n\n 1. Eager mode with `tf.function` decorations enabled\n 2. Eager mode with `tf.function` decorations disabled\n 3. Graph mode (eveything)\n\n When applied to a test class, all the methods in the class are affected.\n\n Args:\n test_class_or_method: the `TestCase` class or method to decorate.\n\n Returns:\n decorator: A generated TF `test_combinations` decorator, or if\n `test_class_or_method` is not `None`, the generated decorator applied to\n that function.\n \"\"\"\n decorator = test_combinations.generate(\n (test_combinations.combine(mode='graph',\n tf_function='enabled') +\n test_combinations.combine(mode='eager',\n tf_function=['enabled', 'disabled'])),\n test_combinations=[\n combinations.EagerGraphCombination(),\n ExecuteFunctionsEagerlyCombination(),\n ])\n\n if test_class_or_method:\n return decorator(test_class_or_method)\n return decorator\n\n\ndef test_graph_and_eager_modes(test_class_or_method=None):\n \"\"\"Decorator for generating graph and eager mode tests from a single test.\n\n Must be applied to subclasses of `parameterized.TestCase` (from\n absl/testing), or a method of such a subclass.\n\n When applied to a test method, this decorator results in the replacement of\n that method with a two new test methods, one executed in graph mode and the\n other in eager mode.\n\n When applied to a test class, all the methods in the class are affected.\n\n Args:\n test_class_or_method: the `TestCase` class or method to decorate.\n\n Returns:\n decorator: A generated TF `test_combinations` decorator, or if\n `test_class_or_method` is not `None`, the generated decorator applied to\n that function.\n \"\"\"\n decorator = test_combinations.generate(\n test_combinations.combine(mode=['graph', 'eager']),\n test_combinations=[combinations.EagerGraphCombination()])\n\n if test_class_or_method:\n return decorator(test_class_or_method)\n return decorator\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\"\"\"Tests for MixtureSameFamily distribution.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\n# Dependency imports\nimport numpy as np\nimport tensorflow.compat.v1 as tf1\nimport tensorflow.compat.v2 as tf\nimport tensorflow_probability as tfp\n\nfrom tensorflow_probability.python.internal import hypothesis_testlib as tfp_hps\nfrom tensorflow_probability.python.internal import tensorshape_util\nfrom tensorflow_probability.python.internal import test_case\nfrom tensorflow_probability.python.internal import test_util as tfp_test_util\nfrom tensorflow.python.framework import test_util # pylint: disable=g-direct-tensorflow-import\n\ntfd = tfp.distributions\n\n\nclass _MixtureSameFamilyTest(tfp_test_util.VectorDistributionTestHelpers):\n\n def testSampleAndLogProbUnivariateShapes(self):\n gm = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(\n probs=self._build_tensor([0.3, 0.7])),\n components_distribution=tfd.Normal(\n loc=self._build_tensor([-1., 1]),\n scale=self._build_tensor([0.1, 0.5])))\n x = gm.sample([4, 5], seed=tfp_test_util.test_seed())\n log_prob_x = gm.log_prob(x)\n self.assertAllEqual([4, 5], self._shape(x))\n self.assertAllEqual([4, 5], self._shape(log_prob_x))\n\n def testSampleAndLogProbBatch(self):\n gm = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(\n probs=self._build_tensor([[0.3, 0.7]])),\n components_distribution=tfd.Normal(\n loc=self._build_tensor([[-1., 1]]),\n scale=self._build_tensor([[0.1, 0.5]])))\n x = gm.sample([4, 5], seed=tfp_test_util.test_seed())\n log_prob_x = gm.log_prob(x)\n self.assertAllEqual([4, 5, 1], self._shape(x))\n self.assertAllEqual([4, 5, 1], self._shape(log_prob_x))\n\n def testSampleAndLogProbShapesBroadcastMix(self):\n mix_probs = self._build_tensor([.3, .7])\n bern_probs = self._build_tensor([[.4, .6], [.25, .75]])\n bm = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(probs=mix_probs),\n components_distribution=tfd.Bernoulli(probs=bern_probs))\n x = bm.sample([4, 5], seed=tfp_test_util.test_seed())\n log_prob_x = bm.log_prob(x)\n x_ = self.evaluate(x)\n self.assertAllEqual([4, 5, 2], self._shape(x))\n self.assertAllEqual([4, 5, 2], self._shape(log_prob_x))\n self.assertAllEqual(\n np.ones_like(x_, dtype=np.bool), np.logical_or(x_ == 0., x_ == 1.))\n\n def testSampleAndLogProbMultivariateShapes(self):\n gm = self._build_mvndiag_mixture(\n probs=[0.3, 0.7],\n loc=[[-1., 1], [1, -1]],\n scale_identity_multiplier=[1., 0.5])\n x = gm.sample([4, 5], seed=tfp_test_util.test_seed())\n log_prob_x = gm.log_prob(x)\n self.assertAllEqual([4, 5, 2], self._shape(x))\n self.assertAllEqual([4, 5], self._shape(log_prob_x))\n\n def testSampleAndLogProbBatchMultivariateShapes(self):\n gm = self._build_mvndiag_mixture(\n probs=[0.3, 0.7],\n loc=[[[-1., 1], [1, -1]], [[0., 1], [1, 0]]],\n scale_identity_multiplier=[1., 0.5])\n x = gm.sample([4, 5], seed=tfp_test_util.test_seed())\n log_prob_x = gm.log_prob(x)\n self.assertAllEqual([4, 5, 2, 2], self._shape(x))\n self.assertAllEqual([4, 5, 2], self._shape(log_prob_x))\n\n def testSampleConsistentLogProb(self):\n gm = self._build_mvndiag_mixture(\n probs=[0.3, 0.7],\n loc=[[-1., 1], [1, -1]],\n scale_identity_multiplier=[1., 0.5])\n # Ball centered at component0's mean.\n self.run_test_sample_consistent_log_prob(\n self.evaluate, gm, radius=1., center=[-1., 1], rtol=0.02)\n # Larger ball centered at component1's mean.\n self.run_test_sample_consistent_log_prob(\n self.evaluate, gm, radius=1., center=[1., -1], rtol=0.02)\n\n def testLogCdf(self):\n gm = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(\n probs=self._build_tensor([0.3, 0.7])),\n components_distribution=tfd.Normal(\n loc=self._build_tensor([-1., 1]),\n scale=self._build_tensor([0.1, 0.5])))\n x = gm.sample(10, seed=tfp_test_util.test_seed())\n actual_log_cdf = gm.log_cdf(x)\n expected_log_cdf = tf.reduce_logsumexp(\n (gm.mixture_distribution.logits_parameter() +\n gm.components_distribution.log_cdf(x[..., tf.newaxis])),\n axis=1)\n actual_log_cdf_, expected_log_cdf_ = self.evaluate(\n [actual_log_cdf, expected_log_cdf])\n self.assertAllClose(actual_log_cdf_, expected_log_cdf_, rtol=1e-6, atol=0.0)\n\n def testCovarianceWithBatch(self):\n d = self._build_mvndiag_mixture(\n probs=[0.2, 0.3, 0.5],\n loc=np.zeros((2, 1, 5, 3, 4)),\n scale_identity_multiplier=[1., 0.75, 0.5])\n self.assertAllEqual((2, 1, 5, 4, 4), self.evaluate(d.covariance()).shape)\n\n def testSampleConsistentMeanCovariance(self):\n gm = self._build_mvndiag_mixture(\n probs=[0.3, 0.7],\n loc=[[-1., 1], [1, -1]],\n scale_identity_multiplier=[1., 0.5])\n self.run_test_sample_consistent_mean_covariance(self.evaluate, gm)\n\n def testVarianceConsistentCovariance(self):\n gm = self._build_mvndiag_mixture(\n probs=[0.3, 0.7],\n loc=[[-1., 1], [1, -1]],\n scale_identity_multiplier=[1., 0.5])\n cov_, var_ = self.evaluate([gm.covariance(), gm.variance()])\n self.assertAllClose(cov_.diagonal(), var_, atol=0.)\n\n def testReparameterizationOfNonReparameterizedComponents(self):\n with self.assertRaises(ValueError):\n tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(\n logits=self._build_tensor([-0.3, 0.4])),\n components_distribution=tfd.Bernoulli(\n logits=self._build_tensor([0.1, -0.1])),\n reparameterize=True)\n\n def testSecondGradientIsDisabled(self):\n if not self.use_static_shape:\n return\n\n # Testing using GradientTape in both eager and graph modes.\n # GradientTape does not support some control flow ops in graph mode, which\n # is not a problem here as this code does not use any control flow.\n logits = self._build_tensor([[0.1, 0.5]])\n with tf.GradientTape() as g:\n g.watch(logits)\n with tf.GradientTape() as gg:\n gg.watch(logits)\n mixture = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(\n logits=logits),\n components_distribution=tfd.Normal(\n loc=self._build_tensor([[0.4, 0.25]]),\n scale=self._build_tensor([[0.1, 0.5]])),\n reparameterize=True)\n\n sample = mixture.sample()\n grad = gg.gradient(sample, logits)\n\n with self.assertRaises(LookupError):\n g.gradient(grad, logits)\n\n def _testMixtureReparameterizationGradients(\n self, mixture_func, parameters, function, num_samples):\n assert function in ['mean', 'variance']\n\n if not self.use_static_shape:\n return\n\n def sample_estimate(*parameters):\n mixture = mixture_func(*parameters)\n values = mixture.sample(num_samples, seed=tfp_test_util.test_seed())\n if function == 'variance':\n values = tf.math.squared_difference(values, mixture.mean())\n return tf.reduce_mean(values, axis=0)\n\n def exact(*parameters):\n mixture = mixture_func(*parameters)\n # Normal mean does not depend on the scale, so add 0 * variance\n # to avoid None gradients. Also do the same for variance, just in case.\n if function == 'variance':\n return mixture.variance() + 0 * mixture.mean()\n elif function == 'mean':\n return mixture.mean() + 0 * mixture.variance()\n\n _, actual = tfp.math.value_and_gradient(sample_estimate, parameters)\n _, expected = tfp.math.value_and_gradient(exact, parameters)\n self.assertAllClose(actual, expected, atol=0.1, rtol=0.2)\n\n def testReparameterizationGradientsNormalScalarComponents(self):\n def mixture_func(logits, loc, scale):\n return tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(logits=logits),\n components_distribution=tfd.Normal(loc=loc, scale=scale),\n reparameterize=True)\n\n for function in ['mean', 'variance']:\n self._testMixtureReparameterizationGradients(\n mixture_func,\n [self._build_tensor([[0.1, 0.5]]), # logits\n self._build_tensor([[0.4, 0.25]]), # loc\n self._build_tensor([[0.1, 0.5]])], # scale\n function,\n num_samples=10000)\n\n def testReparameterizationGradientsNormalVectorComponents(self):\n def mixture_func(logits, loc, scale):\n return tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(logits=logits),\n components_distribution=tfd.Independent(\n tfd.Normal(loc=loc, scale=scale), reinterpreted_batch_ndims=1),\n reparameterize=True)\n\n for function in ['mean', 'variance']:\n self._testMixtureReparameterizationGradients(\n mixture_func,\n [self._build_tensor([0.5, -0.2, 0.1]), # logits\n self._build_tensor([[-1., 1], [0.5, -1], [-1., 0.5]]), # mean\n self._build_tensor([[0.1, 0.5], [0.3, 0.5], [0.2, 0.3]])], # scale\n function,\n num_samples=20000)\n\n def testReparameterizationGradientsNormalMatrixComponents(self):\n def mixture_func(logits, loc, scale):\n return tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(logits=logits),\n components_distribution=tfd.Independent(\n tfd.Normal(loc=loc, scale=scale), reinterpreted_batch_ndims=2),\n reparameterize=True)\n\n for function in ['mean', 'variance']:\n self._testMixtureReparameterizationGradients(\n mixture_func,\n [self._build_tensor([0.7, 0.2, 0.1]), # logits\n self._build_tensor([[[-1., 1]], [[0.5, -1]], [[-1., 0.5]]]), # mean\n # scale\n self._build_tensor([[[0.1, 0.5]], [[0.3, 0.5]], [[0.2, 0.3]]])],\n function,\n num_samples=50000)\n\n def testReparameterizationGradientsExponentialScalarComponents(self):\n def mixture_func(logits, rate):\n return tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(logits=logits),\n components_distribution=tfd.Exponential(rate=rate),\n reparameterize=True)\n\n for function in ['mean', 'variance']:\n self._testMixtureReparameterizationGradients(\n mixture_func,\n [self._build_tensor([0.7, 0.2, 0.1]), # logits\n self._build_tensor([1., 0.5, 1.])], # rate\n function,\n num_samples=10000)\n\n def testDeterministicSampling(self):\n seed = tfp_test_util.test_seed()\n tf1.set_random_seed(seed)\n dist = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(logits=[0., 0.]),\n components_distribution=tfd.Normal(loc=[0., 200.], scale=[1., 1.]))\n sample_1 = self.evaluate(dist.sample([100], seed=seed))\n tf1.set_random_seed(seed)\n sample_2 = self.evaluate(dist.sample([100], seed=seed))\n self.assertAllClose(sample_1, sample_2)\n\n def testGradientsThroughParams(self):\n logits = self._build_variable([1., 2., 3.])\n loc = self._build_variable([0., 0., 0])\n scale = self._build_variable(1.)\n dist = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(logits=logits),\n components_distribution=tfd.Logistic(loc=loc, scale=scale),\n validate_args=True)\n with tf.GradientTape() as tape:\n loss = -dist.log_prob([5., 4.])\n grad = tape.gradient(loss, dist.trainable_variables)\n self.assertLen(grad, 3)\n self.assertAllNotNone(grad)\n\n logits = self._build_variable(np.zeros((4, 4, 5)))\n loc = self._build_variable(np.zeros((4, 4, 5, 2, 3)))\n scale = self._build_variable(1.)\n dist = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(logits=logits),\n components_distribution=tfd.Independent(\n tfd.Logistic(loc=loc, scale=scale),\n reinterpreted_batch_ndims=self._build_tensor(2, dtype=np.int32)),\n validate_args=True)\n with tf.GradientTape() as tape:\n loss = -dist.log_prob(np.zeros((4, 4, 2, 3)))\n grad = tape.gradient(loss, dist.trainable_variables)\n self.assertLen(grad, 3)\n self.assertAllNotNone(grad)\n\n def testExcessiveConcretizationOfParams(self):\n logits = tfp_hps.defer_and_count_usage(\n self._build_variable(np.zeros((4, 4, 5)), name='logits'))\n concentration = tfp_hps.defer_and_count_usage(\n self._build_variable(np.zeros((4, 4, 5, 3)), name='concentration'))\n dist = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(logits=logits),\n components_distribution=tfd.Dirichlet(concentration=concentration),\n validate_args=True)\n\n # Many methods use mixture_distribution and components_distribution at most\n # once, and thus incur no extra reads/concretizations of parameters.\n\n for method in ('batch_shape_tensor', 'event_shape_tensor',\n 'mean', 'sample'):\n with tfp_hps.assert_no_excessive_var_usage(method, max_permissible=2):\n getattr(dist, method)()\n\n for method in ('log_prob', 'prob'):\n with tfp_hps.assert_no_excessive_var_usage('method', max_permissible=2):\n getattr(dist, method)(np.ones((4, 4, 3)) / 3.)\n\n # TODO(b/140579567): The `variance()` and `covariance()` methods require\n # calling both:\n # - `self.components_distribution.mean()`\n # - `self.components_distribution.variance()` or `.covariance()`\n # Thus, these methods incur an additional concretization (or two if\n # `validate_args=True` for `self.components_distribution`).\n\n for method in ('variance', 'covariance'):\n with tfp_hps.assert_no_excessive_var_usage(method, max_permissible=3):\n getattr(dist, method)()\n\n # TODO(b/140579567): When event ndims is not known statically, several\n # methods call `self.components_distribution.event_shape_tensor()` to\n # determine the number of event dimensions. Depending on the underlying\n # distribution, this would likely incur additional concretizations of the\n # parameters of `self.components_distribution`. The methods are:\n # - `log_cdf` and `cdf`\n # - `log_prob` and `prob`\n # - `mean` and `variance`\n # - `sample`\n #\n # NOTE: `Distribution.survival_function` and `log_survival_function` will\n # call `Distribution.cdf` and `Distribution.log_cdf`, resulting in one\n # additional call to `_parameter_control_dependencies`, and thus an\n # additional concretizations of the underlying distribution parameters.\n\n def testExcessiveConcretizationOfParamsWithReparameterization(self):\n logits = tfp_hps.defer_and_count_usage(self._build_variable(\n np.zeros(5), name='logits', static_rank=True))\n loc = tfp_hps.defer_and_count_usage(self._build_variable(\n np.zeros((4, 4, 5)), name='loc', static_rank=True))\n scale = tfp_hps.defer_and_count_usage(self._build_variable(\n 1., name='scale', static_rank=True))\n dist = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(logits=logits),\n components_distribution=tfd.Logistic(loc=loc, scale=scale),\n reparameterize=True, validate_args=True)\n\n # TODO(b/140579567): With reparameterization, there are additional reads of\n # the parameters of the underlying mixture and components distributions when\n # sampling, from calls in `_distributional_transform` to:\n #\n # - `self.mixture_distribution.logits_parameter`\n # - `self.components_distribution.log_prob`\n # - `self.components_distribution.cdf`\n #\n # NOTE: In the unlikely case that samples have a statically-known rank but\n # the rank of `self.components_distribution.event_shape` is not known\n # statically, there can be additional reads in `_distributional_transform`\n # from calling `self.components_distribution.is_scalar_event`.\n\n with tfp_hps.assert_no_excessive_var_usage('sample', max_permissible=4):\n dist.sample()\n\n def testSampleGradientsThroughParams(self):\n logits = self._build_variable(np.zeros(5), static_rank=True)\n loc = self._build_variable(np.zeros((4, 5, 2, 3)), static_rank=True)\n scale = self._build_variable(1., static_rank=True)\n dist = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(logits=logits),\n components_distribution=tfd.Independent(\n tfd.Logistic(loc=loc, scale=scale), reinterpreted_batch_ndims=2),\n reparameterize=True, validate_args=True)\n with tf.GradientTape() as tape:\n loss = tf.reduce_sum(dist.sample(2))\n grad = tape.gradient(loss, dist.trainable_variables)\n self.assertLen(grad, 3)\n self.assertAllNotNone(grad)\n\n def _shape(self, x):\n if self.use_static_shape:\n return tensorshape_util.as_list(x.shape)\n else:\n return self.evaluate(tf.shape(x))\n\n def _build_mvndiag_mixture(self, probs, loc, scale_identity_multiplier):\n components_distribution = tfd.MultivariateNormalDiag(\n loc=self._build_tensor(loc),\n scale_identity_multiplier=self._build_tensor(\n scale_identity_multiplier))\n\n # Use a no-op `Independent` wrapper to possibly create dynamic ndims.\n wrapped_components_distribution = tfd.Independent(\n components_distribution,\n reinterpreted_batch_ndims=self._build_tensor(0, dtype=np.int32))\n # Lambda ensures that the covariance fn sees `self=components_distribution`.\n wrapped_components_distribution._covariance = (\n lambda: components_distribution.covariance()) # pylint: disable=unnecessary-lambda\n\n gm = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(\n probs=self._build_tensor(probs)),\n components_distribution=wrapped_components_distribution,\n validate_args=True)\n return gm\n\n def _build_tensor(self, ndarray, dtype=None):\n # Enforce parameterized dtype and static/dynamic testing.\n ndarray = np.asarray(ndarray).astype(\n dtype if dtype is not None else self.dtype)\n if self.use_static_shape:\n return tf.convert_to_tensor(ndarray)\n else:\n return tf1.placeholder_with_default(ndarray, shape=None)\n\n def _build_variable(self, ndarray, name=None, dtype=None, static_rank=False):\n if dtype is None:\n dtype = self.dtype\n ndarray = np.asarray(ndarray).astype(dtype)\n if self.use_static_shape:\n return tf.Variable(ndarray, name=name, dtype=dtype)\n elif static_rank:\n return tf.Variable(ndarray, name=name, dtype=dtype,\n shape=tf.TensorShape([None] * len(ndarray.shape)))\n else:\n return tf.Variable(ndarray, name=name, dtype=dtype,\n shape=tf.TensorShape(None))\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass MixtureSameFamilyTestStatic32(\n _MixtureSameFamilyTest,\n test_case.TestCase):\n use_static_shape = True\n dtype = np.float32\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass MixtureSameFamilyTestDynamic32(\n _MixtureSameFamilyTest,\n test_case.TestCase):\n use_static_shape = False\n dtype = np.float32\n\n def testMatchingComponentsSizeAssertions(self):\n logits = self._build_variable(np.zeros(5))\n loc = self._build_variable(np.zeros((4, 5, 2, 3)), static_rank=True)\n scale = self._build_variable(1.)\n dist = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(logits=logits),\n components_distribution=tfd.Independent(\n tfd.Logistic(loc=loc, scale=scale), reinterpreted_batch_ndims=2),\n validate_args=True)\n\n self.evaluate([v.initializer for v in [logits, loc, scale]])\n self.evaluate(dist.mean())\n\n msg = ('`mixture_distribution` components.* does not equal '\n r'`components_distribution.batch_shape\\[-1\\]`')\n with self.assertRaisesRegex(Exception, msg):\n with tf.control_dependencies([loc.assign(np.zeros((4, 7, 2, 3)))]):\n self.evaluate(dist.mean())\n\n def testMatchingBatchShapeAssertions(self):\n logits = self._build_variable(np.zeros(5))\n loc = self._build_variable(np.zeros((4, 5, 2, 3)), static_rank=True)\n scale = self._build_variable(1.)\n dist = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(logits=logits),\n components_distribution=tfd.Independent(\n tfd.Logistic(loc=loc, scale=scale), reinterpreted_batch_ndims=2),\n validate_args=True)\n\n self.evaluate([v.initializer for v in [logits, loc, scale]])\n self.evaluate(dist.sample())\n\n msg = ('`mixture_distribution.batch_shape`.* is not compatible with '\n '`components_distribution.batch_shape')\n with self.assertRaisesRegex(Exception, msg):\n with tf.control_dependencies([logits.assign(np.zeros((4, 3, 5)))]):\n self.evaluate(dist.sample())\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass MixtureSameFamilyTestStatic64(\n _MixtureSameFamilyTest,\n test_case.TestCase):\n use_static_shape = True\n dtype = np.float64\n\nif __name__ == '__main__':\n tf.test.main()\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\"\"\"Positive-semidefinite kernels package.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport warnings\n\nfrom tensorflow_probability.python.math.psd_kernels.exp_sin_squared import ExpSinSquared\nfrom tensorflow_probability.python.math.psd_kernels.exponentiated_quadratic import ExponentiatedQuadratic\nfrom tensorflow_probability.python.math.psd_kernels.feature_scaled import FeatureScaled\nfrom tensorflow_probability.python.math.psd_kernels.feature_transformed import FeatureTransformed\nfrom tensorflow_probability.python.math.psd_kernels.kumaraswamy_transformed import KumaraswamyTransformed\nfrom tensorflow_probability.python.math.psd_kernels.matern import MaternFiveHalves\nfrom tensorflow_probability.python.math.psd_kernels.matern import MaternOneHalf\nfrom tensorflow_probability.python.math.psd_kernels.matern import MaternThreeHalves\nfrom tensorflow_probability.python.math.psd_kernels.polynomial import Linear\nfrom tensorflow_probability.python.math.psd_kernels.polynomial import Polynomial\nfrom tensorflow_probability.python.math.psd_kernels.positive_semidefinite_kernel import PositiveSemidefiniteKernel\nfrom tensorflow_probability.python.math.psd_kernels.rational_quadratic import RationalQuadratic\nfrom tensorflow_probability.python.math.psd_kernels.schur_complement import SchurComplement\n\n\nfrom tensorflow.python.util.all_util import remove_undocumented\n\nwarnings.warn(\n 'tfp.positive_semidefinite_kernels module has been moved to '\n 'tfp.math.psd_kernels. This alias will be deleted on 2019-12-01',\n stacklevel=5)\n\n_allowed_symbols = [\n 'ExponentiatedQuadratic',\n 'ExpSinSquared',\n 'FeatureScaled',\n 'FeatureTransformed',\n 'KumaraswamyTransformed',\n 'Linear',\n 'MaternFiveHalves',\n 'MaternOneHalf',\n 'MaternThreeHalves',\n 'Polynomial',\n 'PositiveSemidefiniteKernel',\n 'RationalQuadratic',\n 'SchurComplement',\n]\n\nremove_undocumented(__name__, _allowed_symbols)\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# ============================================================================\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\n# Dependency imports\nimport numpy as np\n\nimport tensorflow.compat.v2 as tf\n\nfrom tensorflow_probability.python.experimental.auto_batching import allocation_strategy\nfrom tensorflow_probability.python.experimental.auto_batching import dsl\nfrom tensorflow_probability.python.experimental.auto_batching import instructions\nfrom tensorflow_probability.python.experimental.auto_batching import lowering\nfrom tensorflow_probability.python.experimental.auto_batching import numpy_backend\nfrom tensorflow_probability.python.experimental.auto_batching import tf_backend\nfrom tensorflow_probability.python.experimental.auto_batching import type_inference\nfrom tensorflow_probability.python.experimental.auto_batching import virtual_machine as vm\nfrom tensorflow_probability.python.internal import test_case\nfrom tensorflow.python.framework import test_util # pylint: disable=g-direct-tensorflow-import\n\nTF_BACKEND = tf_backend.TensorFlowBackend()\n\nNP_BACKEND = numpy_backend.NumpyBackend()\n\n\ndef _execute(prog, inputs, stack_depth, backend):\n return vm.execute(\n prog, [inputs], max_stack_depth=stack_depth, backend=backend)\n\n\ndef fibonacci_program():\n ab = dsl.ProgramBuilder()\n\n def fib_type(arg_types):\n return arg_types[0]\n\n with ab.function('fibonacci', type_inference=fib_type) as fibonacci:\n ab.param('n')\n ab.var.cond = ab.primop(lambda n: n > 1)\n with ab.if_(ab.var.cond, then_name='recur'):\n ab.var.nm1 = ab.primop(lambda n: n - 1)\n ab.var.fibm1 = ab.call(fibonacci, [ab.var.nm1])\n ab.var.nm2 = ab.primop(lambda n: n - 2)\n ab.var.fibm2 = ab.call(fibonacci, [ab.var.nm2])\n ab.var.ans = ab.primop(lambda fibm1, fibm2: fibm1 + fibm2)\n with ab.else_(else_name='base-case', continue_name='finish'):\n ab.var.ans = ab.const(1)\n ab.return_(ab.var.ans)\n\n prog = ab.program(main=fibonacci)\n return prog\n\n\ndef even_odd_program():\n ab = dsl.ProgramBuilder()\n\n def pred_type(_):\n return instructions.TensorType(np.bool, ())\n\n odd = ab.declare_function('odd', type_inference=pred_type)\n\n with ab.function('even', type_inference=pred_type) as even:\n ab.param('n')\n ab.var.cond = ab.primop(lambda n: n <= 0)\n with ab.if_(ab.var.cond, then_name='base-case'):\n ab.var.ans = ab.const(True)\n with ab.else_(else_name='recur', continue_name='finish'):\n ab.var.nm1 = ab.primop(lambda n: n - 1)\n ab.var.ans = ab.call(odd, [ab.var.nm1])\n ab.return_(ab.var.ans)\n\n with ab.define_function(odd):\n ab.param('n')\n ab.var.cond = ab.primop(lambda n: n <= 0)\n with ab.if_(ab.var.cond, then_name='base-case'):\n ab.var.ans = ab.const(False)\n with ab.else_(else_name='recur', continue_name='finish'):\n ab.var.nm1 = ab.primop(lambda n: n - 1)\n ab.var.ans = ab.call(even, [ab.var.nm1])\n ab.return_(ab.var.ans)\n\n prog = ab.program(main=even)\n return prog\n\n\ndef synthetic_pattern_program():\n ab = dsl.ProgramBuilder()\n def my_type(_):\n int_ = instructions.TensorType(np.int64, ())\n return ((int_, int_), int_, (int_, int_))\n\n with ab.function('synthetic', type_inference=my_type) as syn:\n ab.param('batch_size_index')\n one, three, five = ab.locals_(3)\n ab((one, (five, three))).pattern = ab.primop(lambda: (1, (2, 3)))\n ab(((ab.var.four, five), ab.var.six)).pattern = ab.primop(\n lambda: ((4, 5), 6))\n ab.return_(((one, three), ab.var.four, (five, ab.var.six)))\n\n prog = ab.program(main=syn)\n return prog\n\n\n@test_util.run_all_in_graph_and_eager_modes\nclass AutoBatchingTest(test_case.TestCase):\n\n def testAutoBatchingFibonacciNumpy(self):\n for inputs, outputs in ([5], [8]), ([5, 6, 8, 9], [8, 13, 34, 55]):\n # This test doesn't pass with int32 input types, because (apparently)\n # numpy can't tell the difference between an ndarray of shape () and known\n # dtype, and a scalar (literal) whose dtype needs to be inferred.\n # To wit:\n # (np.zeros((), dtype=np.int32) - 1).dtype == np.int64\n # because that's somehow the best numpy can do, even though\n # (np.zeros([6], dtype=np.int32) - 1).dtype == np.int32\n # Needless to say, this messes up type inference for programs like\n # Fibonacci whose unbatched input shape is scalar.\n inputs = np.array(inputs, dtype=np.int64)\n outputs = np.array(outputs, dtype=np.int64)\n prog = fibonacci_program()\n # print(prog)\n typed = type_inference.infer_types(prog, [inputs], NP_BACKEND)\n # print(typed)\n alloc = allocation_strategy.optimize(typed)\n lowered = lowering.lower_function_calls(alloc)\n # print(lowered)\n self.assertAllEqual(outputs, _execute(lowered, inputs, 15, NP_BACKEND))\n\n def testAutoBatchingFibonacciTF(self):\n for inputs, outputs in ([5], [8]), ([5, 6, 8, 9], [8, 13, 34, 55]):\n inputs = np.array(inputs, dtype=np.int32)\n outputs = np.array(outputs, dtype=np.int32)\n prog = fibonacci_program()\n # print(prog)\n inputs_t = tf.constant(inputs, dtype=np.int32)\n typed = type_inference.infer_types(prog, [inputs_t], TF_BACKEND)\n # print(typed)\n alloc = allocation_strategy.optimize(typed)\n lowered = lowering.lower_function_calls(alloc)\n # print(lowered)\n self.assertAllEqual(\n outputs, self.evaluate(_execute(lowered, inputs_t, 15, TF_BACKEND)))\n\n def testAutoBatchingEvenOddNumpy(self):\n for inputs, outputs in ([5], [False]), ([5, 6, 8, 9],\n [False, True, True, False]):\n inputs = np.array(inputs, dtype=np.int64)\n outputs = np.array(outputs, dtype=np.bool)\n prog = even_odd_program()\n # print(prog)\n typed = type_inference.infer_types(prog, [inputs], NP_BACKEND)\n # print(typed)\n alloc = allocation_strategy.optimize(typed)\n lowered = lowering.lower_function_calls(alloc)\n # print(lowered)\n self.assertAllEqual(outputs, _execute(lowered, inputs, 15, NP_BACKEND))\n\n def testAutoBatchingEvenOddTF(self):\n for inputs, outputs in ([5], [False]), ([5, 6, 8, 9],\n [False, True, True, False]):\n inputs = np.array(inputs, dtype=np.int32)\n outputs = np.array(outputs, dtype=np.int32)\n prog = even_odd_program()\n # print(prog)\n inputs_t = tf.constant(inputs, dtype=np.int32)\n typed = type_inference.infer_types(prog, [inputs_t], TF_BACKEND)\n # print(typed)\n alloc = allocation_strategy.optimize(typed)\n lowered = lowering.lower_function_calls(alloc)\n # print(lowered)\n self.assertAllEqual(\n outputs, self.evaluate(_execute(lowered, inputs_t, 15, TF_BACKEND)))\n\n def testAutoBatchingMultivalueTF(self):\n input_ = np.array([1, 1, 1], dtype=np.int64)\n output = ((np.array([1, 1, 1], dtype=np.int64),\n np.array([3, 3, 3], dtype=np.int64)),\n np.array([4, 4, 4], dtype=np.int64),\n (np.array([5, 5, 5], dtype=np.int64),\n np.array([6, 6, 6], dtype=np.int64)))\n prog = synthetic_pattern_program()\n # print(prog)\n input_t = tf.constant(input_, dtype=np.int64)\n typed = type_inference.infer_types(prog, [input_t], TF_BACKEND)\n # print(typed)\n alloc = allocation_strategy.optimize(typed)\n lowered = lowering.lower_function_calls(alloc)\n # print(lowered)\n for expected, obtained in instructions.pattern_zip(\n output, self.evaluate(_execute(lowered, input_t, 15, TF_BACKEND))):\n self.assertAllEqual(expected, obtained)\n\nif __name__ == '__main__':\n tf.test.main()\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\"\"\"CategoricalToDiscrete bijector.\n\nThis bijector is hidden from public API for now because it is only valid for\ncategorical distribution.\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport tensorflow.compat.v2 as tf\n\nfrom tensorflow_probability.python.bijectors import bijector\nfrom tensorflow_probability.python.internal import assert_util\nfrom tensorflow_probability.python.internal import dtype_util\nfrom tensorflow_probability.python.internal import tensor_util\nfrom tensorflow_probability.python.internal import tensorshape_util\n\n__all__ = [\n 'CategoricalToDiscrete',\n]\n\n\nclass CategoricalToDiscrete(bijector.Bijector):\n \"\"\"Bijector which computes `Y = g(X) = values[X]`.\n\n Example Usage:\n\n ```python\n bijector = CategoricalToDiscrete(map_values=[0.01, 0.1, 1., 10.])\n bijector.forward([1, 3, 2, 1, 0]) = [1., 10., 1., 0.1, 0.01]\n bijector.inverse([1., 10., 1., 0.1, 0.01]) = [1, 3, 2, 1, 0]\n ```\n\n \"\"\"\n\n def __init__(self,\n map_values,\n validate_args=False,\n name='categorical_to_discrete'):\n \"\"\"Instantiates `CategoricalToDiscrete` bijector.\n\n Args:\n map_values: 1D numerical tensor of discrete values to map to, sorted in\n strictly increasing order.\n validate_args: Python `bool` indicating whether arguments should be\n checked for correctness.\n name: Python `str` name given to ops managed by this object.\n \"\"\"\n with tf.name_scope(name):\n dtype = dtype_util.common_dtype([map_values], tf.float32)\n self._map_values = tensor_util.convert_nonref_to_tensor(\n map_values, name='map_values', dtype=dtype)\n super(CategoricalToDiscrete, self).__init__(\n forward_min_event_ndims=0,\n is_constant_jacobian=True,\n validate_args=validate_args,\n name=name)\n\n def _forward(self, x):\n map_values = tf.convert_to_tensor(self.map_values)\n if self.validate_args:\n with tf.control_dependencies([\n assert_util.assert_equal(\n (0 <= x) & (x < tf.size(map_values)),\n True,\n message='indices out of bound')\n ]):\n x = tf.identity(x)\n # If we want batch dims in self.map_values, we can (after broadcasting),\n # use:\n # tf.gather(self.map_values, x, batch_dims=-1, axis=-1)\n return tf.gather(map_values, indices=x)\n\n def _inverse(self, y):\n map_values = tf.convert_to_tensor(self.map_values)\n flat_y = tf.reshape(y, shape=[-1])\n # Search for the indices of map_values that are closest to flat_y.\n # Since map_values is strictly increasing, the closest is either the\n # first one that is strictly greater than flat_y, or the one before it.\n upper_candidates = tf.minimum(\n tf.size(map_values) - 1,\n tf.searchsorted(map_values, values=flat_y, side='right'))\n lower_candidates = tf.maximum(0, upper_candidates - 1)\n candidates = tf.stack([lower_candidates, upper_candidates], axis=-1)\n lower_cand_diff = tf.abs(flat_y - self._forward(lower_candidates))\n upper_cand_diff = tf.abs(flat_y - self._forward(upper_candidates))\n if self.validate_args:\n with tf.control_dependencies([\n assert_util.assert_near(\n tf.minimum(lower_cand_diff, upper_cand_diff),\n 0,\n message='inverse value not found')\n ]):\n candidates = tf.identity(candidates)\n candidate_selector = tf.stack([\n tf.range(tf.size(flat_y), dtype=tf.int32),\n tf.argmin([lower_cand_diff, upper_cand_diff], output_type=tf.int32)\n ],\n axis=-1)\n return tf.reshape(\n tf.gather_nd(candidates, candidate_selector), shape=y.shape)\n\n def _inverse_log_det_jacobian(self, y):\n return tf.constant(0., dtype=y.dtype)\n\n @property\n def map_values(self):\n return self._map_values\n\n def _parameter_control_dependencies(self, is_init):\n return _maybe_check_valid_map_values(self.map_values, self.validate_args)\n\n\ndef _maybe_check_valid_map_values(map_values, validate_args):\n \"\"\"Validate `map_values` if `validate_args`==True.\"\"\"\n assertions = []\n\n message = 'Rank of map_values must be 1.'\n if tensorshape_util.rank(map_values.shape) is not None:\n if tensorshape_util.rank(map_values.shape) != 1:\n raise ValueError(message)\n elif validate_args:\n assertions.append(assert_util.assert_rank(map_values, 1, message=message))\n\n message = 'Size of map_values must be greater than 0.'\n if tensorshape_util.num_elements(map_values.shape) is not None:\n if tensorshape_util.num_elements(map_values.shape) == 0:\n raise ValueError(message)\n elif validate_args:\n assertions.append(\n assert_util.assert_greater(tf.size(map_values), 0, message=message))\n\n if validate_args:\n assertions.append(\n assert_util.assert_equal(\n tf.math.is_strictly_increasing(map_values),\n True,\n message='map_values is not strictly increasing.'))\n\n return assertions\n"
]
| [
[
"tensorflow.compat.v1.name_scope",
"tensorflow.compat.v2.range",
"tensorflow.compat.v2.TensorArray",
"tensorflow.compat.v2.shape",
"tensorflow.compat.v2.cast",
"tensorflow.compat.v2.unstack",
"tensorflow.compat.v2.reshape",
"tensorflow.compat.v2.compat.dimension_value",
"tensorflow.compat.v2.stack",
"tensorflow.compat.v2.size",
"tensorflow.compat.v2.convert_to_tensor",
"tensorflow.compat.v2.constant"
],
[
"tensorflow.compat.v2.cast",
"numpy.mean",
"tensorflow.compat.v1.set_random_seed",
"tensorflow.compat.v2.test.main",
"numpy.concatenate",
"tensorflow.compat.v1.global_variables_initializer",
"tensorflow.compat.v1.train.get_or_create_global_step",
"numpy.sqrt",
"tensorflow.compat.v1.train.polynomial_decay",
"tensorflow.compat.v2.linalg.cholesky",
"tensorflow.compat.v2.concat",
"numpy.zeros",
"tensorflow.compat.v2.math.rsqrt",
"tensorflow.compat.v2.expand_dims",
"tensorflow.compat.v2.linalg.matvec",
"tensorflow.compat.v2.executing_eagerly",
"tensorflow.compat.v2.Variable",
"tensorflow.compat.v2.square",
"tensorflow.compat.v2.ones_like",
"tensorflow.compat.v2.constant"
],
[
"numpy.ones_like",
"numpy.random.rand",
"tensorflow.compat.v2.matmul",
"scipy.stats.dirichlet.mean",
"tensorflow.compat.v2.GradientTape",
"tensorflow.compat.v2.sqrt",
"scipy.special.digamma",
"scipy.stats.beta",
"tensorflow.compat.v2.test.main",
"numpy.zeros_like",
"scipy.stats.dirichlet.entropy",
"scipy.stats.dirichlet.var",
"numpy.isfinite",
"numpy.array",
"numpy.zeros",
"tensorflow.compat.v2.linalg.diag_part",
"tensorflow.compat.v2.Variable",
"tensorflow.compat.v2.reduce_mean",
"scipy.special.gammaln",
"tensorflow.compat.v2.TensorShape",
"numpy.sum",
"numpy.ones",
"tensorflow.compat.v2.zeros",
"numpy.all",
"tensorflow.compat.v2.constant"
],
[
"tensorflow.compat.v2.config.experimental_run_functions_eagerly",
"tensorflow.python.framework.test_combinations.combine",
"tensorflow.python.framework.test_combinations.OptionalParameter",
"tensorflow.python.framework.combinations.EagerGraphCombination"
],
[
"numpy.logical_or",
"numpy.ones_like",
"tensorflow.compat.v1.placeholder_with_default",
"numpy.zeros",
"tensorflow.compat.v2.shape",
"numpy.asarray",
"tensorflow.compat.v2.TensorShape",
"numpy.ones",
"tensorflow.compat.v2.Variable",
"tensorflow.compat.v2.GradientTape",
"tensorflow.compat.v1.set_random_seed",
"tensorflow.compat.v2.convert_to_tensor",
"tensorflow.compat.v2.reduce_mean",
"tensorflow.compat.v2.test.main"
],
[
"tensorflow.python.util.all_util.remove_undocumented"
],
[
"numpy.array",
"tensorflow.compat.v2.constant",
"tensorflow.compat.v2.test.main"
],
[
"tensorflow.compat.v2.gather_nd",
"tensorflow.compat.v2.math.is_strictly_increasing",
"tensorflow.compat.v2.gather",
"tensorflow.compat.v2.searchsorted",
"tensorflow.compat.v2.maximum",
"tensorflow.compat.v2.reshape",
"tensorflow.compat.v2.minimum",
"tensorflow.compat.v2.argmin",
"tensorflow.compat.v2.stack",
"tensorflow.compat.v2.size",
"tensorflow.compat.v2.name_scope",
"tensorflow.compat.v2.convert_to_tensor",
"tensorflow.compat.v2.identity",
"tensorflow.compat.v2.constant"
]
]
|
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.nn.functional.normalize",
"numpy.asarray",
"numpy.random.seed",
"numpy.round",
"numpy.triu",
"torch.from_numpy",
"torch.manual_seed",
"numpy.nonzero",
"sklearn.cluster.DBSCAN",
"numpy.sort",
"torch.nn.DataParallel",
"torch.pow"
]
]
|
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.array",
"sklearn.preprocessing.minmax_scale",
"numpy.logical_xor",
"sklearn.preprocessing.StandardScaler",
"torch.nn.Sequential",
"numpy.random.permutation",
"numpy.ones",
"numpy.where",
"numpy.apply_along_axis",
"scipy.ndimage.median_filter",
"sklearn.preprocessing.binarize",
"sklearn.preprocessing.MultiLabelBinarizer",
"numpy.convolve"
]
]
|
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.zeros",
"numpy.exp",
"matplotlib.pyplot.set_cmap",
"matplotlib.pyplot.figure",
"matplotlib.ticker.FormatStrFormatter",
"matplotlib.ticker.LinearLocator",
"numpy.sqrt",
"numpy.fft.fftshift",
"matplotlib.pyplot.show",
"numpy.linspace",
"numpy.meshgrid",
"matplotlib.pyplot.imshow"
]
]
|
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.TextLineReader",
"tensorflow.train.shuffle_batch",
"tensorflow.decode_csv"
]
]
|
HusseinLezzaik/Consensus-Algorithm-for-2-Mobile-Robots | [
"ecdb28793cc1f5fa6cded752908105ec37e9bfc7",
"ecdb28793cc1f5fa6cded752908105ec37e9bfc7",
"ecdb28793cc1f5fa6cded752908105ec37e9bfc7"
]
| [
"Real Topology Graph/GNN Model 2/Fully Connected Graph/test_n3_cyclic.py",
"Real Topology Graph/GNN Model 1/Fully Connected Graph/Main_MLP_line.py",
"Real Topology Graph/GNN Model 2/Cyclic Graph/test_n2_robot3.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",
"\"\"\"\n\nConsensus Algorithm for 6 Mobile robots using MLP Model for Line Graph Implementation\n\nInputs: Mx, My\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#distance = 2\n\nA = np.ones(6) - np.identity(6) # Adjancency Matrix fully connected case 6x6\n\nux = np.zeros((6,1)) # 6x1 controller vector\nuy = np.zeros((6,1)) # 6x1 controller vector\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\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.publisher_l4 = self.create_publisher(Float32, '/leftMotorSpeedrobot4', 0) #Change according to topic in child script,String to Float32\n self.publisher_r4 = self.create_publisher(Float32, '/rightMotorSpeedrobot4', 0) #Change according to topic in child script,String to Float32\n self.publisher_l5 = self.create_publisher(Float32, '/leftMotorSpeedrobot5', 0) #Change according to topic in child script,String to Float32\n self.publisher_r5 = self.create_publisher(Float32, '/rightMotorSpeedrobot5', 0) #Change according to topic in child script,String to Float32\n self.publisher_l6 = self.create_publisher(Float32, '/leftMotorSpeedrobot6', 0) #Change according to topic in child script,String to Float32\n self.publisher_r6 = self.create_publisher(Float32, '/rightMotorSpeedrobot6', 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 #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.k = 1 # Control Gain\n self.scene = 0 # Nb of scene iteration\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 1 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 \" Mobile Robot 4 Parameters \"\n self.x4 = 0\n self.y4 = 0\n self.Theta4 = 0\n self.v4 = 0\n self.w4 = 0\n self.vL4 = 0\n self.vR4 = 0 \n \n \" Mobile Robot 5 Parameters \"\n self.x5 = 0\n self.y5 = 0\n self.Theta5 = 0\n self.v5 = 0\n self.w5 = 0\n self.vL5 = 0\n self.vR5 = 0\n\n \" Mobile Robot 6 Parameters \"\n self.x6 = 0\n self.y6 = 0\n self.Theta6 = 0\n self.v6 = 0\n self.w6 = 0\n self.vL6 = 0\n self.vR6 = 0\n \n def timer_callback(self):\n \n \" Calculate Mx1, My1, ...... Mx6, My6 \"\n \n Mx1 = self.x2 - self.x1 # 1x1\n My1 = self.y2 - self.y1 # 1x1\n \n Mx2 = ( ( self.x1 - self.x2 ) + ( self.x3 - self.x2 ) ) / 2 # 1x1\n My2 = ( ( self.y1 - self.y2 ) + ( self.y3 - self.y2 ) ) / 2 # 1x1 \n\n Mx3 = ( ( self.x2 - self.x3 ) + ( self.x4 - self.x3 ) ) / 2 # 1x1\n My3 = ( ( self.y2 - self.y3 ) + ( self.y4 - self.y3 ) ) / 2 # 1x1 \n \n Mx4 = ( ( self.x3 - self.x4 ) + ( self.x5 - self.x4 ) ) / 2 # 1x1\n My4 = ( ( self.y4 - self.y4 ) + ( self.y5 - self.y4 ) ) / 2 # 1x1 \n\n Mx5 = ( ( self.x4 - self.x5 ) + ( self.x6 - self.x5 ) ) / 2 # 1x1\n My5 = ( ( self.y4 - self.y5 ) + ( self.y6 - self.y5 ) ) / 2 # 1x1 \n \n Mx6 = self.x5 - self.x6 # 1x1\n My6 = self.y5 - self.y6 # 1x1 \n\n \" Use MLP to Predict control inputs \"\n \n relative_pose_1 = [ Mx1, My1 ] # tensor data for MLP model\n relative_pose_2 = [ Mx2, My2 ] # tensor data for MLP model\n relative_pose_3 = [ Mx3, My3 ] # tensor data for MLP model\n relative_pose_4 = [ Mx4, My4 ] # tensor data for MLP model\n relative_pose_5 = [ Mx5, My5 ] # tensor data for MLP model\n relative_pose_6 = [ Mx6, My6 ] # tensor data for MLP model\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 u4_predicted = MLP_Model.predict(relative_pose_4, loaded_model) # predict control input u4, tensor\n u5_predicted = MLP_Model.predict(relative_pose_5, loaded_model) # predict control input u5, tensor\n u6_predicted = MLP_Model.predict(relative_pose_6, loaded_model) # predict control input u6, tensor\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 u4_predicted_np = np.array([[ u4_predicted[0][0] ], [ u4_predicted[0][1] ]]) # from tensor to numpy array for calculation \n u5_predicted_np = np.array([[ u5_predicted[0][0] ], [ u5_predicted[0][1] ]]) # from tensor to numpy array for calculation\n u6_predicted_np = np.array([[ u6_predicted[0][0] ], [ u6_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 S4 = np.array([[self.v4], [self.w4]]) #2x1\n G4 = np.array([[1,0], [0,1/L]]) #2x2\n R4 = np.array([[math.cos(self.Theta4),math.sin(self.Theta4)],[-math.sin(self.Theta4),math.cos(self.Theta4)]]) #2x2\n S4 = np.dot(np.dot(G4, R4), u4_predicted_np) #2x1 \n\n S5 = np.array([[self.v5], [self.w5]]) #2x1\n G5 = np.array([[1,0], [0,1/L]]) #2x2\n R5 = np.array([[math.cos(self.Theta5),math.sin(self.Theta5)],[-math.sin(self.Theta5),math.cos(self.Theta5)]]) #2x2\n S5 = np.dot(np.dot(G5, R5), u5_predicted_np) #2x1\n\n S6 = np.array([[self.v6], [self.w6]]) #2x1\n G6 = np.array([[1,0], [0,1/L]]) #2x2\n R6 = np.array([[math.cos(self.Theta6),math.sin(self.Theta6)],[-math.sin(self.Theta6),math.cos(self.Theta6)]]) #2x2\n S6 = np.dot(np.dot(G6, R6), u6_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 Speed_L4 = np.array([[self.vL4], [self.vR4]]) # Vector 2x1 for Speed of Robot 4\n Speed_L5 = np.array([[self.vL5], [self.vR5]]) # Vector 2x1 for Speed of Robot 5\n Speed_L6 = np.array([[self.vL6], [self.vR6]]) # Vector 2x1 for Speed of Robot 6\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 M4 = np.array([[S4[0]],[S4[1]]]).reshape(2,1) #2x1\n M5 = np.array([[S5[0]],[S5[1]]]).reshape(2,1) #2x1\n M6 = np.array([[S6[0]],[S6[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 (VL3, VR3)\n Speed_L4 = np.dot(Di, M4) # 2x1 (VL4, VR4)\n Speed_L5 = np.dot(Di, M5) # 2x1 (VL5, VR5)\n Speed_L6 = np.dot(Di, M6) # 2x1 (VL6, VR6)\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 VL4 = float(Speed_L4[0])\n VR4 = float(Speed_L4[1])\n VL5 = float(Speed_L5[0])\n VR5 = float(Speed_L5[1]) \n VL6 = float(Speed_L6[0])\n VR6 = float(Speed_L6[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 #self.get_logger().info('Publishing R1: \"%s\"' % msgr1.data)\n\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 \" Publish Speed Commands to Robot 4 \"\n \n msgl4 = Float32()\n msgr4 = Float32()\n msgl4.data = VL4\n msgr4.data = VR4\n self.publisher_l4.publish(msgl4)\n self.publisher_r4.publish(msgr4) \n \n \n \" Publish Speed Commands to Robot 5 \"\n \n msgl5 = Float32()\n msgr5 = Float32()\n msgl5.data = VL5\n msgr5.data = VR5\n self.publisher_l5.publish(msgl5)\n self.publisher_r5.publish(msgr5) \n\n\n \" Publish Speed Commands to Robot 6 \"\n \n msgl6 = Float32()\n msgr6 = Float32()\n msgl6.data = VL6\n msgr6.data = VR6\n self.publisher_l6.publish(msgl6)\n self.publisher_r6.publish(msgr6)\n\n self.i += 1 \n\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\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 \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 if msg.transforms[0].child_frame_id == 'robot4' :\n \n self.x4 = msg.transforms[0].transform.translation.x\n self.y4 = msg.transforms[0].transform.translation.y\n self.xr4 = msg.transforms[0].transform.rotation.x\n self.yr4 = msg.transforms[0].transform.rotation.y\n self.zr4 = msg.transforms[0].transform.rotation.z\n self.wr4 = msg.transforms[0].transform.rotation.w\n self.Theta4 = euler_from_quaternion(self.xr4,self.yr4,self.zr4,self.wr4) \n \n if msg.transforms[0].child_frame_id == 'robot5' :\n \n self.x5 = msg.transforms[0].transform.translation.x\n self.y5 = msg.transforms[0].transform.translation.y\n self.xr5 = msg.transforms[0].transform.rotation.x\n self.yr5 = msg.transforms[0].transform.rotation.y\n self.zr5 = msg.transforms[0].transform.rotation.z\n self.wr5 = msg.transforms[0].transform.rotation.w\n self.Theta5 = euler_from_quaternion(self.xr5,self.yr5,self.zr5,self.wr5) \n \n if msg.transforms[0].child_frame_id == 'robot6' :\n \n self.x6 = msg.transforms[0].transform.translation.x\n self.y6 = msg.transforms[0].transform.translation.y\n self.xr6 = msg.transforms[0].transform.rotation.x\n self.yr6 = msg.transforms[0].transform.rotation.y\n self.zr6 = msg.transforms[0].transform.rotation.z\n self.wr6 = msg.transforms[0].transform.rotation.w\n self.Theta6 = euler_from_quaternion(self.xr6,self.yr6,self.zr6,self.wr6) \n \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\nConsensus Algorithm for 2 Robots using MLP Model\n\nScene: Robot 1, Robot 3\n\nInputs: Mx, My\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_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 timer_period = 0.1 # 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.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 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.Phix3 = 0 # 1x1\n self.Phiy3 = 0 # 1x1\n self.t += 1 \n \n Mx1 = self.x3 - self.x1\n My1 = self.y3 - self.y1\n \n Mx3 = self.x1 - self.x3\n My3 = self.y1 - self.y3 \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_3 = [ Mx3, My3, self.Phix3, self.Phiy3 ] # tensor data for MLP model\n\n u1_predicted = MLP_Model.predict(relative_pose_1, loaded_model) # predict control input u1, tensor\n u3_predicted = MLP_Model.predict(relative_pose_3, loaded_model) # predict control input u2, tensor\n\n self.Phix1 = u3_predicted[0][0] # 1x1\n self.Phiy1 = u3_predicted[0][1] # 1x1\n \n self.Phix3 = u1_predicted[0][0] # 1x1\n self.Phiy3 = u1_predicted[0][1] # 1x1\n \n u1_predicted_np = np.array([[ u1_predicted[0][0] ], [ u1_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 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_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 M3 = np.array([[S3[0]],[S3[1]]]).reshape(2,1) #2x1\n\n Speed_L1 = np.dot(Di, M1) # 2x1 (VL1, VR1)\n Speed_L3 = np.dot(Di, M3) # 2x1 (VL1, VR1)\n\n VL1 = float(Speed_L1[0])\n VR1 = float(Speed_L1[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 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 == '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.dot",
"numpy.linalg.inv",
"torch.load"
],
[
"numpy.array",
"numpy.dot",
"numpy.zeros",
"numpy.ones",
"numpy.identity",
"torch.load",
"numpy.linalg.inv"
],
[
"numpy.array",
"numpy.dot",
"numpy.linalg.inv",
"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.testing.assert_allclose",
"numpy.array",
"numpy.sin",
"numpy.random.rand",
"numpy.isnan",
"numpy.random.RandomState",
"numpy.random.seed",
"numpy.logspace",
"numpy.diff",
"numpy.arange",
"numpy.cos",
"numpy.linspace",
"numpy.meshgrid",
"numpy.vstack"
]
]
|
davidbrochart/pythran | [
"24b6c8650fe99791a4091cbdc2c24686e86aa67c",
"24b6c8650fe99791a4091cbdc2c24686e86aa67c",
"24b6c8650fe99791a4091cbdc2c24686e86aa67c",
"24b6c8650fe99791a4091cbdc2c24686e86aa67c"
]
| [
"pythran/tests/cases/lapl3d.py",
"docs/papers/sc2013/hyantes_core.py",
"pythran/tests/pydata/compute_mask.py",
"pythran/tests/scipy/solve_toeplitz.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",
"#pythran export run(float, float, float, float, float, float, int, int, float [][])\nimport math\nfrom numpy import zeros\ndef run(xmin, ymin, xmax, ymax, step, range_, range_x, range_y, t):\n pt = zeros((range_x, range_y, 3))\n \"omp parallel for private(i,j,k,tmp)\"\n for i in xrange(range_x):\n for j in xrange(range_y):\n pt[i,j,0], pt[i,j,1] = (xmin+step*i)*180/math.pi, (ymin+step*j)*180/math.pi\n for k in xrange(t.shape[0]):\n tmp = 6368.* math.acos( math.cos(xmin+step*i)*math.cos( t[k,0] ) * math.cos((ymin+step*j)-t[k,1])+ math.sin(xmin+step*i)*math.sin(t[k,0]))\n if tmp < range_:\n pt[i,j,2]+= t[k,2] / (1+tmp)\n return pt\n",
"#pythran export compute_mask(int[:,:], int[:,:])\n#runas import numpy as np; coords = np.array([[0, 0, 1, 1, 2, 2]]); indices = np.array([[0, 3, 2]]); compute_mask(coords, indices)\n\nimport numpy as np\ndef compute_mask(coords, indices): # pragma: no cover\n \"\"\"\n Gets the mask for the coords given the indices in slice format.\n\n Works with either start-stop ranges of matching indices into coords\n called \"pairs\" (start-stop pairs) or filters the mask directly, based\n on which is faster.\n\n Exploits the structure in sorted coords, which is that for a constant\n value of coords[i - 1], coords[i - 2] and so on, coords[i] is sorted.\n Concretely, ``coords[i, coords[i - 1] == v1 & coords[i - 2] = v2, ...]``\n is always sorted. It uses this sortedness to find sub-pairs for each\n dimension given the previous, and so on. This is efficient for small\n slices or ints, but not for large ones.\n\n After it detects that working with pairs is rather inefficient (or after\n going through each possible index), it constructs a filtered mask from the\n start-stop pairs.\n\n Parameters\n ----------\n coords : np.ndarray\n The coordinates of the array.\n indices : np.ndarray\n The indices in the form of slices such that indices[:, 0] are starts,\n indices[:, 1] are stops and indices[:, 2] are steps.\n\n Returns\n -------\n mask : np.ndarray\n The starts and stops in the mask.\n is_slice : bool\n Whether or not the array represents a continuous slice.\n\n Examples\n --------\n Let's create some mock coords and indices\n\n >>> import numpy as np\n >>> coords = np.array([[0, 0, 1, 1, 2, 2]])\n >>> indices = np.array([[0, 3, 2]]) # Equivalent to slice(0, 3, 2)\n\n Now let's get the mask. Notice that the indices of ``0`` and ``2`` are matched.\n\n >>> _compute_mask(coords, indices)\n (array([0, 1, 4, 5]), False)\n\n Now, let's try with a more \"continuous\" slice. Matches ``0`` and ``1``.\n\n >>> indices = np.array([[0, 2, 1]])\n >>> _compute_mask(coords, indices)\n (array([0, 4]), True)\n\n This is equivalent to mask being ``slice(0, 4, 1)``.\n \"\"\"\n # Set the initial mask to be the entire range of coordinates.\n starts = [0]\n stops = [coords.shape[1]]\n n_matches = coords.shape[1]\n\n i = 0\n while i < len(indices):\n # Guesstimate whether working with pairs is more efficient or\n # working with the mask directly.\n # One side is the estimate of time taken for binary searches\n # (n_searches * log(avg_length))\n # The other is an estimated time of a linear filter for the mask.\n n_pairs = len(starts)\n n_current_slices = _get_slice_len(indices[i]) * n_pairs + 2\n if n_current_slices * np.log(n_current_slices / max(n_pairs, 1)) > \\\n n_matches + n_pairs:\n break\n\n # For each of the pairs, search inside the coordinates for other\n # matching sub-pairs.\n # This gets the start-end coordinates in coords for each 'sub-array'\n # Which would come out of indexing a single integer.\n starts, stops, n_matches = _get_mask_pairs(starts, stops, coords[i], indices[i])\n\n i += 1\n\n # Combine adjacent pairs\n starts, stops = _join_adjacent_pairs(starts, stops)\n\n # If just one pair is left over, treat it as a slice.\n if i == len(indices) and len(starts) == 1:\n return np.array([starts[0], stops[0]]), True\n\n # Convert start-stop pairs into mask, filtering by remaining\n # coordinates.\n mask = _filter_pairs(starts, stops, coords[i:], indices[i:])\n\n return np.array(mask, dtype=np.intp), False\n\n\ndef _get_slice_len(idx):\n \"\"\"\n Get the number of elements in a slice.\n\n Parameters\n ----------\n idx : np.ndarray\n A (3,) shaped array containing start, stop, step\n\n Returns\n -------\n n : int\n The length of the slice.\n\n Examples\n --------\n >>> idx = np.array([5, 15, 5])\n >>> _get_slice_len(idx)\n 2\n \"\"\"\n start, stop, step = idx[0], idx[1], idx[2]\n\n if step > 0:\n return (stop - start + step - 1) // step\n else:\n return (start - stop - step - 1) // (-step)\n\n\ndef _get_mask_pairs(starts_old, stops_old, c, idx): # pragma: no cover\n \"\"\"\n Gets the pairs for a following dimension given the pairs for\n a dimension.\n\n For each pair, it searches in the following dimension for\n matching coords and returns those.\n\n The total combined length of all pairs is returned to\n help with the performance guesstimate.\n\n Parameters\n ----------\n starts_old, stops_old : list[int]\n The starts and stops from the previous index.\n c : np.ndarray\n The coords for this index's dimension.\n idx : np.ndarray\n The index in the form of a slice.\n idx[0], idx[1], idx[2] = start, stop, step\n\n Returns\n -------\n starts, stops: list\n The starts and stops after applying the current index.\n n_matches : int\n The sum of elements in all ranges.\n\n Examples\n --------\n >>> c = np.array([1, 2, 1, 2, 1, 1, 2, 2])\n >>> starts_old = [4]\n >>> stops_old = [8]\n >>> idx = np.array([1, 2, 1])\n >>> _get_mask_pairs(starts_old, stops_old, c, idx)\n ([4], [6], 2)\n \"\"\"\n starts = []\n stops = []\n n_matches = 0\n\n for j in range(len(starts_old)):\n # For each matching \"integer\" in the slice, search within the \"sub-coords\"\n # Using binary search.\n for p_match in range(idx[0], idx[1], idx[2]):\n start = np.searchsorted(c[starts_old[j]:stops_old[j]], p_match) + starts_old[j]\n stop = np.searchsorted(c[starts_old[j]:stops_old[j]], p_match + 1) + starts_old[j]\n\n if start != stop:\n starts.append(start)\n stops.append(stop)\n n_matches += stop - start\n\n return starts, stops, n_matches\n\ndef _join_adjacent_pairs(starts_old, stops_old): # pragma: no cover\n \"\"\"\n Joins adjacent pairs into one. For example, 2-5 and 5-7\n will reduce to 2-7 (a single pair). This may help in\n returning a slice in the end which could be faster.\n\n Parameters\n ----------\n starts_old, stops_old : list[int]\n The input starts and stops\n\n Returns\n -------\n starts, stops : list[int]\n The reduced starts and stops.\n\n Examples\n --------\n >>> starts = [2, 5]\n >>> stops = [5, 7]\n >>> _join_adjacent_pairs(starts, stops)\n ([2], [7])\n \"\"\"\n if len(starts_old) <= 1:\n return starts_old, stops_old\n\n starts = [starts_old[0]]\n stops = []\n\n for i in range(1, len(starts_old)):\n if starts_old[i] != stops_old[i - 1]:\n starts.append(starts_old[i])\n stops.append(stops_old[i - 1])\n\n stops.append(stops_old[-1])\n\n return starts, stops\n\ndef _filter_pairs(starts, stops, coords, indices): # pragma: no cover\n \"\"\"\n Converts all the pairs into a single integer mask, additionally filtering\n by the indices.\n\n Parameters\n ----------\n starts, stops : list[int]\n The starts and stops to convert into an array.\n coords : np.ndarray\n The coordinates to filter by.\n indices : np.ndarray\n The indices in the form of slices such that indices[:, 0] are starts,\n indices[:, 1] are stops and indices[:, 2] are steps.\n\n Returns\n -------\n mask : list\n The output integer mask.\n\n Examples\n --------\n >>> import numpy as np\n >>> starts = [2]\n >>> stops = [7]\n >>> coords = np.array([[0, 1, 2, 3, 4, 5, 6, 7]])\n >>> indices = np.array([[2, 8, 2]]) # Start, stop, step pairs\n >>> _filter_pairs(starts, stops, coords, indices)\n [2, 4, 6]\n \"\"\"\n mask = []\n\n # For each pair,\n for i in range(len(starts)):\n # For each element match within the pair range\n for j in range(starts[i], stops[i]):\n match = True\n\n # Check if it matches all indices\n for k in range(len(indices)):\n idx = indices[k]\n elem = coords[k, j]\n\n match &= ((elem - idx[0]) % idx[2] == 0 and\n ((idx[2] > 0 and idx[0] <= elem < idx[1])\n or (idx[2] < 0 and idx[0] >= elem > idx[1])))\n\n # and append to the mask if so.\n if match:\n mask.append(j)\n\n return mask\n",
"# Author: Robert T. McGibbon, December 2014\n\nfrom numpy import zeros, asarray, complex128, float64, zeros_like\n\n#pythran export levinson(float64[], float64[])\n#pythran export levinson(complex128[], complex128[])\n#runas import numpy as np; x = np.arange(1, 4.)*7; y = np.arange(-11., -9.)\n\ndef levinson(a, b):\n \"\"\"Solve a linear Toeplitz system using Levinson recursion.\n\n Parameters\n ----------\n a : array, dtype=double or complex128, shape=(2n-1,)\n The first column of the matrix in reverse order (without the diagonal)\n followed by the first (see below)\n b : array, dtype=double or complex128, shape=(n,)\n The right hand side vector. Both a and b must have the same type\n (double or complex128).\n\n Notes\n -----\n For example, the 5x5 toeplitz matrix below should be represented as\n the linear array ``a`` on the right ::\n\n [ a0 a1 a2 a3 a4 ]\n [ a-1 a0 a1 a2 a3 ]\n [ a-2 a-1 a0 a1 a2 ] -> [a-4 a-3 a-2 a-1 a0 a1 a2 a3 a4]\n [ a-3 a-2 a-1 a0 a1 ]\n [ a-4 a-3 a-2 a-1 a0 ]\n\n Returns\n -------\n x : arrray, shape=(n,)\n The solution vector\n reflection_coeff : array, shape=(n+1,)\n Toeplitz reflection coefficients. When a is symmetric Toeplitz and\n ``b`` is ``a[n:]``, as in the solution of autoregressive systems,\n then ``reflection_coeff`` also correspond to the partial\n autocorrelation function.\n \"\"\"\n # Adapted from toeplitz.f90 by Alan Miller, accessed at\n # http://jblevins.org/mirror/amiller/toeplitz.f90\n # Released under a Public domain declaration.\n\n n = b.shape[0]\n x = zeros_like(b) # result\n g = zeros_like(b) # workspace\n h = zeros_like(b) # workspace\n reflection_coeff = zeros(n+1, dtype=b.dtype) # history\n assert len(a) == (2*n) - 1\n\n if a[n-1] == 0:\n raise ValueError('Singular principal minor')\n\n x[0] = b[0] / a[n-1]\n reflection_coeff[0] = 1\n reflection_coeff[1] = x[0]\n\n if (n == 1):\n return asarray(x), asarray(reflection_coeff)\n\n g[0] = a[n-2] / a[n-1]\n h[0] = a[n] / a[n-1]\n\n for m in range(1, n):\n # Compute numerator and denominator of x[m]\n x_num = -b[m]\n x_den = -a[n-1]\n for j in range(m):\n nmj = n + m - (j+1)\n x_num = x_num + a[nmj] * x[j]\n x_den = x_den + a[nmj] * g[m-j-1]\n if x_den == 0:\n raise ValueError('Singular principal minor')\n x[m] = x_num / x_den\n reflection_coeff[m+1] = x[m]\n\n # Compute x\n for j in range(m):\n x[j] = x[j] - x[m] * g[m-j-1]\n if m == n-1:\n return asarray(x), asarray(reflection_coeff)\n\n # Compute the numerator and denominator of g[m] and h[m]\n g_num = -a[n-m-2]\n h_num = -a[n+m]\n g_den = -a[n-1]\n for j in range(m):\n g_num = g_num + a[n+j-m-1] * g[j]\n h_num = h_num + a[n+m-j-1] * h[j]\n g_den = g_den + a[n+j-m-1] * h[m-j-1]\n\n if g_den == 0.0:\n raise ValueError(\"Singular principal minor\")\n\n # Compute g and h\n g[m] = g_num / g_den\n h[m] = h_num / x_den\n k = m - 1\n m2 = (m + 1) >> 1\n c1 = g[m]\n c2 = h[m]\n for j in range(m2):\n gj = g[j]\n gk = g[k]\n hj = h[j]\n hk = h[k]\n g[j] = gj - (c1 * hk)\n g[k] = gk - (c1 * hj)\n h[j] = hj - (c2 * gk)\n h[k] = hk - (c2 * gj)\n k -= 1\n"
]
| [
[
"numpy.max",
"numpy.abs"
],
[
"numpy.zeros"
],
[
"numpy.searchsorted",
"numpy.array"
],
[
"numpy.zeros_like",
"numpy.asarray",
"numpy.zeros"
]
]
|
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.std",
"numpy.array"
]
]
|
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.load",
"numpy.save"
]
]
|
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.ReLU",
"torch.nn.Conv2d",
"torch.nn.Linear",
"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"
]
| [
[
"torch.distributed.is_available",
"torch.distributed.get_world_size",
"torch.utils.data.get_worker_info",
"scipy.io.loadmat",
"torch.distributed.is_initialized",
"numpy.frombuffer",
"torch.distributed.get_rank"
]
]
|
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.DataFrame",
"pandas.read_csv",
"pandas.Series",
"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",
"046e625b09262261373d7b8039fb652547201368",
"e0db5a564225a7cb62e7a23df97267019006302f"
]
| [
"monai/networks/blocks/dints_block.py",
"monai/handlers/utils.py",
"tests/test_hausdorff_distance.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",
"# 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\nimport os\nfrom collections import OrderedDict\nfrom typing import TYPE_CHECKING, Dict, Optional, Sequence, Union\n\nimport numpy as np\nimport torch\n\nfrom monai.config import IgniteInfo, KeysCollection, PathLike\nfrom monai.utils import ensure_tuple, look_up_option, min_version, optional_import\n\nidist, _ = optional_import(\"ignite\", IgniteInfo.OPT_IMPORT_VERSION, min_version, \"distributed\")\nif TYPE_CHECKING:\n from ignite.engine import Engine\nelse:\n Engine, _ = optional_import(\"ignite.engine\", IgniteInfo.OPT_IMPORT_VERSION, min_version, \"Engine\")\n\n__all__ = [\"stopping_fn_from_metric\", \"stopping_fn_from_loss\", \"write_metrics_reports\", \"from_engine\"]\n\n\ndef stopping_fn_from_metric(metric_name: str):\n \"\"\"\n Returns a stopping function for ignite.handlers.EarlyStopping using the given metric name.\n \"\"\"\n\n def stopping_fn(engine: Engine):\n return engine.state.metrics[metric_name]\n\n return stopping_fn\n\n\ndef stopping_fn_from_loss():\n \"\"\"\n Returns a stopping function for ignite.handlers.EarlyStopping using the loss value.\n \"\"\"\n\n def stopping_fn(engine: Engine):\n return -engine.state.output # type:ignore\n\n return stopping_fn\n\n\ndef write_metrics_reports(\n save_dir: PathLike,\n images: Optional[Sequence[str]],\n metrics: Optional[Dict[str, Union[torch.Tensor, np.ndarray]]],\n metric_details: Optional[Dict[str, Union[torch.Tensor, np.ndarray]]],\n summary_ops: Optional[Union[str, Sequence[str]]],\n deli: str = \",\",\n output_type: str = \"csv\",\n):\n \"\"\"\n Utility function to write the metrics into files, contains 3 parts:\n 1. if `metrics` dict is not None, write overall metrics into file, every line is a metric name and value pair.\n 2. if `metric_details` dict is not None, write raw metric data of every image into file, every line for 1 image.\n 3. if `summary_ops` is not None, compute summary based on operations on `metric_details` and write to file.\n\n Args:\n save_dir: directory to save all the metrics reports.\n images: name or path of every input image corresponding to the metric_details data.\n if None, will use index number as the filename of every input image.\n metrics: a dictionary of (metric name, metric value) pairs.\n metric_details: a dictionary of (metric name, metric raw values) pairs, usually, it comes from metrics\n computation, for example, the raw value can be the mean_dice of every channel of every input image.\n summary_ops: expected computation operations to generate the summary report.\n it can be: None, \"*\" or list of strings, default to None.\n None - don't generate summary report for every expected metric_details.\n \"*\" - generate summary report for every metric_details with all the supported operations.\n list of strings - generate summary report for every metric_details with specified operations, they\n should be within list: [\"mean\", \"median\", \"max\", \"min\", \"<int>percentile\", \"std\", \"notnans\"].\n the number in \"<int>percentile\" should be [0, 100], like: \"15percentile\". default: \"90percentile\".\n for more details, please check: https://numpy.org/doc/stable/reference/generated/numpy.nanpercentile.html.\n note that: for the overall summary, it computes `nanmean` of all classes for each image first,\n then compute summary. example of the generated summary report::\n\n class mean median max 5percentile 95percentile notnans\n class0 6.0000 6.0000 7.0000 5.1000 6.9000 2.0000\n class1 6.0000 6.0000 6.0000 6.0000 6.0000 1.0000\n mean 6.2500 6.2500 7.0000 5.5750 6.9250 2.0000\n\n deli: the delimiter character in the saved file, default to \",\" as the default output type is `csv`.\n to be consistent with: https://docs.python.org/3/library/csv.html#csv.Dialect.delimiter.\n output_type: expected output file type, supported types: [\"csv\"], default to \"csv\".\n\n \"\"\"\n if output_type.lower() != \"csv\":\n raise ValueError(f\"unsupported output type: {output_type}.\")\n\n if not os.path.exists(save_dir):\n os.makedirs(save_dir)\n\n if metrics is not None and len(metrics) > 0:\n with open(os.path.join(save_dir, \"metrics.csv\"), \"w\") as f:\n for k, v in metrics.items():\n f.write(f\"{k}{deli}{str(v)}\\n\")\n if metric_details is not None and len(metric_details) > 0:\n for k, v in metric_details.items():\n if isinstance(v, torch.Tensor):\n v = v.cpu().numpy()\n if v.ndim == 0:\n # reshape to [1, 1] if no batch and class dims\n v = v.reshape((1, 1))\n elif v.ndim == 1:\n # reshape to [N, 1] if no class dim\n v = v.reshape((-1, 1))\n\n # add the average value of all classes to v\n class_labels = [\"class\" + str(i) for i in range(v.shape[1])] + [\"mean\"]\n v = np.concatenate([v, np.nanmean(v, axis=1, keepdims=True)], axis=1)\n\n with open(os.path.join(save_dir, f\"{k}_raw.csv\"), \"w\") as f:\n f.write(f\"filename{deli}{deli.join(class_labels)}\\n\")\n for i, b in enumerate(v):\n f.write(f\"{images[i] if images is not None else str(i)}{deli}{deli.join([str(c) for c in b])}\\n\")\n\n if summary_ops is not None:\n supported_ops = OrderedDict(\n {\n \"mean\": np.nanmean,\n \"median\": np.nanmedian,\n \"max\": np.nanmax,\n \"min\": np.nanmin,\n \"90percentile\": lambda x: np.nanpercentile(x[0], x[1]),\n \"std\": np.nanstd,\n \"notnans\": lambda x: (~np.isnan(x)).sum(),\n }\n )\n ops = ensure_tuple(summary_ops)\n if \"*\" in ops:\n ops = tuple(supported_ops.keys())\n\n def _compute_op(op: str, d: np.ndarray):\n if not op.endswith(\"percentile\"):\n c_op = look_up_option(op, supported_ops)\n return c_op(d)\n\n threshold = int(op.split(\"percentile\")[0])\n return supported_ops[\"90percentile\"]((d, threshold)) # type: ignore\n\n with open(os.path.join(save_dir, f\"{k}_summary.csv\"), \"w\") as f:\n f.write(f\"class{deli}{deli.join(ops)}\\n\")\n for i, c in enumerate(np.transpose(v)):\n f.write(f\"{class_labels[i]}{deli}{deli.join([f'{_compute_op(k, c):.4f}' for k in ops])}\\n\")\n\n\ndef from_engine(keys: KeysCollection, first: bool = False):\n \"\"\"\n Utility function to simplify the `batch_transform` or `output_transform` args of ignite components\n when handling dictionary or list of dictionaries(for example: `engine.state.batch` or `engine.state.output`).\n Users only need to set the expected keys, then it will return a callable function to extract data from\n dictionary and construct a tuple respectively.\n\n If data is a list of dictionaries after decollating, extract expected keys and construct lists respectively,\n for example, if data is `[{\"A\": 1, \"B\": 2}, {\"A\": 3, \"B\": 4}]`, from_engine([\"A\", \"B\"]): `([1, 3], [2, 4])`.\n\n It can help avoid a complicated `lambda` function and make the arg of metrics more straight-forward.\n For example, set the first key as the prediction and the second key as label to get the expected data\n from `engine.state.output` for a metric::\n\n from monai.handlers import MeanDice, from_engine\n\n metric = MeanDice(\n include_background=False,\n output_transform=from_engine([\"pred\", \"label\"])\n )\n\n Args:\n keys: specified keys to extract data from dictionary or decollated list of dictionaries.\n first: whether only extract specified keys from the first item if input data is a list of dictionaries,\n it's used to extract the scalar data which doesn't have batch dim and was replicated into every\n dictionary when decollating, like `loss`, etc.\n\n\n \"\"\"\n keys = ensure_tuple(keys)\n\n def _wrapper(data):\n if isinstance(data, dict):\n return tuple(data[k] for k in keys)\n if isinstance(data, list) and isinstance(data[0], dict):\n # if data is a list of dictionaries, extract expected keys and construct lists,\n # if `first=True`, only extract keys from the first item of the list\n ret = [data[0][k] if first else [i[k] for i in data] for k in keys]\n return tuple(ret) if len(ret) > 1 else ret[0]\n\n return _wrapper\n",
"# 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\nimport unittest\nfrom typing import Tuple\n\nimport numpy as np\nimport torch\nfrom parameterized import parameterized\n\nfrom monai.metrics import HausdorffDistanceMetric\n\n\ndef create_spherical_seg_3d(\n radius: float = 20.0, centre: Tuple[int, int, int] = (49, 49, 49), im_shape: Tuple[int, int, int] = (99, 99, 99)\n) -> np.ndarray:\n \"\"\"\n Return a 3D image with a sphere inside. Voxel values will be\n 1 inside the sphere, and 0 elsewhere.\n\n Args:\n radius: radius of sphere (in terms of number of voxels, can be partial)\n centre: location of sphere centre.\n im_shape: shape of image to create\n\n See also:\n :py:meth:`~create_test_image_3d`\n \"\"\"\n # Create image\n image = np.zeros(im_shape, dtype=np.int32)\n spy, spx, spz = np.ogrid[\n -centre[0] : im_shape[0] - centre[0], -centre[1] : im_shape[1] - centre[1], -centre[2] : im_shape[2] - centre[2]\n ]\n circle = (spx * spx + spy * spy + spz * spz) <= radius * radius\n\n image[circle] = 1\n image[~circle] = 0\n return image\n\n\nTEST_CASES = [\n [[create_spherical_seg_3d(), create_spherical_seg_3d(), 1], [0, 0, 0, 0, 0, 0]],\n [\n [\n create_spherical_seg_3d(radius=20, centre=(20, 20, 20)),\n create_spherical_seg_3d(radius=20, centre=(19, 19, 19)),\n ],\n [1.7320508075688772, 1.7320508075688772, 1, 1, 3, 3],\n ],\n [\n [\n create_spherical_seg_3d(radius=33, centre=(19, 33, 22)),\n create_spherical_seg_3d(radius=33, centre=(20, 33, 22)),\n ],\n [1, 1, 1, 1, 1, 1],\n ],\n [\n [\n create_spherical_seg_3d(radius=20, centre=(20, 33, 22)),\n create_spherical_seg_3d(radius=40, centre=(20, 33, 22)),\n ],\n [20.09975124224178, 20.223748416156685, 15, 20, 24, 35],\n ],\n [\n [\n # pred does not have foreground (but gt has), the metric should be inf\n np.zeros([99, 99, 99]),\n create_spherical_seg_3d(radius=40, centre=(20, 33, 22)),\n ],\n [np.inf, np.inf, np.inf, np.inf, np.inf, np.inf],\n ],\n [\n [\n # gt does not have foreground (but pred has), the metric should be inf\n create_spherical_seg_3d(),\n np.zeros([99, 99, 99]),\n ],\n [np.inf, np.inf, np.inf, np.inf, np.inf, np.inf],\n ],\n [\n [\n create_spherical_seg_3d(radius=20, centre=(20, 33, 22)),\n create_spherical_seg_3d(radius=40, centre=(20, 33, 22)),\n 95,\n ],\n [19.924858845171276, 20.09975124224178, 14, 18, 22, 33],\n ],\n]\n\nTEST_CASES_NANS = [\n [\n [\n # both pred and gt do not have foreground, metric and not_nans should be 0\n np.zeros([99, 99, 99]),\n np.zeros([99, 99, 99]),\n ]\n ]\n]\n\n\nclass TestHausdorffDistance(unittest.TestCase):\n @parameterized.expand(TEST_CASES)\n def test_value(self, input_data, expected_value):\n percentile = None\n if len(input_data) == 3:\n [seg_1, seg_2, percentile] = input_data\n else:\n [seg_1, seg_2] = input_data\n ct = 0\n seg_1 = torch.tensor(seg_1)\n seg_2 = torch.tensor(seg_2)\n for metric in [\"euclidean\", \"chessboard\", \"taxicab\"]:\n for directed in [True, False]:\n hd_metric = HausdorffDistanceMetric(\n include_background=False, distance_metric=metric, percentile=percentile, directed=directed\n )\n # shape of seg_1, seg_2 are: HWD, converts to BNHWD\n batch, n_class = 2, 3\n batch_seg_1 = seg_1.unsqueeze(0).unsqueeze(0).repeat([batch, n_class, 1, 1, 1])\n batch_seg_2 = seg_2.unsqueeze(0).unsqueeze(0).repeat([batch, n_class, 1, 1, 1])\n hd_metric(batch_seg_1, batch_seg_2)\n result = hd_metric.aggregate()\n expected_value_curr = expected_value[ct]\n np.testing.assert_allclose(expected_value_curr, result, rtol=1e-7)\n ct += 1\n\n @parameterized.expand(TEST_CASES_NANS)\n def test_nans(self, input_data):\n [seg_1, seg_2] = input_data\n seg_1 = torch.tensor(seg_1)\n seg_2 = torch.tensor(seg_2)\n hd_metric = HausdorffDistanceMetric(include_background=False, get_not_nans=True)\n batch_seg_1 = seg_1.unsqueeze(0).unsqueeze(0)\n batch_seg_2 = seg_2.unsqueeze(0).unsqueeze(0)\n hd_metric(batch_seg_1, batch_seg_2)\n result, not_nans = hd_metric.aggregate()\n np.testing.assert_allclose(0, result, rtol=1e-7)\n np.testing.assert_allclose(0, not_nans, rtol=1e-7)\n\n\nif __name__ == \"__main__\":\n unittest.main()\n"
]
| [
[
"torch.nn.Upsample"
],
[
"numpy.nanpercentile",
"numpy.nanmean",
"numpy.isnan",
"numpy.transpose"
],
[
"numpy.testing.assert_allclose",
"torch.tensor",
"numpy.zeros"
]
]
|
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"
]
| [
[
"sklearn.ensemble.RandomForestClassifier",
"sklearn.metrics.precision_score",
"sklearn.feature_extraction.text.TfidfVectorizer",
"pandas.concat",
"pandas.read_csv",
"sklearn.metrics.f1_score",
"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.Dropout",
"torch.nn.init.kaiming_uniform_",
"torch.nn.AdaptiveAvgPool2d",
"torch.nn.MaxPool2d",
"torch.nn.init.constant_",
"torch.nn.ReLU",
"torch.nn.Conv2d",
"torch.nn.init.normal_",
"torch.flatten"
]
]
|
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"
]
| [
[
"pandas.DataFrame",
"numpy.array",
"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.use",
"torch.device",
"matplotlib.pyplot.get_cmap",
"torch.no_grad",
"matplotlib.pyplot.subplots",
"torch.cuda.is_available",
"matplotlib.pyplot.pause",
"torch.load"
]
]
|
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"
]
| [
[
"tensorflow.Graph",
"tensorflow.Session",
"tensorflow.GraphDef",
"tensorflow.import_graph_def",
"tensorflow.gfile.GFile",
"tensorflow.ConfigProto",
"numpy.squeeze",
"numpy.expand_dims"
]
]
|
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.DataFrame",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.clf",
"pandas.read_csv"
]
]
|
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.linspace",
"numpy.polyfit",
"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.to_datetime",
"pandas.testing.assert_frame_equal",
"pandas.Index",
"pandas.DataFrame",
"pandas.to_timedelta",
"pandas.MultiIndex.from_tuples",
"pandas.testing.assert_series_equal",
"pandas.Series"
]
]
|
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"
]
| [
[
"scipy.spatial.distance_matrix",
"numpy.array",
"numpy.dot"
]
]
|
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"
]
| [
[
"numpy.random.seed",
"pandas.read_csv"
]
]
|
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.concat",
"tensorflow.py_func",
"tensorflow.argmax",
"tensorflow.ones_like",
"tensorflow.reshape",
"tensorflow.stack",
"tensorflow.gather",
"tensorflow.greater",
"tensorflow.unstack"
],
[
"tensorflow.constant_initializer",
"tensorflow.random_normal_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.DataFrame",
"pandas.MultiIndex.from_product",
"pandas.Series"
]
]
|
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"
]
| [
[
"scipy.sparse.coo_matrix",
"numpy.zeros",
"scipy.sparse.csc_matrix",
"numpy.ones",
"scipy.sparse.csr_matrix"
]
]
|
breandan/tensorflow | [
"7509bad95200e1baed4eb488dbeaaa2c505a2824",
"7509bad95200e1baed4eb488dbeaaa2c505a2824",
"7509bad95200e1baed4eb488dbeaaa2c505a2824",
"7509bad95200e1baed4eb488dbeaaa2c505a2824",
"7509bad95200e1baed4eb488dbeaaa2c505a2824"
]
| [
"tensorflow/contrib/learn/python/learn/dataframe/transforms/batch.py",
"tensorflow/python/lib/io/tf_record.py",
"tensorflow/contrib/distributions/python/ops/chi2.py",
"tensorflow/python/framework/test_util_test.py",
"tensorflow/contrib/framework/python/ops/variables_test.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",
"# Copyright 2016 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\"\"\"The Chi2 distribution class.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nfrom tensorflow.contrib.distributions.python.ops import gamma\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.ops import math_ops\n\n\nclass Chi2(gamma.Gamma):\n \"\"\"The Chi2 distribution with degrees of freedom df.\n\n The PDF of this distribution is:\n\n ```pdf(x) = (x^(df/2 - 1)e^(-x/2))/(2^(k/2)Gamma(k/2)), x > 0```\n\n Note that the Chi2 distribution is a special case of the Gamma distribution,\n with Chi2(df) = Gamma(df/2, 1/2).\n \"\"\"\n\n def __init__(self, df, name=\"Chi2\"):\n with ops.op_scope([df], name, \"init\"):\n df = ops.convert_to_tensor(df)\n self._df = df\n super(Chi2, self).__init__(alpha=df / 2,\n beta=math_ops.cast(0.5, dtype=df.dtype))\n\n @property\n def df(self):\n return self._df\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\"\"\"Tests for tensorflow.ops.test_util.\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport threading\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\nimport tensorflow as tf\n\nfrom google.protobuf import text_format\n\nfrom tensorflow.core.framework import graph_pb2\nfrom tensorflow.python.framework import errors\nfrom tensorflow.python.framework import ops\nfrom tensorflow.python.framework import test_util\nfrom tensorflow.python.platform import googletest\nfrom tensorflow.python.ops import constant_op\nfrom tensorflow.python.ops import logging_ops\n\n\nclass TestUtilTest(test_util.TensorFlowTestCase):\n\n def test_assert_ops_in_graph(self):\n with self.test_session():\n constant_op.constant([\"hello\", \"taffy\"], name=\"hello\")\n test_util.assert_ops_in_graph({\"hello\": \"Const\"}, ops.get_default_graph())\n\n self.assertRaises(\n ValueError, test_util.assert_ops_in_graph, {\"bye\": \"Const\"},\n ops.get_default_graph())\n\n self.assertRaises(\n ValueError, test_util.assert_ops_in_graph, {\"hello\": \"Variable\"},\n ops.get_default_graph())\n\n def test_assert_equal_graph_def(self):\n with tf.Graph().as_default() as g:\n def_empty = g.as_graph_def()\n tf.constant(5, name=\"five\")\n tf.constant(7, name=\"seven\")\n def_57 = g.as_graph_def()\n with tf.Graph().as_default() as g:\n tf.constant(7, name=\"seven\")\n tf.constant(5, name=\"five\")\n def_75 = g.as_graph_def()\n # Comparing strings is order dependent\n self.assertNotEqual(str(def_57), str(def_75))\n # assert_equal_graph_def doesn't care about order\n tf.test.assert_equal_graph_def(def_57, def_75)\n # Compare two unequal graphs\n with self.assertRaisesRegexp(AssertionError,\n r\"^Found unexpected node 'seven\"):\n tf.test.assert_equal_graph_def(def_57, def_empty)\n\n def testIsGoogleCudaEnabled(self):\n # The test doesn't assert anything. It ensures the py wrapper\n # function is generated correctly.\n if test_util.IsGoogleCudaEnabled():\n print(\"GoogleCuda is enabled\")\n else:\n print(\"GoogleCuda is disabled\")\n\n def testAssertProtoEqualsStr(self):\n\n graph_str = \"node { name: 'w1' op: 'params' }\"\n graph_def = graph_pb2.GraphDef()\n text_format.Merge(graph_str, graph_def)\n\n # test string based comparison\n self.assertProtoEquals(graph_str, graph_def)\n\n # test original comparison\n self.assertProtoEquals(graph_def, graph_def)\n\n def testNDArrayNear(self):\n a1 = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])\n a2 = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])\n a3 = np.array([[10.0, 20.0, 30.0], [40.0, 50.0, 60.0]])\n self.assertTrue(self._NDArrayNear(a1, a2, 1e-5))\n self.assertFalse(self._NDArrayNear(a1, a3, 1e-5))\n\n def testCheckedThreadSucceeds(self):\n def noop(ev):\n ev.set()\n\n event_arg = threading.Event()\n\n self.assertFalse(event_arg.is_set())\n t = self.checkedThread(target=noop, args=(event_arg,))\n t.start()\n t.join()\n self.assertTrue(event_arg.is_set())\n\n def testCheckedThreadFails(self):\n def err_func():\n return 1 // 0\n\n t = self.checkedThread(target=err_func)\n t.start()\n with self.assertRaises(self.failureException) as fe:\n t.join()\n self.assertTrue(\"integer division or modulo by zero\" in str(fe.exception))\n\n def testCheckedThreadWithWrongAssertionFails(self):\n x = 37\n\n def err_func():\n self.assertTrue(x < 10)\n\n t = self.checkedThread(target=err_func)\n t.start()\n with self.assertRaises(self.failureException) as fe:\n t.join()\n self.assertTrue(\"False is not true\" in str(fe.exception))\n\n def testMultipleThreadsWithOneFailure(self):\n def err_func(i):\n self.assertTrue(i != 7)\n\n threads = [self.checkedThread(target=err_func, args=(i,))\n for i in range(10)]\n for t in threads:\n t.start()\n for i, t in enumerate(threads):\n if i == 7:\n with self.assertRaises(self.failureException):\n t.join()\n else:\n t.join()\n\n def _WeMustGoDeeper(self, msg):\n with self.assertRaisesOpError(msg):\n node_def = ops._NodeDef(\"op_type\", \"name\")\n node_def_orig = ops._NodeDef(\"op_type_orig\", \"orig\")\n op_orig = ops.Operation(node_def_orig, ops.get_default_graph())\n op = ops.Operation(node_def, ops.get_default_graph(), original_op=op_orig)\n raise errors.UnauthenticatedError(node_def, op, \"true_err\")\n\n def testAssertRaisesOpErrorDoesNotPassMessageDueToLeakedStack(self):\n with self.assertRaises(AssertionError):\n self._WeMustGoDeeper(\"this_is_not_the_error_you_are_looking_for\")\n\n self._WeMustGoDeeper(\"true_err\")\n self._WeMustGoDeeper(\"name\")\n self._WeMustGoDeeper(\"orig\")\n\n def testAllCloseScalars(self):\n self.assertAllClose(7, 7 + 1e-8)\n with self.assertRaisesRegexp(AssertionError, r\"Not equal to tolerance\"):\n self.assertAllClose(7, 8)\n\n def testArrayNear(self):\n a = [1, 2]\n b = [1, 2, 5]\n with self.assertRaises(AssertionError):\n self.assertArrayNear(a, b, 0.001)\n a = [1, 2]\n b = [[1, 2], [3, 4]]\n with self.assertRaises(TypeError):\n self.assertArrayNear(a, b, 0.001)\n a = [1, 2]\n b = [1, 2]\n self.assertArrayNear(a, b, 0.001)\n\n def testForceGPU(self):\n with self.assertRaisesRegexp(errors.InvalidArgumentError,\n \"Cannot assign a device to node\"):\n with self.test_session(force_gpu=True):\n # this relies on us not having a GPU implementation for assert, which\n # seems sensible\n x = [True]\n y = [15]\n logging_ops.Assert(x, y).run()\n\nif __name__ == \"__main__\":\n googletest.main()\n",
"# Copyright 2016 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\"\"\"variables tests.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\n\nimport numpy as np\nimport tensorflow as tf\n\n\nclass LocalVariableTest(tf.test.TestCase):\n\n def test_local_variable(self):\n with self.test_session() as sess:\n self.assertEquals([], tf.local_variables())\n value0 = 42\n tf.contrib.framework.local_variable(value0)\n value1 = 43\n tf.contrib.framework.local_variable(value1)\n variables = tf.local_variables()\n self.assertEquals(2, len(variables))\n self.assertRaises(tf.OpError, sess.run, variables)\n tf.initialize_variables(variables).run()\n self.assertAllEqual(set([value0, value1]), set(sess.run(variables)))\n\n def testLocalVariableNameAndShape(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.local_variable([1, 1, 1, 1, 1], name='a')\n self.assertEquals(a.op.name, 'A/a')\n self.assertListEqual(a.get_shape().as_list(), [5])\n self.assertListEqual([a], tf.contrib.framework.get_local_variables())\n\n def testLocalVariableNotInAllVariables(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.local_variable(0)\n self.assertFalse(a in tf.all_variables())\n self.assertTrue(a in tf.local_variables())\n\n def testLocalVariableNotInVariablesToRestore(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.local_variable(0)\n self.assertFalse(a in tf.contrib.framework.get_variables_to_restore())\n self.assertTrue(a in tf.local_variables())\n\n def testGetVariablesDontReturnsTransients(self):\n with self.test_session():\n with tf.variable_scope('A'):\n tf.contrib.framework.local_variable(0)\n with tf.variable_scope('B'):\n tf.contrib.framework.local_variable(0)\n self.assertEquals([], tf.contrib.framework.get_variables('A'))\n self.assertEquals([], tf.contrib.framework.get_variables('B'))\n\n def testGetLocalVariablesReturnsTransients(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.local_variable(0)\n with tf.variable_scope('B'):\n b = tf.contrib.framework.local_variable(0)\n self.assertEquals([a], tf.contrib.framework.get_local_variables('A'))\n self.assertEquals([b], tf.contrib.framework.get_local_variables('B'))\n\n def testInitializedVariableValue(self):\n with self.test_session() as sess:\n a = tf.contrib.framework.local_variable([0, 0, 0, 0, 0], name='a')\n sess.run(tf.initialize_local_variables())\n self.assertAllEqual(a.eval(), [0]*5)\n\n\nclass GlobalStepTest(tf.test.TestCase):\n\n def _assert_global_step(self, global_step, expected_dtype=tf.int64):\n self.assertEquals('%s:0' % tf.GraphKeys.GLOBAL_STEP, global_step.name)\n self.assertEquals(expected_dtype, global_step.dtype.base_dtype)\n self.assertEquals([], global_step.get_shape().as_list())\n\n def test_invalid_dtype(self):\n with tf.Graph().as_default() as g:\n self.assertEquals(None, tf.contrib.framework.get_global_step())\n tf.Variable(\n 0.0, trainable=False, dtype=tf.float32, name=tf.GraphKeys.GLOBAL_STEP)\n self.assertRaisesRegexp(\n TypeError, 'does not have integer type',\n tf.contrib.framework.get_global_step)\n self.assertRaisesRegexp(\n TypeError, 'does not have integer type',\n tf.contrib.framework.get_global_step, g)\n\n def test_invalid_shape(self):\n with tf.Graph().as_default() as g:\n self.assertEquals(None, tf.contrib.framework.get_global_step())\n tf.Variable(\n [0], trainable=False, dtype=tf.int32, name=tf.GraphKeys.GLOBAL_STEP)\n self.assertRaisesRegexp(\n TypeError, 'not scalar',\n tf.contrib.framework.get_global_step)\n self.assertRaisesRegexp(\n TypeError, 'not scalar',\n tf.contrib.framework.get_global_step, g)\n\n def test_create_global_step(self):\n self.assertEquals(None, tf.contrib.framework.get_global_step())\n with tf.Graph().as_default() as g:\n global_step = tf.contrib.framework.create_global_step()\n self._assert_global_step(global_step)\n self.assertRaisesRegexp(\n ValueError, 'already exists', tf.contrib.framework.create_global_step)\n self.assertRaisesRegexp(\n ValueError, 'already exists', tf.contrib.framework.create_global_step,\n g)\n self._assert_global_step(\n tf.contrib.framework.create_global_step(tf.Graph()))\n\n def test_get_global_step(self):\n with tf.Graph().as_default() as g:\n self.assertEquals(None, tf.contrib.framework.get_global_step())\n tf.Variable(\n 0, trainable=False, dtype=tf.int32, name=tf.GraphKeys.GLOBAL_STEP)\n self._assert_global_step(\n tf.contrib.framework.get_global_step(), expected_dtype=tf.int32)\n self._assert_global_step(\n tf.contrib.framework.get_global_step(g), expected_dtype=tf.int32)\n\n def test_get_or_create_global_step(self):\n with tf.Graph().as_default() as g:\n self.assertEquals(None, tf.contrib.framework.get_global_step())\n self._assert_global_step(\n tf.contrib.framework.get_or_create_global_step())\n self._assert_global_step(\n tf.contrib.framework.get_or_create_global_step(g))\n\n\nclass VariablesTest(tf.test.TestCase):\n\n def testCreateVariable(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [5])\n self.assertEquals(a.op.name, 'A/a')\n self.assertListEqual(a.get_shape().as_list(), [5])\n\n def testGetVariables(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [5])\n with tf.variable_scope('B'):\n b = tf.contrib.framework.variable('a', [5])\n self.assertEquals([a, b], tf.contrib.framework.get_variables())\n self.assertEquals([a], tf.contrib.framework.get_variables('A'))\n self.assertEquals([b], tf.contrib.framework.get_variables('B'))\n\n def testGetVariablesSuffix(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [5])\n with tf.variable_scope('A'):\n b = tf.contrib.framework.variable('b', [5])\n self.assertEquals([a], tf.contrib.framework.get_variables(suffix='a'))\n self.assertEquals([b], tf.contrib.framework.get_variables(suffix='b'))\n\n def testGetVariableWithSingleVar(self):\n with self.test_session():\n with tf.variable_scope('parent'):\n a = tf.contrib.framework.variable('child', [5])\n self.assertEquals(\n a, tf.contrib.framework.get_unique_variable('parent/child'))\n\n def testGetVariableWithDistractors(self):\n with self.test_session():\n with tf.variable_scope('parent'):\n a = tf.contrib.framework.variable('child', [5])\n with tf.variable_scope('child'):\n tf.contrib.framework.variable('grandchild1', [7])\n tf.contrib.framework.variable('grandchild2', [9])\n self.assertEquals(\n a, tf.contrib.framework.get_unique_variable('parent/child'))\n\n def testGetVariableThrowsExceptionWithNoMatch(self):\n var_name = 'cant_find_me'\n with self.test_session():\n with self.assertRaises(ValueError):\n tf.contrib.framework.get_unique_variable(var_name)\n\n def testGetThrowsExceptionWithChildrenButNoMatch(self):\n var_name = 'parent/child'\n with self.test_session():\n with tf.variable_scope(var_name):\n tf.contrib.framework.variable('grandchild1', [7])\n tf.contrib.framework.variable('grandchild2', [9])\n with self.assertRaises(ValueError):\n tf.contrib.framework.get_unique_variable(var_name)\n\n def testGetVariablesToRestore(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [5])\n with tf.variable_scope('B'):\n b = tf.contrib.framework.variable('a', [5])\n self.assertEquals([a, b],\n tf.contrib.framework.get_variables_to_restore())\n\n def testIncludeGetVariablesToRestore(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [5])\n with tf.variable_scope('B'):\n b = tf.contrib.framework.variable('a', [5])\n self.assertEquals([a, b], tf.contrib.framework.get_variables())\n self.assertEquals([a],\n tf.contrib.framework.get_variables_to_restore(['A']))\n\n def testExcludeGetVariablesToRestore(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [5])\n with tf.variable_scope('B'):\n b = tf.contrib.framework.variable('a', [5])\n self.assertEquals([a, b], tf.contrib.framework.get_variables())\n self.assertEquals([a],\n tf.contrib.framework.get_variables_to_restore(\n exclude=['B']))\n\n def testWrongIncludeGetVariablesToRestore(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [5])\n with tf.variable_scope('B'):\n b = tf.contrib.framework.variable('a', [5])\n self.assertEquals([a, b], tf.contrib.framework.get_variables())\n self.assertEquals([],\n tf.contrib.framework.get_variables_to_restore(['a']))\n\n def testGetMixedVariablesToRestore(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [5])\n b = tf.contrib.framework.variable('b', [5])\n with tf.variable_scope('B'):\n c = tf.contrib.framework.variable('c', [5])\n d = tf.contrib.framework.variable('d', [5])\n self.assertEquals([a, b, c, d], tf.contrib.framework.get_variables())\n self.assertEquals([a, c],\n tf.contrib.framework.get_variables_to_restore(\n include=['A/a', 'B/c']))\n\n def testExcludeGetMixedVariablesToRestore(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [5])\n b = tf.contrib.framework.variable('b', [5])\n with tf.variable_scope('B'):\n c = tf.contrib.framework.variable('c', [5])\n d = tf.contrib.framework.variable('d', [5])\n self.assertEquals([a, b, c, d], tf.contrib.framework.get_variables())\n self.assertEquals([b, d],\n tf.contrib.framework.get_variables_to_restore(\n exclude=['A/a', 'B/c']))\n\n def testReuseVariable(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [])\n with tf.variable_scope('A', reuse=True):\n b = tf.contrib.framework.variable('a', [])\n self.assertEquals(a, b)\n self.assertListEqual([a], tf.contrib.framework.get_variables())\n\n def testVariableWithRegularizer(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [], regularizer=tf.nn.l2_loss)\n loss = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)[0]\n self.assertDeviceEqual(loss.device, a.device)\n\n def testVariableWithRegularizerColocate(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [], device='gpu:0',\n regularizer=tf.nn.l2_loss)\n loss = tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES)[0]\n self.assertDeviceEqual(loss.device, a.device)\n\n def testVariableWithDevice(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [], device='cpu:0')\n b = tf.contrib.framework.variable('b', [], device='cpu:1')\n self.assertDeviceEqual(a.device, 'cpu:0')\n self.assertDeviceEqual(b.device, 'cpu:1')\n\n def testVariableWithDeviceFromScope(self):\n with self.test_session():\n with tf.device('/cpu:0'):\n a = tf.contrib.framework.variable('a', [])\n b = tf.contrib.framework.variable('b', [], device='cpu:1')\n self.assertDeviceEqual(a.device, 'cpu:0')\n self.assertDeviceEqual(b.device, 'cpu:1')\n\n def testVariableWithDeviceFunction(self):\n class DevFn(object):\n\n def __init__(self):\n self.counter = -1\n\n def __call__(self, op):\n self.counter += 1\n return 'cpu:%d' % self.counter\n\n with self.test_session():\n with tf.contrib.framework.arg_scope([tf.contrib.framework.variable],\n device=DevFn()):\n a = tf.contrib.framework.variable('a', [])\n b = tf.contrib.framework.variable('b', [])\n c = tf.contrib.framework.variable('c', [], device='cpu:12')\n d = tf.contrib.framework.variable('d', [])\n with tf.device('cpu:99'):\n e_init = tf.constant(12)\n e = tf.contrib.framework.variable('e', initializer=e_init)\n self.assertDeviceEqual(a.device, 'cpu:0')\n self.assertDeviceEqual(a.initial_value.device, 'cpu:0')\n self.assertDeviceEqual(b.device, 'cpu:1')\n self.assertDeviceEqual(b.initial_value.device, 'cpu:1')\n self.assertDeviceEqual(c.device, 'cpu:12')\n self.assertDeviceEqual(c.initial_value.device, 'cpu:12')\n self.assertDeviceEqual(d.device, 'cpu:2')\n self.assertDeviceEqual(d.initial_value.device, 'cpu:2')\n self.assertDeviceEqual(e.device, 'cpu:3')\n self.assertDeviceEqual(e.initial_value.device, 'cpu:99')\n\n def testVariableWithReplicaDeviceSetter(self):\n with self.test_session():\n with tf.device(tf.train.replica_device_setter(ps_tasks=2)):\n a = tf.contrib.framework.variable('a', [])\n b = tf.contrib.framework.variable('b', [])\n c = tf.contrib.framework.variable('c', [], device='cpu:12')\n d = tf.contrib.framework.variable('d', [])\n with tf.device('cpu:99'):\n e_init = tf.constant(12)\n e = tf.contrib.framework.variable('e', initializer=e_init)\n # The values below highlight how the replica_device_setter puts initial\n # values on the worker job, and how it merges explicit devices.\n self.assertDeviceEqual(a.device, '/job:ps/task:0/cpu:0')\n self.assertDeviceEqual(a.initial_value.device, a.device)\n self.assertDeviceEqual(b.device, '/job:ps/task:1/cpu:0')\n self.assertDeviceEqual(b.initial_value.device, b.device)\n self.assertDeviceEqual(c.device, '/job:ps/task:0/cpu:12')\n self.assertDeviceEqual(c.initial_value.device, c.device)\n self.assertDeviceEqual(d.device, '/job:ps/task:1/cpu:0')\n self.assertDeviceEqual(d.initial_value.device, d.device)\n self.assertDeviceEqual(e.device, '/job:ps/task:0/cpu:0')\n self.assertDeviceEqual(e.initial_value.device, '/job:worker/cpu:99')\n\n def testVariableWithVariableDeviceChooser(self):\n\n with tf.Graph().as_default():\n device_fn = tf.contrib.framework.VariableDeviceChooser(num_tasks=2)\n with tf.contrib.framework.arg_scope([tf.contrib.framework.variable],\n device=device_fn):\n a = tf.contrib.framework.variable('a', [])\n b = tf.contrib.framework.variable('b', [])\n c = tf.contrib.framework.variable('c', [], device='cpu:12')\n d = tf.contrib.framework.variable('d', [])\n with tf.device('cpu:99'):\n e_init = tf.constant(12)\n e = tf.contrib.framework.variable('e', initializer=e_init)\n # The values below highlight how the VariableDeviceChooser puts initial\n # values on the same device as the variable job.\n self.assertDeviceEqual(a.device, '/job:ps/task:0/cpu:0')\n self.assertDeviceEqual(a.initial_value.device, a.device)\n self.assertDeviceEqual(b.device, '/job:ps/task:1/cpu:0')\n self.assertDeviceEqual(b.initial_value.device, b.device)\n self.assertDeviceEqual(c.device, '/cpu:12')\n self.assertDeviceEqual(c.initial_value.device, c.device)\n self.assertDeviceEqual(d.device, '/job:ps/task:0/cpu:0')\n self.assertDeviceEqual(d.initial_value.device, d.device)\n self.assertDeviceEqual(e.device, '/job:ps/task:1/cpu:0')\n self.assertDeviceEqual(e.initial_value.device, '/cpu:99')\n\n def testVariableGPUPlacement(self):\n\n with tf.Graph().as_default():\n device_fn = tf.contrib.framework.VariableDeviceChooser(device_type='GPU')\n with tf.contrib.framework.arg_scope([tf.contrib.framework.variable],\n device=device_fn):\n a = tf.contrib.framework.variable('a', [])\n b = tf.contrib.framework.variable('b', [])\n c = tf.contrib.framework.variable('c', [], device='cpu:12')\n d = tf.contrib.framework.variable('d', [])\n with tf.device('cpu:99'):\n e_init = tf.constant(12)\n e = tf.contrib.framework.variable('e', initializer=e_init)\n # The values below highlight how the VariableDeviceChooser puts initial\n # values on the same device as the variable job.\n self.assertDeviceEqual(a.device, '/gpu:0')\n self.assertDeviceEqual(a.initial_value.device, a.device)\n self.assertDeviceEqual(b.device, '/gpu:0')\n self.assertDeviceEqual(b.initial_value.device, b.device)\n self.assertDeviceEqual(c.device, '/cpu:12')\n self.assertDeviceEqual(c.initial_value.device, c.device)\n self.assertDeviceEqual(d.device, '/gpu:0')\n self.assertDeviceEqual(d.initial_value.device, d.device)\n self.assertDeviceEqual(e.device, '/gpu:0')\n self.assertDeviceEqual(e.initial_value.device, '/cpu:99')\n\n\nclass ModelVariablesTest(tf.test.TestCase):\n\n def testNameAndShape(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.model_variable('a', [5])\n self.assertEquals(a.op.name, 'A/a')\n self.assertListEqual(a.get_shape().as_list(), [5])\n self.assertListEqual([a], tf.contrib.framework.get_model_variables('A'))\n\n def testNotInLocalVariables(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.model_variable('a', [5])\n self.assertTrue(a in tf.all_variables())\n self.assertFalse(a in tf.local_variables())\n\n def testGetVariablesReturns(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.model_variable('a', [5])\n with tf.variable_scope('B'):\n b = tf.contrib.framework.model_variable('a', [5])\n self.assertEquals([a], tf.contrib.framework.get_variables('A'))\n self.assertEquals([b], tf.contrib.framework.get_variables('B'))\n\n def testGetModelVariables(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.model_variable('a', [5])\n with tf.variable_scope('B'):\n b = tf.contrib.framework.model_variable('a', [5])\n self.assertEquals([a], tf.contrib.framework.get_model_variables('A'))\n self.assertEquals([b], tf.contrib.framework.get_model_variables('B'))\n\n def testGetLocalVariables(self):\n with self.test_session():\n with tf.variable_scope('A'):\n _ = tf.contrib.framework.model_variable('a', [5])\n with tf.variable_scope('B'):\n _ = tf.contrib.framework.model_variable('a', [5])\n self.assertEquals([], tf.contrib.framework.get_local_variables('A'))\n self.assertEquals([], tf.contrib.framework.get_local_variables('B'))\n\n def testInitializedVariableValue(self):\n with self.test_session() as sess:\n a = tf.contrib.framework.model_variable('a', [5], initializer=tf.ones)\n sess.run(tf.initialize_all_variables())\n self.assertAllEqual(a.eval(), [1]*5)\n\n def testDeviceFn(self):\n class DevFn(object):\n\n def __init__(self):\n self.counter = -1\n\n def __call__(self, op):\n self.counter += 1\n return '/cpu:%d' % self.counter\n\n with tf.Graph().as_default():\n with tf.contrib.framework.arg_scope([tf.contrib.framework.model_variable],\n device=DevFn()):\n a = tf.contrib.framework.model_variable('a', [5])\n b = tf.contrib.framework.model_variable('b', [20])\n self.assertDeviceEqual(a.device, '/cpu:0')\n self.assertDeviceEqual(a.initial_value.device, '/cpu:0')\n self.assertDeviceEqual(b.device, '/cpu:1')\n self.assertDeviceEqual(b.initial_value.device, '/cpu:1')\n\n def testVariableWithVariableDeviceChooser(self):\n\n with tf.Graph().as_default():\n device_fn = tf.contrib.framework.VariableDeviceChooser()\n with tf.contrib.framework.arg_scope([tf.contrib.framework.model_variable],\n device=device_fn):\n a = tf.contrib.framework.model_variable('a', [5])\n b = tf.contrib.framework.model_variable('b', [20])\n self.assertDeviceEqual(a.device, 'cpu:0')\n self.assertDeviceEqual(a.initial_value.device, a.device)\n self.assertDeviceEqual(b.device, 'cpu:0')\n self.assertDeviceEqual(b.initial_value.device, b.device)\n\n\nclass GetVariablesCollections(tf.test.TestCase):\n\n def testVariableCollection(self):\n with self.test_session():\n a = tf.contrib.framework.variable('a', [], collections='A')\n b = tf.contrib.framework.variable('b', [], collections='B')\n self.assertEquals(a, tf.get_collection('A')[0])\n self.assertEquals(b, tf.get_collection('B')[0])\n\n def testVariableCollections(self):\n with self.test_session():\n a = tf.contrib.framework.variable('a', [], collections=['A', 'C'])\n b = tf.contrib.framework.variable('b', [], collections=['B', 'C'])\n self.assertEquals(a, tf.get_collection('A')[0])\n self.assertEquals(b, tf.get_collection('B')[0])\n self.assertListEqual([a, b], tf.get_collection('C'))\n\n def testVariableCollectionsWithArgScope(self):\n with self.test_session():\n with tf.contrib.framework.arg_scope([tf.contrib.framework.variable],\n collections='A'):\n a = tf.contrib.framework.variable('a', [])\n b = tf.contrib.framework.variable('b', [])\n self.assertListEqual([a, b], tf.get_collection('A'))\n\n def testVariableCollectionsWithArgScopeNested(self):\n with self.test_session():\n with tf.contrib.framework.arg_scope([tf.contrib.framework.variable],\n collections='A'):\n a = tf.contrib.framework.variable('a', [])\n with tf.contrib.framework.arg_scope([tf.contrib.framework.variable],\n collections='B'):\n b = tf.contrib.framework.variable('b', [])\n self.assertEquals(a, tf.get_collection('A')[0])\n self.assertEquals(b, tf.get_collection('B')[0])\n\n def testVariableCollectionsWithArgScopeNonNested(self):\n with self.test_session():\n with tf.contrib.framework.arg_scope([tf.contrib.framework.variable],\n collections='A'):\n a = tf.contrib.framework.variable('a', [])\n with tf.contrib.framework.arg_scope([tf.contrib.framework.variable],\n collections='B'):\n b = tf.contrib.framework.variable('b', [])\n tf.contrib.framework.variable('c', [])\n self.assertListEqual([a], tf.get_collection('A'))\n self.assertListEqual([b], tf.get_collection('B'))\n\n def testVariableRestoreWithArgScopeNested(self):\n with self.test_session():\n a = tf.contrib.framework.variable('a', [])\n with tf.contrib.framework.arg_scope([tf.contrib.framework.variable],\n trainable=False,\n collections=['A', 'B']):\n b = tf.contrib.framework.variable('b', [])\n c = tf.contrib.framework.variable('c', [], trainable=False)\n self.assertEquals([a, c], tf.contrib.framework.get_variables_to_restore())\n self.assertEquals([a], tf.trainable_variables())\n self.assertEquals([b], tf.get_collection('A'))\n self.assertEquals([b], tf.get_collection('B'))\n\n\nclass GetVariablesBySuffixTest(tf.test.TestCase):\n\n def testGetVariableGivenNameScoped(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [5])\n b = tf.contrib.framework.variable('b', [5])\n self.assertEquals([a],\n tf.contrib.framework.get_variables_by_suffix('a'))\n self.assertEquals([b],\n tf.contrib.framework.get_variables_by_suffix('b'))\n\n def testGetVariableWithScope(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [5])\n fooa = tf.contrib.framework.variable('fooa', [5])\n with tf.variable_scope('B'):\n a2 = tf.contrib.framework.variable('a', [5])\n matched_variables = tf.contrib.framework.get_variables_by_suffix('a')\n self.assertEquals([a, fooa, a2], matched_variables)\n matched_variables = tf.contrib.framework.get_variables_by_suffix('/a')\n self.assertEquals([a, a2], matched_variables)\n matched_variables = tf.contrib.framework.get_variables_by_suffix(\n 'a', scope='A')\n self.assertEquals([a, fooa], matched_variables)\n\n def testGetVariableWithoutScope(self):\n with self.test_session():\n a = tf.contrib.framework.variable('a', [5])\n fooa = tf.contrib.framework.variable('fooa', [5])\n b_a = tf.contrib.framework.variable('B/a', [5])\n matched_variables = tf.contrib.framework.get_variables_by_suffix('a')\n self.assertEquals([a, fooa, b_a], matched_variables)\n matched_variables = tf.contrib.framework.get_variables_by_suffix('fooa')\n self.assertEquals([fooa], matched_variables)\n\n\nclass GetVariablesByNameTest(tf.test.TestCase):\n\n def testGetVariableGivenNameScoped(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [5])\n b = tf.contrib.framework.variable('b', [5])\n self.assertEquals([a], tf.contrib.framework.get_variables_by_name('a'))\n self.assertEquals([b], tf.contrib.framework.get_variables_by_name('b'))\n\n def testGetVariableWithScope(self):\n with self.test_session():\n with tf.variable_scope('A'):\n a = tf.contrib.framework.variable('a', [5])\n fooa = tf.contrib.framework.variable('fooa', [5])\n with tf.variable_scope('B'):\n a2 = tf.contrib.framework.variable('a', [5])\n matched_variables = tf.contrib.framework.get_variables_by_name('a')\n self.assertEquals([a, a2], matched_variables)\n matched_variables = tf.contrib.framework.get_variables_by_name('fooa')\n self.assertEquals([fooa], matched_variables)\n matched_variables = tf.contrib.framework.get_variables_by_name('/a')\n self.assertEquals([], matched_variables)\n matched_variables = tf.contrib.framework.get_variables_by_name('a',\n scope='A')\n self.assertEquals([a], matched_variables)\n\n def testGetVariableWithoutScope(self):\n with self.test_session():\n a = tf.contrib.framework.variable('a', [5])\n fooa = tf.contrib.framework.variable('fooa', [5])\n b_a = tf.contrib.framework.variable('B/a', [5])\n matched_variables = tf.contrib.framework.get_variables_by_name('a')\n self.assertEquals([a, b_a], matched_variables)\n matched_variables = tf.contrib.framework.get_variables_by_name('fooa')\n self.assertEquals([fooa], matched_variables)\n\n\nclass AssignFromValuesTest(tf.test.TestCase):\n\n def testNoScopes(self):\n init_value0 = np.asarray([1.0, 3.0, 9.0]).reshape((1, 3, 1))\n init_value1 = np.asarray([2.0, 4.0, 6.0, 8.0]).reshape((2, 1, 2))\n\n with self.test_session() as sess:\n initializer = tf.truncated_normal_initializer(stddev=.1)\n var0 = tf.contrib.framework.variables.variable(\n 'my_var0', shape=[1, 3, 1], initializer=initializer)\n var1 = tf.contrib.framework.variables.variable(\n 'my_var1', shape=[2, 1, 2], initializer=initializer)\n\n var_names_to_values = {'my_var0': init_value0, 'my_var1': init_value1}\n assign_op, feed_dict = tf.contrib.framework.variables.assign_from_values(\n var_names_to_values)\n\n # Initialize the variables.\n sess.run(tf.initialize_all_variables())\n\n # Perform the assignment.\n sess.run(assign_op, feed_dict)\n\n # Request and test the variable values:\n var0, var1 = sess.run([var0, var1])\n self.assertAllEqual(init_value0, var0)\n self.assertAllEqual(init_value1, var1)\n\n def testWithScopes(self):\n init_value0 = np.asarray([1.0, 3.0, 9.0]).reshape((1, 3, 1))\n init_value1 = np.asarray([2.0, 4.0, 6.0, 8.0]).reshape((2, 1, 2))\n\n with self.test_session() as sess:\n initializer = tf.truncated_normal_initializer(stddev=.1)\n\n with tf.variable_scope('my_model/my_layer0'):\n var0 = tf.contrib.framework.variables.variable(\n 'my_var0', shape=[1, 3, 1], initializer=initializer)\n with tf.variable_scope('my_model/my_layer1'):\n var1 = tf.contrib.framework.variables.variable(\n 'my_var1', shape=[2, 1, 2], initializer=initializer)\n\n var_names_to_values = {'my_model/my_layer0/my_var0': init_value0,\n 'my_model/my_layer1/my_var1': init_value1}\n assign_op, feed_dict = tf.contrib.framework.variables.assign_from_values(\n var_names_to_values)\n\n # Initialize the variables.\n sess.run(tf.initialize_all_variables())\n\n # Perform the assignment.\n sess.run(assign_op, feed_dict)\n\n # Request and test the variable values:\n var0, var1 = sess.run([var0, var1])\n self.assertAllEqual(init_value0, var0)\n self.assertAllEqual(init_value1, var1)\n\n\nclass AssignFromCheckpointTest(tf.test.TestCase):\n\n def create_checkpoint_from_values(self, var_names_to_values, checkpoint_dir,\n global_step=None):\n \"\"\"Creates a checkpoint from a mapping of name to values in model_dir.\n\n Args:\n var_names_to_values: a map from variable names to values.\n checkpoint_dir: the directory where the checkpoint will be saved.\n global_step: the global step used to save the checkpoint.\n\n Returns:\n the model_path to the checkpoint.\n \"\"\"\n var_list = []\n with tf.Session('', graph=tf.Graph()) as sess:\n # Create a set of variables to save in the checkpoint.\n for var_name in var_names_to_values:\n var_value = var_names_to_values[var_name]\n var_list.append(tf.Variable(var_value, name=var_name))\n saver = tf.train.Saver(var_list)\n init_op = tf.initialize_variables(var_list)\n sess.run(init_op)\n # Save the initialized values in the file at 'checkpoint_dir'\n return saver.save(sess, checkpoint_dir, global_step=global_step)\n\n def testLoadExistingVariables(self):\n init_value0 = 10.0\n init_value1 = 20.0\n var_names_to_values = {'v0': init_value0, 'v1': init_value1}\n\n model_dir = os.path.join(self.get_temp_dir(), 'model')\n with self.test_session() as sess:\n model_path = self.create_checkpoint_from_values(var_names_to_values,\n model_dir)\n var0 = tf.contrib.framework.variables.variable('my_var0', shape=[])\n var1 = tf.contrib.framework.variables.variable('my_var1', shape=[])\n\n vars_to_restore = {'v0': var0, 'v1': var1}\n op, feed_dict = tf.contrib.framework.variables.assign_from_checkpoint(\n model_path, vars_to_restore)\n\n # Initialize the variables.\n sess.run(tf.initialize_all_variables())\n\n # Perform the assignment.\n sess.run(op, feed_dict)\n\n # Request and test the variable values:\n self.assertEqual(init_value0, var0.eval())\n self.assertEqual(init_value1, var1.eval())\n\n def testRaisesValueErrorIfAVariableIsntFound(self):\n init_value0 = 10.0\n init_value1 = 20.0\n var_names_to_values = {'v0': init_value0, 'v1': init_value1}\n\n model_dir = os.path.join(self.get_temp_dir(), 'model')\n with self.test_session():\n model_path = self.create_checkpoint_from_values(var_names_to_values,\n model_dir)\n var0 = tf.contrib.framework.variables.variable('my_var0', shape=[])\n var1 = tf.contrib.framework.variables.variable('my_var1', shape=[])\n\n vars_to_restore = {'v0_fake': var0, 'v1': var1}\n\n with self.assertRaises(ValueError):\n tf.contrib.framework.variables.assign_from_checkpoint(model_path,\n vars_to_restore)\n\n def testInitFromCheckpointWithScopes(self):\n init_value0 = np.asarray([1.0, 3.0, 9.0],\n dtype=np.float32).reshape((1, 3, 1))\n init_value1 = np.asarray([2.0, 4.0, 6.0, 8.0],\n dtype=np.float32).reshape((2, 1, 2))\n\n var_names_to_values = {'layer0/v0': init_value0, 'layer1/v1': init_value1}\n model_dir = os.path.join(self.get_temp_dir(), 'model')\n with self.test_session() as sess:\n model_path = self.create_checkpoint_from_values(var_names_to_values,\n model_dir)\n with tf.variable_scope('my_model/my_layer0'):\n var0 = tf.contrib.framework.variables.variable('my_var0',\n shape=init_value0.shape)\n with tf.variable_scope('my_model/my_layer1'):\n var1 = tf.contrib.framework.variables.variable('my_var1',\n shape=init_value1.shape)\n\n vars_to_restore = {'layer0/v0': var0, 'layer1/v1': var1}\n op, feed_dict = tf.contrib.framework.variables.assign_from_checkpoint(\n model_path,\n vars_to_restore)\n\n # Initialize the variables.\n sess.run(tf.initialize_all_variables())\n\n # Perform the assignment.\n sess.run(op, feed_dict)\n\n # Request and test the variable values:\n self.assertAllEqual(init_value0, var0.eval())\n self.assertAllEqual(init_value1, var1.eval())\n\nif __name__ == '__main__':\n tf.test.main()\n"
]
| [
[
"tensorflow.python.training.input.batch",
"tensorflow.python.training.input.shuffle_batch"
],
[
"tensorflow.python.util.compat.as_bytes"
],
[
"tensorflow.python.ops.math_ops.cast",
"tensorflow.python.framework.ops.convert_to_tensor",
"tensorflow.python.framework.ops.op_scope"
],
[
"numpy.array",
"tensorflow.python.platform.googletest.main",
"tensorflow.Graph",
"tensorflow.python.ops.logging_ops.Assert",
"tensorflow.core.framework.graph_pb2.GraphDef",
"tensorflow.python.framework.ops._NodeDef",
"tensorflow.constant",
"tensorflow.python.framework.errors.UnauthenticatedError",
"tensorflow.python.ops.constant_op.constant",
"tensorflow.test.assert_equal_graph_def",
"tensorflow.python.framework.ops.get_default_graph",
"tensorflow.python.framework.test_util.IsGoogleCudaEnabled"
],
[
"tensorflow.local_variables",
"tensorflow.contrib.framework.variables.assign_from_checkpoint",
"tensorflow.contrib.framework.variables.assign_from_values",
"tensorflow.contrib.framework.model_variable",
"tensorflow.contrib.framework.get_model_variables",
"tensorflow.contrib.framework.variable",
"tensorflow.trainable_variables",
"tensorflow.contrib.framework.get_variables_to_restore",
"tensorflow.contrib.framework.get_variables",
"tensorflow.Variable",
"tensorflow.contrib.framework.VariableDeviceChooser",
"tensorflow.contrib.framework.variables.variable",
"tensorflow.train.Saver",
"tensorflow.constant",
"tensorflow.variable_scope",
"tensorflow.initialize_local_variables",
"tensorflow.contrib.framework.create_global_step",
"tensorflow.get_collection",
"tensorflow.all_variables",
"tensorflow.initialize_all_variables",
"tensorflow.contrib.framework.get_or_create_global_step",
"tensorflow.contrib.framework.get_variables_by_suffix",
"tensorflow.test.main",
"tensorflow.contrib.framework.get_variables_by_name",
"tensorflow.contrib.framework.get_unique_variable",
"tensorflow.contrib.framework.local_variable",
"tensorflow.train.replica_device_setter",
"tensorflow.contrib.framework.get_local_variables",
"numpy.asarray",
"tensorflow.Graph",
"tensorflow.initialize_variables",
"tensorflow.device",
"tensorflow.truncated_normal_initializer",
"tensorflow.contrib.framework.arg_scope",
"tensorflow.contrib.framework.get_global_step"
]
]
|
thegodone/gcnn_keras | [
"2009b9ab9a07c1a369849478812fcc2cb9799945",
"2009b9ab9a07c1a369849478812fcc2cb9799945"
]
| [
"kgcnn/literature/GAT.py",
"kgcnn/literature/GATv2.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",
"import tensorflow as tf\nimport tensorflow.keras as ks\n\nfrom kgcnn.layers.casting import ChangeTensorType\nfrom kgcnn.layers.conv.attention import AttentionHeadGATV2\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 by Veličković et al. (2018)\n# https://arxiv.org/abs/1710.10903\n# Improved by\n# How Attentive are Graph Attention Networks?\n# by Brody et al. (2021)\n\nmodel_default = {'name': \"GATv2\",\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 GATv2 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 `AttentionHeadGATV2` 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\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 = [AttentionHeadGATV2(**attention_args)([nk, 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 `GATv2`\")\n\n # Define model output\n model = tf.keras.models.Model(inputs=[node_input, edge_input, edge_index_input], outputs=main_output)\n return model\n"
]
| [
[
"tensorflow.keras.layers.Flatten",
"tensorflow.keras.layers.Input",
"tensorflow.keras.models.Model"
],
[
"tensorflow.keras.layers.Flatten",
"tensorflow.keras.layers.Input",
"tensorflow.keras.models.Model"
]
]
|
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_allclose",
"numpy.array_equal",
"numpy.random.random",
"numpy.concatenate",
"numpy.empty",
"pandas.DataFrame",
"numpy.random.randint",
"numpy.append",
"numpy.vstack",
"numpy.array",
"numpy.testing.assert_equal",
"numpy.ix_",
"numpy.all",
"numpy.add",
"numpy.asarray",
"numpy.random.seed",
"numpy.repeat",
"numpy.unique",
"numpy.isin"
]
]
|
hpgit/HumanFoot | [
"f9a1a341b7c43747bddcd5584b8c98a0d1ac2973",
"f9a1a341b7c43747bddcd5584b8c98a0d1ac2973",
"f9a1a341b7c43747bddcd5584b8c98a0d1ac2973",
"f9a1a341b7c43747bddcd5584b8c98a0d1ac2973",
"f9a1a341b7c43747bddcd5584b8c98a0d1ac2973"
]
| [
"DartWalkingFoot/main_DartTrackingFoot1.py",
"MomentumProject/foot_example_segfoot_constraint/mtOptimize.py",
"DartMuscle/muscle.py",
"PyCommon/modules/Simulator/hpQPSimulator.py",
"DartWalkingFoot/main_TrackingFoot0.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",
"import numpy as np\nimport numpy.linalg as npl\n\nimport sys\nif '../PyCommon/modules' not in sys.path:\n sys.path.append('../PyCommon/modules')\nimport PyCommon.modules.Math.mmMath as mm\nimport PyCommon.modules.Util.ysPythonEx as ype\n\ndef getTrackingWeight(DOFs, skeleton, weightMap, rootPositionWeight=0.):\n weights = [1.]*skeleton.getJointNum()\n for name, weight in weightMap.items():\n index = skeleton.getJointIndex(name)\n if index is not None:\n weights[index] = weight\n\n totalDOF = 0\n for dof in DOFs:\n totalDOF += dof\n\n weights_ext = [None]*totalDOF\n ype.repeatListElements(weights, weights_ext, DOFs)\n weights_ext[0:3] = [rootPositionWeight, rootPositionWeight, rootPositionWeight]\n\n return weights_ext\n\n\ndef addTrackingTerms(problem, totalDOF, weight, jointWeights, ddth_des_flat):\n # minimize | Wt(ddth_des - ddth) |^2\n problem.addObjective_matrix(np.diag( [jointWeights[i] for i in range(len(jointWeights))] ), np.array([jointWeights[i]*ddth_des_flat[i] for i in range(len(jointWeights))]), weight )\n\n\ndef addLinearTerms(problem, totalDOF, weight, dL_des, R, r_bias):\n # minimize | dL_des - (R*ddth + r_bias) |^2\n problem.addObjective_matrix(R, dL_des - r_bias, weight)\n\n\ndef addAngularTerms(problem, totalDOF, weight, dH_des, S, s_bias):\n # minimize | dH_des - (S*ddth + s_bias) |^2\n problem.addObjective_matrix(S, dH_des - s_bias, weight)\n\n\ndef addEndEffectorTerms(problem, totalDOF, weight, J, dJ, dth, ddP_des):\n # minimize | ddP_des - (J*ddth + dJ)|^2\n problem.addObjective_matrix(J, ddP_des - dJ, weight)\n\n\ndef addSoftPointConstraintTerms(problem, totalDOF, weight, ddP_des, Q, q_bias):\n # minimize | ddP_des - (Q*ddth + q_bias) |^2\n problem.addObjective_matrix(Q, ddP_des - q_bias, weight)\n\n\ndef setConstraint(problem, totalDOF, J, dJ, dth_flat, a_sup):\n # subject to J_sup*ddth + dJ_sup*dth_flat = a_sup\n problem.setConstraint_matrix(J, a_sup - np.dot(dJ, dth_flat))\n\n\ndef addConstraint(problem, totalDOF, J, dJ, dth_flat, a_sup):\n # subject to J_sup*ddth + dJ_sup*dth_flat = a_sup\n problem.addConstraint_matrix(J, a_sup - np.dot(dJ, dth_flat))\n\n\ndef addConstraint2(problem, totalDOF, J, dJdq, dth_flat, a_sup):\n # subject to J_sup*ddth + dJ_sup*dth_flat = a_sup\n problem.addConstraint_matrix(J, a_sup - dJdq)\n\n\n# Quadratic Programming \n# x = [ddotq tau lambda]\n\ndef addQPTrackingTerms(qp, totalProblemSize, si, totalDOF, weight, jointWeights, ddth_des_flat):\n # minimize | Wt(ddth_des - ddth) |^2\n #jointWeights[0] = .5\n #jointWeights[1] = 1.1\n #jointWeights[2] = .5\n #jointWeights[3] = 1.1\n #jointWeights[4] = 1.1\n #jointWeights[5] = 1.1\n\n jointWeights[0] = .5\n jointWeights[1] = .1\n jointWeights[2] = .5\n jointWeights[3] = .0001\n jointWeights[4] = .0001\n jointWeights[5] = .0001\n\n aaa = .5\n #A = np.diag( np.append([jointWeights[i] for i in range(len(jointWeights))], np.zeros(totalProblemSize-totalDOF)) )\n A = np.diag( np.append([aaa for i in range(len(jointWeights))], np.zeros(totalProblemSize-totalDOF)) )\n #b = np.append(np.array([jointWeights[i]*ddth_des_flat[i] for i in range(len(jointWeights))]), np.zeros(totalProblemSize-totalDOF))\n b = np.append(np.array([aaa*ddth_des_flat[i] for i in range(len(jointWeights))]), np.zeros(totalProblemSize-totalDOF))\n qp.addObjective(A,b,weight)\n\ndef addQPTorqueTerms(qp, totalProblemSize, si, totalActuator, weight, jointTorqueWeights):\n # minimize |tau|^2\n A = np.diag(np.append(np.append(np.zeros((si)), 1.*np.ones((totalActuator))), np.zeros(totalProblemSize-si-totalActuator)))\n b = np.zeros(totalProblemSize)\n qp.addObjective(A,b,weight)\n\ndef addQPContactForceTerms(qp, totalProblemSize, si, totalContact, weight):\n # minimize |lambda|^2\n A = np.diag(np.append(np.zeros(si), 1.*np.ones(totalContact)))\n b = np.zeros(totalProblemSize)\n qp.addObjective(A,b,weight)\n\ndef addQPEqualityEomConstraint(qp, totalProblemSize, totalDOF, totalActuator, totalContact, M, c, JcTVc_append):\n # subject to Mq'' -tau - JcTVclambda = -b\n # tau[0:6) = 0\n # [M -I -JcTVc]\n S = np.diag(np.append(np.zeros(6), 1.*np.ones(totalActuator-6)))\n A = np.vstack(( np.zeros((6,totalProblemSize)), np.hstack(( M,-S,-JcTVc_append )) ))\n for i in range(0, 6):\n A[i, totalDOF+i] = 1.\n b = np.append(np.zeros(6), -c)\n qp.addEqualityConstraint(A, b)\n\ndef addQPEqualityInverseEomConstraint(qp, totalProblemSize, totalDOF, totalActuator, totalContact, invM, invMc, JcTVc_append):\n # subject to Mq'' -tau - JcTVclambda = -b\n # tau[0:6) = 0\n # [I -M^-1 -M^-1*JcTVc]\n S = np.diag(np.append(np.zeros(6), 1.*np.ones(totalActuator-6)))\n #A = np.vstack(( np.zeros((6,totalProblemSize)), np.hstack(( np.eye(totalDOF),-np.dot(invM, S),np.dot(invM, -JcTVc_append) )) ))\n A = np.vstack(( np.zeros((6,totalProblemSize)), np.hstack(( np.eye(totalDOF),-invM,-np.dot(invM, JcTVc_append) )) ))\n for i in range(0, 6):\n A[i, totalDOF+i] = 1.\n b = np.append(np.zeros(6), -invMc)\n #print(A[totalDOF:totalDOF+6])\n qp.addEqualityConstraint(A, b)\n\ndef addQPEqualityContactConstraint(qp, totalProblemSize, totalDOF, totalActuator, totalContact, Jc, dJc, dth, a_c):\n # subject to Jc q'' = -dJc q' + a_sup\n A = np.hstack( (Jc , np.zeros((6, totalActuator+totalContact))) )\n b = -np.dot(dJc, dth) + a_c\n qp.addEqualityConstraint(A, b)\n\ndef addQPInequalityTorqueConstraint(qp, totalProblemSize, totalDOF, totalActuator, totalContact, torqueMax, torqueMin):\n # subject to tau <= max and -tau <= min\n G_max = np.hstack((np.zeros((totalActuator-6, totalDOF+6)), np.diag(1.*np.ones(totalActuator-6)), np.zeros((totalActuator-6, totalContact)) ))\n G_min = -G_max\n G = np.vstack((G_max, G_min))\n h = np.append( torqueMax, -torqueMin)\n if G.shape[0] != h.shape[0]:\n print('Inequality Torque : G and h shapes are not matched')\n\n qp.addInequalityConstraint(G, h)\n\ndef addQPInequalityContactForceConstraint(qp, totalProblemSize, totalDOF, totalActuator, totalContact):\n # subject to -lambda <= 0\n G = -np.hstack((np.zeros((totalContact, totalDOF+totalActuator)), np.diag(1.*np.ones(totalContact)) ))\n h = np.zeros(totalContact)\n if G.shape[0] != h.shape[0]:\n print('Inequality Contact : G and h shapes are not matched')\n qp.addInequalityConstraint(G, h)\n\ndef addQPInequalityVelocityConstraint(qp, totalProblemSize, totalDOF, totalActuator, totalContact, VcTJc_list, VcTdJc_list, dVcTJc_list, dq, ac_offset_list, invdt):\n # subject to -(VcTJcq'' + VcTJc'q' + VcT'Jcq') <= 0\n #TODO:\n # assume that Vc' = 0 <- is it right? check it!\n G = None\n h = None\n for i in range(len(VcTJc_list)):\n G_temp = np.hstack( (-VcTJc_list[i], np.zeros((4, totalActuator+totalContact))) )\n #h_temp = np.dot(VcTdJc_list[i], dq) + (-.05)*np.ones(4)\n #h_temp = (-1/30.)*np.dot(VcTJc_list[i], dq)+ np.dot(VcTdJc_list[i], dq) + (-1.)*ac_offset_list[i]\n #h_temp = (-1/30.)*np.dot(VcTJc_list[i], dq)+ np.dot(VcTdJc_list[i], dq)\n h_temp = np.dot(dVcTJc_list[i], dq) + np.dot(VcTdJc_list[i], dq) + np.dot(VcTJc_list[i], dq) * invdt + (-1.)*ac_offset_list[i]\n if G == None:\n G = G_temp.copy()\n h = h_temp.copy()\n else:\n G = np.vstack( (G, G_temp) )\n h = np.append( h, h_temp )\n\n if G.shape[0] != h.shape[0]:\n print('Inequality Velocity : G and h shapes are not matched')\n qp.addInequalityConstraint(G, h)\n",
"from math import exp, sin, cos, asin, pi, sqrt\nfrom scipy.optimize import minimize_scalar\n\n# muscle specific parameters\nf_m_o, l_m_o, l_t_sl, alpha_opt = 0, 0, 0, 0\n\n# all muslces share these parameters\neps_t_o = 0.033\neps_m_o = 0.6\nk_pe = 4.0\ngamma = 0.5\ndot_l_m_max_tilde = 10.\nf_m_len_tilde = 1.8\nA_f = 0.3\n\n# Force-Length Relationship of Tendon\nf_t_toe_tilde = 0.33\nk_toe = 3.0\nk_lin = 1.712 / eps_t_o\neps_t_toe = 0.609 * eps_t_o\n\ndef g_t_tilde(l_t):\n eps_t = l_t / l_t_sl - 1.\n if eps_t <= eps_t_toe:\n return f_t_toe_tilde * (exp(k_toe * eps_t / eps_t_toe - 1.) - 1.) \\\n / \\\n (exp(k_toe) - 1.)\n else:\n return k_lin * (eps_t - eps_t_toe) + f_t_toe_tilde\n\n\n# Passive Force-Length Relationship of Muscle\ndef g_pl_tilde(l_m):\n l_m_tilde = l_m / l_m_o\n if l_m_tilde <= 1:\n return 0\n else:\n return (exp(k_pe * (l_m_tilde - 1)/eps_m_o) - 1) \\\n / \\\n (exp(k_pe) - 1)\n\n\n# Active Force-Length Relationship of Muscle\ndef g_al_tilde(l_m):\n l_m_tilde = l_m / l_m_o\n return exp(-(l_m_tilde-1)*(l_m_tilde-1)/gamma)\n\n\n# Force-Velocity Relationship of Muscle\ndef g_vl_tilde(dot_l_m):\n dot_l_m_tilde = dot_l_m / l_m_o\n if dot_l_m_tilde <= 0:\n return (dot_l_m_tilde + dot_l_m_max_tilde) \\\n / \\\n (dot_l_m_max_tilde - dot_l_m_tilde/A_f)\n else:\n _a = dot_l_m_tilde * (2. + 2./A_f)\n _b = dot_l_m_max_tilde * (f_m_len_tilde - 1.)\n return (f_m_len_tilde * _a + _b) / (_a + _b)\n\n\ndef compute_activation_deriv_scalar(u, a, tau_act, tau_deact):\n tau_total = 0.\n if u < a:\n tau_total = tau_deact / (0.5 + 1.5*a)\n else:\n tau_total = tau_act * (0.5 + 1.5*a)\n dadt = (u-a) / tau_total\n return dadt\n\n\ndef compute_cos_pennation_scalar(l_m, l_m_opt, pa_opt):\n pa = 0.\n\n if l_m < 0.:\n l_m = 0.\n\n if l_m < 1e-6:\n pa = asin(1.)\n else:\n pa = asin( l_m_opt * sin(pa_opt) / l_m )\n\n if pa > pi/4.:\n pa = pi/4.\n\n return cos(pa)\n\n\ndef compute_norm_tendon_force_scalar(eps_t, eps_t_o):\n f_t_norm = 0.\n if eps_t > eps_t_toe:\n f_t_norm = k_lin * (eps_t - eps_t_toe) + f_t_toe_tilde\n elif eps_t > 0.:\n f_t_norm = (f_t_toe_tilde / (exp(k_toe)-1.)) * (exp(k_toe * eps_t / eps_t_toe) - 1.)\n else:\n f_t_norm = 0.\n\n return f_t_norm\n\ndef compute_norm_passive_fiber_force_by_length_scalar(l_m_norm, eps_m_o, k_pe):\n f_p_norm = 0.\n if l_m_norm > 1.:\n f_p_norm = (exp(k_pe * (l_m_norm - 1.) / eps_m_o) - 1.) / (exp(k_pe) - 1.)\n else:\n f_p_norm = 0\n return f_p_norm\n\n\ndef compute_norm_active_fiber_force_by_length_scalar(l_m_norm, gamma):\n return exp(-(l_m_norm-1.)*(l_m_norm-1.) / gamma)\n\n\ndef compute_norm_active_fiber_force_by_velocity_scalar(dl_mdt_norm, a_f, f_m_len, v_m_max):\n gv_norm = 0.\n if dl_mdt_norm <= 0.:\n gv_norm = (dl_mdt_norm + v_m_max) / (v_m_max - dl_mdt_norm/a_f)\n else:\n lm_term = dl_mdt_norm*(2.+2./a_f)\n lmax_term = v_m_max*(f_m_len-1.)\n gv_norm = (f_m_len*lm_term + lmax_term) / (lm_term + lmax_term)\n return gv_norm\n\n\ndef compute_norm_fiber_length_deriv_scalar(f_m_norm, a, f_l, a_f, f_m_len, damping, v_m_max, option=None):\n a_f_l = a * f_l\n if damping > 0.:\n d = damping\n k = 1.\n\n if f_m_norm <= a_f_l:\n _a = d/a_f\n _b = -(a_f_l + f_m_norm/a_f + k*d)\n _c = k*(f_m_norm - a_f_l)\n else:\n _a = -(2.+2./a_f) * d / f_m_len\n _b = -((2.+2./a_f) * (a_f_l*f_m_len - f_m_norm)/(f_m_len-1.) + k*d)\n _c = k*(f_m_norm - a_f_l)\n\n det = _b*_b - 4*_a*_c\n dl_mdt_unit = (-_b-sqrt(det))/(2.*_a)\n else:\n if f_m_norm <= a_f_l:\n _b = a_f_l + (f_m_norm / a_f)\n else:\n _b = ( (2. + 2. /a_f) * (a_f_l * f_m_len - f_m_norm ) ) / (f_m_len - 1.)\n\n if _b > 0.:\n dl_mdt_unit = (f_m_norm - a_f_l) / _b\n else:\n dl_mdt_unit = 0.\n\n return v_m_max * dl_mdt_unit\n\n\ndef get_fiber_length_deriv_scalar(a, l_m, l_mt, l_m_opt, pa_opt, l_t_sl, eps_t_o, eps_m_o,\n k_pe, gamma, a_f, f_m_len, damping, v_m_max, option=None):\n cos_pa = compute_cos_pennation_scalar(l_m, l_m_opt, pa_opt)\n\n l_t = l_mt - l_m * cos_pa\n eps_t = (l_t - l_t_sl) / l_t_sl\n f_t_norm = compute_norm_tendon_force_scalar(eps_t, eps_t_o)\n\n l_m_norm = l_m / l_m_opt\n f_p_norm = compute_norm_passive_fiber_force_by_length_scalar(l_m_norm, eps_m_o, k_pe)\n f_l = compute_norm_active_fiber_force_by_length_scalar(l_m_norm, gamma)\n\n f_m_norm = f_t_norm / cos_pa - f_p_norm\n dl_mdt_norm = compute_norm_fiber_length_deriv_scalar(f_m_norm, a, f_l, a_f, f_m_len, damping, v_m_max, option)\n\n dl_mdt = l_m_opt * dl_mdt_norm\n\n return dl_mdt\n\n\ndef get_isometric_fiber_length(a, l_m, l_mt, l_m_opt, pa_opt, l_t_sl, eps_t_o, eps_m_o,\n k_pe, gamma, a_f, f_m_len, damping, v_m_max, option=None):\n def obj_dl_m(_l_m):\n dl_mdt = get_fiber_length_deriv_scalar(a, _l_m, l_mt, l_m_opt, pa_opt, l_t_sl, eps_t_o, eps_m_o,\n k_pe, gamma, a_f, f_m_len, damping, v_m_max, 'modified_damping')\n return dl_mdt * dl_mdt\n\n ub = max(0., l_mt - l_t_sl)\n\n result = minimize_scalar(obj_dl_m, bounds=(0., ub), method='bounded')\n return result.x\n\n\nclass Muscle(object):\n def __init__(self):\n pass",
"from fltk import *\nimport copy\nimport numpy as np\nimport numpy.linalg as npl\n\nimport sys\nif '..' not in sys.path:\n sys.path.append('..')\nimport Math.mmMath as mm\nimport Resource.ysMotionLoader as yf\nimport Simulator.csVpWorld as cvw\nimport Simulator.csVpModel as cvm\nimport GUI.ysSimpleViewer as ysv\nimport Optimization.ysAnalyticConstrainedOpt as yac\nimport ArticulatedBody.ysJacobian as yjc\nimport Util.ysPythonEx as ype\nimport ArticulatedBody.ysReferencePoints as yrp\nimport ArticulatedBody.ysMomentum as ymt\nimport ArticulatedBody.ysControl as yct\n\ndef getPartJacobian(_Jsys, _jIdx):\n # warning : only Jsys works.\n return _Jsys[6*_jIdx : 6*_jIdx+6].copy()\n\nclass QPSimulator:\n def __init__(self):\n self.qp = yac.QP()\n self.qp.clear()\n\n # parameter\n self.Kt = 200.\n self.Dt = 2*(self.Kt**.5)\n self.Kl = 1000.\n self.Dl = 2*(self.Kl**.5)\n self.Kh = 1000.\n self.Dh = 2*(self.Kh**.5)\n #self.Ke = 100\n #self.De = 2*(self.Ke**.5)\n self.Ke = 10\n self.De = 2*(self.Ke**.5)\n\n self.Bt = 10.\n self.Btau = 1.\n self.Bcon = 1.\n self.Bl = 100.\n self.Bh = 100.\n self.Be = 100.\n\n # constants\n self.mu = 1.\n self.contactPerSide = 4 # vertices of boxes always checked\n\n # flat data structure\n self.ddth_des_flat = None\n self.dth_flat = None\n self.dth_r_flat = None\n self.ddth_r_flat = None\n self.ddth_sol = None\n self.totalDOF = 0\n\n self.extForce = None\n self.extForceBody = None\n self.extDuration = 0\n\n self.Vc_tmp = np.zeros((4,3))\n self.Vc_tmp[0] = mm.normalize2(( self.mu, 1, 0))\n self.Vc_tmp[1] = mm.normalize2((-self.mu, 1, 0))\n self.Vc_tmp[2] = mm.normalize2(( 0, 1, self.mu))\n self.Vc_tmp[3] = mm.normalize2(( 0, 1, -self.mu))\n\n self.CP_old = None\n\n #self.dH_des = None\n #self.dL_des_plane = None\n\n # jacobian\n self.Jsys = None\n self.dJsys = None\n\n def setupWeight(self, Kt, Kl, Kh, Ke, Bt, Btau, Bcon, Bl=0., Bh=0., Be=0.):\n self.Kt = Kt\n self.Dt = 2*(self.Kt**.5)\n self.Kl = Kl\n self.Dl = 2*(self.Kl**.5)\n self.Kh = Kh\n self.Dh = 2*(self.Kh**.5)\n self.Ke = Ke\n self.De = 2*(self.Ke**.5)\n\n self.Bt = Bt\n self.Btau = Btau\n self.Bcon = Bcon\n self.Bl = Bl\n self.Bh = Bh\n self.Be = Be\n\n def addExternalForces(self, force, forceBody, duration):\n self.extForce = np.hstack( (force, np.zeros(3)) )\n self.extForceBody = forceBody\n self.extDuration = duration\n\n def setupQP(self, frame, motion, mcfg, model, world, config, timestep):\n motionModel = cvm.VpMotionModel(world, motion[frame], mcfg)\n\n # constants\n invdt = 1./timestep\n\n # dofs and flat data structure\n totalDOF = model.getTotalDOF()\n DOFs = model.getDOFs()\n self.totalDOF = totalDOF\n self.ddth_des_flat = ype.makeFlatList(totalDOF)\n self.ddth_r_flat = ype.makeFlatList(totalDOF)\n self.dth_flat = ype.makeFlatList(totalDOF)\n self.dth_r_flat = ype.makeFlatList(totalDOF)\n self.ddth_sol = ype.makeNestedList(DOFs)\n\n # momentum matrix\n linkMasses = model.getBodyMasses()\n totalMass = model.getTotalMass()\n TO = ymt.make_TO(linkMasses)\n dTO = ymt.make_dTO(len(linkMasses))\n\n # optimization\n self.qp.clear()\n\n\n Vc_tmp = self.Vc_tmp\n\n\n # tracking\n w = self.getTrackingWeight(DOFs, motion[0].skeleton, config['weightMap'])\n\n th_r = motion.getDOFPositionsLocal(frame)\n th = model.getDOFPositionsLocal()\n dth_r = motion.getDOFVelocitiesLocal(frame)\n dth = model.getDOFVelocitiesLocal()\n ddth_r = motion.getDOFAccelerationsLocal(frame)\n ddth_des = yct.getDesiredDOFAccelerations(th_r, th, dth_r, dth, ddth_r, self.Kt, self.Dt)\n\n linkPositions = model.getBodyPositionsGlobal()\n linkVelocities = model.getBodyVelocitiesGlobal()\n linkAngVelocities = model.getBodyAngVelocitiesGlobal()\n linkInertias = model.getBodyInertiasGlobal()\n\n jointPositions = model.getJointPositionsGlobal()\n jointAxeses = model.getDOFAxesesLocal()\n\n #linkPositions_ref = motionModel.getBodyPositionsGlobal()\n #linkVelocities_ref = motionModel.getBodyVelocitiesGlobal()\n #linkAngVelocities_ref = motionModel.getBodyAngVelocitiesGlobal()\n #linkInertias_ref = motionModel.getBodyInertiasGlobal()\n\n #jointPositions_ref = motionModel.getJointPositionsGlobal()\n #jointAxeses_ref = motionModel.getDOFAxesesLocal()\n\n ype.flatten(ddth_des, self.ddth_des_flat)\n ype.flatten(dth, self.dth_flat)\n ype.flatten(dth_r, self.dth_r_flat)\n ype.flatten(ddth_r, self.ddth_r_flat)\n\n # get CoM\n CM = yrp.getCM(linkPositions, linkMasses, totalMass)\n dCM = yrp.getCM(linkVelocities, linkMasses, totalMass)\n CM_plane = copy.copy(CM); CM_plane[1]=0.\n dCM_plane = copy.copy(dCM); dCM_plane[1]=0.\n\n P = ymt.getPureInertiaMatrix(TO, linkMasses, linkPositions, CM, linkInertias)\n dP = ymt.getPureInertiaMatrixDerivative(dTO, linkMasses, linkVelocities, dCM, linkAngVelocities, linkInertias)\n\n\n # jacobian\n Jsup = yjc.makeEmptyJacobian(DOFs, 1)\n dJsup = Jsup.copy()\n Jsys_old = None\n\n if self.Jsys != None:\n Jsys_old = self.Jsys.copy()\n\n if self.Jsys == None:\n self.Jsys = yjc.makeEmptyJacobian(DOFs, model.getBodyNum())\n self.dJsys = self.Jsys.copy()\n\n allLinkJointMasks = yjc.getAllLinkJointMasks(motion[0].skeleton)\n\n yjc.computeJacobian2(self.Jsys, DOFs, jointPositions, jointAxeses, linkPositions, allLinkJointMasks)\n if Jsys_old ==None:\n self.dJsys = self.Jsys-self.Jsys\n else:\n self.dJsys = (self.Jsys - Jsys_old)*invdt\n #yjc.computeJacobianDerivative2(self.dJsys, DOFs, jointPositions, jointAxeses, linkAngVelocities, linkPositions, allLinkJointMasks)\n\n #CM_ref = yrp.getCM(linkPositions_ref, linkMasses, totalMass)\n #dCM_ref = yrp.getCM(linkVelocities_ref, linkMasses, totalMass)\n #CM_ref_plane = copy.copy(CM_ref); CM_ref_plane[1]=0.\n #dCM_ref_plane = copy.copy(dCM_ref); dCM_ref_plane[1]=0.\n\n #P_ref = ymt.getPureInertiaMatrix(TO, linkMasses, linkPositions_ref, CM_ref, linkInertias_ref)\n #dP_ref = ymt.getPureInertiaMatrixDerivative(dTO, linkMasses, linkVelocities_ref, dCM_ref, linkAngVelocities_ref, linkInertias_ref)\n\n # get EoM\n totalActuator = totalDOF\n\n invM = np.zeros((totalActuator,totalDOF))\n invMc = np.zeros(totalDOF)\n model.getInverseEquationOfMotion(invM, invMc)\n #print invMc\n\n # contact detection\n Ks = 1\n Ds = 1\n supsupR = motion[0].skeleton.getJointIndex('RightLeg')\n supsupL = motion[0].skeleton.getJointIndex('LeftLeg')\n supR = motion[0].skeleton.getJointIndex('RightFoot')\n supL = motion[0].skeleton.getJointIndex('LeftFoot')\n bodyIDsToCheck = range(world.getBodyNum())\n #print bodyIDsToCheck\n #bodyIDsToCheck = [supsupR, supsupL]\n #bodyIDsToCheck = [supR, supL]\n mus = [.5]*len(bodyIDsToCheck)\n bodyIDs, contactPositions, contactPositionLocals, contactForces, contactVelocities = world.calcPenaltyForce(bodyIDsToCheck, mus, Ks, Ds)\n #bodyIDs, contactPositions, contactPositionLocals, contactForces, contactVelocities = world.calcManyPenaltyForce(self.contactPerSide, bodyIDsToCheck, mus, Ks, Ds)\n #bodyIDs, contactPositions, contactPositionLocals, contactForces, contactVelocities = world.calcOnePenaltyForce(bodyIDsToCheck, mus, Ks, Ds)\n\n #print bodyIDs, contactPositions\n\n footCenterL = model.getBodyPositionGlobal(supL)\n footCenterR = model.getBodyPositionGlobal(supR)\n footCenter = footCenterL.copy()\n\n footRefCenterL = motionModel.getBodyPositionGlobal(supL)\n footRefCenterR = motionModel.getBodyPositionGlobal(supR)\n #if supL in bodyIDs:\n #if supR in bodyIDs:\n #footCenter = footCenterL + (footCenterR-footCenterL)/2.\n #else:\n #footCenter = footCenterL.copy()\n #else:\n #if supR in bodyIDs:\n #footCenter = footCenterR.copy()\n #else:\n #footCenter = np.array((0,0,0))\n\n contactL = 1\n contactR = 1\n\n if footRefCenterL[1] < 0.2:\n if footRefCenterR[1] < 0.2:\n footCenter = footCenterL + (footCenterR-footCenterL)/2.\n else:\n footCenter = footCenterL.copy()\n contactR = 0\n else:\n contactL = 0\n if footRefCenterR[1] < 0.2:\n footCenter = footCenterR.copy()\n else:\n footCenter = np.array((0,0,0))\n contactR = 0\n #print(contactR, contactL)\n footCenter[1] = 0.\n\n # linear momentum\n CM_ref = footCenter\n #CM_ref =\n #dL_des_plane = self.Kl*totalMass*(CM_ref - CM) + self.Dl*totalMass*(dCM_ref - dCM)\n dL_des_plane = self.Kl*totalMass*(CM_ref - CM) + self.Dl*totalMass*(-dCM)\n dL_des_plane[1] = 0.\n\n # angular momentum\n CP_ref = footCenter\n #bodyIDs, contactPositions, contactPositionLocals, contactForces = world.calcManyPenaltyForce(bodyIDsToCheck, mus, Ks, Ds)\n #CP = yrp.getCP(contactPositions, contactForces)\n CP = yrp.getSimpleCP(contactPositions)\n if self.CP_old==None or CP==None:\n dCP = None\n else:\n dCP = (CP - self.CP_old[0])/(1/30.)\n self.CP_old = CP\n\n if CP!=None and dCP!=None:\n ddCP_des = self.Kh*(CP_ref - CP) - self.Dh*(dCP)\n CP_des = CP + dCP*(1/30.) + .5*ddCP_des*((1/30.)**2)\n dH_des = np.cross((CP_des - CM), (dL_des_plane + totalMass*np.array((0,-9.8,0))))\n #if contactChangeCount >0: # and contactChangeType == 'DtoS':\n ##dH_des *= (maxContactChangeCount - contactChangeCount)/(maxContactChangeCount*10)\n #dH_des *= (self.maxContactChangeCount - self.contactChangeCount)/(self.maxContactChangeCount)\n ##dH_des *= (contactChangeCount)/(maxContactChangeCount)*.9+.1\n else:\n dH_des = None\n H = np.dot(P, np.dot(self.Jsys, self.dth_flat))\n dH_des = -self.Kh*H[3:]\n\n\n\n # equality constraints\n JcTVc_append = np.zeros((totalDOF, 0))\n VcTJc_list = []\n VcTdJc_list = []\n dVcTJc_list = []\n ac_offset_list = []\n totalContact = 4*len(bodyIDs)\n totalProblem = totalDOF+totalActuator+totalContact\n\n preSup = -1\n for i in range(len(contactPositions)):\n sup = bodyIDs[i]\n supJointMasks = [yjc.getLinkJointMask(motion[0].skeleton, sup)]\n\n if preSup != sup:\n bodyPos = linkPositions[sup]\n bodyVel = linkVelocities[sup]\n #yjc.computeJacobian2(Jsup, DOFs, jointPositions, jointAxeses, [bodyPos], supJointMasks)\n #yjc.computeJacobianDerivative2(dJsup, DOFs, jointPositions, jointAxeses, linkAngVelocities, [bodyPos], supJointMasks)\n Jsup = getPartJacobian(self.Jsys, sup)\n dJsup = getPartJacobian(self.dJsys, sup)\n\n R_dAd = np.hstack( (np.vstack( (np.eye(3), mm.getCrossMatrixForm(-bodyPos)) ), np.vstack( (np.zeros((3,3)), np.eye(3)) ) ) )\n dR_dAd = np.hstack( (np.vstack( (np.eye(3), mm.getCrossMatrixForm(-bodyVel)) ), np.vstack( (np.zeros((3,3)), np.eye(3)) ) ) )\n #R_dAd = np.hstack( (np.vstack( (np.eye(3), mm.getCrossMatrixForm(-contactPositions[i])) ), np.vstack( (np.zeros((3,3)), np.eye(3)) ) ) )\n #dR_dAd = np.hstack( (np.vstack( (np.eye(3), mm.getCrossMatrixForm(-contactVelocities[i])) ), np.vstack( (np.zeros((3,3)), np.eye(3)) ) ) )\n\n p = contactPositions[i]\n dotp = contactVelocities[i]\n VcT_tmp = np.zeros((4,6))\n dVcT_tmp = VcT_tmp.copy()\n for ii in range(4):\n n = Vc_tmp[ii]\n pcn = np.cross(contactPositions[i], Vc_tmp[ii])\n VcT_tmp[ii][:3] =n\n VcT_tmp[ii][3:] =pcn\n dotpcn = np.cross(contactVelocities[i], Vc_tmp[ii])\n dVcT_tmp[ii][3:] = dotpcn\n\n Vc = np.dot(R_dAd, VcT_tmp.T)\n dVc = np.dot(R_dAd, dVcT_tmp.T) + np.dot(dR_dAd, VcT_tmp.T)\n\n JcTVc = np.dot( Jsup.T, Vc)\n JcTVc_append = np.hstack((JcTVc_append, JcTVc))\n VcTJc_list.append( JcTVc.T )\n VcTdJc_list.append( np.dot(Vc.T, dJsup) )\n dVcTJc_list.append( np.dot(dVc.T, Jsup) )\n\n #TODO:\n # when friction cones and velocity cones differ?\n #JcTVc = np.dot( Jsup.T, VcT.T)\n #JcTVc_append = np.hstack((JcTVc_append, JcTVc))\n #VcTJc_list.append( JcTVc.T )\n #VcTdJc_list.append( np.dot(VcT, dJsup) )\n #dVcTJc_list.append( np.dot(dVcT, Jsup) )\n\n penDepth = -0.05-contactPositions[i][1]\n if penDepth < 0.:\n penDepth = 0.\n #penDepth = 0.\n ac_offset = 1000.*penDepth*np.ones(4)\n ac_offset_list.append(ac_offset)\n preSup = sup\n\n extForce = np.zeros(totalActuator)\n if self.extDuration > 0:\n Jext = yjc.makeEmptyJacobian(DOFs, 1)\n extForcePos = model.getBodyPositionGlobal(self.extForceBody)\n extJointMasks = [yjc.getLinkJointMask(motion[0].skeleton, self.extForceBody)]\n yjc.computeJacobian2(Jext, DOFs, jointPositions, jointAxeses, [extForcePos], extJointMasks)\n extForce = np.dot(Jext.T, self.extForce)\n\n self.extDuration -= timestep\n if self.extDuration < 0:\n self.extDuration = 0\n\n self.addQPEqualityInverseEomConstraint(totalProblem, totalDOF, totalActuator, totalContact, invM, invMc, JcTVc_append, extForce)\n\n # inequality constraints\n\n if totalContact> 0:\n self.addQPInequalityContactForceConstraint(totalProblem, totalDOF, totalActuator, totalContact)\n self.addQPInequalityVelocityConstraint(totalProblem, totalDOF, totalActuator, totalContact, VcTJc_list, VcTdJc_list,dVcTJc_list, self.dth_flat, ac_offset_list, invdt)\n #self.addQPInequalityVelocityConstraint(totalProblem, totalDOF, totalActuator, totalContact, VcTJc_vel_list, VcTdJc_vel_list,dVcTJc_vel_list, self.dth_flat, ac_offset_list, 30.)\n torqueMax = 1000.*np.ones(totalActuator-6)\n torqueMin = -torqueMax\n self.addQPInequalityTorqueConstraint(totalProblem, totalDOF, totalActuator, totalContact, torqueMax, torqueMin)\n\n # objectives\n self.addQPTrackingTerms(totalProblem, 0, totalDOF, self.Bt, w, self.ddth_des_flat)\n self.addQPTorqueTerms(totalProblem, totalDOF, totalActuator, self.Btau, w)\n if totalContact > 0:\n self.addQPContactForceTerms(totalProblem, totalDOF+totalActuator, totalContact, self.Bcon)\n #if dH_des !=None:\n #\tallLinkJointMasks = yjc.getAllLinkJointMasks(motion[0].skeleton)\n #\tyjc.computeJacobian2(Jsys, DOFs, jointPositions, jointAxeses, linkPositions, allLinkJointMasks)\n #\tyjc.computeJacobianDerivative2(dJsys, DOFs, jointPositions, jointAxeses, linkAngVelocities, linkPositions, allLinkJointMasks)\n #\tself.addLinearAndAngularBalancigTerms(totalProblem, 0, totalDOF, self.Bl, self.Bh, P, self.Jsys, self.dth_flat, dP, self.dJsys, dL_des_plane, dH_des)\n\n # end effector\n #TODO:\n eeList = [supR, supL]\n #eeList = []\n\n #if totalContact > 0:\n for ee in eeList:\n eeCenter = model.getBodyPositionGlobal(ee)\n eeJointMasks = [yjc.getLinkJointMask(motion[0].skeleton, ee)]\n yjc.computeJacobian2(Jsup, DOFs, jointPositions, jointAxeses, [eeCenter], eeJointMasks)\n yjc.computeJacobianDerivative2(dJsup, DOFs, jointPositions, jointAxeses, linkAngVelocities, [eeCenter], eeJointMasks, False)\n ee_genvel_ref = np.dot(Jsup, self.dth_r_flat)\n ee_genacc_ref = np.dot(Jsup, self.ddth_r_flat) + np.dot(dJsup, self.dth_r_flat)\n\n ee_pos_ref = motionModel.getBodyPositionGlobal(ee)\n ee_pos = model.getBodyPositionGlobal(ee)\n ee_vel_ref = ee_genvel_ref[:3]\n ee_vel = model.getBodyVelocityGlobal(ee)\n ee_acc_ref = ee_genacc_ref[:3]\n ddp_des_pos = self.Ke*( (ee_pos_ref-th_r[0][0]) - (ee_pos-th[0][0]) )\n ddp_des_pos += self.De*(ee_vel_ref - ee_vel)\n ddp_des_pos += ee_acc_ref\n\n eeOri = model.getBodyOrientationGlobal(ee)\n eeAngVel = model.getBodyAngVelocityGlobal(ee)\n ee_angvel_ref = ee_genvel_ref[3:]\n ee_angacc_ref = ee_genacc_ref[3:]\n a_ori_diff = mm.logSO3(mm.getSO3FromVectors(np.dot(eeOri, np.array([0,1,0])), np.array([0,1,0])))\n ddp_des_ang = self.Ke*a_ori_diff + self.De*(-eeAngVel)\n #ddp_des_ang = self.Ke*a_ori_diff + self.De*(ee_angvel_ref-eeAngVel)\n #ddp_des_ang += ee_angacc_ref\n\n ddp_des = np.hstack( (ddp_des_pos, ddp_des_ang) )\n\n #self.addEndEffectorTerms(totalProblem, 0, totalDOF, Jsup, dJsup, self.dth_flat, ddp_des, self.Be)\n self.addEqualityEndEffectorTerms(totalProblem, 0, totalDOF, Jsup, dJsup, self.dth_flat, ddp_des, self.Be)\n\n return contactPositions, CP, CM, footCenter, dL_des_plane, CM_ref\n\n\n def stepQP(self, model, timestep):\n totalDOF = self.totalDOF\n # optimization\n x = self.qp.solve()\n ype.nested(np.array(x[:totalDOF].T).flatten(), self.ddth_sol)\n test_ddq = np.array(x[:totalDOF].T).flatten()\n test_tau = np.array(x[totalDOF:2*totalDOF].T).flatten()\n test_lambda = np.array(x[2*totalDOF:].T).flatten()\n\n # integrate\n if self.ddth_sol != None:\n model.stepKinematics(timestep, self.ddth_sol)\n self.ddth_des_flat = None\n self.dth_flat = None\n self.ddth_sol = None\n #np.dot(Vc_tmp.T, np.array(test_lambda[4*i:4*i+4]))\n if test_lambda != []:\n contactForces = []\n for i in range(len(test_lambda)/4):\n contactForces.append( np.dot(self.Vc_tmp.T, test_lambda[4*i:4*i+4]))\n\n return x, contactForces\n else:\n return x, None\n else:\n print(\"setup QP first!\")\n return None\n\n # objectives\n def getTrackingWeight(self, DOFs, skeleton, weightMap, rootPositionWeight=0.):\n weights = [1.]*skeleton.getJointNum()\n for name, weight in weightMap.items():\n index = skeleton.getJointIndex(name)\n weights[index] = weight\n\n totalDOF = 0\n for dof in DOFs:\n totalDOF += dof\n\n weights_ext = [None]*totalDOF\n ype.repeatListElements(weights, weights_ext, DOFs)\n weights_ext[0:3] = [rootPositionWeight, rootPositionWeight, rootPositionWeight]\n\n return weights_ext\n\n def addQPTrackingTerms(self, totalProblemSize, si, totalDOF, weight, jointWeights, ddth_des_flat):\n # minimize | Wt(ddth_des - ddth) |^2\n #jointWeights[0] = 1.\n #jointWeights[1] = 1.\n #jointWeights[2] = 1.\n A = np.diag( np.append([jointWeights[i] for i in range(len(jointWeights))], np.zeros(totalProblemSize-totalDOF)) )\n b = np.append(np.array([jointWeights[i]*ddth_des_flat[i] for i in range(len(jointWeights))]), np.zeros(totalProblemSize-totalDOF))\n self.qp.addObjective(A,b,weight)\n\n def addQPTorqueTerms(self, totalProblemSize, si, totalActuator, weight, jointTorqueWeights):\n # minimize |tau|^2\n A = np.diag(np.append(np.append(np.zeros((si)), 1.*np.ones((totalActuator))), np.zeros(totalProblemSize-si-totalActuator)))\n b = np.zeros(totalProblemSize)\n self.qp.addObjective(A,b,weight)\n\n def addQPContactForceTerms(self, totalProblemSize, si, totalContact, weight):\n # minimize |lambda|^2\n A = np.diag(np.append(np.zeros(si), 1.*np.ones(totalContact)))\n b = np.zeros(totalProblemSize)\n self.qp.addObjective(A,b,weight)\n\n def addLinearAndAngularBalancigTerms(self, totalProblemSize, si, totalDOF, linearWeight, angularWeight, P, Jsys, dth, dotP, dotJsys, dotLdes, dotHdes):\n #minimize |Bl(dotL - dotLdes)|^2 and |Bh(dotH - dotHdes)|^2\n Wl = linearWeight ** .5\n Wh = angularWeight ** .5\n W = np.diag( np.append( Wl*np.ones(3), Wh*np.ones(3) ) )\n A = np.hstack( (np.dot(W, np.dot(P, Jsys)), np.zeros( (6, totalProblemSize - totalDOF))))\n b = np.hstack( (dotLdes, dotHdes) ) - np.dot(dotP, np.dot(Jsys, dth)) - np.dot(P, np.dot(dotJsys, dth))\n self.qp.addObjective(A, np.dot(W,b))\n\n def addEndEffectorTerms(self, totalProblemSize, si, totalDOF, Jee, dJee, dth, ddp_des, weight):\n #minimize |ddp - ddp_des|^2 = |J * ddth - (ddp_des-dJ * dth)|^2\n #foot should be parallel to ground\n A = np.hstack( ( Jee.copy(), np.zeros((6, totalProblemSize-totalDOF)) ) )\n b = ddp_des - np.dot(dJee, dth)\n #self.qp.addEqualityConstraint(A[3:], b[3:])\n self.qp.addObjective(A, b, weight)\n #self.qp.addObjective(A[:0], b[:0], weight)\n #self.qp.addObjective(A[2:], b[2:], weight)\n\n # constraints\n def addQPEqualityEomConstraint(self, totalProblemSize, totalDOF, totalActuator, totalContact, M, c, JcTVc_append):\n # subject to Mq'' -tau - JcTVclambda = -b\n # tau[0:6) = 0\n # [M -I -JcTVc]\n S = np.diag(np.append(np.zeros(6), 1.*np.ones(totalActuator-6)))\n A = np.vstack(( np.zeros((6,totalProblemSize)), np.hstack(( M,-S,-JcTVc_append )) ))\n for i in range(0, 6):\n A[i, totalDOF+i] = 1.\n b = np.append(np.zeros(6), -c)\n self.qp.addEqualityConstraint(A, b)\n\n def addEqualityEndEffectorTerms(self, totalProblemSize, si, totalDOF, Jee, dJee, dth, ddp_des, weight):\n #minimize J * ddth = ddp_des - dJ * dth\n #foot should be parallel to ground\n A = np.hstack( ( Jee.copy(), np.zeros((6, totalProblemSize-totalDOF)) ) )\n b = ddp_des - np.dot(dJee, dth)\n self.qp.addEqualityConstraint(A[3:], b[3:])\n #self.qp.addEqualityConstraint(A, b)\n\n def addQPEqualityInverseEomConstraint(self, totalProblemSize, totalDOF, totalActuator, totalContact, invM, invMc, JcTVc_append, extForce):\n # subject to Mq'' -tau - JcTVclambda = -b\n # tau[0:6) = 0\n # [I -M^-1 -M^-1*JcTVc]\n S = np.diag(np.append(np.zeros(6), 1.*np.ones(totalActuator-6)))\n #A = np.vstack(( np.zeros((6,totalProblemSize)), np.hstack(( np.eye(totalDOF),-np.dot(invM, S),np.dot(invM, -JcTVc_append) )) ))\n A = np.vstack(( np.zeros((6,totalProblemSize)), np.hstack(( np.eye(totalDOF),-invM,-np.dot(invM, JcTVc_append) )) ))\n for i in range(0, 6):\n A[i, totalDOF+i] = 1.\n b = np.append(np.zeros(6), -invMc)\n b += np.append(np.zeros(6), np.dot(invM, extForce))\n #print(A[totalDOF:totalDOF+6])\n self.qp.addEqualityConstraint(A, b)\n\n def addQPEqualityContactConstraint(self, totalProblemSize, totalDOF, totalActuator, totalContact, Jc, dJc, dth, a_c):\n # subject to Jc q'' = -dJc q' + a_sup\n A = np.hstack( (Jc , np.zeros((6, totalActuator+totalContact))) )\n b = -np.dot(dJc, dth) + a_c\n self.qp.addEqualityConstraint(A, b)\n\n def addQPInequalityTorqueConstraint(self, totalProblemSize, totalDOF, totalActuator, totalContact, torqueMax, torqueMin):\n # subject to tau <= max and -tau <= min\n G_max = np.hstack((np.zeros((totalActuator-6, totalDOF+6)), np.diag(1.*np.ones(totalActuator-6)), np.zeros((totalActuator-6, totalContact)) ))\n G_min = -G_max\n G = np.vstack((G_max, G_min))\n h = np.append( torqueMax, -torqueMin)\n if G.shape[0] != h.shape[0]:\n print('Inequality Torque : G and h shapes are not matched')\n\n self.qp.addInequalityConstraint(G, h)\n\n def addQPInequalityContactForceConstraint(self, totalProblemSize, totalDOF, totalActuator, totalContact):\n # subject to -lambda <= 0\n G = -np.hstack((np.zeros((totalContact, totalDOF+totalActuator)), np.diag(1.*np.ones(totalContact)) ))\n h = np.zeros(totalContact)\n if G.shape[0] != h.shape[0]:\n print('Inequality Contact : G and h shapes are not matched')\n self.qp.addInequalityConstraint(G, h)\n\n def addQPInequalityVelocityConstraint(self, totalProblemSize, totalDOF, totalActuator, totalContact, VcTJc_list, VcTdJc_list, dVcTJc_list, dq, ac_offset_list, invdt):\n # subject to -(VcTJcq'' + VcTJc'q' + VcT'Jcq') <= 0\n #TODO:\n # assume that Vc' = 0 <- is it right? check it!\n G = None\n h = None\n for i in range(len(VcTJc_list)):\n G_temp = np.hstack( (-VcTJc_list[i], np.zeros((4, totalActuator+totalContact))) )\n #h_temp = np.dot(VcTdJc_list[i], dq) + (-.05)*np.ones(4)\n #h_temp = (-1/30.)*np.dot(VcTJc_list[i], dq)+ np.dot(VcTdJc_list[i], dq) + (-1.)*ac_offset_list[i]\n #h_temp = (-1/30.)*np.dot(VcTJc_list[i], dq)+ np.dot(VcTdJc_list[i], dq)\n h_temp = np.dot(dVcTJc_list[i], dq) + np.dot(VcTdJc_list[i], dq) + np.dot(VcTJc_list[i], dq) * invdt + (-1.)*ac_offset_list[i]\n if G == None:\n G = G_temp.copy()\n h = h_temp.copy()\n else:\n G = np.vstack( (G, G_temp) )\n h = np.append( h, h_temp )\n\n if G.shape[0] != h.shape[0]:\n print('Inequality Velocity : G and h shapes are not matched')\n self.qp.addInequalityConstraint(G, h)\n",
"from fltk import *\nimport copy\nimport os.path\ntry:\n import pickle\nexcept ImportError:\n import cPickle as pickle\nimport time\nimport numpy as np\n\nimport PyCommon.modules.Math.mmMath as mm\nfrom PyCommon.modules.Math import mmMath as mm\nfrom PyCommon.modules.Math import csMath as cm\nfrom PyCommon.modules.Math import ysFunctionGraph as yfg\nfrom PyCommon.modules.Renderer import ysRenderer as yr\nfrom PyCommon.modules.Simulator import ysVpUtil as yvu\nfrom PyCommon.modules.GUI import ysSimpleViewer as ysv\nfrom PyCommon.modules.GUI import ysMultiViewer as ymv\nfrom PyCommon.modules.ArticulatedBody import ysControl as yct\nfrom 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\nfrom PyCommon.modules.Motion import ysSkeletonEdit as yhe\nfrom PyCommon.modules.Motion import mmAnalyticIK as aik\n# from 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 hpLCPSimul2 as hls\nfrom PyCommon.modules.GUI import hpSimpleViewer as hsv\nfrom PyCommon.modules.Util import ysPythonEx as ype\n\nfrom PyCommon.modules.Simulator import csVpModel_py as pcvm\nfrom PyCommon.modules.Simulator import csVpWorld_py as pcvw\n\n\nimport math\n# from matplotlib import pyplot as plt\n# from matplotlib import collections\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\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'] = .3\n massMap['RightFoot_foot_0_1'] = .3\n massMap['RightFoot_foot_0_0_0'] = .3\n massMap['RightFoot_foot_0_1_0'] = .3\n massMap['RightFoot_foot_1_0'] = .3\n massMap['RightFoot_foot_1_1'] = .3\n massMap['RightFoot_foot_1_2'] = .3\n massMap['LeftFoot_foot_0_0'] = .3\n massMap['LeftFoot_foot_0_1'] = .3\n massMap['LeftFoot_foot_0_0_0'] = .3\n massMap['LeftFoot_foot_0_1_0'] = .3\n massMap['LeftFoot_foot_1_0'] = .3\n massMap['LeftFoot_foot_1_1'] = .3\n massMap['LeftFoot_foot_1_2'] = .3\n\n return massMap\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 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 = mcfg.getNode(node_name)\n node.geom = 'MyFoot4'\n node.width = 0.01\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 node = mcfg.getNode('RightFoot')\n node.density = 200.\n node.geom = 'MyFoot5'\n node.width = 0.01\n # node.jointType = 'U'\n\n node = mcfg.getNode('LeftFoot')\n node.density = 200.\n node.geom = 'MyFoot5'\n node.width = 0.01\n # node.jointType = 'U'\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 capsulize('RightFoot_foot_0_0')\n node = mcfg.getNode('RightFoot_foot_0_0')\n node.addGeom('MyFoot3', [0.02*np.array([-0.3, 0., 2.5*0.25]), mm.exp([0., -math.atan2(1.2, 2.5), 0.])], ypc.CapsuleMaterial(400., .01, 0.02*2.5+0.02))\n node.addGeom('MyFoot3', [0.02*np.array([-0.3-1.2, 0., 2.5*0.25]), mm.exp([0., -math.atan2(1.2, 2.5), 0.])], ypc.CapsuleMaterial(400., .01, 0.02*2.5+0.02))\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 = 'R'\n\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(400., .01, -1))\n node.addGeom('MyFoot4', [0.02*np.array([-1.2, 0., 0.]), mm.exp([0.]*3)], ypc.CapsuleMaterial(400., .01, -1))\n node.jointType = 'R'\n\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(400., .01, -1))\n node.addGeom('MyFoot3', [0.02*np.array([1.2, 0., 0.]), mm.exp([0.]*3)], ypc.CapsuleMaterial(400.,.01, -1))\n node.jointType = 'R'\n\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(400., .01, -1))\n node.addGeom('MyFoot4', [0.02*np.array([1.2, 0., 0.]), mm.exp([0.]*3)], ypc.CapsuleMaterial(400., .01, -1))\n node.jointType = 'R'\n\n capsulize('RightFoot_foot_1_0')\n node = mcfg.getNode('RightFoot_foot_1_0')\n node.addGeom('MyFoot3', [0.02*np.array([0., 0., .7]), mm.exp([0.]*3)], ypc.CapsuleMaterial(400., .01, 0.02*2.0+0.02))\n # node.addGeom('MyFoot4', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(1000., .01, -1))\n node.jointType = 'R'\n\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(400., .01, -1))\n node.jointType = 'R'\n\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(400., .01, -1))\n node.jointType = 'R'\n\n\n capsulize('LeftFoot_foot_0_0')\n node = mcfg.getNode('LeftFoot_foot_0_0')\n node.addGeom('MyFoot3', [0.02*np.array([0.3, 0., 2.5*0.25]), mm.exp([0., math.atan2(1.2, 2.5), 0.])], ypc.CapsuleMaterial(400., .01, 0.02*2.5+0.02))\n node.addGeom('MyFoot3', [0.02*np.array([0.3+1.2, 0., 2.5*0.25]), mm.exp([0., math.atan2(1.2, 2.5), 0.])], ypc.CapsuleMaterial(400., .01, 0.02*2.5+0.02))\n # node.addGeom('MyFoot4', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(1000., .01, -1))\n node.jointType = 'R'\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(400., .01, -1))\n node.addGeom('MyFoot4', [0.02*np.array([1.2, 0., 0.]), mm.exp([0.]*3)], ypc.CapsuleMaterial(400., .01, -1))\n node.jointType = 'R'\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(400., .01, -1))\n node.addGeom('MyFoot3', [0.02*np.array([-1.2, 0., 0.]), mm.exp([0.]*3)], ypc.CapsuleMaterial(400., .01, -1))\n node.jointType = 'R'\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(400., .01, -1))\n node.addGeom('MyFoot4', [0.02*np.array([-1.2, 0., 0.]), mm.exp([0.]*3)], ypc.CapsuleMaterial(400., .01, -1))\n node.jointType = 'R'\n\n capsulize('LeftFoot_foot_1_0')\n node = mcfg.getNode('LeftFoot_foot_1_0')\n node.addGeom('MyFoot3', [0.02*np.array([0., 0., .7]), mm.exp([0.]*3)], ypc.CapsuleMaterial(400., .01, 0.02*2.0+0.02))\n # node.addGeom('MyFoot4', [np.array([0.]*3), mm.exp([0.]*3)], ypc.CapsuleMaterial(1000., .01, -1))\n node.jointType = 'R'\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(400., .01, -1))\n node.jointType = 'R'\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(400., .01, -1))\n node.jointType = 'R'\n\n\n return mcfg\n\n\ndef walkings():\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 = 20.\n Dt = 2.*(Kt**.5)\n # Dt = Kt/900.\n Ks = 2000.\n Ds = 2.*(Ks**.5)\n mu = 1.\n # Dt = 0.\n\n # constaants\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 = .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 dir = current_path+'/ppmotion/'\n # dir = './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_pos_sag_faster = .05\n filename = 'wd2_WalkForwardNormal00.bvh'\n # filename = 'wd2_WalkForwardNormal00_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_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 # motion\n #TODO:\n bvh = yf.readBvhFileAsBvh(dir+filename)\n # motion_ori = bvh.toJointMotion(1.0, False)\n\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, .02)\n partBvh = yf.readBvhFileAsBvh(partBvhFilePath)\n partBvh.mirror('YZ')\n bvh.replaceJointFromBvh('LeftFoot', partBvh, .02)\n\n motion_ori = bvh.toJointMotion(1., False)\n\n # motion_ori = yf.readBvhFile(dir+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 #===============================================================================\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\n stitch_func = lambda x : 1. - yfg.hermite2nd(x)\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_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\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 = 30\n wcfg.timeStep = (frameTime)/stepsPerFrame\n\n vpWorld = pcvw.VpWorld(wcfg)\n motionModel = pcvm.VpMotionModel(vpWorld, motion_ori[0], mcfg)\n # ModelOffset = np.array([0., 0., 0.])\n # motionModel.translateByOffset(ModelOffset)\n controlModel = pcvm.VpControlModel(vpWorld, motion_ori[0], mcfg)\n vpWorld.SetIntegrator(\"IMPLICIT_EULER_FAST\")\n vpWorld.initialize()\n print(controlModel)\n # controlModel = None\n\n\n # motionModel.recordVelByFiniteDiff()\n controlModel.initializeHybridDynamics()\n # controlModel.initializeForwardDynamics()\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(dir+segname, 'r')\n seginfo = cPickle.load(segfile)\n segfile.close()\n\n for i in seginfo:\n print(i)\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 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 #===============================================================================\n # information\n #===============================================================================\n bodyIDsToCheck = range(vpWorld.getBodyNum())\n mus = [mu]*len(bodyIDsToCheck)\n\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 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 # for i in lIDs+rIDs:\n # controlModel.setHybridDynamics(i, \"DYNAMIC\")\n\n # each dof is whether KINEMATIC or not\n hdAccMask = [True]*controlModel.getTotalDOF()\n hdAccMask[:6] = [False]*6\n # for i in lIDs+rIDs:\n # hdAccMask[3+3*i : 6+3*i] = [False]*3\n\n\n lID = controlModel.name2id('LeftFoot'); rID = controlModel.name2id('RightFoot')\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 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 halfFootHeight = controlModel.getBodyShape(lFoot)[1] / 2.\n # halfFootHeight = 0.05\n\n for fi in forceInfos:\n fi.targetBody = spine\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 if MULTI_VIEWER:\n viewer = ymv.MultiViewer(800, 655)\n # viewer = ymv.MultiViewer(800, 655, True)\n viewer.setRenderers1([yr.VpModelRenderer(motionModel, MOTION_COLOR, yr.POLYGON_FILL)])\n viewer.setRenderers2([yr.VpModelRenderer(controlModel, CHARACTER_COLOR, yr.POLYGON_FILL)])\n else:\n viewer = ysv.SimpleViewer()\n # viewer = hsv.hpSimpleViewer()\n # viewer.record(False)\n\n viewer.doc.addRenderer('motionModel', yr.VpModelRenderer(motionModel, (0,150,255), yr.POLYGON_LINE))\n viewer.doc.addRenderer('controlModel', yr.VpModelRenderer(controlModel, (50,200,200), yr.POLYGON_FILL))\n\n # viewer.doc.addObject('motion_ori', motion_ori)\n # viewer.doc.addRenderer('motion_ori', yr.JointMotionRenderer(motion_ori, (0,100,255), yr.LINK_BONE))\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_stf_stabilize', yr.JointMotionRenderer(motion_stf_stabilize, (255,0,0), yr.LINK_BONE))\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_swf_orientation', yr.JointMotionRenderer(motion_swf_orientation, (255,100,0), 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_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\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_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 if not REPEATED:\n viewer.setMaxFrame(len(motion_ori)-1)\n else:\n viewer.setMaxFrame(1000)\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 # 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] = motion_ori[frame].getJointPositionGlobal(0)\n viewer.setCameraTarget1(cameraTargets1[frame])\n\n if cameraTargets2[frame] is None:\n cameraTargets2[frame] = controlModel.getJointPositionGlobal(0)\n viewer.setCameraTarget2(cameraTargets2[frame])\n\n else:\n if cameraTargets[frame] is None:\n cameraTargets[frame] = controlModel.getJointPositionGlobal(0)\n viewer.setCameraTarget(cameraTargets[frame])\n if plot is not None:\n plot.updateVline(frame)\n viewer.setPostFrameCallback_Always(postFrameCallback_Always)\n\n plot = None\n # plot = ymp.InteractivePlot()\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!=None:\n plot.close()\n viewer.onClose(data)\n viewer.callback(viewer_onClose)\n\n def simulateCallback(frame):\n # seginfo\n segIndex = seg_index[0]\n curState = seginfo[segIndex]['state']\n curInterval = 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 i in range(len(legList)):\n if legList[i] == 10:\n legList[i] = skeleton.getJointIndex('RightUpLeg')\n\n for footList in (stanceFoots, swingFoots):\n for i in range(len(footList)):\n if footList[i] == 12:\n footList[i] = 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 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\n\n\n prev_frame = frame-1 if frame>0 else 0\n # prev_frame = frame\n\n # information\n # dCM_tar = yrp.getCM(motion_seg.getJointVelocitiesGlobal(frame), bodyMasses, upperMass, uppers)\n # CM_tar = yrp.getCM(motion_seg.getJointPositionsGlobal(frame), bodyMasses, upperMass, uppers)\n ## dCM_tar = yrp.getCM(motion_seg.getJointVelocitiesGlobal(frame), bodyMasses, totalMass)\n ## CM_tar = yrp.getCM(motion_seg.getJointPositionsGlobal(frame), bodyMasses, totalMass)\n # stf_tar = motion_seg.getJointPositionGlobal(stanceFoots[0], frame)\n # CMr_tar = CM_tar - stf_tar\n\n dCM_tar = motion_seg.getJointVelocityGlobal(0, prev_frame)\n CM_tar = motion_seg.getJointPositionGlobal(0, prev_frame)\n # dCM_tar = yrp.getCM(motion_seg.getJointVelocitiesGlobal(prev_frame), bodyMasses, upperMass, uppers)\n # CM_tar = yrp.getCM(motion_seg.getJointPositionsGlobal(prev_frame), bodyMasses, upperMass, uppers)\n # dCM_tar = yrp.getCM(motion_seg.getJointVelocitiesGlobal(prev_frame), bodyMasses, totalMass)\n # CM_tar = yrp.getCM(motion_seg.getJointPositionsGlobal(prev_frame), bodyMasses, totalMass)\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 = controlModel.getJointPositionGlobal(0)\n # CM = yrp.getCM(controlModel.getJointPositionsGlobal(), bodyMasses, upperMass, uppers)\n # CM = yrp.getCM(controlModel.getJointPositionsGlobal(), bodyMasses, totalMass)\n CMreal = yrp.getCM(controlModel.getJointPositionsGlobal(), bodyMasses, totalMass)\n stf = controlModel.getJointPositionGlobal(stanceFoots[0])\n CMr = CM - stf\n\n diff_dCM = mm.projectionOnPlane(dCM-dCM_tar, (1,0,0), (0,0,1))\n diff_dCM_axis = np.cross((0,1,0), diff_dCM)\n rd_vec1[0] = diff_dCM; rd_vecori1[0] = CM_tar\n\n diff_CMr = mm.projectionOnPlane(CMr-CMr_tar, (1,0,0), (0,0,1))\n # rd_vec1[0] = diff_CMr; rd_vecori1[0] = stf_tar\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 # direction = mm.normalize2(mm.projectionOnPlane(dCM, (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 # rd_vec1[0] = diff_dCM_sag; rd_vecori1[0] = CM_tar\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-curInterval[0])/float(curInterval[1]-curInterval[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 # 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, 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 # match stance leg\n motion_match_stl.append(motion_stf_stabilize[frame].copy())\n motion_match_stl.goToFrame(frame)\n if MATCH_STANCE_LEG:\n if curState!=yba.GaitState.STOP:\n for i in range(len(stanceLegs)):\n stanceLeg = stanceLegs[i]\n stanceFoot = stanceFoots[i]\n\n # # motion stance leg -> character stance leg as time goes\n R_motion = motion_match_stl[frame].getJointOrientationGlobal(stanceLeg)\n R_character = controlModel.getJointOrientationGlobal(stanceLeg)\n motion_match_stl[frame].setJointOrientationGlobal(stanceLeg, cm.slerp(R_motion, R_character, match_stl_func(t)))\n\n # t_y = match_stl_func_y(t)\n # t_xz = match_stl_func(t)\n #\n # R_motion = motion_match_stl[frame].getJointOrientationGlobal(stanceLeg)\n # R_character = controlModel.getJointOrientationGlobal(stanceLeg)\n # R = np.dot(R_character, R_motion.T)\n # R_y, R_xz = mm.projectRotation((0,1,0), R)\n # motion_match_stl[frame].mulJointOrientationGlobal(stanceLeg, mm.scaleSO3(R_xz, t_xz))\n # motion_match_stl[frame].mulJointOrientationGlobal(stanceLeg, mm.scaleSO3(R_y, t_y))\n\n # swing foot placement\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 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\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 # restore swing foot global orientation\n # motion_swf_placement[frame].setJointOrientationGlobal(swingFoot, R_swf)\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 prev_R_swp[0] = (R_swp_sag, R_swp_cor)\n\n # swing foot height\n motion_swf_height.append(motion_swf_placement[frame].copy())\n # motion_swf_height.append(motion_stitch[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 if OLD_SWING_HEIGHT:\n height_tar = motion_swf_height[frame].getJointPositionGlobal(swingFoot)[1] - 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 # motion_debug1[frame] = motion_swf_height[frame].copy()\n\n # rotate\n motion_swf_height[frame].rotateByTarget(controlModel.getJointOrientationGlobal(0))\n # motion_debug2[frame] = motion_swf_height[frame].copy()\n # motion_debug2[frame].translateByTarget(controlModel.getJointPositionGlobal(0))\n\n if OLD_SWING_HEIGHT:\n height_cur = motion_swf_height[frame].getJointPositionGlobal(swingFoot)[1] - motion_swf_height[frame].getJointPositionGlobal(stanceFoot)[1]\n else:\n height_cur = controlModel.getJointPositionGlobal(swingFoot)[1] - halfFootHeight - c_swf_offset\n d_height_cur = controlModel.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 # return\n # motion_debug3[frame] = motion_swf_height[frame].copy()\n # motion_debug3[frame].translateByTarget(controlModel.getJointPositionGlobal(0))\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 if plot!=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.append(motion_swf_placement[frame].copy())\n motion_stf_push.goToFrame(frame)\n if STANCE_FOOT_PUSH:\n # TODO:\n # swingFoots?????????????????????????\n for swingFoot in swingFoots:\n # max_t = (maxStfPushFrame)/float(curInterval[1]-curInterval[0])\n # stf_push_func = yfg.concatenate([yfg.sine, yfg.zero], [max_t*2])\n stf_push_func = yfg.concatenate([yfg.sine, yfg.zero], [c_taking_duration*2])\n\n R_swp_sag = mm.I_SO3()\n # R_swp_sag = np.dot(R_swp_sag, mm.exp(diff_dCM_sag_axis * K_stp_vel * -stf_push_func(t)))\n\n # if step_length_cur[0] < step_length_tar[0]:\n # ratio = step_length_cur[0] / step_length_tar[0]\n # R_max = maxmaxStfPushFrame\n # R_zero =\n R_swp_sag = np.dot(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(swingFoot, R_swp_sag)\n\n # stance foot balancing\n motion_stf_balancing.append(motion_stf_push[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 motion_stf_balancing[frame].mulJointOrientationGlobal(stanceFoot, R_stb)\n #TODO:\n # hwangpil\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(controlModel.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\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(20.)*np.array([1., 0., 0.]))\n motion_stf_balancing[frame].mulJointOrientationLocal(stanceFoot, R_target_ankle)\n #'''\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\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 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 = controlModel.getDOFPositions()\n dth_r = motion_control.getDOFVelocities(frame)\n dth = controlModel.getDOFVelocities()\n ddth_r = motion_control.getDOFAccelerations(frame)\n ddth_des = yct.getDesiredDOFAccelerations(th_r, th, dth_r, dth, ddth_r, Kt, Dt, weightMap)\n\n totalDOF = controlModel.getTotalDOF()\n # ddth_des_flat = ype.makeFlatList(totalDOF)\n ddth_des_flat = ype.makeFlatList(controlModel.get3dExtendTotalDOF())\n ype.flatten(ddth_des, ddth_des_flat)\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 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 contactPositions = None\n\n for i in range(stepsPerFrame):\n if 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, controlModel, 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\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 if contactForces is not None and len(contactForces) > 0:\n CP += yrp.getCP(contactPositions, contactForces)\n F += sum(contactForces)\n avg_dCM[0] += controlModel.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 del rd_point2[:]\n if contactPositions is not None:\n rd_point2.extend(contactPositions)\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\n # print curState\n # print bodyIDs\n\n '''\n print skeleton.getJointIndex('LeftFoot') = 3\n print skeleton.getJointIndex('LeftFoot_foot_0_0') = 4\n print skeleton.getJointIndex('LeftFoot_foot_0_1') = 5\n print skeleton.getJointIndex('LeftFoot_foot_1_0')\n print skeleton.getJointIndex('LeftFoot_foot_1_1')\n print skeleton.getJointIndex('LeftFoot_foot_2_0')\n print skeleton.getJointIndex('LeftFoot_foot_2_1') = 9\n print skeleton.getJointIndex('RightFoot') = 18\n print skeleton.getJointIndex('RightFoot_foot_0_0') = 19\n print skeleton.getJointIndex('RightFoot_foot_0_1')\n print skeleton.getJointIndex('RightFoot_foot_1_0')\n print skeleton.getJointIndex('RightFoot_foot_1_1')\n print skeleton.getJointIndex('RightFoot_foot_2_0')\n print skeleton.getJointIndex('RightFoot_foot_2_1') = 24\n '''\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 # original\n '''\n swingID = lID if curState==yba.GaitState.LSWING else rID\n contact = False\n\n if swingID in bodyIDs:\n minContactVel = 1000.\n for i in range(len(bodyIDs)):\n if bodyIDs[i]==swingID:\n vel = controlModel.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 extended[0] = False\n '''\n # segmented foot\n swingIDs = copy.deepcopy(lIDs) if curState==yba.GaitState.LSWING else copy.deepcopy(rIDs)\n\n contact = False\n\n for swingID in swingIDs:\n if swingID in bodyIDs:\n minContactVel = 1000.\n for i in range(len(bodyIDs)):\n if bodyIDs[i]==swingID:\n vel = controlModel.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 extended[0] = False\n\n if contact:\n # print frame, 'foot touch'\n lastFrame = True\n acc_offset[0] += frame - curInterval[1]\n\n elif frame == len(motion_seg)-1:\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 # # extend for swing foot ground speed matching & swing foot height lower\n ## extendedPostures = ymt.extendByIntegration(motion_stitch, 1, preserveJoints, diff)\n ## extendedPostures = [motion_stitch[-1]]\n ##\n # extendFrameNum = frame - curInterval[1] + 1\n # k = 1.-extendFrameNum/5.\n # if k<0.: k=0.\n # extendedPostures = ymt.extendByIntegrationAttenuation(motion_stitch, 1, preserveJoints, diff, k)\n #\n ## if len(swingFoots)>0 and np.inner(dCM_tar, dCM)>0.:\n ## print frame, 'speed matching'\n ## R_swf = motion_stitch[-1].getJointOrientationGlobal(swingFoots[0])\n ##\n ## p_swf = motion_stitch[-1].getJointPositionGlobal(swingFoots[0])\n ## v_swf = motion_stitch.getJointVelocityGlobal(swingFoots[0], frame-diff, frame)\n ## a_swf = motion_stitch.getJointAccelerationGlobal(swingFoots[0], frame-diff, frame)\n ## p_swf += v_swf * (frameTime) + a_swf * (frameTime)*(frameTime)\n ## aik.ik_analytic(extendedPostures[0], swingFoots[0], p_swf)\n ##\n ## extendedPostures[0].setJointOrientationGlobal(swingFoots[0], R_swf)\n #\n # motion_stitch.extend(extendedPostures)\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 print('%d (%d): end of %dth seg (%s, %s)'%(frame, frame-curInterval[1],segIndex, yba.GaitState.text[curState], curInterval))\n if plot!=None: plot.addDataPoint('diff', frame, (frame-curInterval[1])*.01)\n\n if len(stanceFoots)>0 and len(swingFoots)>0:\n # step_cur = controlModel.getJointPositionGlobal(swingFoots[0]) - controlModel.getJointPositionGlobal(stanceFoots[0])\n # step_tar = motion_seg[curInterval[1]].getJointPositionGlobal(swingFoots[0]) - motion_seg[curInterval[1]].getJointPositionGlobal(stanceFoots[0])\n step_cur = controlModel.getJointPositionGlobal(0) - controlModel.getJointPositionGlobal(stanceFoots[0])\n step_tar = motion_seg[curInterval[1]].getJointPositionGlobal(0) - motion_seg[curInterval[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 # rd_vec1[0] = step_tar_sag\n # rd_vecori1[0] = motion_seg[curInterval[1]].getJointPositionGlobal(stanceFoots[0])\n # rd_vec2[0] = step_cur_sag\n # rd_vecori2[0] = controlModel.getJointPositionGlobal(stanceFoots[0])\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 # motion_seg.extend(ymb.getAttachedNextMotion(curSeg, motion_seg[-1], False, False))\n # motion_stitch.extend(ymb.getStitchedNextMotion(curSeg, motion_control[-1], transitionLength, stitch_func, True, False))\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 # motion_seg.extend(ymb.getAttachedNextMotion(curSeg, motion_seg[-1], False, True))\n # motion_stitch.extend(ymb.getStitchedNextMotion(curSeg, motion_control[-1], transitionLength, stitch_func, True, True))\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 # 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!=None:\n plot.addDataPoint('zero', frame, 0)\n plot.updatePoints()\n\n\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\n\nwalkings()\n"
]
| [
[
"numpy.array",
"numpy.dot",
"numpy.isnan",
"numpy.linalg.norm",
"numpy.zeros",
"numpy.argmin",
"numpy.eye",
"numpy.around",
"numpy.inner",
"numpy.cross"
],
[
"numpy.dot",
"numpy.zeros",
"numpy.ones",
"numpy.eye",
"numpy.append",
"numpy.hstack",
"numpy.vstack"
],
[
"scipy.optimize.minimize_scalar"
],
[
"numpy.array",
"numpy.dot",
"numpy.zeros",
"numpy.ones",
"numpy.eye",
"numpy.append",
"numpy.hstack",
"numpy.cross",
"numpy.vstack"
],
[
"numpy.array",
"numpy.dot",
"numpy.cross",
"numpy.inner"
]
]
|
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",
"a2741201bbf33f5408306198d220d90f8f7b7250",
"a2741201bbf33f5408306198d220d90f8f7b7250"
]
| [
"rlpyt/models/pg/atari_lstm_model.py",
"rlpyt/utils/launching/affinity.py",
"rlpyt/agents/dqn/dqn_agent.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",
"from rlpyt.utils.collections import AttrDict\n\n# Readable-to-less-readable abbreviations.\nN_GPU = \"gpu\"\nCONTEXTS_PER_GPU = \"cxg\" # CUDA contexts.\nGPU_PER_RUN = \"gpr\"\nN_CPU_CORE = \"cpu\"\nHYPERTHREAD_OFFSET = \"hto\" # Can specify if different from n_cpu_core.\nN_SOCKET = \"skt\"\nRUN_SLOT = \"slt\"\nCPU_PER_WORKER = \"cpw\"\nCPU_PER_RUN = \"cpr\" # For cpu-only.\nCPU_RESERVED = \"res\" # Reserve CPU cores per master, not allowed by workers.\n# For async sampling / optimizing.\nASYNC_SAMPLE = \"ass\"\nSAMPLE_GPU_PER_RUN = \"sgr\"\nOPTIM_SAMPLE_SHARE_GPU = \"oss\"\n# For alternating sampler.\nALTERNATING = \"alt\"\nSET_AFFINITY = \"saf\"\n\nABBREVS = [\n N_GPU,\n CONTEXTS_PER_GPU,\n GPU_PER_RUN,\n N_CPU_CORE,\n HYPERTHREAD_OFFSET,\n N_SOCKET,\n CPU_PER_RUN,\n CPU_PER_WORKER,\n CPU_RESERVED,\n ASYNC_SAMPLE,\n SAMPLE_GPU_PER_RUN,\n OPTIM_SAMPLE_SHARE_GPU,\n ALTERNATING,\n SET_AFFINITY,\n]\n\n\n# API\n\n\ndef quick_affinity_code(n_parallel=None, use_gpu=True, contexts_per_gpu=1):\n \"\"\"Tried to autodetect hardware resources and divide them evenly among learning runs.\n\n Args:\n n_parallel (int or None): Can specify the number of concurrent learning runs; if using GPU, leave as ``None`` to use all GPUs, 1 per run\n use_gpu (bool): self-explanatory\n \"\"\"\n if not (use_gpu or n_parallel):\n raise ValueError(\"Either use_gpu must be True or n_parallel > 0 must be given.\")\n import psutil\n\n # n_cpu_core = psutil.cpu_count(logical=False) # sometimes gives bad results\n n_cpu_core = psutil.cpu_count() // 2 # assume hyperthreads will be counted\n if use_gpu:\n import torch\n\n n_gpu = torch.cuda.device_count()\n else:\n n_gpu = 0\n if n_gpu > 0:\n if n_parallel is not None:\n n_gpu = min(n_parallel, n_gpu)\n n_runs = n_gpu * contexts_per_gpu\n n_cpu_core = (n_cpu_core // n_runs) * n_runs # Same for all.\n return encode_affinity(\n n_cpu_core=n_cpu_core, n_gpu=n_gpu, contexts_per_gpu=contexts_per_gpu\n )\n else:\n if not n_parallel:\n raise ValueError(\n \"n_parallel > 0 must be given if use_gpu=False or no GPUs are present.\"\n )\n n_parallel = min(n_parallel, n_cpu_core)\n n_cpu_core = (n_cpu_core // n_parallel) * n_parallel # Same for all.\n cpu_per_run = n_cpu_core // n_parallel\n return encode_affinity(n_cpu_core=n_cpu_core, n_gpu=0, cpu_per_run=cpu_per_run)\n\n\ndef encode_affinity(\n n_cpu_core=1, # Total number to use on machine (not virtual).\n n_gpu=0, # Total number to use on machine.\n contexts_per_gpu=1, # e.g. 2 will put two experiments per GPU.\n gpu_per_run=1, # For multi-GPU optimizaion.\n cpu_per_run=1, # Specify if not using GPU.\n cpu_per_worker=1, # Use 1 unless environment is multi-threaded.\n cpu_reserved=0, # Number CPU to reserve per GPU.\n hyperthread_offset=None, # Leave None for auto-detect.\n n_socket=None, # Leave None for auto-detect.\n run_slot=None, # Leave None in `run` script, but specified in `train` script.\n async_sample=False, # True if asynchronous sampling / optimization.\n sample_gpu_per_run=0, # For asynchronous sampling.\n optim_sample_share_gpu=False, # Async sampling, overrides sample_gpu.\n alternating=False, # True for altenating sampler.\n set_affinity=True, # Everything same except psutil.Process().cpu_affinity(cpus)\n):\n \"\"\"Encodes the hardware configuration into a string (with meanings defined\n in this file) which can be passed as a command line argument to call the\n training script. Use in overall experiments setup script to specify\n computer and experiment resources into ``run_experiments()``.\n\n We refer to an \"experiment\" as an individual learning run, i.e. one set of\n hyperparameters and which does not interact with other runs.\n\n Args:\n n_cpu_core (int): Total number of phyical cores to use on machine (not virtual)\n n_gpu (int): Total number of GPUs to use on machine\n contexts_per_gpu (int): How many experiment to share each GPU\n gpu_per_run (int): How many GPUs to use per experiment (for multi-GPU optimization)\n cpu_per_run (int): If not using GPU, specify how macores per experiment\n cpu_per_worker (int): CPU cores per sampler worker; 1 unless environment is multi-threaded\n cpu_reserved (int): Number of CPUs to reserve per GPU, and not allow sampler to use them\n hyperthread_offset (int): Typically the number of physical cores, since they are labeled 0-x, and hyperthreads as (x+1)-2x; use 0 to disable hyperthreads, None to auto-detect\n n_socket (int): Number of CPU sockets in machine; tries to keep CPUs grouped on same socket, and match socket-to-GPU affinity\n run_slot (int): Which hardware slot to use; leave ``None`` into ``run_experiments()``, but specified for inidividual train script\n async_sample (bool): True if asynchronous sampling/optimization mode; different affinity structure needed\n sample_gpu_per_run (int): In asynchronous mode only, number of action-server GPUs per experiment\n optim_sample_share_gpu (bool): In asynchronous mode only, whether to use same GPU(s) for both training and sampling\n alternating (bool): True if using alternating sampler (will make more worker assignments)\n set_affinity (bool): False to disable runner and sampler from setting cpu affinity via `psutil`, maybe inappropriate in cloud machines.\n\n \"\"\"\n affinity_code = f\"{n_cpu_core}{N_CPU_CORE}_{n_gpu}{N_GPU}\"\n if hyperthread_offset is None:\n hyperthread_offset = get_hyperthread_offset()\n if n_socket is None:\n n_socket = get_n_socket()\n if contexts_per_gpu > 1:\n affinity_code += f\"_{contexts_per_gpu}{CONTEXTS_PER_GPU}\"\n if gpu_per_run > 1:\n affinity_code += f\"_{gpu_per_run}{GPU_PER_RUN}\"\n if n_gpu == 0:\n affinity_code += f\"_{cpu_per_run}{CPU_PER_RUN}\"\n if cpu_per_worker > 1:\n affinity_code += f\"_{cpu_per_worker}{CPU_PER_WORKER}\"\n if hyperthread_offset != n_cpu_core:\n affinity_code += f\"_{hyperthread_offset}{HYPERTHREAD_OFFSET}\"\n if n_socket > 1:\n affinity_code += f\"_{n_socket}{N_SOCKET}\"\n if cpu_reserved > 0:\n affinity_code += f\"_{cpu_reserved}{CPU_RESERVED}\"\n if async_sample:\n affinity_code += f\"_1{ASYNC_SAMPLE}\"\n if sample_gpu_per_run > 0:\n affinity_code += f\"_{sample_gpu_per_run}{SAMPLE_GPU_PER_RUN}\"\n if optim_sample_share_gpu:\n affinity_code += f\"_1{OPTIM_SAMPLE_SHARE_GPU}\"\n if alternating:\n affinity_code += f\"_1{ALTERNATING}\"\n if not set_affinity:\n affinity_code += f\"_0{SET_AFFINITY}\"\n if run_slot is not None:\n assert run_slot <= (n_gpu * contexts_per_gpu) // gpu_per_run\n affinity_code = f\"{run_slot}{RUN_SLOT}_\" + affinity_code\n return affinity_code\n\n\ndef prepend_run_slot(run_slot, affinity_code):\n \"\"\"Use in launch manager when assigning run slot.\"\"\"\n return f\"{run_slot}{RUN_SLOT}_\" + affinity_code\n\n\ndef affinity_from_code(run_slot_affinity_code):\n \"\"\"Use in individual experiment script; pass output to Runner.\"\"\"\n run_slot, aff_code = remove_run_slot(run_slot_affinity_code)\n aff_params = decode_affinity(aff_code)\n if aff_params.get(N_GPU, 0) > 0:\n if aff_params.pop(ASYNC_SAMPLE, 0) > 0:\n return build_async_affinity(run_slot, **aff_params)\n elif aff_params.get(GPU_PER_RUN, 1) > 1:\n return build_multigpu_affinity(run_slot, **aff_params)\n return build_gpu_affinity(run_slot, **aff_params)\n return build_cpu_affinity(run_slot, **aff_params)\n\n\ndef make_affinity(run_slot=0, **kwargs):\n \"\"\"Input same kwargs as ``encode_affinity()``, returns the AttrDict form.\"\"\"\n return affinity_from_code(encode_affinity(run_slot=run_slot, **kwargs))\n\n\n# Helpers\n\n\ndef get_n_socket():\n import subprocess\n\n return max(\n 1,\n int(\n subprocess.check_output(\n 'cat /proc/cpuinfo | grep \"physical id\" | sort -u | wc -l', shell=True\n )\n ),\n )\n\n\ndef get_hyperthread_offset():\n import psutil # (If returns 0, will not try to use hyperthreads.)\n\n # UNRELIABLE:\n # hto = psutil.cpu_count() - psutil.cpu_count(logical=False)\n vcpu = psutil.cpu_count()\n if vcpu != psutil.cpu_count(logical=False) and vcpu % 2 == 0:\n # Best guess?\n return vcpu // 2\n return 0\n\n\ndef get_n_run_slots(affinity_code):\n aff = decode_affinity(affinity_code)\n if aff.get(\"ass\", 0) > 0: # Asynchronous sample mode.\n total_gpu = aff.get(\"gpr\", 1) + aff.get(\"sgr\", 0) * (1 - aff.get(\"oss\", 0))\n n_run_slots = aff[\"gpu\"] // total_gpu # NOTE: no cxg yet.\n elif aff.get(\"gpu\", 0) > 0:\n n_run_slots = (aff[\"gpu\"] * aff.get(\"cxg\", 1)) // aff.get(\"gpr\", 1)\n else:\n n_run_slots = aff[\"cpu\"] // aff[\"cpr\"]\n return n_run_slots\n\n\ndef remove_run_slot(run_slot_affinity_code):\n run_slot_str, aff_code = run_slot_affinity_code.split(\"_\", 1)\n assert run_slot_str[-3:] == RUN_SLOT\n run_slot = int(run_slot_str[:-3])\n return run_slot, aff_code\n\n\ndef decode_affinity(affinity_code):\n codes = affinity_code.split(\"_\")\n aff_kwargs = dict()\n for code in codes:\n abrv = code[-3:]\n if abrv not in ABBREVS:\n raise ValueError(f\"Unrecognized affinity code abbreviation: {abrv}\")\n value = int(code[:-3])\n aff_kwargs[abrv] = value\n return aff_kwargs\n\n\ndef build_cpu_affinity(\n slt, cpu, cpr, cpw=1, hto=None, res=0, skt=1, gpu=0, alt=0, saf=1\n):\n assert gpu == 0\n assert cpu % cpr == 0\n hto = cpu if hto is None else hto # Default is None, 0 is OFF.\n assert (hto - cpu) % skt == 0\n n_run_slots = cpu // cpr\n assert slt <= n_run_slots\n cpu_per_skt = max(cpu, hto) // skt\n if n_run_slots >= skt:\n slt_per_skt = n_run_slots // skt\n my_skt = slt // slt_per_skt\n slt_in_skt = slt % slt_per_skt\n min_core = my_skt * cpu_per_skt + slt_in_skt * cpr\n cores = tuple(range(min_core, min_core + cpr))\n else: # One run multiple sockets.\n skt_per_slt = skt // n_run_slots\n cores = list()\n low_skt = slt * skt_per_slt\n for s in range(skt_per_slt):\n min_core = (low_skt + s) * cpu_per_skt\n high_core = min_core + cpr // skt_per_slt\n cores.extend(list(range(min_core, high_core)))\n cores = tuple(cores)\n worker_cores = cores[res:]\n assert len(worker_cores) % cpw == 0\n master_cpus = get_master_cpus(cores, hto)\n workers_cpus = get_workers_cpus(worker_cores, cpw, hto, alt)\n affinity = AttrDict(\n all_cpus=master_cpus,\n master_cpus=master_cpus,\n workers_cpus=workers_cpus,\n master_torch_threads=len(cores),\n worker_torch_threads=cpw,\n alternating=bool(alt), # Just to pass through a check.\n set_affinity=bool(saf),\n )\n return affinity\n\n\ndef build_gpu_affinity(\n slt, gpu, cpu, cxg=1, cpw=1, hto=None, res=0, skt=1, alt=0, saf=1\n):\n \"\"\"Divides CPUs evenly among GPUs.\"\"\"\n n_ctx = gpu * cxg\n assert slt < n_ctx\n assert cpu % n_ctx == 0\n cpr = cpu // n_ctx\n if cxg > 1:\n slt = (slt % gpu) * cxg + slt // gpu # Spread over GPUs first.\n affinity = build_cpu_affinity(\n slt, cpu, cpr, cpw=cpw, hto=hto, res=res, skt=skt, gpu=0, alt=alt, saf=saf\n )\n affinity[\"cuda_idx\"] = slt // cxg\n return affinity\n\n\ndef build_multigpu_affinity(\n run_slot, gpu, cpu, gpr=1, cpw=1, hto=None, res=0, skt=1, alt=0, saf=1\n):\n return [\n build_gpu_affinity(\n slt, gpu, cpu, cxg=1, cpw=cpw, hto=hto, res=res, skt=skt, alt=alt, saf=saf\n )\n for slt in range(run_slot * gpr, (run_slot + 1) * gpr)\n ]\n\n\ndef build_async_affinity(\n run_slot, gpu, cpu, gpr=1, sgr=0, oss=0, cpw=1, hto=None, res=1, skt=1, alt=0, saf=1\n):\n oss = bool(oss)\n sgr = gpr if oss else sgr\n total_gpr = gpr + sgr * (not oss)\n n_run_slots = gpu // total_gpr\n assert run_slot < n_run_slots\n cpr = cpu // n_run_slots\n smp_cpr = cpr - res * gpr\n gpu_per_skt = gpu // skt\n hto = cpu if hto is None else hto # Default is None, 0 is OFF.\n cpu_per_skt = max(cpu, hto) // skt\n opt_affinities = list()\n smp_affinities = list()\n all_cpus = tuple()\n if total_gpr <= gpu_per_skt:\n run_per_skt = n_run_slots // skt\n assert n_run_slots % skt == 0 # Relax later?\n skt_per_run = 1\n run_in_skt = run_slot % run_per_skt\n my_skt = run_slot // run_per_skt\n low_opt_gpu = my_skt * gpu_per_skt + run_in_skt * total_gpr\n high_opt_gpu = low_opt_gpu + gpr\n my_opt_gpus = list(range(low_opt_gpu, high_opt_gpu))\n my_smp_gpus = (\n my_opt_gpus if oss else list(range(high_opt_gpu, high_opt_gpu + sgr))\n )\n else: # One run takes more than one socket: spread opt gpus across sockets.\n skt_per_run = skt // n_run_slots\n low_skt = run_slot * skt_per_run\n assert gpr % skt_per_run == 0, \"Maybe try n_socket=1.\"\n assert sgr % skt_per_run == 0, \"Maybe try n_socket=1.\"\n my_opt_gpus = list()\n my_smp_gpus = list()\n run_in_skt = run_per_skt = 0\n for s in range(skt_per_run):\n low_opt_gpu = (low_skt + s) * gpu_per_skt\n high_opt_gpu = low_opt_gpu + gpr // skt_per_run\n my_opt_gpus.extend(list(range(low_opt_gpu, high_opt_gpu)))\n if oss:\n my_smp_gpus = my_opt_gpus\n else:\n high_smp_gpu = high_opt_gpu + sgr // skt_per_run\n my_smp_gpus.extend(list(range(high_opt_gpu, high_smp_gpu)))\n for i, opt_gpu in enumerate(my_opt_gpus):\n gpu_in_skt = opt_gpu % gpu_per_skt\n gpu_skt = opt_gpu // gpu_per_skt\n gpu_res = i if run_per_skt >= 1 else gpu_in_skt\n low_opt_core = gpu_skt * cpu_per_skt + run_in_skt * cpr + gpu_res * res\n high_opt_core = low_opt_core + res\n opt_cores = tuple(range(low_opt_core, high_opt_core))\n opt_cpus = get_master_cpus(opt_cores, hto)\n opt_affinity = dict(\n cpus=opt_cpus,\n cuda_idx=opt_gpu,\n torch_threads=len(opt_cores),\n set_affinity=bool(saf),\n )\n opt_affinities.append(opt_affinity)\n all_cpus += opt_cpus\n wrkr_per_smp = smp_cpr // cpw\n smp_cpr = wrkr_per_smp * cpw\n smp_cpg = smp_cpr // max(1, sgr)\n for i, smp_gpu in enumerate(my_smp_gpus):\n gpu_skt = smp_gpu // gpu_per_skt\n gpu_in_skt = smp_gpu % gpu_per_skt\n smp_cpu_off = i if run_per_skt >= 1 else gpu_in_skt - (gpr // skt_per_run)\n low_smp_core = (\n gpu_skt * cpu_per_skt\n + run_in_skt * cpr\n + (gpr // skt_per_run) * res\n + smp_cpu_off * smp_cpg\n )\n high_smp_core = low_smp_core + smp_cpg\n master_cores = tuple(range(low_smp_core, high_smp_core))\n master_cpus = get_master_cpus(master_cores, hto)\n workers_cpus = get_workers_cpus(master_cores, cpw, hto, alt)\n smp_affinity = AttrDict(\n all_cpus=master_cpus,\n master_cpus=master_cpus,\n workers_cpus=workers_cpus,\n master_torch_threads=len(master_cores),\n worker_torch_threads=cpw,\n cuda_idx=smp_gpu,\n alternating=bool(alt), # Just to pass through a check.\n set_affinity=bool(saf),\n )\n smp_affinities.append(smp_affinity)\n all_cpus += master_cpus\n if not smp_affinities: # sgr==0; CPU sampler.\n if total_gpr <= gpu_per_skt:\n low_smp_core = my_skt * cpu_per_skt + run_in_skt * cpr + gpr * res\n master_cores = tuple(range(low_smp_core, low_smp_core + smp_cpr))\n else:\n master_cores = tuple()\n for s in range(skt_per_run):\n low_smp_core = (low_skt + s) * cpu_per_skt + (gpr // gpu_per_skt) * res\n master_cores += tuple(\n range(low_smp_core, low_smp_core + smp_cpr // skt_per_run)\n )\n master_cpus = get_master_cpus(master_cores, hto)\n workers_cpus = get_workers_cpus(master_cores, cpw, hto, alt)\n smp_affinities = AttrDict(\n all_cpus=master_cpus,\n master_cpus=master_cpus,\n workers_cpus=workers_cpus,\n master_torch_threads=len(master_cores),\n worker_torch_threads=cpw,\n cuda_idx=None,\n alternating=bool(alt), # Just to pass through a check.\n set_affinity=bool(saf),\n )\n all_cpus += master_cpus\n affinity = AttrDict(\n all_cpus=all_cpus, # For exp launcher to use taskset.\n optimizer=opt_affinities,\n sampler=smp_affinities,\n set_affinity=bool(saf),\n )\n\n return affinity\n\n\n# def offset_for_socket(hto, cpu, skt, slt, n_run_slots):\n# \"\"\"If hto==cpu or skt==1, returns 0.\"\"\"\n# assert (hto - cpu) % skt == 0\n# rem_cpu_per_skt = (hto - cpu) // skt\n# slt_per_skt = n_run_slots // skt\n# my_skt = slt // slt_per_skt\n# return my_skt * rem_cpu_per_skt\n\n\ndef get_master_cpus(cores, hto):\n hyperthreads = tuple(c + hto for c in cores) if hto > 0 else ()\n return tuple(cores) + hyperthreads\n\n\ndef get_workers_cpus(cores, cpw, hto, alt):\n cores = cores[: (len(cores) // cpw) * cpw] # No worker less than cpw.\n cpus = tuple(cores[i : i + cpw] for i in range(0, len(cores), cpw))\n if hto > 0:\n hyperthreads = tuple(c + hto for c in cores)\n hyperthreads = tuple(\n hyperthreads[i : i + cpw] for i in range(0, len(cores), cpw)\n )\n if alt:\n cpus += hyperthreads\n else:\n cpus = tuple(c + h for c, h in zip(cpus, hyperthreads))\n elif alt:\n cpus += cpus\n return cpus\n\n\ndef build_affinities_gpu_1cpu_drive(\n slt, gpu, cpu, cxg=1, gpr=1, cpw=1, hto=None, skt=1\n):\n \"\"\"OLD.\n Divides CPUs evenly among GPUs, with one CPU held open for each GPU, to\n drive it. Workers assigned on the remaining CPUs. Master permitted to use\n driver core + worker cores (good in case of multi-context per GPU and old\n alternating action server sampler, from accel_rl). GPU-driving CPUs grouped\n at the lowest numbered cores of each CPU socket.\n \"\"\"\n if gpr > 1:\n raise NotImplementedError # (parallel training)\n n_ctx = gpu * cxg\n n_run_slots = n_ctx // gpr\n assert slt < n_run_slots\n cpu_per_gpu = cpu // gpu\n sim_cpu_per_gpu = cpu_per_gpu - 1\n n_sim_cpu = cpu - gpu\n sim_cpu_per_ctx = n_sim_cpu // n_ctx\n\n assert gpu >= skt\n assert gpu % skt == 0\n gpu_per_skt = gpu // skt\n assert cpu % skt == 0\n cpu_per_skt = cpu // skt\n\n my_ctx = slt # Different for multi-context run, not implemented.\n my_gpu = my_ctx // cxg\n my_skt = my_gpu // gpu_per_skt\n gpu_in_skt = my_gpu % gpu_per_skt\n gpu_core = gpu_in_skt + my_skt * cpu_per_skt\n ctx_in_gpu = my_ctx % cxg\n\n min_sim_core = (\n my_skt * cpu_per_skt\n + gpu_per_skt\n + gpu_in_skt * sim_cpu_per_gpu\n + ctx_in_gpu * sim_cpu_per_ctx\n )\n sim_cores = tuple(range(min_sim_core, min_sim_core + sim_cpu_per_ctx))\n\n assert len(sim_cores) % cpw == 0\n if hto is None:\n hto = cpu\n if hto > 0:\n hyperthreads = tuple(c + hto for c in sim_cores)\n workers_cpus = tuple(\n sim_cores[i : i + cpw] + hyperthreads[i : i + cpw]\n for i in range(0, len(sim_cores), cpw)\n )\n master_cpus = (gpu_core,) + sim_cores + (gpu_core + hto,) + hyperthreads\n else:\n workers_cpus = tuple(\n sim_cores[i : i + cpw] for i in range(0, len(sim_cores), cpw)\n )\n master_cpus = (gpu_core,) + sim_cores\n\n affinity = AttrDict(\n all_cpus=master_cpus,\n master_cpus=master_cpus,\n workers_cpus=workers_cpus,\n master_torch_threads=1,\n worker_torch_threads=cpw,\n cuda_idx=my_gpu,\n )\n return affinity\n",
"import torch\n\nfrom rlpyt.agents.base import AgentStep, BaseAgent\nfrom rlpyt.agents.dqn.epsilon_greedy import EpsilonGreedyAgentMixin\nfrom rlpyt.distributions.epsilon_greedy import EpsilonGreedy\nfrom rlpyt.models.utils import update_state_dict\nfrom rlpyt.utils.buffer import buffer_to\nfrom rlpyt.utils.collections import namedarraytuple\nfrom rlpyt.utils.logging import logger\n\n# from torch.nn.parallel import DistributedDataParallel as DDP\n# from torch.nn.parallel import DistributedDataParallelCPU as DDPC # Deprecated\n\n\nAgentInfo = namedarraytuple(\"AgentInfo\", \"q\")\n\n\nclass DqnAgent(EpsilonGreedyAgentMixin, BaseAgent):\n \"\"\"\n Standard agent for DQN algorithms with epsilon-greedy exploration.\n \"\"\"\n\n def __call__(self, observation, prev_action, prev_reward):\n \"\"\"Returns Q-values for states/observations (with grad).\"\"\"\n prev_action = self.distribution.to_onehot(prev_action)\n model_inputs = buffer_to(\n (observation, prev_action, prev_reward), device=self.device\n )\n q = self.model(*model_inputs)\n return q.cpu()\n\n def initialize(self, env_spaces, share_memory=False, global_B=1, env_ranks=None):\n \"\"\"Along with standard initialization, creates vector-valued epsilon\n for exploration, if applicable, with a different epsilon for each\n environment instance.\"\"\"\n _initial_model_state_dict = self.initial_model_state_dict\n self.initial_model_state_dict = (\n None # don't let base agent try to initialize model\n )\n super().initialize(\n env_spaces, share_memory, global_B=global_B, env_ranks=env_ranks\n )\n self.target_model = self.ModelCls(**self.env_model_kwargs, **self.model_kwargs)\n if _initial_model_state_dict is not None:\n self.model.load_state_dict(_initial_model_state_dict[\"model\"])\n self.target_model.load_state_dict(_initial_model_state_dict[\"model\"])\n self.distribution = EpsilonGreedy(dim=env_spaces.action.n)\n if env_ranks is not None:\n self.make_vec_eps(global_B, env_ranks)\n\n def to_device(self, cuda_idx=None):\n super().to_device(cuda_idx)\n self.target_model.to(self.device)\n\n def state_dict(self):\n return dict(\n model=self.model.state_dict(), target=self.target_model.state_dict()\n )\n\n @torch.no_grad()\n def step(self, observation, prev_action, prev_reward):\n \"\"\"Computes Q-values for states/observations and selects actions by\n epsilon-greedy. (no grad)\"\"\"\n prev_action = self.distribution.to_onehot(prev_action)\n model_inputs = buffer_to(\n (observation, prev_action, prev_reward), device=self.device\n )\n q = self.model(*model_inputs)\n q = q.cpu()\n action = self.distribution.sample(q)\n agent_info = AgentInfo(q=q)\n # action, agent_info = buffer_to((action, agent_info), device=\"cpu\")\n return AgentStep(action=action, agent_info=agent_info)\n\n def target(self, observation, prev_action, prev_reward):\n \"\"\"Returns the target Q-values for states/observations.\"\"\"\n prev_action = self.distribution.to_onehot(prev_action)\n model_inputs = buffer_to(\n (observation, prev_action, prev_reward), device=self.device\n )\n target_q = self.target_model(*model_inputs)\n return target_q.cpu()\n\n def update_target(self, tau=1):\n \"\"\"Copies the model parameters into the target model.\"\"\"\n update_state_dict(self.target_model, self.model.state_dict(), tau)\n"
]
| [
[
"torch.nn.Linear",
"torch.nn.LSTM"
],
[
"torch.cuda.device_count"
],
[
"torch.no_grad"
]
]
|
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.Linear",
"torch.nn.ModuleList",
"torch.nn.init.constant_",
"torch.nn.functional.dropout",
"torch.nn.init.xavier_uniform_",
"torch.nn.ReLU",
"torch.nn.BatchNorm1d",
"torch.nn.functional.relu",
"torch.Tensor",
"torch.nn.Embedding"
]
]
|
rjpower/tensorflow-io | [
"39aa0b46cfaa403121fdddbd491a03d2f3190a87",
"39aa0b46cfaa403121fdddbd491a03d2f3190a87"
]
| [
"tensorflow_io/cifar/__init__.py",
"tests/test_pcap_eager.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",
"# Copyright 2019 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\"); you may not\n# use this file except in compliance with the License. You may obtain a copy of\n# 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, WITHOUT\n# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the\n# License for the specific language governing permissions and limitations under\n# the License.\n# ==============================================================================\n\"\"\"\nTest PcapDataset\n\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\nimport tensorflow as tf\nimport tensorflow_io.pcap as pcap_io # pylint: disable=wrong-import-position\n\nif not (hasattr(tf, \"version\") and tf.version.VERSION.startswith(\"2.\")):\n tf.compat.v1.enable_eager_execution()\n\n\ndef test_pcap_input():\n \"\"\"test_pcap_input\n \"\"\"\n print(\"Testing PcapDataset\")\n pcap_filename = os.path.join(\n os.path.dirname(os.path.abspath(__file__)), \"test_pcap\", \"http.pcap\")\n file_url = \"file://\" + pcap_filename\n url_filenames = [file_url]\n dataset = pcap_io.PcapDataset(url_filenames, batch=1)\n\n packets_total = 0\n for v in dataset:\n (packet_timestamp, packet_data) = v\n if packets_total == 0:\n assert packet_timestamp.numpy()[0] == 1084443427.311224 # we know this is the correct value in the test pcap file\n assert len(packet_data.numpy()[0]) == 62 # we know this is the correct packet data buffer length in the test pcap file\n packets_total += 1\n assert packets_total == 43 # we know this is the correct number of packets in the test pcap file\n\nif __name__ == \"__main__\":\n test.main()\n"
]
| [
[
"tensorflow.python.util.all_util.remove_undocumented"
],
[
"tensorflow.version.VERSION.startswith",
"tensorflow.compat.v1.enable_eager_execution"
]
]
|
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.GRU",
"torch.nn.ModuleList",
"torch.nn.functional.dropout",
"torch.add",
"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.contrib.rnn.GRUCell",
"tensorflow.variable_scope",
"tensorflow.shape",
"tensorflow.squeeze"
]
]
|
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()"
]
| [
[
"numpy.array",
"sklearn.datasets.make_blobs",
"matplotlib.pyplot.plot",
"scipy.spatial.ConvexHull",
"matplotlib.pyplot.show"
]
]
|
wgfi110/athena | [
"e704884ec6a3a947769d892aa267578038e49ecb",
"e704884ec6a3a947769d892aa267578038e49ecb"
]
| [
"athena/data/datasets/base.py",
"athena/data/datasets/preprocess.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",
"# coding=utf-8\n# Copyright (C) ATHENA AUTHORS; Ruixiong Zhang;\n# 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# pylint: disable=missing-function-docstring, invalid-name\n\n\"\"\" preprecessing for speech features \"\"\"\nimport random\nimport tensorflow as tf\nfrom PIL import Image\nfrom ...utils.hparam import register_and_parse_hparams\nimport tensorflow as tf\n\nclass SpecAugment:\n \"\"\"Implementation of specaugument from paper \"SpecAugment: A Simple Data\n Augmentation Method for Automatic Speech Recognition\"\n\n Args:\n preprocess_config: it contains configs below::\n\n time_warping: warped time parameter, should be in (0, time / 2),\n a random horizontal center point in (W, time_steps - W) will be warped\n either to left or right by a distance chosen from range [0, W) randomly.\n time_masking: masked time range, should be in (0, time_steps),\n the final masked time steps will be [t_0, t_0 + t),\n t is random from[0, T), t_0 is random from [0, time_steps - t)\n frequency_masking: masked frequency range, should be in (0, dimension),\n the final masked frequencies will be [f_0, f_0 + f),\n f is random from[0, F), f_0 is random from [0, dimension - f)\n mask_cols: masking operation is executed mask_cols times in each axis\n \"\"\"\n\n default_config = {\n \"time_warping\": 0,\n \"time_masking\": 0,\n \"frequency_masking\": 0,\n \"mask_cols\": 0,\n \"mask_type\": \"mean\"\n }\n\n def __init__(self, preprocess_config):\n hparams = register_and_parse_hparams(self.default_config, preprocess_config, cls=self.__class__)\n self.time_warping = hparams.time_warping\n self.time_masking = hparams.time_masking\n self.frequency_masking = hparams.frequency_masking\n self.mask_cols = hparams.mask_cols\n self.mask_type = hparams.mask_type\n\n def __call__(self, feat):\n \"\"\"spec augment preprocess for audio features\n\n Args:\n feat: audio features, shape should be [time_steps, dimension, channels]\n\n Returns:\n processed features\n \"\"\"\n feat = self.feat_time_warping(feat)\n feat = self.feat_masking(feat, axis=0, mask_num=self.time_masking)\n feat = self.feat_masking(feat, axis=1, mask_num=self.frequency_masking)\n return feat\n\n def feat_time_warping(self, feat):\n \"\"\"time warping for spec agument\n\n Args:\n feat: audio features, shape should be [time_steps, dimension, channels]\n\n Returns:\n time warped features\n \"\"\"\n time_steps = feat.shape[0]\n if self.time_warping >= time_steps - self.time_warping - 1 or self.time_warping == 0:\n return feat\n feat = tf.squeeze(feat).numpy()\n center = random.randrange(self.time_warping + 1, time_steps - self.time_warping)\n distance = random.randrange(-self.time_warping + 1, self.time_warping)\n warped = center + distance\n left = Image.fromarray(feat[:center]).resize(\n (feat.shape[1], warped), Image.BICUBIC)\n right = Image.fromarray(feat[center:]).resize(\n (feat.shape[1], time_steps - warped), Image.BICUBIC)\n feat[:warped] = left\n feat[warped:] = right\n warped_feat = tf.expand_dims(tf.convert_to_tensor(feat), -1)\n return warped_feat\n\n def feat_masking(self, feat, axis=0, mask_num=0):\n \"\"\"masking for spec augment\n\n Args:\n feat: audio features, shape should be [time_steps, dimension, channels]\n axis (int, optional): the axis to be masked. Defaults to 0.\n mask_num (int, optional): masked time or frequency range. Defaults to 0.\n\n Returns:\n masked features\n \"\"\"\n time_steps, freq_dim, channels = feat.shape\n\n dim_size = tf.shape(feat)[axis]\n if mask_num > dim_size or mask_num == 0 or self.mask_cols == 0:\n return feat\n\n total_t = tf.random.uniform([self.mask_cols, 1], 0, mask_num, tf.int32)\n max_t = tf.reduce_max(total_t)\n t_0 = tf.random.uniform([self.mask_cols, 1], 0, dim_size - max_t, tf.int32)\n t_end = t_0 + total_t\n t_0 = tf.tile(t_0, [1, dim_size]) # (mask_cols, dim_size)\n t_end = tf.tile(t_end, [1, dim_size]) # (mask_cols, dim_size)\n base_mask = tf.expand_dims(tf.range(dim_size), axis=0)\n base_mask = tf.tile(base_mask, [self.mask_cols, 1])\n # (time_mask_cols, time_steps)\n mask = tf.math.logical_xor(t_end <= base_mask, base_mask < t_0)\n final_mask = mask[0]\n for mask_bran in mask:\n final_mask = tf.math.logical_and(final_mask, mask_bran)\n if axis == 0:\n final_mask = tf.tile(final_mask[:, tf.newaxis, tf.newaxis], [1, freq_dim, channels])\n elif axis == 1:\n final_mask = tf.tile(final_mask[tf.newaxis, :, tf.newaxis], [time_steps, 1, channels])\n if self.mask_type == \"mean\":\n mask_metrics = tf.tile(tf.reduce_mean(feat, keepdims=True),\n [time_steps, freq_dim, channels])\n else:\n mask_metrics = tf.zeros(shape=[time_steps, freq_dim, channels])\n feat = tf.where(final_mask, feat, mask_metrics)\n return feat\n"
]
| [
[
"tensorflow.compat.v2.data.Dataset.from_generator",
"tensorflow.device"
],
[
"tensorflow.convert_to_tensor",
"tensorflow.shape",
"tensorflow.math.logical_xor",
"tensorflow.range",
"tensorflow.zeros",
"tensorflow.where",
"tensorflow.random.uniform",
"tensorflow.reduce_max",
"tensorflow.math.logical_and",
"tensorflow.squeeze",
"tensorflow.tile",
"tensorflow.reduce_mean"
]
]
|
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"
]
| [
[
"numpy.concatenate",
"numpy.array",
"numpy.empty",
"torch.set_default_tensor_type",
"torch.no_grad",
"numpy.where",
"torch.load",
"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"
]
| [
[
"torch.nn.Linear",
"torch.round",
"numpy.int8",
"torch.nn.init.kaiming_normal_",
"numpy.min",
"torch.ones",
"torch.cuda.is_available",
"torch.load",
"torch.nn.DataParallel",
"numpy.int16",
"numpy.max",
"torch.sqrt",
"torch.nn.MaxPool2d",
"torch.nn.init.constant_",
"torch.abs",
"numpy.arange",
"numpy.int32",
"torch.Tensor",
"numpy.array",
"numpy.zeros",
"numpy.round",
"torch.nn.Sequential",
"torch.nn.ReLU",
"numpy.float32",
"torch.nn.Conv2d",
"torch.log2",
"numpy.lib.pad",
"numpy.sum",
"numpy.ones",
"torch.nn.AdaptiveAvgPool2d"
]
]
|
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.cat",
"torch.split",
"torch.no_grad",
"torch.nn.functional.embedding",
"torch.nn.functional.linear",
"torch.empty",
"torch.Tensor"
]
]
|
wjj19950828/tvm | [
"9c63f4fc318652f6fff68342da2d11b26592a3e0",
"9c63f4fc318652f6fff68342da2d11b26592a3e0",
"9c63f4fc318652f6fff68342da2d11b26592a3e0"
]
| [
"tests/python/frontend/pytorch/test_forward.py",
"python/tvm/testing.py",
"tests/python/unittest/test_tir_ir_builder.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",
"# 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\n# pylint: disable=invalid-name,unnecessary-comprehension\n\"\"\" TVM testing utilities\n\nTesting Markers\n***************\n\nWe use pytest markers to specify the requirements of test functions. Currently\nthere is a single distinction that matters for our testing environment: does\nthe test require a gpu. For tests that require just a gpu or just a cpu, we\nhave the decorator :py:func:`requires_gpu` that enables the test when a gpu is\navailable. To avoid running tests that don't require a gpu on gpu nodes, this\ndecorator also sets the pytest marker `gpu` so we can use select the gpu subset\nof tests (using `pytest -m gpu`).\n\nUnfortunately, many tests are written like this:\n\n.. python::\n\n def test_something():\n for target in all_targets():\n do_something()\n\nThe test uses both gpu and cpu targets, so the test needs to be run on both cpu\nand gpu nodes. But we still want to only run the cpu targets on the cpu testing\nnode. The solution is to mark these tests with the gpu marker so they will be\nrun on the gpu nodes. But we also modify all_targets (renamed to\nenabled_targets) so that it only returns gpu targets on gpu nodes and cpu\ntargets on cpu nodes (using an environment variable).\n\nInstead of using the all_targets function, future tests that would like to\ntest against a variety of targets should use the\n:py:func:`tvm.testing.parametrize_targets` functionality. This allows us\ngreater control over which targets are run on which testing nodes.\n\nIf in the future we want to add a new type of testing node (for example\nfpgas), we need to add a new marker in `tests/python/pytest.ini` and a new\nfunction in this module. Then targets using this node should be added to the\n`TVM_TEST_TARGETS` environment variable in the CI.\n\"\"\"\nimport collections\nimport copy\nimport functools\nimport logging\nimport os\nimport sys\nimport time\nimport pickle\nimport pytest\nimport _pytest\nimport numpy as np\nimport tvm\nimport tvm.arith\nimport tvm.tir\nimport tvm.te\nimport tvm._ffi\nfrom tvm.contrib import nvcc\nfrom tvm.error import TVMError\n\n\ndef assert_allclose(actual, desired, rtol=1e-7, atol=1e-7):\n \"\"\"Version of np.testing.assert_allclose with `atol` and `rtol` fields set\n in reasonable defaults.\n\n Arguments `actual` and `desired` are not interchangeable, since the function\n compares the `abs(actual-desired)` with `atol+rtol*abs(desired)`. Since we\n often allow `desired` to be close to zero, we generally want non-zero `atol`.\n \"\"\"\n actual = np.asanyarray(actual)\n desired = np.asanyarray(desired)\n np.testing.assert_allclose(actual.shape, desired.shape)\n np.testing.assert_allclose(actual, desired, rtol=rtol, atol=atol, verbose=True)\n\n\ndef check_numerical_grads(\n function, input_values, grad_values, function_value=None, delta=1e-3, atol=1e-2, rtol=0.1\n):\n \"\"\"A helper function that checks that numerical gradients of a function are\n equal to gradients computed in some different way (analytical gradients).\n\n Numerical gradients are computed using finite difference approximation. To\n reduce the number of function evaluations, the number of points used is\n gradually increased if the error value is too high (up to 5 points).\n\n Parameters\n ----------\n function\n A function that takes inputs either as positional or as keyword\n arguments (either `function(*input_values)` or `function(**input_values)`\n should be correct) and returns a scalar result. Should accept numpy\n ndarrays.\n\n input_values : Dict[str, numpy.ndarray] or List[numpy.ndarray]\n A list of values or a dict assigning values to variables. Represents the\n point at which gradients should be computed.\n\n grad_values : Dict[str, numpy.ndarray] or List[numpy.ndarray]\n Gradients computed using a different method.\n\n function_value : float, optional\n Should be equal to `function(**input_values)`.\n\n delta : float, optional\n A small number used for numerical computation of partial derivatives.\n The default 1e-3 is a good choice for float32.\n\n atol : float, optional\n Absolute tolerance. Gets multiplied by `sqrt(n)` where n is the size of a\n gradient.\n\n rtol : float, optional\n Relative tolerance.\n \"\"\"\n # If input_values is a list then function accepts positional arguments\n # In this case transform it to a function taking kwargs of the form {\"0\": ..., \"1\": ...}\n if not isinstance(input_values, dict):\n input_len = len(input_values)\n input_values = {str(idx): val for idx, val in enumerate(input_values)}\n\n def _function(_input_len=input_len, _orig_function=function, **kwargs):\n return _orig_function(*(kwargs[str(i)] for i in range(input_len)))\n\n function = _function\n\n grad_values = {str(idx): val for idx, val in enumerate(grad_values)}\n\n if function_value is None:\n function_value = function(**input_values)\n\n # a helper to modify j-th element of val by a_delta\n def modify(val, j, a_delta):\n val = val.copy()\n val.reshape(-1)[j] = val.reshape(-1)[j] + a_delta\n return val\n\n # numerically compute a partial derivative with respect to j-th element of the var `name`\n def derivative(x_name, j, a_delta):\n modified_values = {\n n: modify(val, j, a_delta) if n == x_name else val for n, val in input_values.items()\n }\n return (function(**modified_values) - function_value) / a_delta\n\n def compare_derivative(j, n_der, grad):\n der = grad.reshape(-1)[j]\n return np.abs(n_der - der) < atol + rtol * np.abs(n_der)\n\n for x_name, grad in grad_values.items():\n if grad.shape != input_values[x_name].shape:\n raise AssertionError(\n \"Gradient wrt '{}' has unexpected shape {}, expected {} \".format(\n x_name, grad.shape, input_values[x_name].shape\n )\n )\n\n ngrad = np.zeros_like(grad)\n\n wrong_positions = []\n\n # compute partial derivatives for each position in this variable\n for j in range(np.prod(grad.shape)):\n # forward difference approximation\n nder = derivative(x_name, j, delta)\n\n # if the derivative is not equal to the analytical one, try to use more\n # precise and expensive methods\n if not compare_derivative(j, nder, grad):\n # central difference approximation\n nder = (derivative(x_name, j, -delta) + nder) / 2\n\n if not compare_derivative(j, nder, grad):\n # central difference approximation using h = delta/2\n cnder2 = (\n derivative(x_name, j, delta / 2) + derivative(x_name, j, -delta / 2)\n ) / 2\n # five-point derivative\n nder = (4 * cnder2 - nder) / 3\n\n # if the derivatives still don't match, add this position to the\n # list of wrong positions\n if not compare_derivative(j, nder, grad):\n wrong_positions.append(np.unravel_index(j, grad.shape))\n\n ngrad.reshape(-1)[j] = nder\n\n wrong_percentage = int(100 * len(wrong_positions) / np.prod(grad.shape))\n\n dist = np.sqrt(np.sum((ngrad - grad) ** 2))\n grad_norm = np.sqrt(np.sum(ngrad ** 2))\n\n if not (np.isfinite(dist) and np.isfinite(grad_norm)):\n raise ValueError(\n \"NaN or infinity detected during numerical gradient checking wrt '{}'\\n\"\n \"analytical grad = {}\\n numerical grad = {}\\n\".format(x_name, grad, ngrad)\n )\n\n # we multiply atol by this number to make it more universal for different sizes\n sqrt_n = np.sqrt(float(np.prod(grad.shape)))\n\n if dist > atol * sqrt_n + rtol * grad_norm:\n raise AssertionError(\n \"Analytical and numerical grads wrt '{}' differ too much\\n\"\n \"analytical grad = {}\\n numerical grad = {}\\n\"\n \"{}% of elements differ, first 10 of wrong positions: {}\\n\"\n \"distance > atol*sqrt(n) + rtol*grad_norm\\n\"\n \"distance {} > {}*{} + {}*{}\".format(\n x_name,\n grad,\n ngrad,\n wrong_percentage,\n wrong_positions[:10],\n dist,\n atol,\n sqrt_n,\n rtol,\n grad_norm,\n )\n )\n\n max_diff = np.max(np.abs(ngrad - grad))\n avg_diff = np.mean(np.abs(ngrad - grad))\n logging.info(\n \"Numerical grad test wrt '%s' of shape %s passes, \"\n \"dist = %f, max_diff = %f, avg_diff = %f\",\n x_name,\n grad.shape,\n dist,\n max_diff,\n avg_diff,\n )\n\n\ndef assert_prim_expr_equal(lhs, rhs):\n \"\"\"Assert lhs and rhs equals to each iother.\n\n Parameters\n ----------\n lhs : tvm.tir.PrimExpr\n The left operand.\n\n rhs : tvm.tir.PrimExpr\n The left operand.\n \"\"\"\n ana = tvm.arith.Analyzer()\n res = ana.simplify(lhs - rhs)\n equal = isinstance(res, tvm.tir.IntImm) and res.value == 0\n if not equal:\n raise ValueError(\"{} and {} are not equal\".format(lhs, rhs))\n\n\ndef check_bool_expr_is_true(bool_expr, vranges, cond=None):\n \"\"\"Check that bool_expr holds given the condition cond\n for every value of free variables from vranges.\n\n for example, 2x > 4y solves to x > 2y given x in (0, 10) and y in (0, 10)\n here bool_expr is x > 2y, vranges is {x: (0, 10), y: (0, 10)}, cond is 2x > 4y\n We creates iterations to check,\n for x in range(10):\n for y in range(10):\n assert !(2x > 4y) || (x > 2y)\n\n Parameters\n ----------\n bool_expr : tvm.ir.PrimExpr\n Boolean expression to check\n vranges: Dict[tvm.tir.expr.Var, tvm.ir.Range]\n Free variables and their ranges\n cond: tvm.ir.PrimExpr\n extra conditions needs to be satisfied.\n \"\"\"\n if cond is not None:\n bool_expr = tvm.te.any(tvm.tir.Not(cond), bool_expr)\n\n def _run_expr(expr, vranges):\n \"\"\"Evaluate expr for every value of free variables\n given by vranges and return the tensor of results.\n \"\"\"\n\n def _compute_body(*us):\n vmap = {v: u + r.min for (v, r), u in zip(vranges.items(), us)}\n return tvm.tir.stmt_functor.substitute(expr, vmap)\n\n A = tvm.te.compute([r.extent.value for v, r in vranges.items()], _compute_body)\n args = [tvm.nd.empty(A.shape, A.dtype)]\n sch = tvm.te.create_schedule(A.op)\n mod = tvm.build(sch, [A])\n mod(*args)\n return args[0].numpy()\n\n res = _run_expr(bool_expr, vranges)\n if not np.all(res):\n indices = list(np.argwhere(res == 0)[0])\n counterex = [(str(v), i + r.min) for (v, r), i in zip(vranges.items(), indices)]\n counterex = sorted(counterex, key=lambda x: x[0])\n counterex = \", \".join([v + \" = \" + str(i) for v, i in counterex])\n ana = tvm.arith.Analyzer()\n raise AssertionError(\n \"Expression {}\\nis not true on {}\\n\"\n \"Counterexample: {}\".format(ana.simplify(bool_expr), vranges, counterex)\n )\n\n\ndef check_int_constraints_trans_consistency(constraints_trans, vranges=None):\n \"\"\"Check IntConstraintsTransform is a bijective transformation.\n\n Parameters\n ----------\n constraints_trans : arith.IntConstraintsTransform\n Integer constraints transformation\n vranges: Dict[tvm.tir.Var, tvm.ir.Range]\n Free variables and their ranges\n \"\"\"\n if vranges is None:\n vranges = {}\n\n def _check_forward(constraints1, constraints2, varmap, backvarmap):\n ana = tvm.arith.Analyzer()\n all_vranges = vranges.copy()\n all_vranges.update({v: r for v, r in constraints1.ranges.items()})\n\n # Check that the transformation is injective\n cond_on_vars = tvm.tir.const(1, \"bool\")\n for v in constraints1.variables:\n if v in varmap:\n # variable mapping is consistent\n v_back = ana.simplify(tvm.tir.stmt_functor.substitute(varmap[v], backvarmap))\n cond_on_vars = tvm.te.all(cond_on_vars, v == v_back)\n # Also we have to check that the new relations are true when old relations are true\n cond_subst = tvm.tir.stmt_functor.substitute(\n tvm.te.all(tvm.tir.const(1, \"bool\"), *constraints2.relations), backvarmap\n )\n # We have to include relations from vranges too\n for v in constraints2.variables:\n if v in constraints2.ranges:\n r = constraints2.ranges[v]\n range_cond = tvm.te.all(v >= r.min, v < r.min + r.extent)\n range_cond = tvm.tir.stmt_functor.substitute(range_cond, backvarmap)\n cond_subst = tvm.te.all(cond_subst, range_cond)\n cond_subst = ana.simplify(cond_subst)\n check_bool_expr_is_true(\n tvm.te.all(cond_subst, cond_on_vars),\n all_vranges,\n cond=tvm.te.all(tvm.tir.const(1, \"bool\"), *constraints1.relations),\n )\n\n _check_forward(\n constraints_trans.src,\n constraints_trans.dst,\n constraints_trans.src_to_dst,\n constraints_trans.dst_to_src,\n )\n _check_forward(\n constraints_trans.dst,\n constraints_trans.src,\n constraints_trans.dst_to_src,\n constraints_trans.src_to_dst,\n )\n\n\ndef _get_targets(target_str=None):\n if target_str is None:\n target_str = os.environ.get(\"TVM_TEST_TARGETS\", \"\")\n\n if len(target_str) == 0:\n target_str = DEFAULT_TEST_TARGETS\n\n target_names = set(t.strip() for t in target_str.split(\";\") if t.strip())\n\n targets = []\n for target in target_names:\n target_kind = target.split()[0]\n is_enabled = tvm.runtime.enabled(target_kind)\n is_runnable = is_enabled and tvm.device(target_kind).exist\n targets.append(\n {\n \"target\": target,\n \"target_kind\": target_kind,\n \"is_enabled\": is_enabled,\n \"is_runnable\": is_runnable,\n }\n )\n\n if all(not t[\"is_runnable\"] for t in targets):\n if tvm.runtime.enabled(\"llvm\"):\n logging.warning(\n \"None of the following targets are supported by this build of TVM: %s.\"\n \" Try setting TVM_TEST_TARGETS to a supported target. Defaulting to llvm.\",\n target_str,\n )\n return _get_targets(\"llvm\")\n\n raise TVMError(\n \"None of the following targets are supported by this build of TVM: %s.\"\n \" Try setting TVM_TEST_TARGETS to a supported target.\"\n \" Cannot default to llvm, as it is not enabled.\" % target_str\n )\n\n return targets\n\n\nDEFAULT_TEST_TARGETS = (\n \"llvm;cuda;opencl;metal;rocm;vulkan -from_device=0;nvptx;\"\n \"llvm -device=arm_cpu;opencl -device=mali,aocl_sw_emu\"\n)\n\n\ndef device_enabled(target):\n \"\"\"Check if a target should be used when testing.\n\n It is recommended that you use :py:func:`tvm.testing.parametrize_targets`\n instead of manually checking if a target is enabled.\n\n This allows the user to control which devices they are testing against. In\n tests, this should be used to check if a device should be used when said\n device is an optional part of the test.\n\n Parameters\n ----------\n target : str\n Target string to check against\n\n Returns\n -------\n bool\n Whether or not the device associated with this target is enabled.\n\n Example\n -------\n >>> @tvm.testing.uses_gpu\n >>> def test_mytest():\n >>> for target in [\"cuda\", \"llvm\"]:\n >>> if device_enabled(target):\n >>> test_body...\n\n Here, `test_body` will only be reached by with `target=\"cuda\"` on gpu test\n nodes and `target=\"llvm\"` on cpu test nodes.\n \"\"\"\n assert isinstance(target, str), \"device_enabled requires a target as a string\"\n # only check if device name is found, sometime there are extra flags\n target_kind = target.split(\" \")[0]\n return any(target_kind == t[\"target_kind\"] for t in _get_targets() if t[\"is_runnable\"])\n\n\ndef enabled_targets():\n \"\"\"Get all enabled targets with associated devices.\n\n In most cases, you should use :py:func:`tvm.testing.parametrize_targets` instead of\n this function.\n\n In this context, enabled means that TVM was built with support for\n this target, the target name appears in the TVM_TEST_TARGETS\n environment variable, and a suitable device for running this\n target exists. If TVM_TEST_TARGETS is not set, it defaults to\n variable DEFAULT_TEST_TARGETS in this module.\n\n If you use this function in a test, you **must** decorate the test with\n :py:func:`tvm.testing.uses_gpu` (otherwise it will never be run on the gpu).\n\n Returns\n -------\n targets: list\n A list of pairs of all enabled devices and the associated context\n\n \"\"\"\n return [(t[\"target\"], tvm.device(t[\"target\"])) for t in _get_targets() if t[\"is_runnable\"]]\n\n\ndef _compose(args, decs):\n \"\"\"Helper to apply multiple markers\"\"\"\n if len(args) > 0:\n f = args[0]\n for d in reversed(decs):\n f = d(f)\n return f\n return decs\n\n\ndef uses_gpu(*args):\n \"\"\"Mark to differentiate tests that use the GPU in some capacity.\n\n These tests will be run on CPU-only test nodes and on test nodes with GPUs.\n To mark a test that must have a GPU present to run, use\n :py:func:`tvm.testing.requires_gpu`.\n\n Parameters\n ----------\n f : function\n Function to mark\n \"\"\"\n _uses_gpu = [pytest.mark.gpu]\n return _compose(args, _uses_gpu)\n\n\ndef requires_gpu(*args):\n \"\"\"Mark a test as requiring a GPU to run.\n\n Tests with this mark will not be run unless a gpu is present.\n\n Parameters\n ----------\n f : function\n Function to mark\n \"\"\"\n _requires_gpu = [\n pytest.mark.skipif(\n not tvm.cuda().exist\n and not tvm.rocm().exist\n and not tvm.opencl().exist\n and not tvm.metal().exist\n and not tvm.vulkan().exist,\n reason=\"No GPU present\",\n ),\n *uses_gpu(),\n ]\n return _compose(args, _requires_gpu)\n\n\ndef requires_cuda(*args):\n \"\"\"Mark a test as requiring the CUDA runtime.\n\n This also marks the test as requiring a cuda gpu.\n\n Parameters\n ----------\n f : function\n Function to mark\n \"\"\"\n _requires_cuda = [\n pytest.mark.cuda,\n pytest.mark.skipif(not device_enabled(\"cuda\"), reason=\"CUDA support not enabled\"),\n *requires_gpu(),\n ]\n return _compose(args, _requires_cuda)\n\n\ndef requires_nvptx(*args):\n \"\"\"Mark a test as requiring the NVPTX compilation on the CUDA runtime\n\n This also marks the test as requiring a cuda gpu, and requiring\n LLVM support.\n\n Parameters\n ----------\n f : function\n Function to mark\n\n \"\"\"\n _requires_nvptx = [\n pytest.mark.skipif(not device_enabled(\"nvptx\"), reason=\"NVPTX support not enabled\"),\n *requires_llvm(),\n *requires_gpu(),\n ]\n return _compose(args, _requires_nvptx)\n\n\ndef requires_cudagraph(*args):\n \"\"\"Mark a test as requiring the CUDA Graph Feature\n\n This also marks the test as requiring cuda\n\n Parameters\n ----------\n f : function\n Function to mark\n \"\"\"\n _requires_cudagraph = [\n pytest.mark.skipif(\n not nvcc.have_cudagraph(), reason=\"CUDA Graph is not supported in this environment\"\n ),\n *requires_cuda(),\n ]\n return _compose(args, _requires_cudagraph)\n\n\ndef requires_opencl(*args):\n \"\"\"Mark a test as requiring the OpenCL runtime.\n\n This also marks the test as requiring a gpu.\n\n Parameters\n ----------\n f : function\n Function to mark\n \"\"\"\n _requires_opencl = [\n pytest.mark.opencl,\n pytest.mark.skipif(not device_enabled(\"opencl\"), reason=\"OpenCL support not enabled\"),\n *requires_gpu(),\n ]\n return _compose(args, _requires_opencl)\n\n\ndef requires_rocm(*args):\n \"\"\"Mark a test as requiring the rocm runtime.\n\n This also marks the test as requiring a gpu.\n\n Parameters\n ----------\n f : function\n Function to mark\n \"\"\"\n _requires_rocm = [\n pytest.mark.rocm,\n pytest.mark.skipif(not device_enabled(\"rocm\"), reason=\"rocm support not enabled\"),\n *requires_gpu(),\n ]\n return _compose(args, _requires_rocm)\n\n\ndef requires_metal(*args):\n \"\"\"Mark a test as requiring the metal runtime.\n\n This also marks the test as requiring a gpu.\n\n Parameters\n ----------\n f : function\n Function to mark\n \"\"\"\n _requires_metal = [\n pytest.mark.metal,\n pytest.mark.skipif(not device_enabled(\"metal\"), reason=\"metal support not enabled\"),\n *requires_gpu(),\n ]\n return _compose(args, _requires_metal)\n\n\ndef requires_vulkan(*args):\n \"\"\"Mark a test as requiring the vulkan runtime.\n\n This also marks the test as requiring a gpu.\n\n Parameters\n ----------\n f : function\n Function to mark\n \"\"\"\n _requires_vulkan = [\n pytest.mark.vulkan,\n pytest.mark.skipif(not device_enabled(\"vulkan\"), reason=\"vulkan support not enabled\"),\n *requires_gpu(),\n ]\n return _compose(args, _requires_vulkan)\n\n\ndef requires_tensorcore(*args):\n \"\"\"Mark a test as requiring a tensorcore to run.\n\n Tests with this mark will not be run unless a tensorcore is present.\n\n Parameters\n ----------\n f : function\n Function to mark\n \"\"\"\n _requires_tensorcore = [\n pytest.mark.tensorcore,\n pytest.mark.skipif(\n not tvm.cuda().exist or not nvcc.have_tensorcore(tvm.cuda(0).compute_version),\n reason=\"No tensorcore present\",\n ),\n *requires_gpu(),\n ]\n return _compose(args, _requires_tensorcore)\n\n\ndef requires_llvm(*args):\n \"\"\"Mark a test as requiring llvm to run.\n\n Parameters\n ----------\n f : function\n Function to mark\n \"\"\"\n _requires_llvm = [\n pytest.mark.llvm,\n pytest.mark.skipif(not device_enabled(\"llvm\"), reason=\"LLVM support not enabled\"),\n ]\n return _compose(args, _requires_llvm)\n\n\ndef requires_micro(*args):\n \"\"\"Mark a test as requiring microTVM to run.\n\n Parameters\n ----------\n f : function\n Function to mark\n \"\"\"\n _requires_micro = [\n pytest.mark.skipif(\n tvm.support.libinfo().get(\"USE_MICRO\", \"OFF\") != \"ON\",\n reason=\"MicroTVM support not enabled. Set USE_MICRO=ON in config.cmake to enable.\",\n )\n ]\n return _compose(args, _requires_micro)\n\n\ndef requires_rpc(*args):\n \"\"\"Mark a test as requiring rpc to run.\n\n Parameters\n ----------\n f : function\n Function to mark\n \"\"\"\n _requires_rpc = [\n pytest.mark.skipif(\n tvm.support.libinfo().get(\"USE_RPC\", \"OFF\") != \"ON\",\n reason=\"RPC support not enabled. Set USE_RPC=ON in config.cmake to enable.\",\n )\n ]\n return _compose(args, _requires_rpc)\n\n\ndef _target_to_requirement(target):\n # mapping from target to decorator\n if target.startswith(\"cuda\"):\n return requires_cuda()\n if target.startswith(\"rocm\"):\n return requires_rocm()\n if target.startswith(\"vulkan\"):\n return requires_vulkan()\n if target.startswith(\"nvptx\"):\n return requires_nvptx()\n if target.startswith(\"metal\"):\n return requires_metal()\n if target.startswith(\"opencl\"):\n return requires_opencl()\n if target.startswith(\"llvm\"):\n return requires_llvm()\n return []\n\n\ndef _pytest_target_params(targets, excluded_targets=None, xfail_targets=None):\n # Include unrunnable targets here. They get skipped by the\n # pytest.mark.skipif in _target_to_requirement(), showing up as\n # skipped tests instead of being hidden entirely.\n if targets is None:\n if excluded_targets is None:\n excluded_targets = set()\n\n if xfail_targets is None:\n xfail_targets = set()\n\n target_marks = []\n for t in _get_targets():\n # Excluded targets aren't included in the params at all.\n if t[\"target_kind\"] not in excluded_targets:\n\n # Known failing targets are included, but are marked\n # as expected to fail.\n extra_marks = []\n if t[\"target_kind\"] in xfail_targets:\n extra_marks.append(\n pytest.mark.xfail(\n reason='Known failing test for target \"{}\"'.format(t[\"target_kind\"])\n )\n )\n\n target_marks.append((t[\"target\"], extra_marks))\n\n else:\n target_marks = [(target, []) for target in targets]\n\n return [\n pytest.param(target, marks=_target_to_requirement(target) + extra_marks)\n for target, extra_marks in target_marks\n ]\n\n\ndef _auto_parametrize_target(metafunc):\n \"\"\"Automatically applies parametrize_targets\n\n Used if a test function uses the \"target\" fixture, but isn't\n already marked with @tvm.testing.parametrize_targets. Intended\n for use in the pytest_generate_tests() handler of a conftest.py\n file.\n\n \"\"\"\n if \"target\" in metafunc.fixturenames:\n parametrized_args = [\n arg.strip()\n for mark in metafunc.definition.iter_markers(\"parametrize\")\n for arg in mark.args[0].split(\",\")\n ]\n\n if \"target\" not in parametrized_args:\n # Check if the function is marked with either excluded or\n # known failing targets.\n excluded_targets = getattr(metafunc.function, \"tvm_excluded_targets\", [])\n xfail_targets = getattr(metafunc.function, \"tvm_known_failing_targets\", [])\n metafunc.parametrize(\n \"target\",\n _pytest_target_params(None, excluded_targets, xfail_targets),\n scope=\"session\",\n )\n\n\ndef parametrize_targets(*args):\n \"\"\"Parametrize a test over a specific set of targets.\n\n Use this decorator when you want your test to be run over a\n specific set of targets and devices. It is intended for use where\n a test is applicable only to a specific target, and is\n inapplicable to any others (e.g. verifying target-specific\n assembly code matches known assembly code). In most\n circumstances, :py:func:`tvm.testing.exclude_targets` or\n :py:func:`tvm.testing.known_failing_targets` should be used\n instead.\n\n If used as a decorator without arguments, the test will be\n parametrized over all targets in\n :py:func:`tvm.testing.enabled_targets`. This behavior is\n automatically enabled for any target that accepts arguments of\n ``target`` or ``dev``, so the explicit use of the bare decorator\n is no longer needed, and is maintained for backwards\n compatibility.\n\n Parameters\n ----------\n f : function\n Function to parametrize. Must be of the form `def test_xxxxxxxxx(target, dev)`:,\n where `xxxxxxxxx` is any name.\n targets : list[str], optional\n Set of targets to run against. If not supplied,\n :py:func:`tvm.testing.enabled_targets` will be used.\n\n Example\n -------\n >>> @tvm.testing.parametrize_targets(\"llvm\", \"cuda\")\n >>> def test_mytest(target, dev):\n >>> ... # do something\n \"\"\"\n\n def wrap(targets):\n def func(f):\n return pytest.mark.parametrize(\n \"target\", _pytest_target_params(targets), scope=\"session\"\n )(f)\n\n return func\n\n if len(args) == 1 and callable(args[0]):\n return wrap(None)(args[0])\n return wrap(args)\n\n\ndef exclude_targets(*args):\n \"\"\"Exclude a test from running on a particular target.\n\n Use this decorator when you want your test to be run over a\n variety of targets and devices (including cpu and gpu devices),\n but want to exclude some particular target or targets. For\n example, a test may wish to be run against all targets in\n tvm.testing.enabled_targets(), except for a particular target that\n does not support the capabilities.\n\n Applies pytest.mark.skipif to the targets given.\n\n Parameters\n ----------\n f : function\n Function to parametrize. Must be of the form `def test_xxxxxxxxx(target, dev)`:,\n where `xxxxxxxxx` is any name.\n targets : list[str]\n Set of targets to exclude.\n\n Example\n -------\n >>> @tvm.testing.exclude_targets(\"cuda\")\n >>> def test_mytest(target, dev):\n >>> ... # do something\n\n Or\n\n >>> @tvm.testing.exclude_targets(\"llvm\", \"cuda\")\n >>> def test_mytest(target, dev):\n >>> ... # do something\n\n \"\"\"\n\n def wraps(func):\n func.tvm_excluded_targets = args\n return func\n\n return wraps\n\n\ndef known_failing_targets(*args):\n \"\"\"Skip a test that is known to fail on a particular target.\n\n Use this decorator when you want your test to be run over a\n variety of targets and devices (including cpu and gpu devices),\n but know that it fails for some targets. For example, a newly\n implemented runtime may not support all features being tested, and\n should be excluded.\n\n Applies pytest.mark.xfail to the targets given.\n\n Parameters\n ----------\n f : function\n Function to parametrize. Must be of the form `def test_xxxxxxxxx(target, dev)`:,\n where `xxxxxxxxx` is any name.\n targets : list[str]\n Set of targets to skip.\n\n Example\n -------\n >>> @tvm.testing.known_failing_targets(\"cuda\")\n >>> def test_mytest(target, dev):\n >>> ... # do something\n\n Or\n\n >>> @tvm.testing.known_failing_targets(\"llvm\", \"cuda\")\n >>> def test_mytest(target, dev):\n >>> ... # do something\n\n \"\"\"\n\n def wraps(func):\n func.tvm_known_failing_targets = args\n return func\n\n return wraps\n\n\ndef parameter(*values, ids=None):\n \"\"\"Convenience function to define pytest parametrized fixtures.\n\n Declaring a variable using ``tvm.testing.parameter`` will define a\n parametrized pytest fixture that can be used by test\n functions. This is intended for cases that have no setup cost,\n such as strings, integers, tuples, etc. For cases that have a\n significant setup cost, please use :py:func:`tvm.testing.fixture`\n instead.\n\n If a test function accepts multiple parameters defined using\n ``tvm.testing.parameter``, then the test will be run using every\n combination of those parameters.\n\n The parameter definition applies to all tests in a module. If a\n specific test should have different values for the parameter, that\n test should be marked with ``@pytest.mark.parametrize``.\n\n Parameters\n ----------\n values\n A list of parameter values. A unit test that accepts this\n parameter as an argument will be run once for each parameter\n given.\n\n ids : List[str], optional\n A list of names for the parameters. If None, pytest will\n generate a name from the value. These generated names may not\n be readable/useful for composite types such as tuples.\n\n Returns\n -------\n function\n A function output from pytest.fixture.\n\n Example\n -------\n >>> size = tvm.testing.parameter(1, 10, 100)\n >>> def test_using_size(size):\n >>> ... # Test code here\n\n Or\n\n >>> shape = tvm.testing.parameter((5,10), (512,1024), ids=['small','large'])\n >>> def test_using_size(shape):\n >>> ... # Test code here\n\n \"\"\"\n\n # Optional cls parameter in case a parameter is defined inside a\n # class scope.\n @pytest.fixture(params=values, ids=ids)\n def as_fixture(*_cls, request):\n return request.param\n\n return as_fixture\n\n\n_parametrize_group = 0\n\n\ndef parameters(*value_sets):\n \"\"\"Convenience function to define pytest parametrized fixtures.\n\n Declaring a variable using tvm.testing.parameters will define a\n parametrized pytest fixture that can be used by test\n functions. Like :py:func:`tvm.testing.parameter`, this is intended\n for cases that have no setup cost, such as strings, integers,\n tuples, etc. For cases that have a significant setup cost, please\n use :py:func:`tvm.testing.fixture` instead.\n\n Unlike :py:func:`tvm.testing.parameter`, if a test function\n accepts multiple parameters defined using a single call to\n ``tvm.testing.parameters``, then the test will only be run once\n for each set of parameters, not for all combinations of\n parameters.\n\n These parameter definitions apply to all tests in a module. If a\n specific test should have different values for some parameters,\n that test should be marked with ``@pytest.mark.parametrize``.\n\n Parameters\n ----------\n values : List[tuple]\n A list of parameter value sets. Each set of values represents\n a single combination of values to be tested. A unit test that\n accepts parameters defined will be run once for every set of\n parameters in the list.\n\n Returns\n -------\n List[function]\n Function outputs from pytest.fixture. These should be unpacked\n into individual named parameters.\n\n Example\n -------\n >>> size, dtype = tvm.testing.parameters( (16,'float32'), (512,'float16') )\n >>> def test_feature_x(size, dtype):\n >>> # Test code here\n >>> assert( (size,dtype) in [(16,'float32'), (512,'float16')])\n\n \"\"\"\n global _parametrize_group\n parametrize_group = _parametrize_group\n _parametrize_group += 1\n\n outputs = []\n for param_values in zip(*value_sets):\n\n # Optional cls parameter in case a parameter is defined inside a\n # class scope.\n def fixture_func(*_cls, request):\n return request.param\n\n fixture_func.parametrize_group = parametrize_group\n fixture_func.parametrize_values = param_values\n outputs.append(pytest.fixture(fixture_func))\n\n return outputs\n\n\ndef _parametrize_correlated_parameters(metafunc):\n parametrize_needed = collections.defaultdict(list)\n\n for name, fixturedefs in metafunc.definition._fixtureinfo.name2fixturedefs.items():\n fixturedef = fixturedefs[-1]\n if hasattr(fixturedef.func, \"parametrize_group\") and hasattr(\n fixturedef.func, \"parametrize_values\"\n ):\n group = fixturedef.func.parametrize_group\n values = fixturedef.func.parametrize_values\n parametrize_needed[group].append((name, values))\n\n for parametrize_group in parametrize_needed.values():\n if len(parametrize_group) == 1:\n name, values = parametrize_group[0]\n metafunc.parametrize(name, values, indirect=True)\n else:\n names = \",\".join(name for name, values in parametrize_group)\n value_sets = zip(*[values for name, values in parametrize_group])\n metafunc.parametrize(names, value_sets, indirect=True)\n\n\ndef fixture(func=None, *, cache_return_value=False):\n \"\"\"Convenience function to define pytest fixtures.\n\n This should be used as a decorator to mark functions that set up\n state before a function. The return value of that fixture\n function is then accessible by test functions as that accept it as\n a parameter.\n\n Fixture functions can accept parameters defined with\n :py:func:`tvm.testing.parameter`.\n\n By default, the setup will be performed once for each unit test\n that uses a fixture, to ensure that unit tests are independent.\n If the setup is expensive to perform, then the\n cache_return_value=True argument can be passed to cache the setup.\n The fixture function will be run only once (or once per parameter,\n if used with tvm.testing.parameter), and the same return value\n will be passed to all tests that use it. If the environment\n variable TVM_TEST_DISABLE_CACHE is set to a non-zero value, it\n will disable this feature and no caching will be performed.\n\n Example\n -------\n >>> @tvm.testing.fixture\n >>> def cheap_setup():\n >>> return 5 # Setup code here.\n >>>\n >>> def test_feature_x(target, dev, cheap_setup)\n >>> assert(cheap_setup == 5) # Run test here\n\n Or\n\n >>> size = tvm.testing.parameter(1, 10, 100)\n >>>\n >>> @tvm.testing.fixture\n >>> def cheap_setup(size):\n >>> return 5*size # Setup code here, based on size.\n >>>\n >>> def test_feature_x(cheap_setup):\n >>> assert(cheap_setup in [5, 50, 500])\n\n Or\n\n >>> @tvm.testing.fixture(cache_return_value=True)\n >>> def expensive_setup():\n >>> time.sleep(10) # Setup code here\n >>> return 5\n >>>\n >>> def test_feature_x(target, dev, expensive_setup):\n >>> assert(expensive_setup == 5)\n\n \"\"\"\n\n force_disable_cache = bool(int(os.environ.get(\"TVM_TEST_DISABLE_CACHE\", \"0\")))\n cache_return_value = cache_return_value and not force_disable_cache\n\n # Deliberately at function scope, so that caching can track how\n # many times the fixture has been used. If used, the cache gets\n # cleared after the fixture is no longer needed.\n scope = \"function\"\n\n def wraps(func):\n if cache_return_value:\n func = _fixture_cache(func)\n func = pytest.fixture(func, scope=scope)\n return func\n\n if func is None:\n return wraps\n\n return wraps(func)\n\n\ndef _fixture_cache(func):\n cache = {}\n\n # Can't use += on a bound method's property. Therefore, this is a\n # list rather than a variable so that it can be accessed from the\n # pytest_collection_modifyitems().\n num_uses_remaining = [0]\n\n # Using functools.lru_cache would require the function arguments\n # to be hashable, which wouldn't allow caching fixtures that\n # depend on numpy arrays. For example, a fixture that takes a\n # numpy array as input, then calculates uses a slow method to\n # compute a known correct output for that input. Therefore,\n # including a fallback for serializable types.\n def get_cache_key(*args, **kwargs):\n try:\n hash((args, kwargs))\n return (args, kwargs)\n except TypeError as e:\n pass\n\n try:\n return pickle.dumps((args, kwargs))\n except TypeError as e:\n raise TypeError(\n \"TVM caching of fixtures requires arguments to the fixture \"\n \"to be either hashable or serializable\"\n ) from e\n\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n try:\n cache_key = get_cache_key(*args, **kwargs)\n\n try:\n cached_value = cache[cache_key]\n except KeyError:\n cached_value = cache[cache_key] = func(*args, **kwargs)\n\n try:\n yield copy.deepcopy(cached_value)\n except TypeError as e:\n rfc_url = (\n \"https://github.com/apache/tvm-rfcs/blob/main/rfcs/\"\n \"0007-parametrized-unit-tests.md#unresolved-questions\"\n )\n message = (\n \"TVM caching of fixtures can only be used on serializable data types, not {}.\\n\"\n \"Please see {} for details/discussion.\"\n ).format(type(cached_value), rfc_url)\n raise TypeError(message) from e\n\n finally:\n # Clear the cache once all tests that use a particular fixture\n # have completed.\n num_uses_remaining[0] -= 1\n if not num_uses_remaining[0]:\n cache.clear()\n\n # Set in the pytest_collection_modifyitems()\n wrapper.num_uses_remaining = num_uses_remaining\n\n return wrapper\n\n\ndef _count_num_fixture_uses(items):\n # Helper function, counts the number of tests that use each cached\n # fixture. Should be called from pytest_collection_modifyitems().\n for item in items:\n is_skipped = item.get_closest_marker(\"skip\") or any(\n mark.args[0] for mark in item.iter_markers(\"skipif\")\n )\n if is_skipped:\n continue\n\n for fixturedefs in item._fixtureinfo.name2fixturedefs.values():\n # Only increment the active fixturedef, in a name has been overridden.\n fixturedef = fixturedefs[-1]\n if hasattr(fixturedef.func, \"num_uses_remaining\"):\n fixturedef.func.num_uses_remaining[0] += 1\n\n\ndef _remove_global_fixture_definitions(items):\n # Helper function, removes fixture definitions from the global\n # variables of the modules they were defined in. This is intended\n # to improve readability of error messages by giving a NameError\n # if a test function accesses a pytest fixture but doesn't include\n # it as an argument. Should be called from\n # pytest_collection_modifyitems().\n\n modules = set(item.module for item in items)\n\n for module in modules:\n for name in dir(module):\n obj = getattr(module, name)\n if hasattr(obj, \"_pytestfixturefunction\") and isinstance(\n obj._pytestfixturefunction, _pytest.fixtures.FixtureFunctionMarker\n ):\n delattr(module, name)\n\n\ndef identity_after(x, sleep):\n \"\"\"Testing function to return identity after sleep\n\n Parameters\n ----------\n x : int\n The input value.\n\n sleep : float\n The amount of time to sleep\n\n Returns\n -------\n x : object\n The original value\n \"\"\"\n if sleep:\n time.sleep(sleep)\n return x\n\n\ndef terminate_self():\n \"\"\"Testing function to terminate the process.\"\"\"\n sys.exit(-1)\n\n\ntvm._ffi._init_api(\"testing\", __name__)\n",
"# 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.\nimport tvm\nfrom tvm import te\nimport numpy as np\nimport tvm.testing\nfrom tvm.topi.math import cast\n\n\ndef test_for():\n ib = tvm.tir.ir_builder.create()\n n = te.size_var(\"n\")\n A = ib.allocate(\"float32\", n, name=\"A\", scope=\"global\")\n with ib.for_range(0, n, name=\"i\") as i:\n A[i] = A[i] + 1\n with ib.for_range(0, 10, name=\"j\") as j:\n A[j] = A[j] + 2\n\n body = ib.get()\n assert isinstance(body, tvm.tir.AttrStmt)\n body = body.body\n assert isinstance(body, tvm.tir.Allocate)\n body = body.body\n assert isinstance(body, tvm.tir.For)\n body = body.body\n assert isinstance(body, tvm.tir.SeqStmt)\n assert isinstance(body[1], tvm.tir.For)\n\n\ndef test_if():\n ib = tvm.tir.ir_builder.create()\n n = te.size_var(\"n\")\n A = ib.pointer(\"float32\", name=\"A\")\n tmod = tvm.tir.truncmod\n with ib.for_range(0, n, name=\"i\") as i:\n with ib.if_scope(tmod(i, 2) == 0):\n A[i] = A[i] + 1\n with ib.else_scope():\n A[0] = A[i] + 2\n\n body = ib.get()\n assert A == A\n assert isinstance(body, tvm.tir.For)\n body = body.body\n assert isinstance(body, tvm.tir.IfThenElse)\n assert isinstance(body.condition, tvm.tir.EQ)\n assert isinstance(body.then_case.index, tvm.tir.Var)\n assert body.else_case.index.value == 0\n\n\ndef test_prefetch():\n A = tvm.tir.decl_buffer((10, 20), name=\"A\")\n ib = tvm.tir.ir_builder.create()\n n = te.size_var(\"n\")\n\n with ib.for_range(0, n, name=\"i\") as i:\n ib.emit(\n tvm.tir.Prefetch(\n A, [tvm.ir.Range.from_min_extent(i + 1, 2), tvm.ir.Range.from_min_extent(0, 20)]\n )\n )\n body = ib.get()\n assert body.body.bounds[0].extent.value == 2\n\n\ndef test_cpu():\n n = 1024\n dtype = \"float32\"\n A = te.placeholder((n,), name=\"A\")\n B = te.placeholder((n,), name=\"B\")\n\n def test_device_ir(A, B, C):\n n = A.shape[0]\n max_threads = 8\n ib = tvm.tir.ir_builder.create()\n Aptr = ib.buffer_ptr(A)\n Bptr = ib.buffer_ptr(B)\n Cptr = ib.buffer_ptr(C)\n with ib.for_range(0, n, name=\"i\") as i:\n Cptr[i] = Aptr[i] + Bptr[i]\n body = ib.get()\n return body\n\n C = te.extern(\n A.shape,\n [A, B],\n lambda ins, outs: test_device_ir(ins[0], ins[1], outs[0]),\n name=\"vector_add\",\n dtype=dtype,\n )\n s = te.create_schedule(C.op)\n\n def check_target(target):\n if not tvm.testing.device_enabled(target):\n return\n # build and invoke the kernel.\n fadd = tvm.build(s, [A, B, C], target)\n dev = tvm.device(target, 0)\n # launch the kernel.\n a = tvm.nd.array(np.random.uniform(size=n).astype(A.dtype), dev)\n b = tvm.nd.array(np.random.uniform(size=n).astype(B.dtype), dev)\n c = tvm.nd.array(np.zeros(n, dtype=C.dtype), dev)\n fadd(a, b, c)\n tvm.testing.assert_allclose(c.numpy(), a.numpy() + b.numpy())\n\n check_target(\"llvm\")\n\n\[email protected]_gpu\ndef test_gpu():\n n = te.size_var(\"n\")\n dtype = \"float32\"\n A = te.placeholder((n,), name=\"A\")\n B = te.placeholder((n,), name=\"B\")\n idxd = tvm.tir.indexdiv\n\n def test_device_ir(A, B, C):\n n = A.shape[0]\n max_threads = 32\n ib = tvm.tir.ir_builder.create()\n bx = te.thread_axis(\"blockIdx.x\")\n tx = te.thread_axis(\"threadIdx.x\")\n ib.scope_attr(bx, \"thread_extent\", idxd(n + max_threads - 1, max_threads))\n ib.scope_attr(tx, \"thread_extent\", max_threads)\n idx = bx.var * max_threads + tx.var\n Aptr = ib.buffer_ptr(A)\n Bptr = ib.buffer_ptr(B)\n Cptr = ib.buffer_ptr(C)\n with ib.if_scope(ib.likely(idx < n)):\n Cptr[idx] = Aptr[idx] + Bptr[idx]\n body = ib.get()\n return body\n\n C = te.extern(\n A.shape,\n [A, B],\n lambda ins, outs: test_device_ir(ins[0], ins[1], outs[0]),\n name=\"vector_add\",\n dtype=dtype,\n )\n s = te.create_schedule(C.op)\n bounds = tvm.te.schedule.InferBound(s)\n stmt = tvm.te.schedule.ScheduleOps(s, bounds)\n\n def check_target(target):\n n = 1024\n if not tvm.testing.device_enabled(target):\n return\n # build and invoke the kernel.\n fadd = tvm.build(s, [A, B, C], target)\n dev = tvm.device(target, 0)\n # launch the kernel.\n a = tvm.nd.array(np.random.uniform(size=n).astype(A.dtype), dev)\n b = tvm.nd.array(np.random.uniform(size=n).astype(B.dtype), dev)\n c = tvm.nd.array(np.zeros(n, dtype=C.dtype), dev)\n fadd(a, b, c)\n tvm.testing.assert_allclose(c.numpy(), a.numpy() + b.numpy())\n\n check_target(\"opencl\")\n check_target(\"cuda\")\n\n\ndef test_while_vectorize():\n \"\"\"Test while loop + vectorized inner loop\"\"\"\n\n n = 64\n num_iter = 10\n\n def test_ir(A, B, C):\n ib = tvm.tir.ir_builder.create()\n n = C.shape[0]\n A = ib.buffer_ptr(A)\n B = ib.buffer_ptr(B)\n C = ib.buffer_ptr(C)\n i = ib.allocate(\"int32\", (1,), name=\"i\", scope=\"local\")\n i[0] = 0\n\n with ib.for_range(0, n) as j:\n C[j] = 0.0\n\n with ib.while_loop(i[0] < num_iter):\n with ib.for_range(0, n, kind=\"vectorize\") as j:\n C[j] += A[j] + B[j]\n i[0] += 1\n\n return ib.get()\n\n def check_target(target, ir):\n dtype = \"float32\"\n A = te.placeholder((n,), name=\"A\", dtype=dtype)\n B = te.placeholder((n,), name=\"B\", dtype=dtype)\n\n C = te.extern(\n (n,),\n [A, B],\n lambda ins, outs: ir(ins[0], ins[1], outs[0]),\n name=\"while_vectorize\",\n dtype=dtype,\n )\n s = te.create_schedule(C.op)\n\n with tvm.transform.PassContext(opt_level=3):\n func = tvm.build(s, [A, B, C], target)\n\n dev = tvm.device(target, 0)\n a_np = np.random.uniform(size=n).astype(A.dtype)\n b_np = np.random.uniform(size=n).astype(B.dtype)\n a = tvm.nd.array(a_np, dev)\n b = tvm.nd.array(b_np, dev)\n c = tvm.nd.array(np.zeros(n, dtype=C.dtype), dev)\n func(a, b, c)\n ref = num_iter * (a_np + b_np)\n tvm.testing.assert_allclose(c.numpy(), ref, rtol=1e-5, atol=1e-5)\n\n check_target(\"llvm\", test_ir)\n\n\ndef test_while_collatz():\n \"\"\"Test while loop + if\"\"\"\n\n def collatz_ref(n):\n a = n\n i = 0\n while a > 1:\n if a % 2 == 1:\n a = 3 * a + 1\n else:\n a = a >> 1\n i += 1\n return i\n\n def collatz(ib, n, C):\n i = ib.allocate(\"int32\", (1,), name=\"i\", scope=\"local\")\n a = ib.allocate(\"int32\", (1,), name=\"a\", scope=\"local\")\n i[0] = 0\n a[0] = n\n with ib.while_loop(a[0] > 1):\n with ib.if_scope(tvm.tir.floormod(a[0], 2) == 1):\n a[0] = 3 * a[0] + 1\n with ib.else_scope():\n a[0] = a[0] >> 1\n i[0] += 1\n\n C[n] = i[0]\n\n def collatz_ir_cpu(C):\n ib = tvm.tir.ir_builder.create()\n n = C.shape[0]\n C = ib.buffer_ptr(C)\n\n with ib.for_range(0, n, name=\"i\", kind=\"parallel\") as i:\n collatz(ib, i, C)\n\n body = ib.get()\n\n return body\n\n n = 30\n\n def check_target(target, ir):\n C = te.extern(\n (n,),\n [],\n lambda ins, outs: ir(outs[0]),\n name=\"collatz\",\n dtype=\"int32\",\n )\n s = te.create_schedule(C.op)\n\n with tvm.transform.PassContext(opt_level=3):\n func = tvm.build(s, [C], target)\n\n dev = tvm.device(target, 0)\n c = tvm.nd.array(np.zeros(n, dtype=C.dtype), dev)\n func(c)\n ref = np.array([collatz_ref(i) for i in range(n)])\n tvm.testing.assert_allclose(c.numpy(), ref)\n\n check_target(\"llvm\", collatz_ir_cpu)\n\n\ndef test_while_mandel():\n n = 160\n shape = (n * 2, n)\n t = 300\n\n def mandel_ref():\n def complex_sqr(z):\n return np.array([z[0] ** 2 - z[1] ** 2, z[1] * z[0] * 2])\n\n pixels = np.zeros(shape)\n\n for i in range(pixels.shape[0]):\n for j in range(pixels.shape[1]):\n c = np.array([-0.8, np.cos(t) * 0.2])\n z = np.array([i / n - 1, j / n - 0.5]) * 2\n iterations = 0\n\n while np.linalg.norm(z) < 20 and iterations < 50:\n z = complex_sqr(z) + c\n iterations += 1\n\n pixels[i, j] = 1 - iterations * 0.02\n\n return pixels\n\n def mandel(ib, i, j, pixels):\n z = ib.allocate(\"float32\", (2,), name=\"z\", scope=\"local\")\n tmp = ib.allocate(\"float32\", (1,), name=\"tmp\", scope=\"local\")\n iterations = ib.allocate(\"int32\", (1,), name=\"iterations\", scope=\"local\")\n\n z[0] = (i / float(n) - 1) * 2\n z[1] = (j / float(n) - 0.5) * 2\n iterations[0] = 0\n c = [-0.8, float(np.cos(t)) * 0.2]\n\n def norm(z):\n return tvm.tir.sqrt(z[0] * z[0] + z[1] * z[1])\n\n with ib.while_loop(tvm.tir.all(norm(z) < 20, iterations[0] < 50)):\n tmp[0] = z[0]\n z[0] = z[0] * z[0] - z[1] * z[1] + c[0]\n z[1] = z[1] * tmp[0] * 2 + c[1]\n iterations[0] += 1\n\n pixels[i, j] = 1 - iterations[0] * 0.02\n\n def mandel_ir_cpu(C):\n ib = tvm.tir.ir_builder.create()\n ny = C.shape[0]\n nx = C.shape[1]\n C = ib.buffer_ptr(C)\n\n with ib.for_range(0, ny, name=\"i\", kind=\"parallel\") as i:\n with ib.for_range(0, nx, name=\"j\") as j:\n mandel(ib, i, j, C)\n\n body = ib.get()\n\n return body\n\n def mandel_ir_gpu(C):\n ib = tvm.tir.ir_builder.create()\n ny = C.shape[0]\n nx = C.shape[1]\n C = ib.buffer_ptr(C)\n\n bx = te.thread_axis(\"blockIdx.x\")\n tx = te.thread_axis(\"threadIdx.x\")\n by = te.thread_axis(\"blockIdx.y\")\n ty = te.thread_axis(\"threadIdx.y\")\n\n max_threads = 16\n ib.scope_attr(bx, \"thread_extent\", tvm.tir.indexdiv(nx + max_threads - 1, max_threads))\n ib.scope_attr(tx, \"thread_extent\", max_threads)\n ib.scope_attr(by, \"thread_extent\", tvm.tir.indexdiv(ny + max_threads - 1, max_threads))\n ib.scope_attr(ty, \"thread_extent\", max_threads)\n\n tidx = bx * max_threads + tx\n tidy = by * max_threads + ty\n\n with ib.if_scope(tvm.tir.all(tidx < nx, tidy < ny)):\n mandel(ib, tidy, tidx, C)\n\n body = ib.get()\n\n return body\n\n ref = mandel_ref()\n\n def check_target(target, ir):\n if not tvm.testing.device_enabled(target):\n return\n\n C = te.extern(\n shape,\n [],\n lambda ins, outs: ir(outs[0]),\n name=\"mandel_ir\",\n dtype=\"float32\",\n )\n s = te.create_schedule(C.op)\n\n with tvm.transform.PassContext(opt_level=3):\n func = tvm.build(s, [C], target)\n\n dev = tvm.device(target, 0)\n c = tvm.nd.array(np.zeros(shape, dtype=C.dtype), dev)\n func(c)\n tvm.testing.assert_allclose(c.numpy(), ref, rtol=1e-5, atol=1e-5)\n\n check_target(\"llvm\", mandel_ir_cpu)\n check_target(\"npvtx\", mandel_ir_gpu)\n check_target(\"cuda\", mandel_ir_gpu)\n check_target(\"vulkan\", mandel_ir_gpu)\n\n\ndef test_while_binary_search():\n def binary_search(ib, n, i, Aptr, Bptr, Cptr):\n lo = ib.allocate(\"int32\", (1,), name=\"lo\", scope=\"local\")\n hi = ib.allocate(\"int32\", (1,), name=\"hi\", scope=\"local\")\n\n lo[0] = 0\n hi[0] = n\n v = Bptr[i]\n\n with ib.while_loop(lo[0] < hi[0]):\n mid = lo[0] + (hi[0] - lo[0] >> 1)\n with ib.if_scope(Aptr[mid] < v):\n lo[0] = mid + 1\n with ib.else_scope():\n hi[0] = mid\n\n Cptr[i] = lo[0]\n\n def searchsorted_ir_cpu(A, B, C, n):\n ib = tvm.tir.ir_builder.create()\n Aptr = ib.buffer_ptr(A)\n Bptr = ib.buffer_ptr(B)\n Cptr = ib.buffer_ptr(C)\n\n with ib.for_range(0, n, name=\"i\", kind=\"parallel\") as i:\n binary_search(ib, n, i, Aptr, Bptr, Cptr)\n\n body = ib.get()\n\n return body\n\n def searchsorted_ir_gpu(A, B, C, n):\n ib = tvm.tir.ir_builder.create()\n Aptr = ib.buffer_ptr(A)\n Bptr = ib.buffer_ptr(B)\n Cptr = ib.buffer_ptr(C)\n\n bx = te.thread_axis(\"blockIdx.x\")\n tx = te.thread_axis(\"threadIdx.x\")\n max_threads = 32\n ib.scope_attr(bx, \"thread_extent\", tvm.tir.indexdiv(n + max_threads - 1, max_threads))\n ib.scope_attr(tx, \"thread_extent\", max_threads)\n tid = bx * max_threads + tx\n\n with ib.if_scope(tid < n):\n binary_search(ib, n, tid, Aptr, Bptr, Cptr)\n\n body = ib.get()\n\n return body\n\n n = 1024\n dtype = \"float32\"\n A = te.placeholder((n,), name=\"A\", dtype=dtype)\n B = te.placeholder((n,), name=\"B\", dtype=dtype)\n\n def check_target(target, ir):\n if not tvm.testing.device_enabled(target):\n return\n\n C = te.extern(\n A.shape,\n [A, B],\n lambda ins, outs: ir(ins[0], ins[1], outs[0], n),\n name=\"searchsorted_ir\",\n dtype=\"int32\",\n )\n s = te.create_schedule(C.op)\n\n with tvm.transform.PassContext(opt_level=3):\n func = tvm.build(s, [A, B, C], target)\n\n dev = tvm.device(target, 0)\n a_np = np.random.uniform(size=n).astype(A.dtype)\n b_np = np.random.uniform(size=n).astype(B.dtype)\n a_np = np.sort(a_np)\n a = tvm.nd.array(a_np, dev)\n b = tvm.nd.array(b_np, dev)\n c = tvm.nd.array(np.zeros(n, dtype=C.dtype), dev)\n func(a, b, c)\n ref = np.searchsorted(a_np, b_np)\n tvm.testing.assert_allclose(c.numpy(), ref)\n\n check_target(\"llvm\", searchsorted_ir_cpu)\n check_target(\"cuda\", searchsorted_ir_gpu)\n check_target(\"nvptx\", searchsorted_ir_gpu)\n check_target(\"vulkan\", searchsorted_ir_gpu)\n\n\[email protected]_gpu\ndef test_dyn_shared():\n n = te.size_var(\"n\")\n dtype = \"float32\"\n A = te.placeholder((n,), name=\"A\")\n\n def test_device_ir(A, B):\n n = A.shape[0]\n ib = tvm.tir.ir_builder.create()\n\n tx = te.thread_axis(\"threadIdx.x\")\n ib.scope_attr(tx, \"thread_extent\", n)\n\n temp = ib.allocate(dtype, (n,), scope=\"shared.dyn\") # n is symbolic size\n\n Aptr = ib.buffer_ptr(A)\n Bptr = ib.buffer_ptr(B)\n\n temp[tx] = Aptr[tx]\n depth = tvm.tir.log2(cast(n, \"float32\"))\n\n with ib.for_range(0, depth) as i:\n ib.emit(tvm.tir.Call(None, \"tir.tvm_storage_sync\", tvm.runtime.convert([\"shared\"])))\n d = n >> (i + 1)\n with ib.if_scope(tx < d):\n temp[tx] += temp[tx + d]\n\n Bptr[0] = temp[0]\n return ib.get()\n\n B = te.extern(\n (1,),\n [A],\n lambda ins, outs: test_device_ir(ins[0], outs[0]),\n name=\"reduce\",\n dtype=dtype,\n )\n s = te.create_schedule(B.op)\n\n def check_target(target):\n if not tvm.testing.device_enabled(target):\n return\n\n freduce = tvm.build(s, [A, B], target)\n dev = tvm.device(target, 0)\n\n for n in [512, 1024]:\n a = tvm.nd.array(np.random.uniform(size=n).astype(A.dtype), dev)\n b = tvm.nd.array(np.zeros(1, dtype=B.dtype), dev)\n freduce(a, b)\n tvm.testing.assert_allclose(b.numpy()[0], np.sum(a.numpy()), 1e-4, 1e-4)\n\n for target in [\"cuda\", \"nvptx\"]:\n check_target(target)\n\n\nif __name__ == \"__main__\":\n test_prefetch()\n test_if()\n test_for()\n test_cpu()\n test_gpu()\n test_while_vectorize()\n test_while_collatz()\n test_while_mandel()\n test_while_binary_search()\n test_dyn_shared()\n"
]
| [
[
"torch.cat",
"torch.nn.LeakyReLU",
"torch.nn.MaxPool3d",
"torch.log10",
"torch.nn.MaxPool1d",
"numpy.random.random",
"torch.index_put",
"torch.exp",
"torch.log1p",
"torch.nn.AvgPool2d",
"torch.nn.ConvTranspose2d",
"torch.argsort",
"torch.rsub",
"torch.isfinite",
"torch.jit.load",
"torch.nn.init.normal_",
"torch.tensor",
"torch.index_select",
"torch.asin",
"torch.nn.functional.one_hot",
"torch.min",
"torch.nn.ReplicationPad2d",
"torch.nn.Threshold",
"torch.nn.GroupNorm",
"torch.clamp",
"torch.full_like",
"torch.cuda.empty_cache",
"torch.nn.functional.max_pool1d",
"torch.nn.functional.linear",
"torch.nn.Softplus",
"torch.nn.ReplicationPad1d",
"torch.sinh",
"torch.nn.GELU",
"torch.argmax",
"torch.cumsum",
"torch.nn.LogSoftmax",
"torch.sin",
"torch.split",
"torch.nn.Upsample",
"torch.nn.ReflectionPad1d",
"torch.nn.AdaptiveMaxPool3d",
"torch.nn.Dropout2d",
"torch.nn.Linear",
"torch.isnan",
"torch.logical_xor",
"numpy.mean",
"torch.meshgrid",
"scipy.stats.t.ppf",
"torch.topk",
"torch.nn.functional.avg_pool3d",
"torch.rsqrt",
"torch.nn.Softmax",
"torch.logical_not",
"torch.randint",
"torch.jit.save",
"torch.nn.Conv3d",
"torch.zeros_like",
"torch.nn.ConvTranspose3d",
"torch.neg",
"torch.zeros",
"torch.nonzero",
"numpy.array",
"numpy.zeros",
"torch.max",
"torch.bitwise_xor",
"torch.nn.ReLU",
"torch.nn.Dropout3d",
"torch.log",
"torch.matmul",
"torch.rand",
"torch.unique",
"torch.nn.Sigmoid",
"torch.add",
"torch.nn.ReplicationPad3d",
"torch.nn.functional.avg_pool1d",
"torch.nn.PReLU",
"torch.scatter",
"torch.nn.ConstantPad3d",
"torch.flatten",
"torch.floor",
"torch.nn.functional.max_pool2d",
"torch.nn.AdaptiveAvgPool2d",
"torch.acos",
"torch.stack",
"torch.nn.CELU",
"torch.nn.SELU",
"torch.nn.BatchNorm2d",
"torch.logical_and",
"torch.narrow",
"torch.nn.Hardswish",
"torch.nn.AvgPool3d",
"torch.nn.BatchNorm3d",
"torch.where",
"torch.nn.Hardsigmoid",
"torch.trunc",
"torch.nn.Conv1d",
"torch.scatter_add",
"torch.norm",
"torch.unbind",
"torch.ceil",
"torch.jit.script",
"torch.take",
"torch.masked_select",
"torch.numel",
"torch.true_divide",
"torch.bitwise_not",
"numpy.std",
"torch.nn.Conv2d",
"torch.isinf",
"torch.tan",
"torch.nn.Transformer",
"torch.no_grad",
"torch.atan",
"torch.erf",
"torch.sign",
"torch.nn.ZeroPad2d",
"torch.tanh",
"torch.set_grad_enabled",
"torch.nn.Embedding",
"torch.nn.ELU",
"torch.bincount",
"torch.round",
"torch.ones",
"torch.nn.ConstantPad2d",
"torch.masked_fill",
"torch.cuda.is_available",
"torch.LongTensor",
"torch.jit.trace",
"torch.nn.functional.pad",
"torch.nn.functional.max_pool3d",
"torch.nn.functional.avg_pool2d",
"torch.nn.ConvTranspose1d",
"torch.nn.LayerNorm",
"torch.sqrt",
"torch.nn.MaxPool2d",
"torch.gather",
"torch.nn.AvgPool1d",
"torch.nn.ReflectionPad2d",
"numpy.sqrt",
"torch.nn.Hardtanh",
"torch.cos",
"torch.addcdiv",
"torch.clamp_",
"torch.cosh",
"torch.linspace",
"torch.nn.Softsign",
"torch.nn.AlphaDropout",
"torch.nn.PixelShuffle",
"torch.full",
"torch.nn.InstanceNorm2d",
"torch.log2",
"torch.nn.AdaptiveAvgPool3d",
"torch.sort",
"torch.addcmul",
"torch.nn.NLLLoss",
"torch.nn.Dropout",
"torch.arange",
"torch.nn.functional.interpolate",
"torch.logsumexp",
"numpy.random.uniform",
"torch.is_floating_point",
"torch.nn.LogSigmoid",
"torch.ones_like",
"torch.nn.InstanceNorm3d",
"torch.randn"
],
[
"numpy.testing.assert_allclose",
"numpy.zeros_like",
"numpy.sum",
"numpy.unravel_index",
"numpy.prod",
"numpy.abs",
"numpy.isfinite",
"numpy.all",
"numpy.asanyarray",
"numpy.argwhere"
],
[
"numpy.array",
"numpy.linalg.norm",
"numpy.zeros",
"numpy.random.uniform",
"numpy.sort",
"numpy.cos",
"numpy.searchsorted"
]
]
|
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.zeros",
"torch.cat",
"torch.nn.Softmax",
"torch.nn.ModuleDict",
"torch.bmm",
"torch.tensor",
"torch.eye",
"torch.zeros_like",
"torch.sum"
]
]
|
lightbooster/models | [
"833900b085a353712010c26c66ae9111246b5ac7",
"833900b085a353712010c26c66ae9111246b5ac7"
]
| [
"official/nlp/modeling/models/bert_classifier_test.py",
"official/nlp/modeling/layers/text_layers_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",
"# 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 bert.text_layers.\"\"\"\n\nimport os\nimport tempfile\n\nimport numpy as np\nimport tensorflow as tf\n\nfrom sentencepiece import SentencePieceTrainer\nfrom official.nlp.modeling.layers import text_layers\n\n\nclass RoundRobinTruncatorTest(tf.test.TestCase):\n\n def test_correct_outputs(self):\n\n def test_input(start, lengths):\n return tf.ragged.constant([[start + 10*j + i for i in range(length)]\n for j, length in enumerate(lengths)],\n dtype=tf.int32)\n\n # Single segment.\n single_input = test_input(11, [4, 5, 6])\n expected_single_output = tf.ragged.constant(\n [[11, 12, 13, 14],\n [21, 22, 23, 24, 25],\n [31, 32, 33, 34, 35], # Truncated.\n ])\n\n self.assertAllEqual(\n expected_single_output,\n text_layers.round_robin_truncate_inputs(single_input, limit=5))\n # Test wrapping in a singleton list.\n actual_single_list_output = text_layers.round_robin_truncate_inputs(\n [single_input], limit=5)\n self.assertIsInstance(actual_single_list_output, list)\n self.assertAllEqual(expected_single_output, actual_single_list_output[0])\n\n # Two segments.\n input_a = test_input(111, [1, 2, 2, 3, 4, 5])\n input_b = test_input(211, [1, 3, 4, 2, 2, 5])\n expected_a = tf.ragged.constant(\n [[111],\n [121, 122],\n [131, 132],\n [141, 142, 143],\n [151, 152, 153], # Truncated.\n [161, 162, 163], # Truncated.\n ])\n expected_b = tf.ragged.constant(\n [[211],\n [221, 222, 223],\n [231, 232, 233], # Truncated.\n [241, 242],\n [251, 252],\n [261, 262], # Truncated.\n ])\n actual_a, actual_b = text_layers.round_robin_truncate_inputs(\n [input_a, input_b], limit=5)\n self.assertAllEqual(expected_a, actual_a)\n self.assertAllEqual(expected_b, actual_b)\n\n\n# This test covers the in-process behavior of a BertTokenizer layer.\n# For saving, restoring, and the restored behavior (incl. shape inference),\n# see nlp/tools/export_tfhub_lib_test.py.\nclass BertTokenizerTest(tf.test.TestCase):\n\n def _make_vocab_file(self, vocab, filename=\"vocab.txt\"):\n path = os.path.join(\n tempfile.mkdtemp(dir=self.get_temp_dir()), # New subdir each time.\n filename)\n with tf.io.gfile.GFile(path, \"w\") as f:\n f.write(\"\\n\".join(vocab + [\"\"]))\n return path\n\n def test_uncased(self):\n vocab_file = self._make_vocab_file(\n [\"[PAD]\", \"[UNK]\", \"[CLS]\", \"[SEP]\", \"d\", \"##ef\", \"abc\", \"xy\"])\n bert_tokenize = text_layers.BertTokenizer(\n vocab_file=vocab_file, lower_case=True)\n inputs = tf.constant([\"abc def\", \"ABC DEF d\"])\n token_ids = bert_tokenize(inputs)\n self.assertAllEqual(token_ids, tf.ragged.constant([[[6], [4, 5]],\n [[6], [4, 5], [4]]]))\n bert_tokenize.tokenize_with_offsets = True\n token_ids_2, start_offsets, limit_offsets = bert_tokenize(inputs)\n self.assertAllEqual(token_ids, token_ids_2)\n self.assertAllEqual(start_offsets, tf.ragged.constant([[[0], [4, 5]],\n [[0], [4, 5], [8]]]))\n self.assertAllEqual(limit_offsets, tf.ragged.constant([[[3], [5, 7]],\n [[3], [5, 7], [9]]]))\n self.assertEqual(bert_tokenize.vocab_size.numpy(), 8)\n\n # Repeat the above and test that case matters with lower_case=False.\n def test_cased(self):\n vocab_file = self._make_vocab_file(\n [\"[PAD]\", \"[UNK]\", \"[CLS]\", \"[SEP]\", \"d\", \"##ef\", \"abc\", \"ABC\"])\n bert_tokenize = text_layers.BertTokenizer(\n vocab_file=vocab_file, lower_case=False, tokenize_with_offsets=True)\n inputs = tf.constant([\"abc def\", \"ABC DEF\"])\n token_ids, start_offsets, limit_offsets = bert_tokenize(inputs)\n self.assertAllEqual(token_ids, tf.ragged.constant([[[6], [4, 5]],\n [[7], [1]]]))\n self.assertAllEqual(start_offsets, tf.ragged.constant([[[0], [4, 5]],\n [[0], [4]]]))\n self.assertAllEqual(limit_offsets, tf.ragged.constant([[[3], [5, 7]],\n [[3], [7]]]))\n\n def test_special_tokens_complete(self):\n vocab_file = self._make_vocab_file(\n [\"foo\", \"[PAD]\", \"[UNK]\", \"[CLS]\", \"[SEP]\", \"[MASK]\", \"xy\"])\n bert_tokenize = text_layers.BertTokenizer(\n vocab_file=vocab_file, lower_case=True)\n self.assertDictEqual(bert_tokenize.get_special_tokens_dict(),\n dict(padding_id=1,\n start_of_sequence_id=3,\n end_of_segment_id=4,\n mask_id=5,\n vocab_size=7))\n\n def test_special_tokens_partial(self):\n vocab_file = self._make_vocab_file(\n [\"[PAD]\", \"[CLS]\", \"[SEP]\"])\n bert_tokenize = text_layers.BertTokenizer(\n vocab_file=vocab_file, lower_case=True)\n self.assertDictEqual(bert_tokenize.get_special_tokens_dict(),\n dict(padding_id=0,\n start_of_sequence_id=1,\n end_of_segment_id=2,\n vocab_size=3)) # No mask_id,\n\n def test_special_tokens_in_estimator(self):\n \"\"\"Tests getting special tokens without an Eager init context.\"\"\"\n vocab_file = self._make_vocab_file(\n [\"[PAD]\", \"[UNK]\", \"[CLS]\", \"[SEP]\", \"d\", \"##ef\", \"abc\", \"xy\"])\n\n def input_fn():\n with tf.init_scope():\n self.assertFalse(tf.executing_eagerly())\n # Build a preprocessing Model.\n sentences = tf.keras.layers.Input(shape=[], dtype=tf.string)\n bert_tokenizer = text_layers.BertTokenizer(\n vocab_file=vocab_file, lower_case=True)\n special_tokens_dict = bert_tokenizer.get_special_tokens_dict()\n for k, v in special_tokens_dict.items():\n self.assertIsInstance(v, int, \"Unexpected type for {}\".format(k))\n tokens = bert_tokenizer(sentences)\n packed_inputs = text_layers.BertPackInputs(\n 4, special_tokens_dict=special_tokens_dict)(tokens)\n preprocessing = tf.keras.Model(sentences, packed_inputs)\n # Map the dataset.\n ds = tf.data.Dataset.from_tensors(\n (tf.constant([\"abc\", \"DEF\"]), tf.constant([0, 1])))\n ds = ds.map(lambda features, labels: (preprocessing(features), labels))\n return ds\n\n def model_fn(features, labels, mode):\n del labels # Unused.\n return tf.estimator.EstimatorSpec(mode=mode,\n predictions=features[\"input_word_ids\"])\n\n estimator = tf.estimator.Estimator(model_fn=model_fn)\n outputs = list(estimator.predict(input_fn))\n self.assertAllEqual(outputs, np.array([[2, 6, 3, 0],\n [2, 4, 5, 3]]))\n\n\n# This test covers the in-process behavior of a SentencepieceTokenizer layer.\nclass SentencepieceTokenizerTest(tf.test.TestCase):\n\n def setUp(self):\n super().setUp()\n # Make a sentencepiece model.\n tmp_dir = self.get_temp_dir()\n tempfile.mkdtemp(dir=tmp_dir)\n vocab = [\"a\", \"b\", \"c\", \"d\", \"e\", \"abc\", \"def\", \"ABC\", \"DEF\"]\n model_prefix = os.path.join(tmp_dir, \"spm_model\")\n input_text_file_path = os.path.join(tmp_dir, \"train_input.txt\")\n with tf.io.gfile.GFile(input_text_file_path, \"w\") as f:\n f.write(\" \".join(vocab + [\"\\n\"]))\n # Add 7 more tokens: <pad>, <unk>, [CLS], [SEP], [MASK], <s>, </s>.\n full_vocab_size = len(vocab) + 7\n flags = dict(\n model_prefix=model_prefix,\n model_type=\"word\",\n input=input_text_file_path,\n pad_id=0, unk_id=1, control_symbols=\"[CLS],[SEP],[MASK]\",\n vocab_size=full_vocab_size,\n bos_id=full_vocab_size-2, eos_id=full_vocab_size-1)\n SentencePieceTrainer.Train(\n \" \".join([\"--{}={}\".format(k, v) for k, v in flags.items()]))\n self._spm_path = model_prefix + \".model\"\n\n def test_uncased(self):\n sentencepiece_tokenizer = text_layers.SentencepieceTokenizer(\n model_file_path=self._spm_path, lower_case=True, nbest_size=0)\n\n inputs = tf.constant([\"abc def\", \"ABC DEF d\"])\n token_ids = sentencepiece_tokenizer(inputs)\n self.assertAllEqual(\n token_ids,\n tf.ragged.constant([[8, 12], [8, 12, 11]]))\n sentencepiece_tokenizer.tokenize_with_offsets = True\n token_ids_2, start_offsets, limit_offsets = sentencepiece_tokenizer(inputs)\n self.assertAllEqual(token_ids, token_ids_2)\n self.assertAllEqual(\n start_offsets, tf.ragged.constant([[0, 3], [0, 3, 7]]))\n self.assertAllEqual(\n limit_offsets, tf.ragged.constant([[3, 7], [3, 7, 9]]))\n self.assertEqual(sentencepiece_tokenizer.vocab_size.numpy(), 16)\n\n # Repeat the above and test that case matters with lower_case=False.\n def test_cased(self):\n sentencepiece_tokenizer = text_layers.SentencepieceTokenizer(\n model_file_path=self._spm_path,\n lower_case=False,\n nbest_size=0,\n tokenize_with_offsets=False)\n\n inputs = tf.constant([\"abc def\", \"ABC DEF d\"])\n token_ids = sentencepiece_tokenizer(inputs)\n self.assertAllEqual(\n token_ids,\n tf.ragged.constant([[8, 12], [5, 6, 11]]))\n sentencepiece_tokenizer.tokenize_with_offsets = True\n token_ids_2, start_offsets, limit_offsets = sentencepiece_tokenizer(inputs)\n self.assertAllEqual(token_ids, token_ids_2)\n self.assertAllEqual(\n start_offsets,\n tf.ragged.constant([[0, 3], [0, 3, 7]]))\n self.assertAllEqual(\n limit_offsets,\n tf.ragged.constant([[3, 7], [3, 7, 9]]))\n\n def test_special_tokens(self):\n sentencepiece_tokenizer = text_layers.SentencepieceTokenizer(\n model_file_path=self._spm_path, lower_case=True, nbest_size=0)\n self.assertDictEqual(sentencepiece_tokenizer.get_special_tokens_dict(),\n dict(padding_id=0,\n start_of_sequence_id=2,\n end_of_segment_id=3,\n mask_id=4,\n vocab_size=16))\n\n def test_special_tokens_in_estimator(self):\n \"\"\"Tests getting special tokens without an Eager init context.\"\"\"\n\n def input_fn():\n with tf.init_scope():\n self.assertFalse(tf.executing_eagerly())\n # Build a preprocessing Model.\n sentences = tf.keras.layers.Input(shape=[], dtype=tf.string)\n sentencepiece_tokenizer = text_layers.SentencepieceTokenizer(\n model_file_path=self._spm_path, lower_case=True, nbest_size=0)\n special_tokens_dict = sentencepiece_tokenizer.get_special_tokens_dict()\n for k, v in special_tokens_dict.items():\n self.assertIsInstance(v, int, \"Unexpected type for {}\".format(k))\n tokens = sentencepiece_tokenizer(sentences)\n packed_inputs = text_layers.BertPackInputs(\n 4, special_tokens_dict=special_tokens_dict)(tokens)\n preprocessing = tf.keras.Model(sentences, packed_inputs)\n # Map the dataset.\n ds = tf.data.Dataset.from_tensors(\n (tf.constant([\"abc\", \"DEF\"]), tf.constant([0, 1])))\n ds = ds.map(lambda features, labels: (preprocessing(features), labels))\n return ds\n\n def model_fn(features, labels, mode):\n del labels # Unused.\n return tf.estimator.EstimatorSpec(mode=mode,\n predictions=features[\"input_word_ids\"])\n\n estimator = tf.estimator.Estimator(model_fn=model_fn)\n outputs = list(estimator.predict(input_fn))\n self.assertAllEqual(outputs, np.array([[2, 8, 3, 0],\n [2, 12, 3, 0]]))\n\n def test_strip_diacritics(self):\n sentencepiece_tokenizer = text_layers.SentencepieceTokenizer(\n model_file_path=self._spm_path,\n lower_case=True,\n nbest_size=0,\n strip_diacritics=True)\n inputs = tf.constant([\"a b c d e\", \"ă ḅ č ḓ é\"])\n token_ids = sentencepiece_tokenizer(inputs)\n self.assertAllEqual(\n token_ids,\n tf.ragged.constant([[7, 9, 10, 11, 13], [7, 9, 10, 11, 13]]))\n\n def test_fail_on_tokenize_with_offsets_and_strip_diacritics(self):\n # Raise an error in init().\n with self.assertRaises(ValueError):\n text_layers.SentencepieceTokenizer(\n model_file_path=self._spm_path,\n tokenize_with_offsets=True,\n lower_case=True,\n nbest_size=0,\n strip_diacritics=True)\n\n sentencepiece_tokenizer = text_layers.SentencepieceTokenizer(\n model_file_path=self._spm_path,\n lower_case=True,\n nbest_size=0,\n strip_diacritics=True)\n sentencepiece_tokenizer.tokenize_with_offsets = True\n\n # Raise an error in call():\n inputs = tf.constant([\"abc def\", \"ABC DEF d\", \"Äffin\"])\n with self.assertRaises(ValueError):\n sentencepiece_tokenizer(inputs)\n\n def test_serialize_deserialize(self):\n self.skipTest(\"b/170480226\")\n sentencepiece_tokenizer = text_layers.SentencepieceTokenizer(\n model_file_path=self._spm_path,\n lower_case=False,\n nbest_size=0,\n tokenize_with_offsets=False,\n name=\"sentencepiece_tokenizer_layer\")\n config = sentencepiece_tokenizer.get_config()\n new_tokenizer = text_layers.SentencepieceTokenizer.from_config(config)\n self.assertEqual(config, new_tokenizer.get_config())\n inputs = tf.constant([\"abc def\", \"ABC DEF d\"])\n token_ids = sentencepiece_tokenizer(inputs)\n token_ids_2 = new_tokenizer(inputs)\n self.assertAllEqual(token_ids, token_ids_2)\n\n # TODO(b/170480226): Remove once tf_hub_export_lib_test.py covers saving.\n def test_saving(self):\n sentencepiece_tokenizer = text_layers.SentencepieceTokenizer(\n model_file_path=self._spm_path, lower_case=True, nbest_size=0)\n inputs = tf.keras.layers.Input([], dtype=tf.string)\n outputs = sentencepiece_tokenizer(inputs)\n model = tf.keras.Model(inputs, outputs)\n export_path = tempfile.mkdtemp(dir=self.get_temp_dir())\n model.save(export_path, signatures={})\n\n\nclass BertPackInputsTest(tf.test.TestCase):\n\n def test_round_robin_correct_outputs(self):\n bpi = text_layers.BertPackInputs(\n 10,\n start_of_sequence_id=1001,\n end_of_segment_id=1002,\n padding_id=999,\n truncator=\"round_robin\")\n # Single input, rank 2.\n bert_inputs = bpi(\n tf.ragged.constant([[11, 12, 13],\n [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]]))\n self.assertAllEqual(\n bert_inputs[\"input_word_ids\"],\n tf.constant([[1001, 11, 12, 13, 1002, 999, 999, 999, 999, 999],\n [1001, 21, 22, 23, 24, 25, 26, 27, 28, 1002]]))\n self.assertAllEqual(\n bert_inputs[\"input_mask\"],\n tf.constant([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0],\n [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]))\n self.assertAllEqual(\n bert_inputs[\"input_type_ids\"],\n tf.constant([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]))\n\n # Two inputs, rank 3. Truncation does not respect word boundaries.\n bert_inputs = bpi([\n tf.ragged.constant([[[111], [112, 113]],\n [[121, 122, 123], [124, 125, 126], [127, 128]]]),\n tf.ragged.constant([[[211, 212], [213]],\n [[221, 222], [223, 224, 225], [226, 227, 228]]])\n ])\n self.assertAllEqual(\n bert_inputs[\"input_word_ids\"],\n tf.constant([[1001, 111, 112, 113, 1002, 211, 212, 213, 1002, 999],\n [1001, 121, 122, 123, 124, 1002, 221, 222, 223, 1002]]))\n self.assertAllEqual(\n bert_inputs[\"input_mask\"],\n tf.constant([[1, 1, 1, 1, 1, 1, 1, 1, 1, 0],\n [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]))\n self.assertAllEqual(\n bert_inputs[\"input_type_ids\"],\n tf.constant([[0, 0, 0, 0, 0, 1, 1, 1, 1, 0],\n [0, 0, 0, 0, 0, 0, 1, 1, 1, 1]]))\n\n # Three inputs has not been supported for round_robin so far.\n with self.assertRaisesRegex(ValueError, \"Must pass 1 or 2 inputs\"):\n bert_inputs = bpi([\n tf.ragged.constant([[[111], [112, 113]],\n [[121, 122, 123], [124, 125, 126], [127, 128]]]),\n tf.ragged.constant([[[211, 212], [213]],\n [[221, 222], [223, 224, 225], [226, 227, 228]]]),\n tf.ragged.constant([[[311, 312], [313]],\n [[321, 322], [323, 324, 325], [326, 327, 328]]])\n ])\n\n def test_waterfall_correct_outputs(self):\n bpi = text_layers.BertPackInputs(\n 10,\n start_of_sequence_id=1001,\n end_of_segment_id=1002,\n padding_id=999,\n truncator=\"waterfall\")\n # Single input, rank 2.\n bert_inputs = bpi(\n tf.ragged.constant([[11, 12, 13],\n [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]]))\n self.assertAllEqual(\n bert_inputs[\"input_word_ids\"],\n tf.constant([[1001, 11, 12, 13, 1002, 999, 999, 999, 999, 999],\n [1001, 21, 22, 23, 24, 25, 26, 27, 28, 1002]]))\n self.assertAllEqual(\n bert_inputs[\"input_mask\"],\n tf.constant([[1, 1, 1, 1, 1, 0, 0, 0, 0, 0],\n [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]))\n self.assertAllEqual(\n bert_inputs[\"input_type_ids\"],\n tf.constant([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]))\n\n # Two inputs, rank 3. Truncation does not respect word boundaries.\n bert_inputs = bpi([\n tf.ragged.constant([[[111], [112, 113]],\n [[121, 122, 123], [124, 125, 126], [127, 128]]]),\n tf.ragged.constant([[[211, 212], [213]],\n [[221, 222], [223, 224, 225], [226, 227, 228]]])\n ])\n self.assertAllEqual(\n bert_inputs[\"input_word_ids\"],\n tf.constant([[1001, 111, 112, 113, 1002, 211, 212, 213, 1002, 999],\n [1001, 121, 122, 123, 124, 125, 126, 127, 1002, 1002]]))\n self.assertAllEqual(\n bert_inputs[\"input_mask\"],\n tf.constant([[1, 1, 1, 1, 1, 1, 1, 1, 1, 0],\n [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]))\n self.assertAllEqual(\n bert_inputs[\"input_type_ids\"],\n tf.constant([[0, 0, 0, 0, 0, 1, 1, 1, 1, 0],\n [0, 0, 0, 0, 0, 0, 0, 0, 0, 1]]))\n\n # Three inputs, rank 3. Truncation does not respect word boundaries.\n bert_inputs = bpi([\n tf.ragged.constant([[[111], [112, 113]],\n [[121, 122, 123], [124, 125, 126], [127, 128]]]),\n tf.ragged.constant([[[211], [212]],\n [[221, 222], [223, 224, 225], [226, 227, 228]]]),\n tf.ragged.constant([[[311, 312], [313]],\n [[321, 322], [323, 324, 325], [326, 327]]])\n ])\n self.assertAllEqual(\n bert_inputs[\"input_word_ids\"],\n tf.constant([[1001, 111, 112, 113, 1002, 211, 212, 1002, 311, 1002],\n [1001, 121, 122, 123, 124, 125, 126, 1002, 1002, 1002]]))\n self.assertAllEqual(\n bert_inputs[\"input_mask\"],\n tf.constant([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1],\n [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]))\n self.assertAllEqual(\n bert_inputs[\"input_type_ids\"],\n tf.constant([[0, 0, 0, 0, 0, 1, 1, 1, 2, 2],\n [0, 0, 0, 0, 0, 0, 0, 0, 1, 2]]))\n\n def test_special_tokens_dict(self):\n special_tokens_dict = dict(start_of_sequence_id=1001,\n end_of_segment_id=1002,\n padding_id=999,\n extraneous_key=666)\n bpi = text_layers.BertPackInputs(10,\n special_tokens_dict=special_tokens_dict)\n bert_inputs = bpi(\n tf.ragged.constant([[11, 12, 13],\n [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]]))\n self.assertAllEqual(\n bert_inputs[\"input_word_ids\"],\n tf.constant([[1001, 11, 12, 13, 1002, 999, 999, 999, 999, 999],\n [1001, 21, 22, 23, 24, 25, 26, 27, 28, 1002]]))\n\n\nif __name__ == \"__main__\":\n tf.test.main()\n"
]
| [
[
"tensorflow.constant",
"tensorflow.keras.Input",
"tensorflow.test.main"
],
[
"tensorflow.init_scope",
"tensorflow.io.gfile.GFile",
"tensorflow.estimator.EstimatorSpec",
"numpy.array",
"tensorflow.keras.layers.Input",
"tensorflow.constant",
"tensorflow.keras.Model",
"tensorflow.executing_eagerly",
"tensorflow.test.main",
"tensorflow.estimator.Estimator",
"tensorflow.ragged.constant"
]
]
|
MathMachado/tensorflow | [
"56afda20b15f234c23e8393f7e337e7dd2659c2d",
"56afda20b15f234c23e8393f7e337e7dd2659c2d",
"56afda20b15f234c23e8393f7e337e7dd2659c2d",
"56afda20b15f234c23e8393f7e337e7dd2659c2d"
]
| [
"tensorflow/python/ops/math_grad.py",
"tensorflow/python/debug/cli/analyzer_cli_test.py",
"tensorflow/examples/speech_commands/input_data_test.py",
"tensorflow/contrib/distributions/python/ops/logistic.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",
"# Copyright 2016 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 of the Analyzer CLI Backend.\"\"\"\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\nimport shutil\nimport tempfile\n\nimport numpy as np\nfrom six.moves import xrange # pylint: disable=redefined-builtin\n\nfrom tensorflow.core.protobuf import config_pb2\nfrom tensorflow.core.protobuf import rewriter_config_pb2\nfrom tensorflow.python.client import session\nfrom tensorflow.python.debug.cli import analyzer_cli\nfrom tensorflow.python.debug.cli import cli_config\nfrom tensorflow.python.debug.cli import cli_shared\nfrom tensorflow.python.debug.cli import cli_test_utils\nfrom tensorflow.python.debug.cli import command_parser\nfrom tensorflow.python.debug.cli import debugger_cli_common\nfrom tensorflow.python.debug.lib import debug_data\nfrom tensorflow.python.debug.lib import debug_utils\nfrom tensorflow.python.debug.lib import source_utils\nfrom tensorflow.python.framework import constant_op\nfrom tensorflow.python.framework import test_util\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import control_flow_ops\nfrom tensorflow.python.ops import math_ops\nfrom tensorflow.python.ops import variables\nfrom tensorflow.python.platform import googletest\nfrom tensorflow.python.platform import test\nfrom tensorflow.python.util import tf_inspect\n\n\n# Helper function to accommodate MKL-enabled TensorFlow:\n# MatMul op is supported by MKL and its name is prefixed with \"_Mkl\" during the\n# MKL graph rewrite pass.\ndef _matmul_op_name():\n return \"_MklMatMul\" if test_util.IsMklEnabled() else \"MatMul\"\n\n\ndef _cli_config_from_temp_file():\n return cli_config.CLIConfig(\n config_file_path=os.path.join(tempfile.mkdtemp(), \".tfdbg_config\"))\n\n\ndef no_rewrite_session_config():\n rewriter_config = rewriter_config_pb2.RewriterConfig(\n disable_model_pruning=True,\n constant_folding=rewriter_config_pb2.RewriterConfig.OFF,\n arithmetic_optimization=rewriter_config_pb2.RewriterConfig.OFF,\n dependency_optimization=rewriter_config_pb2.RewriterConfig.OFF,\n pin_to_host_optimization=rewriter_config_pb2.RewriterConfig.OFF)\n\n graph_options = config_pb2.GraphOptions(rewrite_options=rewriter_config)\n return config_pb2.ConfigProto(graph_options=graph_options)\n\n\ndef line_number_above():\n return tf_inspect.stack()[1][2] - 1\n\n\ndef parse_op_and_node(line):\n \"\"\"Parse a line containing an op node followed by a node name.\n\n For example, if the line is\n \" [Variable] hidden/weights\",\n this function will return (\"Variable\", \"hidden/weights\")\n\n Args:\n line: The line to be parsed, as a str.\n\n Returns:\n Name of the parsed op type.\n Name of the parsed node.\n \"\"\"\n\n op_type = line.strip().split(\" \")[0].replace(\"[\", \"\").replace(\"]\", \"\")\n\n # Not using [-1], to tolerate any other items that might be present behind\n # the node name.\n node_name = line.strip().split(\" \")[1]\n\n return op_type, node_name\n\n\ndef assert_column_header_command_shortcut(tst,\n command,\n reverse,\n node_name_regex,\n op_type_regex,\n tensor_filter_name):\n tst.assertFalse(reverse and \"-r\" in command)\n tst.assertFalse(not(op_type_regex) and (\"-t %s\" % op_type_regex) in command)\n tst.assertFalse(\n not(node_name_regex) and (\"-t %s\" % node_name_regex) in command)\n tst.assertFalse(\n not(tensor_filter_name) and (\"-t %s\" % tensor_filter_name) in command)\n\n\ndef assert_listed_tensors(tst,\n out,\n expected_tensor_names,\n expected_op_types,\n node_name_regex=None,\n op_type_regex=None,\n tensor_filter_name=None,\n sort_by=\"timestamp\",\n reverse=False):\n \"\"\"Check RichTextLines output for list_tensors commands.\n\n Args:\n tst: A test_util.TensorFlowTestCase instance.\n out: The RichTextLines object to be checked.\n expected_tensor_names: (list of str) Expected tensor names in the list.\n expected_op_types: (list of str) Expected op types of the tensors, in the\n same order as the expected_tensor_names.\n node_name_regex: Optional: node name regex filter.\n op_type_regex: Optional: op type regex filter.\n tensor_filter_name: Optional: name of the tensor filter.\n sort_by: (str) (timestamp | op_type | tensor_name) the field by which the\n tensors in the list are sorted.\n reverse: (bool) whether the sorting is in reverse (i.e., descending) order.\n \"\"\"\n\n line_iter = iter(out.lines)\n attr_segs = out.font_attr_segs\n line_counter = 0\n\n num_dumped_tensors = int(next(line_iter).split(\" \")[0])\n line_counter += 1\n tst.assertGreaterEqual(num_dumped_tensors, len(expected_tensor_names))\n\n if op_type_regex is not None:\n tst.assertEqual(\"Op type regex filter: \\\"%s\\\"\" % op_type_regex,\n next(line_iter))\n line_counter += 1\n\n if node_name_regex is not None:\n tst.assertEqual(\"Node name regex filter: \\\"%s\\\"\" % node_name_regex,\n next(line_iter))\n line_counter += 1\n\n tst.assertEqual(\"\", next(line_iter))\n line_counter += 1\n\n # Verify the column heads \"t (ms)\", \"Op type\" and \"Tensor name\" are present.\n line = next(line_iter)\n tst.assertIn(\"t (ms)\", line)\n tst.assertIn(\"Op type\", line)\n tst.assertIn(\"Tensor name\", line)\n\n # Verify the command shortcuts in the top row.\n attr_segs = out.font_attr_segs[line_counter]\n attr_seg = attr_segs[0]\n tst.assertEqual(0, attr_seg[0])\n tst.assertEqual(len(\"t (ms)\"), attr_seg[1])\n command = attr_seg[2][0].content\n tst.assertIn(\"-s timestamp\", command)\n assert_column_header_command_shortcut(\n tst, command, reverse, node_name_regex, op_type_regex,\n tensor_filter_name)\n tst.assertEqual(\"bold\", attr_seg[2][1])\n\n idx0 = line.index(\"Size\")\n attr_seg = attr_segs[1]\n tst.assertEqual(idx0, attr_seg[0])\n tst.assertEqual(idx0 + len(\"Size (B)\"), attr_seg[1])\n command = attr_seg[2][0].content\n tst.assertIn(\"-s dump_size\", command)\n assert_column_header_command_shortcut(tst, command, reverse, node_name_regex,\n op_type_regex, tensor_filter_name)\n tst.assertEqual(\"bold\", attr_seg[2][1])\n\n idx0 = line.index(\"Op type\")\n attr_seg = attr_segs[2]\n tst.assertEqual(idx0, attr_seg[0])\n tst.assertEqual(idx0 + len(\"Op type\"), attr_seg[1])\n command = attr_seg[2][0].content\n tst.assertIn(\"-s op_type\", command)\n assert_column_header_command_shortcut(\n tst, command, reverse, node_name_regex, op_type_regex,\n tensor_filter_name)\n tst.assertEqual(\"bold\", attr_seg[2][1])\n\n idx0 = line.index(\"Tensor name\")\n attr_seg = attr_segs[3]\n tst.assertEqual(idx0, attr_seg[0])\n tst.assertEqual(idx0 + len(\"Tensor name\"), attr_seg[1])\n command = attr_seg[2][0].content\n tst.assertIn(\"-s tensor_name\", command)\n assert_column_header_command_shortcut(\n tst, command, reverse, node_name_regex, op_type_regex,\n tensor_filter_name)\n tst.assertEqual(\"bold\", attr_seg[2][1])\n\n # Verify the listed tensors and their timestamps.\n tensor_timestamps = []\n dump_sizes_bytes = []\n op_types = []\n tensor_names = []\n for line in line_iter:\n items = line.split(\" \")\n items = [item for item in items if item]\n\n rel_time = float(items[0][1:-1])\n tst.assertGreaterEqual(rel_time, 0.0)\n\n tensor_timestamps.append(rel_time)\n dump_sizes_bytes.append(command_parser.parse_readable_size_str(items[1]))\n op_types.append(items[2])\n tensor_names.append(items[3])\n\n # Verify that the tensors should be listed in ascending order of their\n # timestamps.\n if sort_by == \"timestamp\":\n sorted_timestamps = sorted(tensor_timestamps)\n if reverse:\n sorted_timestamps.reverse()\n tst.assertEqual(sorted_timestamps, tensor_timestamps)\n elif sort_by == \"dump_size\":\n sorted_dump_sizes_bytes = sorted(dump_sizes_bytes)\n if reverse:\n sorted_dump_sizes_bytes.reverse()\n tst.assertEqual(sorted_dump_sizes_bytes, dump_sizes_bytes)\n elif sort_by == \"op_type\":\n sorted_op_types = sorted(op_types)\n if reverse:\n sorted_op_types.reverse()\n tst.assertEqual(sorted_op_types, op_types)\n elif sort_by == \"tensor_name\":\n sorted_tensor_names = sorted(tensor_names)\n if reverse:\n sorted_tensor_names.reverse()\n tst.assertEqual(sorted_tensor_names, tensor_names)\n else:\n tst.fail(\"Invalid value in sort_by: %s\" % sort_by)\n\n # Verify that the tensors are all listed.\n for tensor_name, op_type in zip(expected_tensor_names, expected_op_types):\n tst.assertIn(tensor_name, tensor_names)\n index = tensor_names.index(tensor_name)\n tst.assertEqual(op_type, op_types[index])\n\n\ndef assert_node_attribute_lines(tst,\n out,\n node_name,\n op_type,\n device,\n input_op_type_node_name_pairs,\n ctrl_input_op_type_node_name_pairs,\n recipient_op_type_node_name_pairs,\n ctrl_recipient_op_type_node_name_pairs,\n attr_key_val_pairs=None,\n num_dumped_tensors=None,\n show_stack_trace=False,\n stack_trace_available=False):\n \"\"\"Check RichTextLines output for node_info commands.\n\n Args:\n tst: A test_util.TensorFlowTestCase instance.\n out: The RichTextLines object to be checked.\n node_name: Name of the node.\n op_type: Op type of the node, as a str.\n device: Name of the device on which the node resides.\n input_op_type_node_name_pairs: A list of 2-tuples of op type and node name,\n for the (non-control) inputs to the node.\n ctrl_input_op_type_node_name_pairs: A list of 2-tuples of op type and node\n name, for the control inputs to the node.\n recipient_op_type_node_name_pairs: A list of 2-tuples of op type and node\n name, for the (non-control) output recipients to the node.\n ctrl_recipient_op_type_node_name_pairs: A list of 2-tuples of op type and\n node name, for the control output recipients to the node.\n attr_key_val_pairs: Optional: attribute key-value pairs of the node, as a\n list of 2-tuples.\n num_dumped_tensors: Optional: number of tensor dumps from the node.\n show_stack_trace: (bool) whether the stack trace of the node's\n construction is asserted to be present.\n stack_trace_available: (bool) whether Python stack trace is available.\n \"\"\"\n\n line_iter = iter(out.lines)\n\n tst.assertEqual(\"Node %s\" % node_name, next(line_iter))\n tst.assertEqual(\"\", next(line_iter))\n tst.assertEqual(\" Op: %s\" % op_type, next(line_iter))\n tst.assertEqual(\" Device: %s\" % device, next(line_iter))\n tst.assertEqual(\"\", next(line_iter))\n tst.assertEqual(\" %d input(s) + %d control input(s):\" %\n (len(input_op_type_node_name_pairs),\n len(ctrl_input_op_type_node_name_pairs)), next(line_iter))\n\n # Check inputs.\n tst.assertEqual(\" %d input(s):\" % len(input_op_type_node_name_pairs),\n next(line_iter))\n for op_type, node_name in input_op_type_node_name_pairs:\n tst.assertEqual(\" [%s] %s\" % (op_type, node_name), next(line_iter))\n\n tst.assertEqual(\"\", next(line_iter))\n\n # Check control inputs.\n if ctrl_input_op_type_node_name_pairs:\n tst.assertEqual(\" %d control input(s):\" %\n len(ctrl_input_op_type_node_name_pairs), next(line_iter))\n for op_type, node_name in ctrl_input_op_type_node_name_pairs:\n tst.assertEqual(\" [%s] %s\" % (op_type, node_name), next(line_iter))\n\n tst.assertEqual(\"\", next(line_iter))\n\n tst.assertEqual(\" %d recipient(s) + %d control recipient(s):\" %\n (len(recipient_op_type_node_name_pairs),\n len(ctrl_recipient_op_type_node_name_pairs)),\n next(line_iter))\n\n # Check recipients, the order of which is not deterministic.\n tst.assertEqual(\" %d recipient(s):\" %\n len(recipient_op_type_node_name_pairs), next(line_iter))\n\n t_recs = []\n for _ in recipient_op_type_node_name_pairs:\n line = next(line_iter)\n\n op_type, node_name = parse_op_and_node(line)\n t_recs.append((op_type, node_name))\n\n tst.assertItemsEqual(recipient_op_type_node_name_pairs, t_recs)\n\n # Check control recipients, the order of which is not deterministic.\n if ctrl_recipient_op_type_node_name_pairs:\n tst.assertEqual(\"\", next(line_iter))\n\n tst.assertEqual(\" %d control recipient(s):\" %\n len(ctrl_recipient_op_type_node_name_pairs),\n next(line_iter))\n\n t_ctrl_recs = []\n for _ in ctrl_recipient_op_type_node_name_pairs:\n line = next(line_iter)\n\n op_type, node_name = parse_op_and_node(line)\n t_ctrl_recs.append((op_type, node_name))\n\n tst.assertItemsEqual(ctrl_recipient_op_type_node_name_pairs, t_ctrl_recs)\n\n # The order of multiple attributes can be non-deterministic.\n if attr_key_val_pairs:\n tst.assertEqual(\"\", next(line_iter))\n\n tst.assertEqual(\"Node attributes:\", next(line_iter))\n\n kv_pairs = []\n for key, val in attr_key_val_pairs:\n key = next(line_iter).strip().replace(\":\", \"\")\n\n val = next(line_iter).strip()\n\n kv_pairs.append((key, val))\n\n tst.assertEqual(\"\", next(line_iter))\n\n tst.assertItemsEqual(attr_key_val_pairs, kv_pairs)\n\n if num_dumped_tensors is not None:\n tst.assertEqual(\"%d dumped tensor(s):\" % num_dumped_tensors,\n next(line_iter))\n tst.assertEqual(\"\", next(line_iter))\n\n dump_timestamps_ms = []\n for _ in xrange(num_dumped_tensors):\n line = next(line_iter)\n\n tst.assertStartsWith(line.strip(), \"Slot 0 @ DebugIdentity @\")\n tst.assertTrue(line.strip().endswith(\" ms\"))\n\n dump_timestamp_ms = float(line.strip().split(\" @ \")[-1].replace(\"ms\", \"\"))\n tst.assertGreaterEqual(dump_timestamp_ms, 0.0)\n\n dump_timestamps_ms.append(dump_timestamp_ms)\n\n tst.assertEqual(sorted(dump_timestamps_ms), dump_timestamps_ms)\n\n if show_stack_trace:\n tst.assertEqual(\"\", next(line_iter))\n tst.assertEqual(\"\", next(line_iter))\n tst.assertEqual(\"Traceback of node construction:\", next(line_iter))\n if stack_trace_available:\n try:\n depth_counter = 0\n while True:\n for i in range(5):\n line = next(line_iter)\n if i == 0:\n tst.assertEqual(depth_counter, int(line.split(\":\")[0]))\n elif i == 1:\n tst.assertStartsWith(line, \" Line:\")\n elif i == 2:\n tst.assertStartsWith(line, \" Function:\")\n elif i == 3:\n tst.assertStartsWith(line, \" Text:\")\n elif i == 4:\n tst.assertEqual(\"\", line)\n\n depth_counter += 1\n except StopIteration:\n tst.assertEqual(0, i)\n else:\n tst.assertEqual(\"(Unavailable because no Python graph has been loaded)\",\n next(line_iter))\n\n\ndef check_syntax_error_output(tst, out, command_prefix):\n \"\"\"Check RichTextLines output for valid command prefix but invalid syntax.\"\"\"\n\n tst.assertEqual([\n \"Syntax error for command: %s\" % command_prefix,\n \"For help, do \\\"help %s\\\"\" % command_prefix\n ], out.lines)\n\n\ndef check_error_output(tst, out, command_prefix, args):\n \"\"\"Check RichTextLines output from invalid/erroneous commands.\n\n Args:\n tst: A test_util.TensorFlowTestCase instance.\n out: The RichTextLines object to be checked.\n command_prefix: The command prefix of the command that caused the error.\n args: The arguments (excluding prefix) of the command that caused the error.\n \"\"\"\n\n tst.assertGreater(len(out.lines), 2)\n tst.assertStartsWith(out.lines[0],\n \"Error occurred during handling of command: %s %s\" %\n (command_prefix, \" \".join(args)))\n\n\ndef check_main_menu(tst,\n out,\n list_tensors_enabled=False,\n node_info_node_name=None,\n print_tensor_node_name=None,\n list_inputs_node_name=None,\n list_outputs_node_name=None):\n \"\"\"Check the main menu annotation of an output.\"\"\"\n\n tst.assertIn(debugger_cli_common.MAIN_MENU_KEY, out.annotations)\n\n menu = out.annotations[debugger_cli_common.MAIN_MENU_KEY]\n tst.assertEqual(list_tensors_enabled,\n menu.caption_to_item(\"list_tensors\").is_enabled())\n\n menu_item = menu.caption_to_item(\"node_info\")\n if node_info_node_name:\n tst.assertTrue(menu_item.is_enabled())\n tst.assertTrue(menu_item.content.endswith(node_info_node_name))\n else:\n tst.assertFalse(menu_item.is_enabled())\n\n menu_item = menu.caption_to_item(\"print_tensor\")\n if print_tensor_node_name:\n tst.assertTrue(menu_item.is_enabled())\n tst.assertTrue(menu_item.content.endswith(print_tensor_node_name))\n else:\n tst.assertFalse(menu_item.is_enabled())\n\n menu_item = menu.caption_to_item(\"list_inputs\")\n if list_inputs_node_name:\n tst.assertTrue(menu_item.is_enabled())\n tst.assertTrue(menu_item.content.endswith(list_inputs_node_name))\n else:\n tst.assertFalse(menu_item.is_enabled())\n\n menu_item = menu.caption_to_item(\"list_outputs\")\n if list_outputs_node_name:\n tst.assertTrue(menu_item.is_enabled())\n tst.assertTrue(menu_item.content.endswith(list_outputs_node_name))\n else:\n tst.assertFalse(menu_item.is_enabled())\n\n tst.assertTrue(menu.caption_to_item(\"run_info\").is_enabled())\n tst.assertTrue(menu.caption_to_item(\"help\").is_enabled())\n\n\ndef check_menu_item(tst, out, line_index, expected_begin, expected_end,\n expected_command):\n attr_segs = out.font_attr_segs[line_index]\n found_menu_item = False\n for begin, end, attribute in attr_segs:\n attributes = [attribute] if not isinstance(attribute, list) else attribute\n menu_item = [attribute for attribute in attributes if\n isinstance(attribute, debugger_cli_common.MenuItem)]\n if menu_item:\n tst.assertEqual(expected_begin, begin)\n tst.assertEqual(expected_end, end)\n tst.assertEqual(expected_command, menu_item[0].content)\n found_menu_item = True\n break\n tst.assertTrue(found_menu_item)\n\n\ndef create_analyzer_cli(dump):\n \"\"\"Create an analyzer CLI.\n\n Args:\n dump: A `DebugDumpDir` object to base the analyzer CLI on.\n\n Returns:\n 1) A `DebugAnalyzer` object created based on `dump`.\n 2) A `CommandHandlerRegistry` that is based on the `DebugAnalyzer` object\n and has the common tfdbg commands, e.g., lt, ni, li, lo, registered.\n \"\"\"\n # Construct the analyzer.\n analyzer = analyzer_cli.DebugAnalyzer(dump, _cli_config_from_temp_file())\n\n # Construct the handler registry.\n registry = debugger_cli_common.CommandHandlerRegistry()\n\n # Register command handlers.\n registry.register_command_handler(\n \"list_tensors\",\n analyzer.list_tensors,\n analyzer.get_help(\"list_tensors\"),\n prefix_aliases=[\"lt\"])\n registry.register_command_handler(\n \"node_info\",\n analyzer.node_info,\n analyzer.get_help(\"node_info\"),\n prefix_aliases=[\"ni\"])\n registry.register_command_handler(\n \"list_inputs\",\n analyzer.list_inputs,\n analyzer.get_help(\"list_inputs\"),\n prefix_aliases=[\"li\"])\n registry.register_command_handler(\n \"list_outputs\",\n analyzer.list_outputs,\n analyzer.get_help(\"list_outputs\"),\n prefix_aliases=[\"lo\"])\n registry.register_command_handler(\n \"print_tensor\",\n analyzer.print_tensor,\n analyzer.get_help(\"print_tensor\"),\n prefix_aliases=[\"pt\"])\n registry.register_command_handler(\n \"print_source\",\n analyzer.print_source,\n analyzer.get_help(\"print_source\"),\n prefix_aliases=[\"ps\"])\n registry.register_command_handler(\n \"list_source\",\n analyzer.list_source,\n analyzer.get_help(\"list_source\"),\n prefix_aliases=[\"ls\"])\n registry.register_command_handler(\n \"eval\",\n analyzer.evaluate_expression,\n analyzer.get_help(\"eval\"),\n prefix_aliases=[\"ev\"])\n\n return analyzer, registry\n\n\n@test_util.run_v1_only(\"b/120545219\")\nclass AnalyzerCLISimpleMulAddTest(test_util.TensorFlowTestCase):\n\n @classmethod\n def setUpClass(cls):\n cls._dump_root = tempfile.mkdtemp()\n cls._dump_root_for_unique = tempfile.mkdtemp()\n\n cls._is_gpu_available = test.is_gpu_available()\n if cls._is_gpu_available:\n gpu_name = test_util.gpu_device_name()\n cls._main_device = \"/job:localhost/replica:0/task:0\" + gpu_name\n else:\n cls._main_device = \"/job:localhost/replica:0/task:0/device:CPU:0\"\n\n cls._curr_file_path = os.path.abspath(\n tf_inspect.getfile(tf_inspect.currentframe()))\n\n cls._sess = session.Session(config=no_rewrite_session_config())\n with cls._sess as sess:\n u_init_val = np.array([[5.0, 3.0], [-1.0, 0.0]])\n v_init_val = np.array([[2.0], [-1.0]])\n\n u_name = \"simple_mul_add/u\"\n v_name = \"simple_mul_add/v\"\n\n u_init = constant_op.constant(u_init_val, shape=[2, 2], name=\"u_init\")\n u = variables.VariableV1(u_init, name=u_name)\n cls._u_line_number = line_number_above()\n\n v_init = constant_op.constant(v_init_val, shape=[2, 1], name=\"v_init\")\n v = variables.VariableV1(v_init, name=v_name)\n cls._v_line_number = line_number_above()\n\n w = math_ops.matmul(u, v, name=\"simple_mul_add/matmul\")\n cls._w_line_number = line_number_above()\n\n x = math_ops.add(w, w, name=\"simple_mul_add/add\")\n cls._x_line_number = line_number_above()\n\n a = variables.VariableV1([1, 3, 3, 7], name=\"a\")\n\n u.initializer.run()\n v.initializer.run()\n a.initializer.run()\n\n run_options = config_pb2.RunOptions(output_partition_graphs=True)\n debug_utils.watch_graph(\n run_options,\n sess.graph,\n debug_ops=[\"DebugIdentity\"],\n debug_urls=\"file://%s\" % cls._dump_root)\n\n # Invoke Session.run().\n run_metadata = config_pb2.RunMetadata()\n sess.run([x], options=run_options, run_metadata=run_metadata)\n cls._debug_dump = debug_data.DebugDumpDir(\n cls._dump_root, partition_graphs=run_metadata.partition_graphs)\n cls._analyzer, cls._registry = create_analyzer_cli(cls._debug_dump)\n\n @classmethod\n def tearDownClass(cls):\n # Tear down temporary dump directory.\n shutil.rmtree(cls._dump_root)\n shutil.rmtree(cls._dump_root_for_unique)\n\n def testMeasureTensorListColumnWidthsGivesRightAnswerForEmptyData(self):\n timestamp_col_width, dump_size_col_width, op_type_col_width = (\n self._analyzer._measure_tensor_list_column_widths([]))\n self.assertEqual(len(\"t (ms)\") + 1, timestamp_col_width)\n self.assertEqual(len(\"Size (B)\") + 1, dump_size_col_width)\n self.assertEqual(len(\"Op type\") + 1, op_type_col_width)\n\n def testMeasureTensorListColumnWidthsGivesRightAnswerForData(self):\n dump = self._debug_dump.dumped_tensor_data[0]\n self.assertLess(dump.dump_size_bytes, 1000)\n self.assertEqual(\n \"VariableV2\", self._debug_dump.node_op_type(dump.node_name))\n _, dump_size_col_width, op_type_col_width = (\n self._analyzer._measure_tensor_list_column_widths([dump]))\n # The length of str(dump.dump_size_bytes) is less than the length of\n # \"Size (B)\" (8). So the column width should be determined by the length of\n # \"Size (B)\".\n self.assertEqual(len(\"Size (B)\") + 1, dump_size_col_width)\n # The length of \"VariableV2\" is greater than the length of \"Op type\". So the\n # column should be determined by the length of \"VariableV2\".\n self.assertEqual(len(\"VariableV2\") + 1, op_type_col_width)\n\n def testListTensors(self):\n # Use shorthand alias for the command prefix.\n out = self._registry.dispatch_command(\"lt\", [])\n\n assert_listed_tensors(self, out, [\n \"simple_mul_add/u:0\", \"simple_mul_add/v:0\", \"simple_mul_add/u/read:0\",\n \"simple_mul_add/v/read:0\", \"simple_mul_add/matmul:0\",\n \"simple_mul_add/add:0\"\n ], [\n \"VariableV2\", \"VariableV2\", \"Identity\", \"Identity\",\n _matmul_op_name(), \"Add\"\n ])\n\n # Check the main menu.\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorsInReverseTimeOrderWorks(self):\n # Use shorthand alias for the command prefix.\n out = self._registry.dispatch_command(\"lt\", [\"-s\", \"timestamp\", \"-r\"])\n assert_listed_tensors(\n self,\n out, [\n \"simple_mul_add/u:0\", \"simple_mul_add/v:0\",\n \"simple_mul_add/u/read:0\", \"simple_mul_add/v/read:0\",\n \"simple_mul_add/matmul:0\", \"simple_mul_add/add:0\"\n ], [\n \"VariableV2\", \"VariableV2\", \"Identity\", \"Identity\",\n _matmul_op_name(), \"Add\"\n ],\n sort_by=\"timestamp\",\n reverse=True)\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorsInDumpSizeOrderWorks(self):\n out = self._registry.dispatch_command(\"lt\", [\"-s\", \"dump_size\"])\n assert_listed_tensors(\n self,\n out, [\n \"simple_mul_add/u:0\", \"simple_mul_add/v:0\",\n \"simple_mul_add/u/read:0\", \"simple_mul_add/v/read:0\",\n \"simple_mul_add/matmul:0\", \"simple_mul_add/add:0\"\n ], [\n \"VariableV2\", \"VariableV2\", \"Identity\", \"Identity\",\n _matmul_op_name(), \"Add\"\n ],\n sort_by=\"dump_size\")\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorsInReverseDumpSizeOrderWorks(self):\n out = self._registry.dispatch_command(\"lt\", [\"-s\", \"dump_size\", \"-r\"])\n assert_listed_tensors(\n self,\n out, [\n \"simple_mul_add/u:0\", \"simple_mul_add/v:0\",\n \"simple_mul_add/u/read:0\", \"simple_mul_add/v/read:0\",\n \"simple_mul_add/matmul:0\", \"simple_mul_add/add:0\"\n ], [\n \"VariableV2\", \"VariableV2\", \"Identity\", \"Identity\",\n _matmul_op_name(), \"Add\"\n ],\n sort_by=\"dump_size\",\n reverse=True)\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorsWithInvalidSortByFieldGivesError(self):\n out = self._registry.dispatch_command(\"lt\", [\"-s\", \"foobar\"])\n self.assertIn(\"ValueError: Unsupported key to sort tensors by: foobar\",\n out.lines)\n\n def testListTensorsInOpTypeOrderWorks(self):\n # Use shorthand alias for the command prefix.\n out = self._registry.dispatch_command(\"lt\", [\"-s\", \"op_type\"])\n assert_listed_tensors(\n self,\n out, [\n \"simple_mul_add/u:0\", \"simple_mul_add/v:0\",\n \"simple_mul_add/u/read:0\", \"simple_mul_add/v/read:0\",\n \"simple_mul_add/matmul:0\", \"simple_mul_add/add:0\"\n ], [\n \"VariableV2\", \"VariableV2\", \"Identity\", \"Identity\",\n _matmul_op_name(), \"Add\"\n ],\n sort_by=\"op_type\",\n reverse=False)\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorsInReverseOpTypeOrderWorks(self):\n # Use shorthand alias for the command prefix.\n out = self._registry.dispatch_command(\"lt\", [\"-s\", \"op_type\", \"-r\"])\n assert_listed_tensors(\n self,\n out, [\n \"simple_mul_add/u:0\", \"simple_mul_add/v:0\",\n \"simple_mul_add/u/read:0\", \"simple_mul_add/v/read:0\",\n \"simple_mul_add/matmul:0\", \"simple_mul_add/add:0\"\n ], [\n \"VariableV2\", \"VariableV2\", \"Identity\", \"Identity\",\n _matmul_op_name(), \"Add\"\n ],\n sort_by=\"op_type\",\n reverse=True)\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorsInTensorNameOrderWorks(self):\n # Use shorthand alias for the command prefix.\n out = self._registry.dispatch_command(\"lt\", [\"-s\", \"tensor_name\"])\n assert_listed_tensors(\n self,\n out, [\n \"simple_mul_add/u:0\", \"simple_mul_add/v:0\",\n \"simple_mul_add/u/read:0\", \"simple_mul_add/v/read:0\",\n \"simple_mul_add/matmul:0\", \"simple_mul_add/add:0\"\n ], [\n \"VariableV2\", \"VariableV2\", \"Identity\", \"Identity\",\n _matmul_op_name(), \"Add\"\n ],\n sort_by=\"tensor_name\",\n reverse=False)\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorsInReverseTensorNameOrderWorks(self):\n # Use shorthand alias for the command prefix.\n out = self._registry.dispatch_command(\"lt\", [\"-s\", \"tensor_name\", \"-r\"])\n assert_listed_tensors(\n self,\n out, [\n \"simple_mul_add/u:0\", \"simple_mul_add/v:0\",\n \"simple_mul_add/u/read:0\", \"simple_mul_add/v/read:0\",\n \"simple_mul_add/matmul:0\", \"simple_mul_add/add:0\"\n ], [\n \"VariableV2\", \"VariableV2\", \"Identity\", \"Identity\",\n _matmul_op_name(), \"Add\"\n ],\n sort_by=\"tensor_name\",\n reverse=True)\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorsFilterByNodeNameRegex(self):\n out = self._registry.dispatch_command(\"list_tensors\",\n [\"--node_name_filter\", \".*read.*\"])\n assert_listed_tensors(\n self,\n out, [\"simple_mul_add/u/read:0\", \"simple_mul_add/v/read:0\"],\n [\"Identity\", \"Identity\"],\n node_name_regex=\".*read.*\")\n\n out = self._registry.dispatch_command(\"list_tensors\", [\"-n\", \"^read\"])\n assert_listed_tensors(self, out, [], [], node_name_regex=\"^read\")\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorFilterByOpTypeRegex(self):\n out = self._registry.dispatch_command(\"list_tensors\",\n [\"--op_type_filter\", \"Identity\"])\n assert_listed_tensors(\n self,\n out, [\"simple_mul_add/u/read:0\", \"simple_mul_add/v/read:0\"],\n [\"Identity\", \"Identity\"],\n op_type_regex=\"Identity\")\n\n out = self._registry.dispatch_command(\n \"list_tensors\", [\"-t\", \"(Add|\" + _matmul_op_name() + \")\"])\n assert_listed_tensors(\n self,\n out, [\"simple_mul_add/add:0\", \"simple_mul_add/matmul:0\"],\n [\"Add\", _matmul_op_name()],\n op_type_regex=(\"(Add|\" + _matmul_op_name() + \")\"))\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorFilterByNodeNameRegexAndOpTypeRegex(self):\n out = self._registry.dispatch_command(\n \"list_tensors\", [\"-t\", \"(Add|MatMul)\", \"-n\", \".*add$\"])\n assert_listed_tensors(\n self,\n out, [\"simple_mul_add/add:0\"], [\"Add\"],\n node_name_regex=\".*add$\",\n op_type_regex=\"(Add|MatMul)\")\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorWithFilterAndNodeNameExclusionWorks(self):\n # First, create and register the filter.\n def is_2x1_vector(datum, tensor):\n del datum # Unused.\n return list(tensor.shape) == [2, 1]\n self._analyzer.add_tensor_filter(\"is_2x1_vector\", is_2x1_vector)\n\n # Use shorthand alias for the command prefix.\n out = self._registry.dispatch_command(\n \"lt\", [\"-f\", \"is_2x1_vector\", \"--filter_exclude_node_names\", \".*v.*\"])\n\n # If the --filter_exclude_node_names were not used, then the matching\n # tensors would be:\n # - simple_mul_add/v:0\n # - simple_mul_add/v/read:0\n # - simple_mul_add/matmul:0\n # - simple_mul_add/add:0\n #\n # With the --filter_exclude_node_names option, only the last two should\n # show up in the result.\n assert_listed_tensors(\n self,\n out, [\"simple_mul_add/matmul:0\", \"simple_mul_add/add:0\"],\n [_matmul_op_name(), \"Add\"],\n tensor_filter_name=\"is_2x1_vector\")\n\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorsFilterNanOrInf(self):\n \"\"\"Test register and invoke a tensor filter.\"\"\"\n\n # First, register the filter.\n self._analyzer.add_tensor_filter(\"has_inf_or_nan\",\n debug_data.has_inf_or_nan)\n\n # Use shorthand alias for the command prefix.\n out = self._registry.dispatch_command(\"lt\", [\"-f\", \"has_inf_or_nan\"])\n\n # This TF graph run did not generate any bad numerical values.\n assert_listed_tensors(\n self, out, [], [], tensor_filter_name=\"has_inf_or_nan\")\n # TODO(cais): A test with some actual bad numerical values.\n\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorNonexistentFilter(self):\n \"\"\"Test attempt to use a nonexistent tensor filter.\"\"\"\n\n out = self._registry.dispatch_command(\"lt\", [\"-f\", \"foo_filter\"])\n\n self.assertEqual([\"ERROR: There is no tensor filter named \\\"foo_filter\\\".\"],\n out.lines)\n check_main_menu(self, out, list_tensors_enabled=False)\n\n def testListTensorsInvalidOptions(self):\n out = self._registry.dispatch_command(\"list_tensors\", [\"--bar\"])\n check_syntax_error_output(self, out, \"list_tensors\")\n\n def testNodeInfoByNodeName(self):\n node_name = \"simple_mul_add/matmul\"\n out = self._registry.dispatch_command(\"node_info\", [node_name])\n\n recipients = [(\"Add\", \"simple_mul_add/add\"), (\"Add\", \"simple_mul_add/add\")]\n\n assert_node_attribute_lines(self, out, node_name, _matmul_op_name(),\n self._main_device,\n [(\"Identity\", \"simple_mul_add/u/read\"),\n (\"Identity\", \"simple_mul_add/v/read\")], [],\n recipients, [])\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n list_inputs_node_name=node_name,\n print_tensor_node_name=node_name,\n list_outputs_node_name=node_name)\n\n # Verify that the node name is bold in the first line.\n self.assertEqual(\n [(len(out.lines[0]) - len(node_name), len(out.lines[0]), \"bold\")],\n out.font_attr_segs[0])\n\n def testNodeInfoShowAttributes(self):\n node_name = \"simple_mul_add/matmul\"\n out = self._registry.dispatch_command(\"node_info\", [\"-a\", node_name])\n\n test_attr_key_val_pairs = [(\"transpose_a\", \"b: false\"),\n (\"transpose_b\", \"b: false\"),\n (\"T\", \"type: DT_DOUBLE\")]\n if test_util.IsMklEnabled():\n test_attr_key_val_pairs.append((\"_kernel\", 's: \"MklNameChangeOp\"'))\n\n assert_node_attribute_lines(\n self,\n out,\n node_name,\n _matmul_op_name(),\n self._main_device, [(\"Identity\", \"simple_mul_add/u/read\"),\n (\"Identity\", \"simple_mul_add/v/read\")], [],\n [(\"Add\", \"simple_mul_add/add\"), (\"Add\", \"simple_mul_add/add\")], [],\n attr_key_val_pairs=test_attr_key_val_pairs)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n list_inputs_node_name=node_name,\n print_tensor_node_name=node_name,\n list_outputs_node_name=node_name)\n\n def testNodeInfoShowDumps(self):\n node_name = \"simple_mul_add/matmul\"\n out = self._registry.dispatch_command(\"node_info\", [\"-d\", node_name])\n\n assert_node_attribute_lines(\n self,\n out,\n node_name,\n _matmul_op_name(),\n self._main_device, [(\"Identity\", \"simple_mul_add/u/read\"),\n (\"Identity\", \"simple_mul_add/v/read\")], [],\n [(\"Add\", \"simple_mul_add/add\"), (\"Add\", \"simple_mul_add/add\")], [],\n num_dumped_tensors=1)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n list_inputs_node_name=node_name,\n print_tensor_node_name=node_name,\n list_outputs_node_name=node_name)\n check_menu_item(self, out, 16,\n len(out.lines[16]) - len(out.lines[16].strip()),\n len(out.lines[16]), \"pt %s:0 -n 0\" % node_name)\n\n def testNodeInfoShowStackTraceUnavailableIsIndicated(self):\n self._debug_dump.set_python_graph(None)\n\n node_name = \"simple_mul_add/matmul\"\n out = self._registry.dispatch_command(\"node_info\", [\"-t\", node_name])\n\n assert_node_attribute_lines(\n self,\n out,\n node_name,\n _matmul_op_name(),\n self._main_device, [(\"Identity\", \"simple_mul_add/u/read\"),\n (\"Identity\", \"simple_mul_add/v/read\")], [],\n [(\"Add\", \"simple_mul_add/add\"), (\"Add\", \"simple_mul_add/add\")], [],\n show_stack_trace=True,\n stack_trace_available=False)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n list_inputs_node_name=node_name,\n print_tensor_node_name=node_name,\n list_outputs_node_name=node_name)\n\n def testNodeInfoShowStackTraceAvailableWorks(self):\n self._debug_dump.set_python_graph(self._sess.graph)\n\n node_name = \"simple_mul_add/matmul\"\n out = self._registry.dispatch_command(\"node_info\", [\"-t\", node_name])\n\n assert_node_attribute_lines(\n self,\n out,\n node_name,\n _matmul_op_name(),\n self._main_device, [(\"Identity\", \"simple_mul_add/u/read\"),\n (\"Identity\", \"simple_mul_add/v/read\")], [],\n [(\"Add\", \"simple_mul_add/add\"), (\"Add\", \"simple_mul_add/add\")], [],\n show_stack_trace=True,\n stack_trace_available=True)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n list_inputs_node_name=node_name,\n print_tensor_node_name=node_name,\n list_outputs_node_name=node_name)\n\n def testNodeInfoByTensorName(self):\n node_name = \"simple_mul_add/u/read\"\n tensor_name = node_name + \":0\"\n out = self._registry.dispatch_command(\"node_info\", [tensor_name])\n\n assert_node_attribute_lines(self, out, node_name, \"Identity\",\n self._main_device,\n [(\"VariableV2\", \"simple_mul_add/u\")], [],\n [(_matmul_op_name(), \"simple_mul_add/matmul\")],\n [])\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n list_inputs_node_name=node_name,\n print_tensor_node_name=node_name,\n list_outputs_node_name=node_name)\n\n def testNodeInfoNonexistentNodeName(self):\n out = self._registry.dispatch_command(\"node_info\", [\"bar\"])\n self.assertEqual(\n [\"ERROR: There is no node named \\\"bar\\\" in the partition graphs\"],\n out.lines)\n # Check color indicating error.\n self.assertEqual({0: [(0, 59, cli_shared.COLOR_RED)]}, out.font_attr_segs)\n check_main_menu(self, out, list_tensors_enabled=True)\n\n def testPrintTensor(self):\n node_name = \"simple_mul_add/matmul\"\n tensor_name = node_name + \":0\"\n out = self._registry.dispatch_command(\n \"print_tensor\", [tensor_name], screen_info={\"cols\": 80})\n\n self.assertEqual([\n \"Tensor \\\"%s:DebugIdentity\\\":\" % tensor_name,\n \" dtype: float64\",\n \" shape: (2, 1)\",\n \"\",\n \"array([[ 7.],\",\n \" [-2.]])\",\n ], out.lines)\n\n self.assertIn(\"tensor_metadata\", out.annotations)\n self.assertIn(4, out.annotations)\n self.assertIn(5, out.annotations)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n node_info_node_name=node_name,\n list_inputs_node_name=node_name,\n list_outputs_node_name=node_name)\n\n def testPrintTensorAndWriteToNpyFile(self):\n node_name = \"simple_mul_add/matmul\"\n tensor_name = node_name + \":0\"\n npy_path = os.path.join(self._dump_root, \"matmul.npy\")\n out = self._registry.dispatch_command(\n \"print_tensor\", [tensor_name, \"-w\", npy_path],\n screen_info={\"cols\": 80})\n\n self.assertEqual([\n \"Tensor \\\"%s:DebugIdentity\\\":\" % tensor_name,\n \" dtype: float64\",\n \" shape: (2, 1)\",\n \"\",\n ], out.lines[:4])\n self.assertTrue(out.lines[4].startswith(\"Saved value to: %s (\" % npy_path))\n # Load the numpy file and verify its contents.\n self.assertAllClose([[7.0], [-2.0]], np.load(npy_path))\n\n def testPrintTensorHighlightingRanges(self):\n node_name = \"simple_mul_add/matmul\"\n tensor_name = node_name + \":0\"\n out = self._registry.dispatch_command(\n \"print_tensor\", [tensor_name, \"--ranges\", \"[-inf, 0.0]\"],\n screen_info={\"cols\": 80})\n\n self.assertEqual([\n \"Tensor \\\"%s:DebugIdentity\\\": \" % tensor_name +\n \"Highlighted([-inf, 0.0]): 1 of 2 element(s) (50.00%)\",\n \" dtype: float64\",\n \" shape: (2, 1)\",\n \"\",\n \"array([[ 7.],\",\n \" [-2.]])\",\n ], out.lines)\n\n self.assertIn(\"tensor_metadata\", out.annotations)\n self.assertIn(4, out.annotations)\n self.assertIn(5, out.annotations)\n self.assertEqual([(8, 11, \"bold\")], out.font_attr_segs[5])\n\n out = self._registry.dispatch_command(\n \"print_tensor\", [tensor_name, \"--ranges\", \"[[-inf, -5.5], [5.5, inf]]\"],\n screen_info={\"cols\": 80})\n\n self.assertEqual([\n \"Tensor \\\"%s:DebugIdentity\\\": \" % tensor_name +\n \"Highlighted([[-inf, -5.5], [5.5, inf]]): \"\n \"1 of 2 element(s) (50.00%)\",\n \" dtype: float64\",\n \" shape: (2, 1)\",\n \"\",\n \"array([[ 7.],\",\n \" [-2.]])\",\n ], out.lines)\n\n self.assertIn(\"tensor_metadata\", out.annotations)\n self.assertIn(4, out.annotations)\n self.assertIn(5, out.annotations)\n self.assertEqual([(9, 11, \"bold\")], out.font_attr_segs[4])\n self.assertNotIn(5, out.font_attr_segs)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n node_info_node_name=node_name,\n list_inputs_node_name=node_name,\n list_outputs_node_name=node_name)\n\n def testPrintTensorHighlightingRangesAndIncludingNumericSummary(self):\n node_name = \"simple_mul_add/matmul\"\n tensor_name = node_name + \":0\"\n out = self._registry.dispatch_command(\n \"print_tensor\", [tensor_name, \"--ranges\", \"[-inf, 0.0]\", \"-s\"],\n screen_info={\"cols\": 80})\n\n self.assertEqual([\n \"Tensor \\\"%s:DebugIdentity\\\": \" % tensor_name +\n \"Highlighted([-inf, 0.0]): 1 of 2 element(s) (50.00%)\",\n \" dtype: float64\",\n \" shape: (2, 1)\",\n \"\",\n \"Numeric summary:\",\n \"| - + | total |\",\n \"| 1 1 | 2 |\",\n \"| min max mean std |\",\n \"| -2.0 7.0 2.5 4.5 |\",\n \"\",\n \"array([[ 7.],\",\n \" [-2.]])\",\n ], out.lines)\n\n self.assertIn(\"tensor_metadata\", out.annotations)\n self.assertIn(10, out.annotations)\n self.assertIn(11, out.annotations)\n self.assertEqual([(8, 11, \"bold\")], out.font_attr_segs[11])\n\n def testPrintTensorWithSlicing(self):\n node_name = \"simple_mul_add/matmul\"\n tensor_name = node_name + \":0\"\n out = self._registry.dispatch_command(\n \"print_tensor\", [tensor_name + \"[1, :]\"], screen_info={\"cols\": 80})\n\n self.assertEqual([\n \"Tensor \\\"%s:DebugIdentity[1, :]\\\":\" % tensor_name, \" dtype: float64\",\n \" shape: (1,)\", \"\", \"array([-2.])\"\n ], out.lines)\n\n self.assertIn(\"tensor_metadata\", out.annotations)\n self.assertIn(4, out.annotations)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n node_info_node_name=node_name,\n list_inputs_node_name=node_name,\n list_outputs_node_name=node_name)\n\n def testPrintTensorInvalidSlicingString(self):\n node_name = \"simple_mul_add/matmul\"\n tensor_name = node_name + \":0\"\n out = self._registry.dispatch_command(\n \"print_tensor\", [tensor_name + \"[1, foo()]\"], screen_info={\"cols\": 80})\n\n self.assertEqual(\"Error occurred during handling of command: print_tensor \"\n + tensor_name + \"[1, foo()]:\", out.lines[0])\n self.assertEqual(\"ValueError: Invalid tensor-slicing string.\",\n out.lines[-2])\n\n def testPrintTensorValidExplicitNumber(self):\n node_name = \"simple_mul_add/matmul\"\n tensor_name = node_name + \":0\"\n out = self._registry.dispatch_command(\n \"print_tensor\", [tensor_name, \"-n\", \"0\"], screen_info={\"cols\": 80})\n\n self.assertEqual([\n \"Tensor \\\"%s:DebugIdentity\\\":\" % tensor_name,\n \" dtype: float64\",\n \" shape: (2, 1)\",\n \"\",\n \"array([[ 7.],\",\n \" [-2.]])\",\n ], out.lines)\n\n self.assertIn(\"tensor_metadata\", out.annotations)\n self.assertIn(4, out.annotations)\n self.assertIn(5, out.annotations)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n node_info_node_name=node_name,\n list_inputs_node_name=node_name,\n list_outputs_node_name=node_name)\n\n def testPrintTensorInvalidExplicitNumber(self):\n node_name = \"simple_mul_add/matmul\"\n tensor_name = node_name + \":0\"\n out = self._registry.dispatch_command(\n \"print_tensor\", [tensor_name, \"-n\", \"1\"], screen_info={\"cols\": 80})\n\n self.assertEqual([\n \"ERROR: Invalid number (1) for tensor simple_mul_add/matmul:0, \"\n \"which generated one dump.\"\n ], out.lines)\n\n self.assertNotIn(\"tensor_metadata\", out.annotations)\n\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n node_info_node_name=node_name,\n list_inputs_node_name=node_name,\n list_outputs_node_name=node_name)\n\n def testPrintTensorMissingOutputSlotLeadsToOnlyDumpedTensorPrinted(self):\n node_name = \"simple_mul_add/matmul\"\n out = self._registry.dispatch_command(\"print_tensor\", [node_name])\n\n self.assertEqual([\n \"Tensor \\\"%s:0:DebugIdentity\\\":\" % node_name, \" dtype: float64\",\n \" shape: (2, 1)\", \"\", \"array([[ 7.],\", \" [-2.]])\"\n ], out.lines)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n node_info_node_name=node_name,\n list_inputs_node_name=node_name,\n list_outputs_node_name=node_name)\n\n def testPrintTensorNonexistentNodeName(self):\n out = self._registry.dispatch_command(\n \"print_tensor\", [\"simple_mul_add/matmul/foo:0\"])\n\n self.assertEqual([\n \"ERROR: Node \\\"simple_mul_add/matmul/foo\\\" does not exist in partition \"\n \"graphs\"\n ], out.lines)\n check_main_menu(self, out, list_tensors_enabled=True)\n\n def testEvalExpression(self):\n node_name = \"simple_mul_add/matmul\"\n tensor_name = node_name + \":0\"\n out = self._registry.dispatch_command(\n \"eval\", [\"np.matmul(`%s`, `%s`.T)\" % (tensor_name, tensor_name)],\n screen_info={\"cols\": 80})\n\n cli_test_utils.assert_lines_equal_ignoring_whitespace(\n self,\n [\"Tensor \\\"from eval of expression \"\n \"'np.matmul(`simple_mul_add/matmul:0`, \"\n \"`simple_mul_add/matmul:0`.T)'\\\":\",\n \" dtype: float64\",\n \" shape: (2, 2)\",\n \"\",\n \"Numeric summary:\",\n \"| - + | total |\",\n \"| 2 2 | 4 |\",\n \"| min max mean std |\"],\n out.lines[:8])\n cli_test_utils.assert_array_lines_close(\n self, [-14.0, 49.0, 6.25, 25.7524270701], out.lines[8:9])\n cli_test_utils.assert_array_lines_close(\n self, [[49.0, -14.0], [-14.0, 4.0]], out.lines[10:])\n\n def testEvalExpressionAndWriteToNpyFile(self):\n node_name = \"simple_mul_add/matmul\"\n tensor_name = node_name + \":0\"\n npy_path = os.path.join(self._dump_root, \"matmul_eval.npy\")\n out = self._registry.dispatch_command(\n \"eval\",\n [\"np.matmul(`%s`, `%s`.T)\" % (tensor_name, tensor_name), \"-w\",\n npy_path], screen_info={\"cols\": 80})\n\n self.assertEqual([\n \"Tensor \\\"from eval of expression \"\n \"'np.matmul(`simple_mul_add/matmul:0`, \"\n \"`simple_mul_add/matmul:0`.T)'\\\":\",\n \" dtype: float64\",\n \" shape: (2, 2)\",\n \"\"], out.lines[:4])\n\n self.assertTrue(out.lines[4].startswith(\"Saved value to: %s (\" % npy_path))\n # Load the numpy file and verify its contents.\n self.assertAllClose([[49.0, -14.0], [-14.0, 4.0]], np.load(npy_path))\n\n def testAddGetTensorFilterLambda(self):\n analyzer = analyzer_cli.DebugAnalyzer(self._debug_dump,\n _cli_config_from_temp_file())\n analyzer.add_tensor_filter(\"foo_filter\", lambda x, y: True)\n self.assertTrue(analyzer.get_tensor_filter(\"foo_filter\")(None, None))\n\n def testAddGetTensorFilterNestedFunction(self):\n analyzer = analyzer_cli.DebugAnalyzer(self._debug_dump,\n _cli_config_from_temp_file())\n\n def foo_filter(unused_arg_0, unused_arg_1):\n return True\n\n analyzer.add_tensor_filter(\"foo_filter\", foo_filter)\n self.assertTrue(analyzer.get_tensor_filter(\"foo_filter\")(None, None))\n\n def testAddTensorFilterEmptyName(self):\n analyzer = analyzer_cli.DebugAnalyzer(self._debug_dump,\n _cli_config_from_temp_file())\n\n with self.assertRaisesRegexp(ValueError,\n \"Input argument filter_name cannot be empty.\"):\n analyzer.add_tensor_filter(\"\", lambda datum, tensor: True)\n\n def testAddTensorFilterNonStrName(self):\n analyzer = analyzer_cli.DebugAnalyzer(self._debug_dump,\n _cli_config_from_temp_file())\n\n with self.assertRaisesRegexp(\n TypeError,\n \"Input argument filter_name is expected to be str, \"\"but is not\"):\n analyzer.add_tensor_filter(1, lambda datum, tensor: True)\n\n def testAddGetTensorFilterNonCallable(self):\n analyzer = analyzer_cli.DebugAnalyzer(self._debug_dump,\n _cli_config_from_temp_file())\n\n with self.assertRaisesRegexp(\n TypeError, \"Input argument filter_callable is expected to be callable, \"\n \"but is not.\"):\n analyzer.add_tensor_filter(\"foo_filter\", \"bar\")\n\n def testGetNonexistentTensorFilter(self):\n analyzer = analyzer_cli.DebugAnalyzer(self._debug_dump,\n _cli_config_from_temp_file())\n\n analyzer.add_tensor_filter(\"foo_filter\", lambda datum, tensor: True)\n with self.assertRaisesRegexp(ValueError,\n \"There is no tensor filter named \\\"bar\\\"\"):\n analyzer.get_tensor_filter(\"bar\")\n\n def _findSourceLine(self, annotated_source, line_number):\n \"\"\"Find line of given line number in annotated source.\n\n Args:\n annotated_source: (debugger_cli_common.RichTextLines) the annotated source\n line_number: (int) 1-based line number\n\n Returns:\n (int) If line_number is found, 0-based line index in\n annotated_source.lines. Otherwise, None.\n \"\"\"\n\n index = None\n for i, line in enumerate(annotated_source.lines):\n if line.startswith(\"L%d \" % line_number):\n index = i\n break\n return index\n\n def testPrintSourceForOpNamesWholeFileWorks(self):\n self._debug_dump.set_python_graph(self._sess.graph)\n out = self._registry.dispatch_command(\n \"print_source\", [self._curr_file_path], screen_info={\"cols\": 80})\n\n # Verify the annotation of the line that creates u.\n index = self._findSourceLine(out, self._u_line_number)\n self.assertEqual(\n [\"L%d u = variables.VariableV1(u_init, name=u_name)\" %\n self._u_line_number,\n \" simple_mul_add/u\",\n \" simple_mul_add/u/Assign\",\n \" simple_mul_add/u/read\"],\n out.lines[index : index + 4])\n self.assertEqual(\"pt simple_mul_add/u\",\n out.font_attr_segs[index + 1][0][2].content)\n # simple_mul_add/u/Assign is not used in this run because the Variable has\n # already been initialized.\n self.assertEqual(cli_shared.COLOR_BLUE, out.font_attr_segs[index + 2][0][2])\n self.assertEqual(\"pt simple_mul_add/u/read\",\n out.font_attr_segs[index + 3][0][2].content)\n\n # Verify the annotation of the line that creates v.\n index = self._findSourceLine(out, self._v_line_number)\n self.assertEqual(\n [\"L%d v = variables.VariableV1(v_init, name=v_name)\" %\n self._v_line_number,\n \" simple_mul_add/v\"],\n out.lines[index : index + 2])\n self.assertEqual(\"pt simple_mul_add/v\",\n out.font_attr_segs[index + 1][0][2].content)\n\n # Verify the annotation of the line that creates w.\n index = self._findSourceLine(out, self._w_line_number)\n self.assertEqual(\n [\"L%d \" % self._w_line_number +\n \"w = math_ops.matmul(u, v, name=\\\"simple_mul_add/matmul\\\")\",\n \" simple_mul_add/matmul\"],\n out.lines[index : index + 2])\n self.assertEqual(\"pt simple_mul_add/matmul\",\n out.font_attr_segs[index + 1][0][2].content)\n\n # Verify the annotation of the line that creates x.\n index = self._findSourceLine(out, self._x_line_number)\n self.assertEqual(\n [\"L%d \" % self._x_line_number +\n \"x = math_ops.add(w, w, name=\\\"simple_mul_add/add\\\")\",\n \" simple_mul_add/add\"],\n out.lines[index : index + 2])\n self.assertEqual(\"pt simple_mul_add/add\",\n out.font_attr_segs[index + 1][0][2].content)\n\n def testPrintSourceForTensorNamesWholeFileWorks(self):\n self._debug_dump.set_python_graph(self._sess.graph)\n out = self._registry.dispatch_command(\n \"print_source\",\n [self._curr_file_path, \"--tensors\"],\n screen_info={\"cols\": 80})\n\n # Verify the annotation of the line that creates u.\n index = self._findSourceLine(out, self._u_line_number)\n self.assertEqual(\n [\"L%d u = variables.VariableV1(u_init, name=u_name)\" %\n self._u_line_number,\n \" simple_mul_add/u/read:0\",\n \" simple_mul_add/u:0\"],\n out.lines[index : index + 3])\n self.assertEqual(\"pt simple_mul_add/u/read:0\",\n out.font_attr_segs[index + 1][0][2].content)\n self.assertEqual(\"pt simple_mul_add/u:0\",\n out.font_attr_segs[index + 2][0][2].content)\n\n def testPrintSourceForOpNamesStartingAtSpecifiedLineWorks(self):\n self._debug_dump.set_python_graph(self._sess.graph)\n out = self._registry.dispatch_command(\n \"print_source\",\n [self._curr_file_path, \"-b\", \"3\"],\n screen_info={\"cols\": 80})\n\n self.assertEqual(\n 2, out.annotations[debugger_cli_common.INIT_SCROLL_POS_KEY])\n\n index = self._findSourceLine(out, self._u_line_number)\n self.assertEqual(\n [\"L%d u = variables.VariableV1(u_init, name=u_name)\" %\n self._u_line_number,\n \" simple_mul_add/u\",\n \" simple_mul_add/u/Assign\",\n \" simple_mul_add/u/read\"],\n out.lines[index : index + 4])\n self.assertEqual(\"pt simple_mul_add/u\",\n out.font_attr_segs[index + 1][0][2].content)\n # simple_mul_add/u/Assign is not used in this run because the Variable has\n # already been initialized.\n self.assertEqual(cli_shared.COLOR_BLUE, out.font_attr_segs[index + 2][0][2])\n self.assertEqual(\"pt simple_mul_add/u/read\",\n out.font_attr_segs[index + 3][0][2].content)\n\n def testPrintSourceForOpNameSettingMaximumElementCountWorks(self):\n self._debug_dump.set_python_graph(self._sess.graph)\n out = self._registry.dispatch_command(\n \"print_source\",\n [self._curr_file_path, \"-m\", \"1\"],\n screen_info={\"cols\": 80})\n\n index = self._findSourceLine(out, self._u_line_number)\n self.assertEqual(\n [\"L%d u = variables.VariableV1(u_init, name=u_name)\" %\n self._u_line_number,\n \" simple_mul_add/u\",\n \" (... Omitted 2 of 3 op(s) ...) +5\"],\n out.lines[index : index + 3])\n self.assertEqual(\"pt simple_mul_add/u\",\n out.font_attr_segs[index + 1][0][2].content)\n more_elements_command = out.font_attr_segs[index + 2][-1][2].content\n self.assertStartsWith(more_elements_command,\n \"ps %s \" % self._curr_file_path)\n self.assertIn(\" -m 6\", more_elements_command)\n\n def testListSourceWorks(self):\n self._debug_dump.set_python_graph(self._sess.graph)\n out = self._registry.dispatch_command(\"list_source\", [])\n\n non_tf_lib_files_start = [\n i for i in xrange(len(out.lines))\n if out.lines[i].startswith(\"Source file path\")][0] + 1\n non_tf_lib_files_end = [\n i for i in xrange(len(out.lines))\n if out.lines[i].startswith(\"TensorFlow Python library file(s):\")][0] - 1\n non_tf_lib_files = [\n line.split(\" \")[0] for line\n in out.lines[non_tf_lib_files_start : non_tf_lib_files_end]]\n self.assertIn(self._curr_file_path, non_tf_lib_files)\n\n # Check that the TF library files are marked with special color attribute.\n for i in xrange(non_tf_lib_files_end + 1, len(out.lines)):\n if not out.lines[i]:\n continue\n for attr_seg in out.font_attr_segs[i]:\n self.assertTrue(cli_shared.COLOR_GRAY in attr_seg[2] or\n attr_seg[2] == cli_shared.COLOR_GRAY)\n\n def testListSourceWithNodeNameFilterWithMatchesWorks(self):\n self._debug_dump.set_python_graph(self._sess.graph)\n out = self._registry.dispatch_command(\"list_source\", [\"-n\", \".*/read\"])\n\n self.assertStartsWith(out.lines[1], \"Node name regex filter: \\\".*/read\\\"\")\n\n non_tf_lib_files_start = [\n i for i in xrange(len(out.lines))\n if out.lines[i].startswith(\"Source file path\")][0] + 1\n non_tf_lib_files_end = [\n i for i in xrange(len(out.lines))\n if out.lines[i].startswith(\"TensorFlow Python library file(s):\")][0] - 1\n non_tf_lib_files = [\n line.split(\" \")[0] for line\n in out.lines[non_tf_lib_files_start : non_tf_lib_files_end]]\n self.assertIn(self._curr_file_path, non_tf_lib_files)\n\n # Check that the TF library files are marked with special color attribute.\n for i in xrange(non_tf_lib_files_end + 1, len(out.lines)):\n if not out.lines[i]:\n continue\n for attr_seg in out.font_attr_segs[i]:\n self.assertTrue(cli_shared.COLOR_GRAY in attr_seg[2] or\n attr_seg[2] == cli_shared.COLOR_GRAY)\n\n def testListSourceWithNodeNameFilterWithNoMatchesWorks(self):\n self._debug_dump.set_python_graph(self._sess.graph)\n out = self._registry.dispatch_command(\"list_source\", [\"-n\", \"^$\"])\n\n self.assertEqual([\n \"List of source files that created nodes in this run\",\n \"Node name regex filter: \\\"^$\\\"\", \"\",\n \"[No source file information.]\"], out.lines)\n\n def testListSourceWithPathAndNodeNameFiltersWorks(self):\n self._debug_dump.set_python_graph(self._sess.graph)\n out = self._registry.dispatch_command(\n \"list_source\", [\"-p\", self._curr_file_path, \"-n\", \".*read\"])\n\n self.assertEqual([\n \"List of source files that created nodes in this run\",\n \"File path regex filter: \\\"%s\\\"\" % self._curr_file_path,\n \"Node name regex filter: \\\".*read\\\"\", \"\"], out.lines[:4])\n\n def testListSourceWithCompiledPythonSourceWorks(self):\n def fake_list_source_files_against_dump(dump,\n path_regex_whitelist=None,\n node_name_regex_whitelist=None):\n del dump, path_regex_whitelist, node_name_regex_whitelist\n return [(\"compiled_1.pyc\", False, 10, 20, 30, 4),\n (\"compiled_2.pyo\", False, 10, 20, 30, 5),\n (\"uncompiled.py\", False, 10, 20, 30, 6)]\n\n with test.mock.patch.object(\n source_utils, \"list_source_files_against_dump\",\n side_effect=fake_list_source_files_against_dump):\n out = self._registry.dispatch_command(\"list_source\", [])\n\n self.assertStartsWith(out.lines[4], \"compiled_1.pyc\")\n self.assertEqual((0, 14, [cli_shared.COLOR_WHITE]),\n out.font_attr_segs[4][0])\n self.assertStartsWith(out.lines[5], \"compiled_2.pyo\")\n self.assertEqual((0, 14, [cli_shared.COLOR_WHITE]),\n out.font_attr_segs[5][0])\n self.assertStartsWith(out.lines[6], \"uncompiled.py\")\n self.assertEqual(0, out.font_attr_segs[6][0][0])\n self.assertEqual(13, out.font_attr_segs[6][0][1])\n self.assertEqual(cli_shared.COLOR_WHITE, out.font_attr_segs[6][0][2][0])\n self.assertEqual(\"ps uncompiled.py -b 6\",\n out.font_attr_segs[6][0][2][1].content)\n\n def testListInputInvolvingNodesWithMultipleOutputs(self):\n \"\"\"List an input tree containing tensors from non-:0 output slot.\"\"\"\n\n with session.Session(config=no_rewrite_session_config()) as sess:\n x = variables.VariableV1([1, 3, 3, 7], name=\"x\")\n _, idx = array_ops.unique(x, name=\"x_unique\")\n idx_times_two = math_ops.multiply(idx, 2, name=\"idx_times_two\")\n self.evaluate(x.initializer)\n\n run_options = config_pb2.RunOptions(output_partition_graphs=True)\n debug_utils.watch_graph(\n run_options,\n sess.graph,\n debug_ops=[\"DebugIdentity\"],\n debug_urls=\"file://%s\" % self._dump_root_for_unique)\n run_metadata = config_pb2.RunMetadata()\n self.assertAllEqual(\n [0, 2, 2, 4],\n sess.run(idx_times_two,\n options=run_options,\n run_metadata=run_metadata))\n debug_dump = debug_data.DebugDumpDir(\n self._dump_root_for_unique,\n partition_graphs=run_metadata.partition_graphs)\n _, registry = create_analyzer_cli(debug_dump)\n\n out = registry.dispatch_command(\"li\", [\"idx_times_two\"])\n self.assertEqual(\n [\"Inputs to node \\\"idx_times_two\\\" (Depth limit = 1):\",\n \"|- (1) x_unique:1\"], out.lines[:2])\n\n\nclass AnalyzerCLIPrintLargeTensorTest(test_util.TensorFlowTestCase):\n\n @classmethod\n def setUpClass(cls):\n cls._dump_root = tempfile.mkdtemp()\n\n with session.Session(config=no_rewrite_session_config()) as sess:\n # 2400 elements should exceed the default threshold (2000).\n x = constant_op.constant(np.zeros([300, 8]), name=\"large_tensors/x\")\n\n run_options = config_pb2.RunOptions(output_partition_graphs=True)\n debug_utils.watch_graph(\n run_options,\n sess.graph,\n debug_ops=[\"DebugIdentity\"],\n debug_urls=\"file://%s\" % cls._dump_root)\n\n # Invoke Session.run().\n run_metadata = config_pb2.RunMetadata()\n sess.run(x, options=run_options, run_metadata=run_metadata)\n\n cls._debug_dump = debug_data.DebugDumpDir(\n cls._dump_root, partition_graphs=run_metadata.partition_graphs)\n\n # Construct the analyzer and command registry.\n cls._analyzer, cls._registry = create_analyzer_cli(cls._debug_dump)\n\n @classmethod\n def tearDownClass(cls):\n # Tear down temporary dump directory.\n shutil.rmtree(cls._dump_root)\n\n def testPrintLargeTensorWithoutAllOption(self):\n out = self._registry.dispatch_command(\n \"print_tensor\", [\"large_tensors/x:0\"], screen_info={\"cols\": 80})\n\n # Assert that ellipses are present in the tensor value printout.\n self.assertIn(\"...,\", out.lines[4])\n\n # 2100 still exceeds 2000.\n out = self._registry.dispatch_command(\n \"print_tensor\", [\"large_tensors/x:0[:, 0:7]\"],\n screen_info={\"cols\": 80})\n\n self.assertIn(\"...,\", out.lines[4])\n\n def testPrintLargeTensorWithAllOption(self):\n out = self._registry.dispatch_command(\n \"print_tensor\", [\"large_tensors/x:0\", \"-a\"],\n screen_info={\"cols\": 80})\n\n # Assert that ellipses are not present in the tensor value printout.\n self.assertNotIn(\"...,\", out.lines[4])\n\n out = self._registry.dispatch_command(\n \"print_tensor\", [\"large_tensors/x:0[:, 0:7]\", \"--all\"],\n screen_info={\"cols\": 80})\n self.assertNotIn(\"...,\", out.lines[4])\n\n\n@test_util.run_v1_only(\"b/120545219\")\nclass AnalyzerCLIControlDepTest(test_util.TensorFlowTestCase):\n\n @classmethod\n def setUpClass(cls):\n cls._dump_root = tempfile.mkdtemp()\n\n cls._is_gpu_available = test.is_gpu_available()\n if cls._is_gpu_available:\n gpu_name = test_util.gpu_device_name()\n cls._main_device = \"/job:localhost/replica:0/task:0\" + gpu_name\n else:\n cls._main_device = \"/job:localhost/replica:0/task:0/device:CPU:0\"\n\n with session.Session(config=no_rewrite_session_config()) as sess:\n x_init_val = np.array([5.0, 3.0])\n x_init = constant_op.constant(x_init_val, shape=[2])\n x = variables.VariableV1(x_init, name=\"control_deps/x\")\n\n y = math_ops.add(x, x, name=\"control_deps/y\")\n y = control_flow_ops.with_dependencies(\n [x], y, name=\"control_deps/ctrl_dep_y\")\n\n z = math_ops.multiply(x, y, name=\"control_deps/z\")\n\n z = control_flow_ops.with_dependencies(\n [x, y], z, name=\"control_deps/ctrl_dep_z\")\n\n x.initializer.run()\n\n run_options = config_pb2.RunOptions(output_partition_graphs=True)\n debug_utils.watch_graph(\n run_options,\n sess.graph,\n debug_ops=[\"DebugIdentity\"],\n debug_urls=\"file://%s\" % cls._dump_root)\n\n # Invoke Session.run().\n run_metadata = config_pb2.RunMetadata()\n sess.run(z, options=run_options, run_metadata=run_metadata)\n\n debug_dump = debug_data.DebugDumpDir(\n cls._dump_root, partition_graphs=run_metadata.partition_graphs)\n\n # Construct the analyzer and command handler registry.\n _, cls._registry = create_analyzer_cli(debug_dump)\n\n @classmethod\n def tearDownClass(cls):\n # Tear down temporary dump directory.\n shutil.rmtree(cls._dump_root)\n\n def testNodeInfoWithControlDependencies(self):\n # Call node_info on a node with control inputs.\n out = self._registry.dispatch_command(\"node_info\",\n [\"control_deps/ctrl_dep_y\"])\n\n assert_node_attribute_lines(\n self, out, \"control_deps/ctrl_dep_y\", \"Identity\",\n self._main_device, [(\"Add\", \"control_deps/y\")],\n [(\"VariableV2\", \"control_deps/x\")],\n [(\"Mul\", \"control_deps/z\")],\n [(\"Identity\", \"control_deps/ctrl_dep_z\")])\n\n # Call node info on a node with control recipients.\n out = self._registry.dispatch_command(\"ni\", [\"control_deps/x\"])\n\n assert_node_attribute_lines(self, out, \"control_deps/x\", \"VariableV2\",\n self._main_device, [], [],\n [(\"Identity\", \"control_deps/x/read\")],\n [(\"Identity\", \"control_deps/ctrl_dep_y\"),\n (\"Identity\", \"control_deps/ctrl_dep_z\")])\n\n # Verify the menu items (command shortcuts) in the output.\n check_menu_item(self, out, 10,\n len(out.lines[10]) - len(\"control_deps/x/read\"),\n len(out.lines[10]), \"ni -a -d -t control_deps/x/read\")\n if out.lines[13].endswith(\"control_deps/ctrl_dep_y\"):\n y_line = 13\n z_line = 14\n else:\n y_line = 14\n z_line = 13\n check_menu_item(self, out, y_line,\n len(out.lines[y_line]) - len(\"control_deps/ctrl_dep_y\"),\n len(out.lines[y_line]),\n \"ni -a -d -t control_deps/ctrl_dep_y\")\n check_menu_item(self, out, z_line,\n len(out.lines[z_line]) - len(\"control_deps/ctrl_dep_z\"),\n len(out.lines[z_line]),\n \"ni -a -d -t control_deps/ctrl_dep_z\")\n\n def testListInputsNonRecursiveNoControl(self):\n \"\"\"List inputs non-recursively, without any control inputs.\"\"\"\n\n # Do not include node op types.\n node_name = \"control_deps/z\"\n out = self._registry.dispatch_command(\"list_inputs\", [node_name])\n\n self.assertEqual([\n \"Inputs to node \\\"%s\\\" (Depth limit = 1):\" % node_name,\n \"|- (1) control_deps/x/read\", \"| |- ...\",\n \"|- (1) control_deps/ctrl_dep_y\", \" |- ...\", \"\", \"Legend:\",\n \" (d): recursion depth = d.\"\n ], out.lines)\n\n # Include node op types.\n out = self._registry.dispatch_command(\"li\", [\"-t\", node_name])\n\n self.assertEqual([\n \"Inputs to node \\\"%s\\\" (Depth limit = 1):\" % node_name,\n \"|- (1) [Identity] control_deps/x/read\", \"| |- ...\",\n \"|- (1) [Identity] control_deps/ctrl_dep_y\", \" |- ...\", \"\", \"Legend:\",\n \" (d): recursion depth = d.\", \" [Op]: Input node has op type Op.\"\n ], out.lines)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n node_info_node_name=node_name,\n print_tensor_node_name=node_name,\n list_outputs_node_name=node_name)\n\n # Verify that the node name has bold attribute.\n self.assertEqual([(16, 16 + len(node_name), \"bold\")], out.font_attr_segs[0])\n\n # Verify the menu items (command shortcuts) in the output.\n check_menu_item(self, out, 1,\n len(out.lines[1]) - len(\"control_deps/x/read\"),\n len(out.lines[1]), \"li -c -r control_deps/x/read\")\n check_menu_item(self, out, 3,\n len(out.lines[3]) - len(\"control_deps/ctrl_dep_y\"),\n len(out.lines[3]), \"li -c -r control_deps/ctrl_dep_y\")\n\n def testListInputsNonRecursiveNoControlUsingTensorName(self):\n \"\"\"List inputs using the name of an output tensor of the node.\"\"\"\n\n # Do not include node op types.\n node_name = \"control_deps/z\"\n tensor_name = node_name + \":0\"\n out = self._registry.dispatch_command(\"list_inputs\", [tensor_name])\n\n self.assertEqual([\n \"Inputs to node \\\"%s\\\" (Depth limit = 1):\" % node_name,\n \"|- (1) control_deps/x/read\", \"| |- ...\",\n \"|- (1) control_deps/ctrl_dep_y\", \" |- ...\", \"\", \"Legend:\",\n \" (d): recursion depth = d.\"\n ], out.lines)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n node_info_node_name=node_name,\n print_tensor_node_name=node_name,\n list_outputs_node_name=node_name)\n check_menu_item(self, out, 1,\n len(out.lines[1]) - len(\"control_deps/x/read\"),\n len(out.lines[1]), \"li -c -r control_deps/x/read\")\n check_menu_item(self, out, 3,\n len(out.lines[3]) - len(\"control_deps/ctrl_dep_y\"),\n len(out.lines[3]), \"li -c -r control_deps/ctrl_dep_y\")\n\n def testListInputsNonRecursiveWithControls(self):\n \"\"\"List inputs non-recursively, with control inputs.\"\"\"\n node_name = \"control_deps/ctrl_dep_z\"\n out = self._registry.dispatch_command(\"li\", [\"-t\", node_name, \"-c\"])\n\n self.assertEqual([\n \"Inputs to node \\\"%s\\\" (Depth limit = 1, \" % node_name +\n \"control inputs included):\", \"|- (1) [Mul] control_deps/z\", \"| |- ...\",\n \"|- (1) (Ctrl) [Identity] control_deps/ctrl_dep_y\", \"| |- ...\",\n \"|- (1) (Ctrl) [VariableV2] control_deps/x\", \"\", \"Legend:\",\n \" (d): recursion depth = d.\", \" (Ctrl): Control input.\",\n \" [Op]: Input node has op type Op.\"\n ], out.lines)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n node_info_node_name=node_name,\n print_tensor_node_name=node_name,\n list_outputs_node_name=node_name)\n check_menu_item(self, out, 1,\n len(out.lines[1]) - len(\"control_deps/z\"),\n len(out.lines[1]), \"li -c -r control_deps/z\")\n check_menu_item(self, out, 3,\n len(out.lines[3]) - len(\"control_deps/ctrl_dep_y\"),\n len(out.lines[3]), \"li -c -r control_deps/ctrl_dep_y\")\n check_menu_item(self, out, 5,\n len(out.lines[5]) - len(\"control_deps/x\"),\n len(out.lines[5]), \"li -c -r control_deps/x\")\n\n def testListInputsRecursiveWithControls(self):\n \"\"\"List inputs recursively, with control inputs.\"\"\"\n node_name = \"control_deps/ctrl_dep_z\"\n out = self._registry.dispatch_command(\"li\", [\"-c\", \"-r\", \"-t\", node_name])\n\n self.assertEqual([\n \"Inputs to node \\\"%s\\\" (Depth limit = 20, \" % node_name +\n \"control inputs included):\", \"|- (1) [Mul] control_deps/z\",\n \"| |- (2) [Identity] control_deps/x/read\",\n \"| | |- (3) [VariableV2] control_deps/x\",\n \"| |- (2) [Identity] control_deps/ctrl_dep_y\",\n \"| |- (3) [Add] control_deps/y\",\n \"| | |- (4) [Identity] control_deps/x/read\",\n \"| | | |- (5) [VariableV2] control_deps/x\",\n \"| | |- (4) [Identity] control_deps/x/read\",\n \"| | |- (5) [VariableV2] control_deps/x\",\n \"| |- (3) (Ctrl) [VariableV2] control_deps/x\",\n \"|- (1) (Ctrl) [Identity] control_deps/ctrl_dep_y\",\n \"| |- (2) [Add] control_deps/y\",\n \"| | |- (3) [Identity] control_deps/x/read\",\n \"| | | |- (4) [VariableV2] control_deps/x\",\n \"| | |- (3) [Identity] control_deps/x/read\",\n \"| | |- (4) [VariableV2] control_deps/x\",\n \"| |- (2) (Ctrl) [VariableV2] control_deps/x\",\n \"|- (1) (Ctrl) [VariableV2] control_deps/x\", \"\", \"Legend:\",\n \" (d): recursion depth = d.\", \" (Ctrl): Control input.\",\n \" [Op]: Input node has op type Op.\"\n ], out.lines)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n node_info_node_name=node_name,\n print_tensor_node_name=node_name,\n list_outputs_node_name=node_name)\n check_menu_item(self, out, 1,\n len(out.lines[1]) - len(\"control_deps/z\"),\n len(out.lines[1]), \"li -c -r control_deps/z\")\n check_menu_item(self, out, 11,\n len(out.lines[11]) - len(\"control_deps/ctrl_dep_y\"),\n len(out.lines[11]), \"li -c -r control_deps/ctrl_dep_y\")\n check_menu_item(self, out, 18,\n len(out.lines[18]) - len(\"control_deps/x\"),\n len(out.lines[18]), \"li -c -r control_deps/x\")\n\n def testListInputsRecursiveWithControlsWithDepthLimit(self):\n \"\"\"List inputs recursively, with control inputs and a depth limit.\"\"\"\n node_name = \"control_deps/ctrl_dep_z\"\n out = self._registry.dispatch_command(\n \"li\", [\"-c\", \"-r\", \"-t\", \"-d\", \"2\", node_name])\n\n self.assertEqual([\n \"Inputs to node \\\"%s\\\" (Depth limit = 2, \" % node_name +\n \"control inputs included):\", \"|- (1) [Mul] control_deps/z\",\n \"| |- (2) [Identity] control_deps/x/read\", \"| | |- ...\",\n \"| |- (2) [Identity] control_deps/ctrl_dep_y\", \"| |- ...\",\n \"|- (1) (Ctrl) [Identity] control_deps/ctrl_dep_y\",\n \"| |- (2) [Add] control_deps/y\", \"| | |- ...\",\n \"| |- (2) (Ctrl) [VariableV2] control_deps/x\",\n \"|- (1) (Ctrl) [VariableV2] control_deps/x\", \"\", \"Legend:\",\n \" (d): recursion depth = d.\", \" (Ctrl): Control input.\",\n \" [Op]: Input node has op type Op.\"\n ], out.lines)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n node_info_node_name=node_name,\n print_tensor_node_name=node_name,\n list_outputs_node_name=node_name)\n check_menu_item(self, out, 1,\n len(out.lines[1]) - len(\"control_deps/z\"),\n len(out.lines[1]), \"li -c -r control_deps/z\")\n check_menu_item(self, out, 10,\n len(out.lines[10]) - len(\"control_deps/x\"),\n len(out.lines[10]), \"li -c -r control_deps/x\")\n\n def testListInputsNodeWithoutInputs(self):\n \"\"\"List the inputs to a node without any input.\"\"\"\n node_name = \"control_deps/x\"\n out = self._registry.dispatch_command(\"li\", [\"-c\", \"-r\", \"-t\", node_name])\n\n self.assertEqual([\n \"Inputs to node \\\"%s\\\" (Depth limit = 20, control \" % node_name +\n \"inputs included):\", \" [None]\", \"\", \"Legend:\",\n \" (d): recursion depth = d.\", \" (Ctrl): Control input.\",\n \" [Op]: Input node has op type Op.\"\n ], out.lines)\n check_main_menu(\n self,\n out,\n list_tensors_enabled=True,\n node_info_node_name=node_name,\n print_tensor_node_name=node_name,\n list_outputs_node_name=node_name)\n\n def testListInputsNonexistentNode(self):\n out = self._registry.dispatch_command(\n \"list_inputs\", [\"control_deps/z/foo\"])\n\n self.assertEqual([\n \"ERROR: There is no node named \\\"control_deps/z/foo\\\" in the \"\n \"partition graphs\"], out.lines)\n\n def testListRecipientsRecursiveWithControlsWithDepthLimit(self):\n \"\"\"List recipients recursively, with control inputs and a depth limit.\"\"\"\n\n out = self._registry.dispatch_command(\n \"lo\", [\"-c\", \"-r\", \"-t\", \"-d\", \"1\", \"control_deps/x\"])\n\n self.assertEqual([\n \"Recipients of node \\\"control_deps/x\\\" (Depth limit = 1, control \"\n \"recipients included):\",\n \"|- (1) [Identity] control_deps/x/read\",\n \"| |- ...\",\n \"|- (1) (Ctrl) [Identity] control_deps/ctrl_dep_y\",\n \"| |- ...\",\n \"|- (1) (Ctrl) [Identity] control_deps/ctrl_dep_z\",\n \"\", \"Legend:\", \" (d): recursion depth = d.\",\n \" (Ctrl): Control input.\",\n \" [Op]: Input node has op type Op.\"], out.lines)\n check_menu_item(self, out, 1,\n len(out.lines[1]) - len(\"control_deps/x/read\"),\n len(out.lines[1]), \"lo -c -r control_deps/x/read\")\n check_menu_item(self, out, 3,\n len(out.lines[3]) - len(\"control_deps/ctrl_dep_y\"),\n len(out.lines[3]), \"lo -c -r control_deps/ctrl_dep_y\")\n check_menu_item(self, out, 5,\n len(out.lines[5]) - len(\"control_deps/ctrl_dep_z\"),\n len(out.lines[5]), \"lo -c -r control_deps/ctrl_dep_z\")\n\n # Verify the bold attribute of the node name.\n self.assertEqual([(20, 20 + len(\"control_deps/x\"), \"bold\")],\n out.font_attr_segs[0])\n\n\n@test_util.run_v1_only(\"b/120545219\")\nclass AnalyzerCLIWhileLoopTest(test_util.TensorFlowTestCase):\n\n @classmethod\n def setUpClass(cls):\n cls._dump_root = tempfile.mkdtemp()\n\n with session.Session(config=no_rewrite_session_config()) as sess:\n loop_var = constant_op.constant(0, name=\"while_loop_test/loop_var\")\n cond = lambda loop_var: math_ops.less(loop_var, 10)\n body = lambda loop_var: math_ops.add(loop_var, 1)\n while_loop = control_flow_ops.while_loop(\n cond, body, [loop_var], parallel_iterations=1)\n\n run_options = config_pb2.RunOptions(output_partition_graphs=True)\n debug_url = \"file://%s\" % cls._dump_root\n\n watch_opts = run_options.debug_options.debug_tensor_watch_opts\n\n # Add debug tensor watch for \"while/Identity\".\n watch = watch_opts.add()\n watch.node_name = \"while/Identity\"\n watch.output_slot = 0\n watch.debug_ops.append(\"DebugIdentity\")\n watch.debug_urls.append(debug_url)\n\n # Invoke Session.run().\n run_metadata = config_pb2.RunMetadata()\n sess.run(while_loop, options=run_options, run_metadata=run_metadata)\n\n cls._debug_dump = debug_data.DebugDumpDir(\n cls._dump_root, partition_graphs=run_metadata.partition_graphs)\n\n cls._analyzer, cls._registry = create_analyzer_cli(cls._debug_dump)\n\n @classmethod\n def tearDownClass(cls):\n # Tear down temporary dump directory.\n shutil.rmtree(cls._dump_root)\n\n def testMultipleDumpsPrintTensorNoNumber(self):\n output = self._registry.dispatch_command(\"pt\", [\"while/Identity:0\"])\n\n self.assertEqual(\"Tensor \\\"while/Identity:0\\\" generated 10 dumps:\",\n output.lines[0])\n\n for i in xrange(10):\n self.assertTrue(output.lines[i + 1].startswith(\"#%d\" % i))\n self.assertTrue(output.lines[i + 1].endswith(\n \" ms] while/Identity:0:DebugIdentity\"))\n\n self.assertEqual(\n \"You can use the -n (--number) flag to specify which dump to print.\",\n output.lines[-3])\n self.assertEqual(\"For example:\", output.lines[-2])\n self.assertEqual(\" print_tensor while/Identity:0 -n 0\", output.lines[-1])\n\n def testMultipleDumpsPrintTensorWithNumber(self):\n for i in xrange(5):\n output = self._registry.dispatch_command(\n \"pt\", [\"while/Identity:0\", \"-n\", \"%d\" % i])\n\n self.assertEqual(\"Tensor \\\"while/Identity:0:DebugIdentity (dump #%d)\\\":\" %\n i, output.lines[0])\n self.assertEqual(\" dtype: int32\", output.lines[1])\n self.assertEqual(\" shape: ()\", output.lines[2])\n self.assertEqual(\"\", output.lines[3])\n self.assertTrue(output.lines[4].startswith(\"array(%d\" % i))\n self.assertTrue(output.lines[4].endswith(\")\"))\n\n def testMultipleDumpsPrintTensorInvalidNumber(self):\n output = self._registry.dispatch_command(\"pt\",\n [\"while/Identity:0\", \"-n\", \"10\"])\n\n self.assertEqual([\n \"ERROR: Specified number (10) exceeds the number of available dumps \"\n \"(10) for tensor while/Identity:0\"\n ], output.lines)\n\n\nif __name__ == \"__main__\":\n googletest.main()\n",
"# Copyright 2017 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 data input for speech commands.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\n\nimport numpy as np\nimport tensorflow as tf\n\nfrom tensorflow.contrib.framework.python.ops import audio_ops as contrib_audio\nfrom tensorflow.examples.speech_commands import input_data\nfrom tensorflow.examples.speech_commands import models\nfrom tensorflow.python.framework import test_util\nfrom tensorflow.python.platform import test\n\n\nclass InputDataTest(test.TestCase):\n\n def _getWavData(self):\n with self.cached_session() as sess:\n sample_data = tf.zeros([32000, 2])\n wav_encoder = contrib_audio.encode_wav(sample_data, 16000)\n wav_data = self.evaluate(wav_encoder)\n return wav_data\n\n def _saveTestWavFile(self, filename, wav_data):\n with open(filename, \"wb\") as f:\n f.write(wav_data)\n\n def _saveWavFolders(self, root_dir, labels, how_many):\n wav_data = self._getWavData()\n for label in labels:\n dir_name = os.path.join(root_dir, label)\n os.mkdir(dir_name)\n for i in range(how_many):\n file_path = os.path.join(dir_name, \"some_audio_%d.wav\" % i)\n self._saveTestWavFile(file_path, wav_data)\n\n def _model_settings(self):\n return {\n \"desired_samples\": 160,\n \"fingerprint_size\": 40,\n \"label_count\": 4,\n \"window_size_samples\": 100,\n \"window_stride_samples\": 100,\n \"fingerprint_width\": 40,\n \"preprocess\": \"mfcc\",\n }\n\n def _runGetDataTest(self, preprocess, window_length_ms):\n tmp_dir = self.get_temp_dir()\n wav_dir = os.path.join(tmp_dir, \"wavs\")\n os.mkdir(wav_dir)\n self._saveWavFolders(wav_dir, [\"a\", \"b\", \"c\"], 100)\n background_dir = os.path.join(wav_dir, \"_background_noise_\")\n os.mkdir(background_dir)\n wav_data = self._getWavData()\n for i in range(10):\n file_path = os.path.join(background_dir, \"background_audio_%d.wav\" % i)\n self._saveTestWavFile(file_path, wav_data)\n model_settings = models.prepare_model_settings(\n 4, 16000, 1000, window_length_ms, 20, 40, preprocess)\n with self.cached_session() as sess:\n audio_processor = input_data.AudioProcessor(\n \"\", wav_dir, 10, 10, [\"a\", \"b\"], 10, 10, model_settings, tmp_dir)\n result_data, result_labels = audio_processor.get_data(\n 10, 0, model_settings, 0.3, 0.1, 100, \"training\", sess)\n self.assertEqual(10, len(result_data))\n self.assertEqual(10, len(result_labels))\n\n def testPrepareWordsList(self):\n words_list = [\"a\", \"b\"]\n self.assertGreater(\n len(input_data.prepare_words_list(words_list)), len(words_list))\n\n def testWhichSet(self):\n self.assertEqual(\n input_data.which_set(\"foo.wav\", 10, 10),\n input_data.which_set(\"foo.wav\", 10, 10))\n self.assertEqual(\n input_data.which_set(\"foo_nohash_0.wav\", 10, 10),\n input_data.which_set(\"foo_nohash_1.wav\", 10, 10))\n\n @test_util.run_deprecated_v1\n def testPrepareDataIndex(self):\n tmp_dir = self.get_temp_dir()\n self._saveWavFolders(tmp_dir, [\"a\", \"b\", \"c\"], 100)\n audio_processor = input_data.AudioProcessor(\"\", tmp_dir, 10, 10,\n [\"a\", \"b\"], 10, 10,\n self._model_settings(), tmp_dir)\n self.assertLess(0, audio_processor.set_size(\"training\"))\n self.assertTrue(\"training\" in audio_processor.data_index)\n self.assertTrue(\"validation\" in audio_processor.data_index)\n self.assertTrue(\"testing\" in audio_processor.data_index)\n self.assertEquals(input_data.UNKNOWN_WORD_INDEX,\n audio_processor.word_to_index[\"c\"])\n\n def testPrepareDataIndexEmpty(self):\n tmp_dir = self.get_temp_dir()\n self._saveWavFolders(tmp_dir, [\"a\", \"b\", \"c\"], 0)\n with self.assertRaises(Exception) as e:\n _ = input_data.AudioProcessor(\"\", tmp_dir, 10, 10, [\"a\", \"b\"], 10, 10,\n self._model_settings(), tmp_dir)\n self.assertTrue(\"No .wavs found\" in str(e.exception))\n\n def testPrepareDataIndexMissing(self):\n tmp_dir = self.get_temp_dir()\n self._saveWavFolders(tmp_dir, [\"a\", \"b\", \"c\"], 100)\n with self.assertRaises(Exception) as e:\n _ = input_data.AudioProcessor(\"\", tmp_dir, 10, 10, [\"a\", \"b\", \"d\"], 10,\n 10, self._model_settings(), tmp_dir)\n self.assertTrue(\"Expected to find\" in str(e.exception))\n\n @test_util.run_deprecated_v1\n def testPrepareBackgroundData(self):\n tmp_dir = self.get_temp_dir()\n background_dir = os.path.join(tmp_dir, \"_background_noise_\")\n os.mkdir(background_dir)\n wav_data = self._getWavData()\n for i in range(10):\n file_path = os.path.join(background_dir, \"background_audio_%d.wav\" % i)\n self._saveTestWavFile(file_path, wav_data)\n self._saveWavFolders(tmp_dir, [\"a\", \"b\", \"c\"], 100)\n audio_processor = input_data.AudioProcessor(\"\", tmp_dir, 10, 10,\n [\"a\", \"b\"], 10, 10,\n self._model_settings(), tmp_dir)\n self.assertEqual(10, len(audio_processor.background_data))\n\n def testLoadWavFile(self):\n tmp_dir = self.get_temp_dir()\n file_path = os.path.join(tmp_dir, \"load_test.wav\")\n wav_data = self._getWavData()\n self._saveTestWavFile(file_path, wav_data)\n sample_data = input_data.load_wav_file(file_path)\n self.assertIsNotNone(sample_data)\n\n def testSaveWavFile(self):\n tmp_dir = self.get_temp_dir()\n file_path = os.path.join(tmp_dir, \"load_test.wav\")\n save_data = np.zeros([16000, 1])\n input_data.save_wav_file(file_path, save_data, 16000)\n loaded_data = input_data.load_wav_file(file_path)\n self.assertIsNotNone(loaded_data)\n self.assertEqual(16000, len(loaded_data))\n\n @test_util.run_deprecated_v1\n def testPrepareProcessingGraph(self):\n tmp_dir = self.get_temp_dir()\n wav_dir = os.path.join(tmp_dir, \"wavs\")\n os.mkdir(wav_dir)\n self._saveWavFolders(wav_dir, [\"a\", \"b\", \"c\"], 100)\n background_dir = os.path.join(wav_dir, \"_background_noise_\")\n os.mkdir(background_dir)\n wav_data = self._getWavData()\n for i in range(10):\n file_path = os.path.join(background_dir, \"background_audio_%d.wav\" % i)\n self._saveTestWavFile(file_path, wav_data)\n model_settings = {\n \"desired_samples\": 160,\n \"fingerprint_size\": 40,\n \"label_count\": 4,\n \"window_size_samples\": 100,\n \"window_stride_samples\": 100,\n \"fingerprint_width\": 40,\n \"preprocess\": \"mfcc\",\n }\n audio_processor = input_data.AudioProcessor(\"\", wav_dir, 10, 10, [\"a\", \"b\"],\n 10, 10, model_settings, tmp_dir)\n self.assertIsNotNone(audio_processor.wav_filename_placeholder_)\n self.assertIsNotNone(audio_processor.foreground_volume_placeholder_)\n self.assertIsNotNone(audio_processor.time_shift_padding_placeholder_)\n self.assertIsNotNone(audio_processor.time_shift_offset_placeholder_)\n self.assertIsNotNone(audio_processor.background_data_placeholder_)\n self.assertIsNotNone(audio_processor.background_volume_placeholder_)\n self.assertIsNotNone(audio_processor.output_)\n\n @test_util.run_deprecated_v1\n def testGetDataAverage(self):\n self._runGetDataTest(\"average\", 10)\n\n @test_util.run_deprecated_v1\n def testGetDataAverageLongWindow(self):\n self._runGetDataTest(\"average\", 30)\n\n @test_util.run_deprecated_v1\n def testGetDataMfcc(self):\n self._runGetDataTest(\"mfcc\", 30)\n\n @test_util.run_deprecated_v1\n def testGetDataMicro(self):\n self._runGetDataTest(\"micro\", 20)\n\n @test_util.run_deprecated_v1\n def testGetUnprocessedData(self):\n tmp_dir = self.get_temp_dir()\n wav_dir = os.path.join(tmp_dir, \"wavs\")\n os.mkdir(wav_dir)\n self._saveWavFolders(wav_dir, [\"a\", \"b\", \"c\"], 100)\n model_settings = {\n \"desired_samples\": 160,\n \"fingerprint_size\": 40,\n \"label_count\": 4,\n \"window_size_samples\": 100,\n \"window_stride_samples\": 100,\n \"fingerprint_width\": 40,\n \"preprocess\": \"mfcc\",\n }\n audio_processor = input_data.AudioProcessor(\"\", wav_dir, 10, 10, [\"a\", \"b\"],\n 10, 10, model_settings, tmp_dir)\n result_data, result_labels = audio_processor.get_unprocessed_data(\n 10, model_settings, \"training\")\n self.assertEqual(10, len(result_data))\n self.assertEqual(10, len(result_labels))\n\n @test_util.run_deprecated_v1\n def testGetFeaturesForWav(self):\n tmp_dir = self.get_temp_dir()\n wav_dir = os.path.join(tmp_dir, \"wavs\")\n os.mkdir(wav_dir)\n self._saveWavFolders(wav_dir, [\"a\", \"b\", \"c\"], 1)\n desired_samples = 1600\n model_settings = {\n \"desired_samples\": desired_samples,\n \"fingerprint_size\": 40,\n \"label_count\": 4,\n \"window_size_samples\": 100,\n \"window_stride_samples\": 100,\n \"fingerprint_width\": 40,\n \"average_window_width\": 6,\n \"preprocess\": \"average\",\n }\n with self.cached_session() as sess:\n audio_processor = input_data.AudioProcessor(\n \"\", wav_dir, 10, 10, [\"a\", \"b\"], 10, 10, model_settings, tmp_dir)\n sample_data = np.zeros([desired_samples, 1])\n for i in range(desired_samples):\n phase = i % 4\n if phase == 0:\n sample_data[i, 0] = 0\n elif phase == 1:\n sample_data[i, 0] = -1\n elif phase == 2:\n sample_data[i, 0] = 0\n elif phase == 3:\n sample_data[i, 0] = 1\n test_wav_path = os.path.join(tmp_dir, \"test_wav.wav\")\n input_data.save_wav_file(test_wav_path, sample_data, 16000)\n\n results = audio_processor.get_features_for_wav(test_wav_path,\n model_settings, sess)\n spectrogram = results[0]\n self.assertEqual(1, spectrogram.shape[0])\n self.assertEqual(16, spectrogram.shape[1])\n self.assertEqual(11, spectrogram.shape[2])\n self.assertNear(0, spectrogram[0, 0, 0], 0.1)\n self.assertNear(200, spectrogram[0, 0, 5], 0.1)\n\n def testGetFeaturesRange(self):\n model_settings = {\n \"preprocess\": \"average\",\n }\n features_min, _ = input_data.get_features_range(model_settings)\n self.assertNear(0.0, features_min, 1e-5)\n\n def testGetMfccFeaturesRange(self):\n model_settings = {\n \"preprocess\": \"mfcc\",\n }\n features_min, features_max = input_data.get_features_range(model_settings)\n self.assertLess(features_min, features_max)\n\n\nif __name__ == \"__main__\":\n test.main()\n",
"# Copyright 2016 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\"\"\"The Logistic distribution class.\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport math\nimport numpy as np\n\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_shape\nfrom tensorflow.python.ops import array_ops\nfrom tensorflow.python.ops import check_ops\nfrom tensorflow.python.ops import math_ops\nfrom tensorflow.python.ops import nn_ops\nfrom tensorflow.python.ops import random_ops\nfrom tensorflow.python.ops.distributions import distribution\nfrom tensorflow.python.util import deprecation\n\n\nclass Logistic(distribution.Distribution):\n \"\"\"The Logistic distribution with location `loc` and `scale` parameters.\n\n #### Mathematical details\n\n The cumulative density function of this distribution is:\n\n ```none\n cdf(x; mu, sigma) = 1 / (1 + exp(-(x - mu) / sigma))\n ```\n\n where `loc = mu` and `scale = sigma`.\n\n The Logistic distribution is a member of the [location-scale family](\n https://en.wikipedia.org/wiki/Location-scale_family), i.e., it can be\n constructed as,\n\n ```none\n X ~ Logistic(loc=0, scale=1)\n Y = loc + scale * X\n ```\n\n #### Examples\n\n Examples of initialization of one or a batch of distributions.\n\n ```python\n import tensorflow_probability as tfp\n tfd = tfp.distributions\n\n # Define a single scalar Logistic distribution.\n dist = tfd.Logistic(loc=0., scale=3.)\n\n # Evaluate the cdf at 1, returning a scalar.\n dist.cdf(1.)\n\n # Define a batch of two scalar valued Logistics.\n # The first has mean 1 and scale 11, the second 2 and 22.\n dist = tfd.Logistic(loc=[1, 2.], scale=[11, 22.])\n\n # Evaluate the pdf of the first distribution on 0, and the second on 1.5,\n # returning a length two tensor.\n dist.prob([0, 1.5])\n\n # Get 3 samples, returning a 3 x 2 tensor.\n dist.sample([3])\n\n # Arguments are broadcast when possible.\n # Define a batch of two scalar valued Logistics.\n # Both have mean 1, but different scales.\n dist = tfd.Logistic(loc=1., scale=[11, 22.])\n\n # Evaluate the pdf of both distributions on the same point, 3.0,\n # returning a length 2 tensor.\n dist.prob(3.0)\n ```\n\n \"\"\"\n\n @deprecation.deprecated(\n \"2018-10-01\",\n \"The TensorFlow Distributions library has moved to \"\n \"TensorFlow Probability \"\n \"(https://github.com/tensorflow/probability). You \"\n \"should update all references to use `tfp.distributions` \"\n \"instead of `tf.contrib.distributions`.\",\n warn_once=True)\n def __init__(self,\n loc,\n scale,\n validate_args=False,\n allow_nan_stats=True,\n name=\"Logistic\"):\n \"\"\"Construct Logistic distributions with mean and scale `loc` and `scale`.\n\n The parameters `loc` and `scale` must be shaped in a way that supports\n broadcasting (e.g. `loc + scale` is a valid operation).\n\n Args:\n loc: Floating point tensor, the means of the distribution(s).\n scale: Floating point tensor, the scales of the distribution(s). Must\n contain only positive values.\n validate_args: Python `bool`, default `False`. When `True` distribution\n parameters are checked for validity despite possibly degrading runtime\n performance. When `False` invalid inputs may silently render incorrect\n outputs.\n allow_nan_stats: Python `bool`, default `True`. When `True`, statistics\n (e.g., mean, mode, variance) use the value \"`NaN`\" to indicate the\n result is undefined. When `False`, an exception is raised if one or\n more of the statistic's batch members are undefined.\n name: The name to give Ops created by the initializer.\n\n Raises:\n TypeError: if loc and scale are different dtypes.\n \"\"\"\n parameters = dict(locals())\n with ops.name_scope(name, values=[loc, scale]) as name:\n with ops.control_dependencies([check_ops.assert_positive(scale)] if\n validate_args else []):\n self._loc = array_ops.identity(loc, name=\"loc\")\n self._scale = array_ops.identity(scale, name=\"scale\")\n check_ops.assert_same_float_dtype([self._loc, self._scale])\n super(Logistic, self).__init__(\n dtype=self._scale.dtype,\n reparameterization_type=distribution.FULLY_REPARAMETERIZED,\n validate_args=validate_args,\n allow_nan_stats=allow_nan_stats,\n parameters=parameters,\n graph_parents=[self._loc, self._scale],\n name=name)\n\n @staticmethod\n def _param_shapes(sample_shape):\n return dict(\n zip((\"loc\", \"scale\"), ([ops.convert_to_tensor(\n sample_shape, dtype=dtypes.int32)] * 2)))\n\n @property\n def loc(self):\n \"\"\"Distribution parameter for the location.\"\"\"\n return self._loc\n\n @property\n def scale(self):\n \"\"\"Distribution parameter for scale.\"\"\"\n return self._scale\n\n def _batch_shape_tensor(self):\n return array_ops.broadcast_dynamic_shape(\n array_ops.shape(self.loc), array_ops.shape(self.scale))\n\n def _batch_shape(self):\n return array_ops.broadcast_static_shape(\n self.loc.get_shape(), self.scale.get_shape())\n\n def _event_shape_tensor(self):\n return constant_op.constant([], dtype=dtypes.int32)\n\n def _event_shape(self):\n return tensor_shape.TensorShape([])\n\n def _sample_n(self, n, seed=None):\n # Uniform variates must be sampled from the open-interval `(0, 1)` rather\n # than `[0, 1)`. To do so, we use `np.finfo(self.dtype.as_numpy_dtype).tiny`\n # because it is the smallest, positive, \"normal\" number. A \"normal\" number\n # is such that the mantissa has an implicit leading 1. Normal, positive\n # numbers x, y have the reasonable property that, `x + y >= max(x, y)`. In\n # this case, a subnormal number (i.e., np.nextafter) can cause us to sample\n # 0.\n uniform = random_ops.random_uniform(\n shape=array_ops.concat([[n], self.batch_shape_tensor()], 0),\n minval=np.finfo(self.dtype.as_numpy_dtype).tiny,\n maxval=1.,\n dtype=self.dtype,\n seed=seed)\n sampled = math_ops.log(uniform) - math_ops.log1p(-1. * uniform)\n return sampled * self.scale + self.loc\n\n def _log_prob(self, x):\n return self._log_unnormalized_prob(x) - self._log_normalization()\n\n def _log_cdf(self, x):\n return -nn_ops.softplus(-self._z(x))\n\n def _cdf(self, x):\n return math_ops.sigmoid(self._z(x))\n\n def _log_survival_function(self, x):\n return -nn_ops.softplus(self._z(x))\n\n def _survival_function(self, x):\n return math_ops.sigmoid(-self._z(x))\n\n def _log_unnormalized_prob(self, x):\n z = self._z(x)\n return - z - 2. * nn_ops.softplus(-z)\n\n def _log_normalization(self):\n return math_ops.log(self.scale)\n\n def _entropy(self):\n # Use broadcasting rules to calculate the full broadcast sigma.\n scale = self.scale * array_ops.ones_like(self.loc)\n return 2 + math_ops.log(scale)\n\n def _mean(self):\n return self.loc * array_ops.ones_like(self.scale)\n\n def _stddev(self):\n return self.scale * array_ops.ones_like(self.loc) * math.pi / math.sqrt(3)\n\n def _mode(self):\n return self._mean()\n\n def _z(self, x):\n \"\"\"Standardize input `x` to a unit logistic.\"\"\"\n with ops.name_scope(\"standardize\", values=[x]):\n return (x - self.loc) / self.scale\n"
]
| [
[
"tensorflow.python.ops.gen_math_ops.sqrt_grad",
"tensorflow.python.ops.math_ops.less",
"tensorflow.python.ops.math_ops.matmul",
"tensorflow.python.ops.array_ops.ones",
"tensorflow.python.ops.math_ops.cross",
"tensorflow.python.ops.math_ops.digamma",
"tensorflow.python.framework.tensor_util.constant_value",
"tensorflow.python.ops.math_ops.realdiv",
"tensorflow.python.ops.math_ops.subtract",
"tensorflow.python.ops.gen_math_ops.reciprocal_grad",
"numpy.prod",
"tensorflow.python.ops.math_ops.complex",
"tensorflow.python.ops.math_ops.greater",
"tensorflow.python.ops.array_ops.rank",
"tensorflow.python.ops.gen_math_ops.xlogy",
"tensorflow.python.ops.gen_math_ops.sigmoid_grad",
"tensorflow.python.ops.array_ops.gather",
"tensorflow.python.ops.array_ops.tile",
"tensorflow.python.ops.math_ops.cumprod",
"tensorflow.python.ops.math_ops.cumulative_logsumexp",
"tensorflow.python.ops.math_ops.reduced_shape",
"tensorflow.python.ops.math_ops.abs",
"tensorflow.python.ops.math_ops.logical_and",
"tensorflow.python.ops.array_ops.zeros_like",
"tensorflow.python.ops.math_ops.sinh",
"tensorflow.python.ops.array_ops.transpose",
"tensorflow.python.ops.math_ops.cos",
"tensorflow.python.ops.array_ops.shape",
"tensorflow.python.ops.math_ops.conj",
"tensorflow.python.ops.math_ops.multiply",
"tensorflow.python.ops.array_ops.broadcast_gradient_args",
"tensorflow.python.ops.array_ops.invert_permutation",
"tensorflow.python.ops.gen_array_ops.broadcast_gradient_args",
"tensorflow.python.eager.context.context",
"tensorflow.python.ops.math_ops.div_no_nan",
"tensorflow.python.ops.array_ops.expand_dims",
"tensorflow.python.ops.array_ops.where_v2",
"numpy.arange",
"tensorflow.python.ops.math_ops.real",
"tensorflow.python.ops.math_ops.add",
"tensorflow.python.ops.math_ops.sign",
"tensorflow.python.ops.math_ops.sparse_segment_sqrt_n_grad",
"tensorflow.python.ops.math_ops.bessel_i0e",
"tensorflow.python.ops.gen_math_ops.igamma_grad_a",
"tensorflow.python.ops.gen_math_ops.mul",
"tensorflow.python.framework.constant_op.constant",
"tensorflow.python.ops.math_ops.xdivy",
"tensorflow.python.ops.array_ops.reshape",
"tensorflow.python.ops.math_ops.pow",
"tensorflow.python.ops.math_ops.greater_equal",
"tensorflow.python.ops.gen_math_ops.xdivy",
"tensorflow.python.ops.array_ops.where",
"tensorflow.python.ops.math_ops.mul_no_nan",
"numpy.finfo",
"tensorflow.python.ops.array_ops.ones_like",
"tensorflow.python.ops.math_ops.reciprocal",
"tensorflow.python.framework.ops.device",
"tensorflow.python.framework.ops.control_dependencies",
"tensorflow.python.ops.math_ops.bessel_i1e",
"tensorflow.python.ops.math_ops.cast",
"tensorflow.python.ops.gen_math_ops.lgamma",
"tensorflow.python.framework.ops.colocate_with",
"tensorflow.python.ops.math_ops.lgamma",
"tensorflow.python.util.object_identity.ObjectIdentityDictionary",
"tensorflow.python.ops.math_ops.maximum",
"tensorflow.python.ops.math_ops.sparse_segment_mean_grad",
"tensorflow.python.ops.math_ops.range",
"tensorflow.python.ops.array_ops.zeros",
"tensorflow.python.ops.math_ops.exp",
"tensorflow.python.ops.gen_math_ops.unsorted_segment_prod",
"tensorflow.python.ops.array_ops.constant",
"tensorflow.python.ops.math_ops.not_equal",
"tensorflow.python.framework.ops.RegisterGradient",
"tensorflow.python.framework.ops.get_default_graph",
"tensorflow.python.ops.math_ops.equal",
"tensorflow.python.ops.math_ops.divide",
"tensorflow.python.ops.math_ops.reduce_sum",
"tensorflow.python.ops.array_ops.broadcast_to",
"tensorflow.python.ops.math_ops.reduce_prod",
"tensorflow.python.eager.context.executing_eagerly",
"tensorflow.python.ops.math_ops.polygamma",
"tensorflow.python.ops.gen_math_ops.mul_no_nan",
"tensorflow.python.ops.gen_math_ops.rsqrt_grad",
"tensorflow.python.compat.compat.forward_compatible",
"tensorflow.python.ops.array_ops.shape_internal",
"tensorflow.python.ops.array_ops.concat",
"tensorflow.python.ops.math_ops.log",
"tensorflow.python.ops.math_ops.cumsum",
"tensorflow.python.ops.math_ops.floor_div",
"numpy.sqrt",
"tensorflow.python.ops.math_ops.cosh",
"tensorflow.python.framework.ops.NotDifferentiable",
"tensorflow.python.ops.math_ops.square",
"tensorflow.python.ops.array_ops.setdiff1d",
"tensorflow.python.ops.math_ops.negative",
"tensorflow.python.ops.math_ops.sin",
"tensorflow.python.ops.gen_math_ops.tanh_grad",
"tensorflow.python.ops.gen_math_ops.mat_mul",
"tensorflow.python.ops.math_ops.imag",
"tensorflow.python.ops.math_ops.zeta",
"tensorflow.python.ops.math_ops.segment_sum",
"tensorflow.python.ops.math_ops.scalar_mul"
],
[
"tensorflow.core.protobuf.config_pb2.ConfigProto",
"tensorflow.python.ops.math_ops.less",
"tensorflow.core.protobuf.config_pb2.RunOptions",
"tensorflow.python.ops.math_ops.matmul",
"numpy.load",
"tensorflow.python.debug.lib.debug_data.DebugDumpDir",
"tensorflow.python.ops.array_ops.unique",
"tensorflow.python.framework.test_util.IsMklEnabled",
"tensorflow.python.framework.test_util.gpu_device_name",
"tensorflow.python.debug.cli.debugger_cli_common.CommandHandlerRegistry",
"tensorflow.python.util.tf_inspect.stack",
"tensorflow.python.debug.cli.cli_test_utils.assert_lines_equal_ignoring_whitespace",
"tensorflow.python.debug.cli.cli_test_utils.assert_array_lines_close",
"tensorflow.python.util.tf_inspect.currentframe",
"tensorflow.core.protobuf.config_pb2.GraphOptions",
"tensorflow.python.ops.math_ops.add",
"tensorflow.python.framework.test_util.run_v1_only",
"tensorflow.python.debug.lib.debug_utils.watch_graph",
"numpy.array",
"tensorflow.python.platform.googletest.main",
"tensorflow.python.ops.variables.VariableV1",
"numpy.zeros",
"tensorflow.python.debug.cli.command_parser.parse_readable_size_str",
"tensorflow.python.platform.test.is_gpu_available",
"tensorflow.python.ops.control_flow_ops.while_loop",
"tensorflow.core.protobuf.rewriter_config_pb2.RewriterConfig",
"tensorflow.python.platform.test.mock.patch.object",
"tensorflow.python.ops.control_flow_ops.with_dependencies",
"tensorflow.python.framework.constant_op.constant",
"tensorflow.core.protobuf.config_pb2.RunMetadata",
"tensorflow.python.ops.math_ops.multiply"
],
[
"tensorflow.examples.speech_commands.input_data.get_features_range",
"tensorflow.zeros",
"numpy.zeros",
"tensorflow.examples.speech_commands.input_data.which_set",
"tensorflow.examples.speech_commands.input_data.load_wav_file",
"tensorflow.examples.speech_commands.input_data.prepare_words_list",
"tensorflow.examples.speech_commands.input_data.save_wav_file",
"tensorflow.examples.speech_commands.input_data.AudioProcessor",
"tensorflow.contrib.framework.python.ops.audio_ops.encode_wav",
"tensorflow.python.platform.test.main",
"tensorflow.examples.speech_commands.models.prepare_model_settings"
],
[
"tensorflow.python.framework.tensor_shape.TensorShape",
"tensorflow.python.ops.array_ops.identity",
"tensorflow.python.framework.constant_op.constant",
"tensorflow.python.ops.math_ops.log",
"tensorflow.python.ops.check_ops.assert_same_float_dtype",
"tensorflow.python.ops.math_ops.log1p",
"numpy.finfo",
"tensorflow.python.ops.array_ops.ones_like",
"tensorflow.python.framework.ops.convert_to_tensor",
"tensorflow.python.ops.check_ops.assert_positive",
"tensorflow.python.ops.array_ops.shape",
"tensorflow.python.util.deprecation.deprecated",
"tensorflow.python.framework.ops.name_scope",
"tensorflow.python.ops.nn_ops.softplus"
]
]
|
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.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel",
"numpy.append",
"matplotlib.pyplot.scatter",
"pandas.read_csv"
]
]
|
changgoo/pyathena-1 | [
"c461ac3390d773537ce52393e3ebf68a3282aa46",
"c461ac3390d773537ce52393e3ebf68a3282aa46"
]
| [
"pyathena/tigress_xco/plt_tigress_xco.py",
"pyathena/sf_cloud_rad/xray.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",
"# xray.py\n\nimport pandas as pd\n\nfrom ..fields.xray_emissivity import get_xray_emissivity\nfrom ..load_sim import LoadSim\n\nclass Xray:\n \n @LoadSim.Decorators.check_pickle\n def read_xray_all(self, nums=None, prefix='xray_all',\n savdir=None, force_override=False):\n rr = dict()\n if nums is None:\n nums = self.nums\n\n \n print('num:', end=' ')\n for i,num in enumerate(nums):\n print(num, end=' ')\n r = self.read_xray(num=num, savdir=savdir, force_override=False)\n if i == 0:\n for k in r.keys():\n rr[k] = []\n\n for k in r.keys():\n try:\n rr[k].append(r[k].value.item())\n except:\n rr[k].append(r[k])\n\n rr = pd.DataFrame(rr)\n return rr\n \n @LoadSim.Decorators.check_pickle\n def read_xray(self, num, Z_gas=1.0, emin_keV=0.5, emax_keV=7.0, prefix='L_X',\n savdir=None, force_override=False):\n \"\"\"\n Function to calculate x-ray luminosity of the snapshot\n \"\"\"\n \n ds = self.load_vtk(num)\n dV = ds.domain['dx'].prod()*(self.u.length.cgs.value)**3\n d = ds.get_field(['density','temperature'])\n em = get_xray_emissivity(d['temperature'].data, Z_gas,\n emin_keV, emax_keV, energy=True)\n d['j_X'] = d['density']**2*em\n #dd['I_X'] = d['j_X'].sum(dim='z')*d.domain['dx'][2]*self.u.length.cgs.value\n\n res = dict()\n res['time'] = ds.domain['time']\n res['L_X'] = float(d['j_X'].sum()*dV)\n\n return res\n \n"
]
| [
[
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.gcf",
"numpy.logspace",
"matplotlib.gridspec.GridSpecFromSubplotSpec",
"matplotlib.pyplot.subplots",
"numpy.logical_and",
"numpy.sqrt",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.yscale",
"matplotlib.pyplot.sca",
"matplotlib.pyplot.title",
"matplotlib.pyplot.close",
"matplotlib.pyplot.figure",
"matplotlib.colors.LogNorm",
"matplotlib.gridspec.GridSpec",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.ylabel"
],
[
"pandas.DataFrame"
]
]
|
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.rand",
"torch.cat",
"torch.nn.functional.sigmoid",
"torch.zeros",
"torch.nn.ModuleList",
"torch.max",
"torch.autograd.Variable",
"torch.from_numpy",
"torch.nn.Conv2d",
"torch.nn.functional.relu",
"torch.randn",
"torch.nn.functional.tanh",
"torch.cumsum"
]
]
|
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.Linear",
"torch.zeros",
"torch.cat",
"torch.nn.Dropout",
"torch.nn.GRU",
"torch.bmm",
"torch.nn.functional.embedding",
"torch.nn.functional.log_softmax",
"torch.nn.functional.linear",
"torch.tensor",
"torch.nn.functional.softmax",
"torch.nn.Embedding"
]
]
|
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.Linear",
"torch.nn.Sigmoid"
]
]
|
anonymousGithub2023/ECCV | [
"7c4b862c898aa6a591bc7f32f95c5900e0492490",
"7c4b862c898aa6a591bc7f32f95c5900e0492490"
]
| [
"collect_latency.py",
"loss_impact.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",
"import torch\n\n\nimport datetime\nimport os\nimport torch\nimport argparse\n\n\nfrom utils import *\n\nADV_NUM = 1000\nBATCH = 20\nif not os.path.isdir('study'):\n os.mkdir('study')\n\n\ndef main(task_id):\n device = torch.device('cuda')\n model_file = MODEL_FILE_LIST[task_id]\n\n encoder, decoder, test_loader, _, word_map = load_dataset_model(model_file, batch_size=BATCH * CAP_PER_IMG)\n print('load model %s successful' % MODEL_FILE_LIST[task_id])\n for attack_norm in [0, 1]:\n task_name = model_file.split('.')[0]\n attack_class = ATTACK_METHOD[0]\n if attack_norm == 0:\n attack_name = 'L2'\n elif attack_norm == 1:\n attack_name = 'Linf'\n else:\n raise NotImplementedError\n config = {\n 'lr': 0.001,\n 'beams': 1,\n 'coeff': 100,\n 'max_len': 60,\n 'max_iter': 1000,\n 'max_per': MAX_PER_DICT[attack_name]\n }\n\n attack = attack_class(encoder, decoder, word_map, attack_norm, device, config)\n results = []\n\n for loss_type in [0, 1]:\n t1 = datetime.datetime.now()\n for i, data in enumerate(test_loader):\n (imgs, caption, caplen, all_captions) = data\n imgs = [imgs[jjj * CAP_PER_IMG:jjj * CAP_PER_IMG + 1] for jjj in range(BATCH)]\n imgs = torch.cat(imgs)\n imgs = imgs.to(attack.device)\n is_success, ori_img, adv_img = attack.run_diff_loss(imgs, loss_type)\n results.append([ori_img, adv_img])\n torch.save(results, 'study/' + str(loss_type) + '_' + attack_name + '_' + task_name + '.adv')\n if i >= 10:\n break\n t2 = datetime.datetime.now()\n print(t2 - t1)\n torch.save(results, 'study/' + str(loss_type) + '_' + attack_name + '_' + task_name + '.adv')\n\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser(description='Transformer')\n parser.add_argument('--task', default=2, type=int, help='experiment subjects')\n args = parser.parse_args()\n main(args.task)\n\n # 3 4 5 6\n"
]
| [
[
"numpy.concatenate",
"numpy.array",
"numpy.savetxt",
"numpy.zeros",
"torch.load"
],
[
"torch.device",
"torch.cat"
]
]
|
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.Sequential",
"torch.nn.MaxPool2d",
"torch.utils.checkpoint.checkpoint",
"torch.nn.ReLU"
]
]
|
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.array",
"numpy.linalg.norm",
"numpy.zeros",
"numpy.argmin",
"numpy.frombuffer",
"numpy.fliplr"
]
]
|
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.quaternion",
"numpy.array",
"numpy.linalg.norm",
"numpy.allclose",
"numpy.random.uniform",
"numpy.arctan2",
"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.ix_",
"numpy.issubdtype",
"numpy.asarray",
"numpy.sqrt"
]
]
|
vishalbelsare/RLScore | [
"713f0a402f7a09e41a609f2ddcaf849b2021a0a7",
"713f0a402f7a09e41a609f2ddcaf849b2021a0a7"
]
| [
"rlscore/test/test_learner/test_query_rankrls.py",
"rlscore/learner/greedy_nfold_rls.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",
"#\n# The MIT License (MIT)\n#\n# This file is part of RLScore \n#\n# Copyright (c) 2014 - 2016 Tapio Pahikkala, Antti Airola\n#\n# Permission is hereby granted, free of charge, to any person obtaining a copy\n# of this software and associated documentation files (the \"Software\"), to deal\n# in the Software without restriction, including without limitation the rights\n# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n# copies of the Software, and to permit persons to whom the Software is\n# furnished to do so, subject to the following conditions:\n#\n# The above copyright notice and this permission notice shall be included in\n# all copies or substantial portions of the Software.\n#\n# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n# THE SOFTWARE.\n\nimport scipy\nimport scipy.sparse as sp\nimport numpy as np\n\nclass GreedyNFoldRLS(object):\n \n def loadResources(self):\n \"\"\"\n Loads the resources from the previously set resource pool.\n \n @raise Exception: when some of the resources required by the learner is not available in the ResourcePool object.\n \"\"\"\n \n Y = self.resource_pool['Y']\n self.Y = Y\n #Number of training examples\n self.size = Y.shape[0]\n if not Y.shape[1] == 1:\n raise Exception('GreedyRLS currently supports only one output at a time. The output matrix is now of shape ' + str(Y.shape) + '.')\n \n X = self.resource_pool['X']\n self.setDataMatrix(X.T)\n if self.resource_pool.has_key('bias'):\n self.bias = float(self.resource_pool['bias'])\n else:\n self.bias = 0.\n if self.resource_pool.has_key('measure'):\n self.measure = self.resource_pool['measure']\n else:\n self.measure = None\n qids = self.resource_pool['qids']\n if not self.resource_pool.has_key('cross-validation_folds'):\n self.resource_pool['cross-validation_folds'] = qids\n self.setQids(qids)\n self.results = {}\n \n \n def setQids(self, qids):\n \"\"\"Sets the qid parameters of the training examples. The list must have as many qids as there are training examples.\n \n @param qids: A list of qid parameters.\n @type qids: List of integers.\"\"\"\n \n self.qidlist = [-1 for i in range(self.size)]\n for i in range(len(qids)):\n for j in qids[i]:\n if j >= self.size:\n raise Exception(\"Index %d in query out of training set index bounds\" %j)\n elif j < 0:\n raise Exception(\"Negative index %d in query, query indices must be non-negative\" %j)\n else:\n self.qidlist[j] = i\n if -1 in self.qidlist:\n raise Exception(\"Not all training examples were assigned a query\")\n \n \n self.qidmap = {}\n for i in range(len(self.qidlist)):\n qid = self.qidlist[i]\n if self.qidmap.has_key(qid):\n sameqids = self.qidmap[qid]\n sameqids.append(i)\n else:\n self.qidmap[qid] = [i]\n self.indslist = []\n for qid in self.qidmap.keys():\n self.indslist.append(self.qidmap[qid])\n \n \n def setDataMatrix(self, X):\n \"\"\"\n Sets the label data for RLS.\n \n @param X: Features of the training examples.\n @type X: scipy sparse matrix\n \"\"\"\n if isinstance(X, scipy.sparse.base.spmatrix):\n self.X = X.todense()\n else:\n self.X = X\n \n \n def train(self):\n regparam = float(self.resource_pool['regparam'])\n self.regparam = regparam\n self.solve_bu(regparam)\n \n \n def solve_bu(self, regparam):\n \"\"\"Trains RLS with the given value of the regularization parameter\n \n @param regparam: value of the regularization parameter\n @type regparam: float\n \"\"\"\n \n self.regparam = regparam\n \n \n X = self.X\n Y = self.Y\n \n if not hasattr(self, \"bias\"):\n self.bias = 0.\n \n tsize = self.size\n fsize = X.shape[0]\n assert X.shape[1] == tsize\n \n rp = regparam\n rpinv = 1. / rp\n \n \n if not self.resource_pool.has_key('subsetsize'):\n raise Exception(\"Parameter 'subsetsize' must be given.\")\n desiredfcount = int(self.resource_pool['subsetsize'])\n if not fsize >= desiredfcount:\n raise Exception('The overall number of features ' + str(fsize) + ' is smaller than the desired number ' + str(desiredfcount) + ' of features to be selected.')\n \n \n \n if self.resource_pool.has_key('calculate_test_error'):\n calculate_test_error = self.resource_pool['calculate_test_error']\n if calculate_test_error == 'True':\n calculate_test_error = True\n self.testY = self.resource_pool['test_labels']\n self.testX = self.resource_pool['prediction_features'].todense()\n self.testQids = self.resource_pool['test_qids'].readQids()\n \n self.testperformances = []\n \n self.testqidmap = {}\n for i in range(len(self.testQids)):\n qid = self.testQids[i]\n if self.testqidmap.has_key(qid):\n sameqids = self.testqidmap[qid]\n sameqids.append(i)\n else:\n self.testqidmap[qid] = [i]\n self.testindslist = []\n for qid in self.testqidmap.keys():\n self.testindslist.append(self.testqidmap[qid])\n else:\n calculate_test_error = False\n else:\n calculate_test_error = False\n \n \n \n \n #Biaz\n cv = np.sqrt(self.bias)*np.mat(np.ones((1, tsize)))\n ca = rpinv * (1. / (1. + cv * rpinv * cv.T)) * (cv * rpinv)\n \n \n self.A = rpinv * Y - cv.T * rpinv * (1. / (1. + cv * rpinv * cv.T)) * (cv * rpinv * Y)\n \n XT = X.T\n GXT = rpinv * XT - cv.T * rpinv * (1. / (1. + cv * rpinv * cv.T)) * ((cv * rpinv) * XT)\n yac = []\n yyac = []\n \n for inds in self.indslist:\n u = cv.T[inds, 0]\n v = ca[0, inds]\n temp = rp * GXT[inds] - rp * rp * u * (1. / (-1. + rp * v * u)) * (v * GXT[inds])\n yac.append(temp)\n temp = rp * self.A[inds] - rp * rp * u * (1. / (-1. + rp * v * u)) * (v * self.A[inds])\n yyac.append(temp)\n \n listX = []\n for ci in range(fsize):\n listX.append(X[ci])\n \n self.selected = []\n \n currentfcount = 0\n self.performances = []\n while currentfcount < desiredfcount:\n \n bestlqocvperf = float('inf')\n \n for ci in range(fsize):\n if ci in self.selected: continue\n cv = listX[ci]\n GXT_ci = GXT[:, ci]\n const = 1. / (1. + cv * GXT_ci)[0, 0]\n cvA = (const * (cv * self.A))[0, 0]\n updA = self.A - GXT_ci * cvA\n lqocvperf = 0.\n for qi in range(len(self.indslist)):\n inds = self.indslist[qi]\n V = GXT_ci[inds].T\n MVT = yac[qi][:, ci]\n gamma = (1. / (-const ** -1. + V * MVT))[0, 0]\n lqodiff = yyac[qi] - cvA * MVT - gamma * MVT * (MVT.T * updA[inds])\n lqocvperf += (lqodiff.T * lqodiff)[0, 0]\n \n if lqocvperf < bestlqocvperf:\n bestcind = ci\n bestlqocvperf = lqocvperf\n \n '''\n if not self.measure is None:\n loopred = Y - multiply(invupddiagG, updA)\n looperf = self.measure.multiOutputPerformance(Y, loopred)\n if bestlooperf is None:\n bestlooperf = looperf\n bestcind = ci\n if self.measure.comparePerformances(looperf, bestlooperf) > 0:\n bestcind = ci\n bestlooperf = looperf\n else:\n #This default squared performance is a bit faster to compute than the one loaded separately.\n loodiff = multiply(invupddiagG, updA)\n looperf = (loodiff.T * loodiff)[0, 0]\n if looperf < bestlooperf:\n bestcind = ci\n bestlooperf = looperf\n '''\n \n self.bestlqocvperf = bestlqocvperf\n self.performances.append(bestlqocvperf)\n cv = listX[bestcind]\n GXT_ci = GXT[:, bestcind]\n const = (1. / (1. + cv * GXT_ci))[0, 0]\n cvA = const * cv * self.A\n self.A = self.A - GXT_ci * cvA\n cvGXT = const * cv * GXT\n GXT = GXT - GXT_ci * cvGXT\n for qi in range(len(self.indslist)):\n inds = self.indslist[qi]\n V = GXT_ci[inds].T\n MVT = yac[qi][:, bestcind]\n gammaMVT = MVT * (1. / (-const ** -1. + V * MVT))\n yyac[qi] = yyac[qi] - MVT * cvA - gammaMVT * (MVT.T * self.A[inds])\n yac[qi] = yac[qi] - MVT * cvGXT - gammaMVT * (MVT.T * GXT[inds])\n self.selected.append(bestcind)\n currentfcount += 1\n \n if calculate_test_error:\n bias_slice = np.sqrt(self.bias) * np.mat(np.ones((1,X.shape[1]),dtype=np.float64))\n X_biased = np.vstack([X,bias_slice])\n selected_plus_bias = self.selected+[fsize]\n cutdiag = sp.lil_matrix((fsize+1, currentfcount + 1))\n for ci, col in zip(selected_plus_bias, range(currentfcount + 1)):\n cutdiag[ci, col] = 1.\n W = cutdiag * (X_biased[selected_plus_bias] * self.A)\n bias_slice = np.sqrt(self.bias) * np.mat(np.ones((1,self.testX.shape[1]),dtype=np.float64))\n testX_biased = np.vstack([self.testX,bias_slice])\n self.Y_predicted = testX_biased.T * W\n if not self.callbackfun is None:\n self.callbackfun.callback(self)\n if not self.callbackfun is None:\n self.callbackfun.finished(self)\n \n bias_slice = np.sqrt(self.bias) * np.mat(np.ones((1,X.shape[1]),dtype=np.float64))\n X = np.vstack([X,bias_slice])\n selected_plus_bias = self.selected+[fsize]\n cutdiag = sp.lil_matrix((fsize+1, currentfcount + 1))\n for ci, col in zip(selected_plus_bias, range(currentfcount + 1)):\n cutdiag[ci, col] = 1.\n self.A = cutdiag * (X[selected_plus_bias] * self.A)\n self.results['selected_features'] = self.selected\n self.results['GreedyRLS_LOO_performances'] = self.performances\n if calculate_test_error:\n self.results['GreedyRLS_test_performances'] = self.testperformances\n"
]
| [
[
"numpy.max",
"numpy.testing.assert_allclose",
"numpy.array",
"numpy.dot",
"numpy.random.rand",
"numpy.zeros",
"numpy.random.seed",
"numpy.sum",
"numpy.ones",
"numpy.random.randn",
"numpy.ix_",
"numpy.eye",
"numpy.where",
"numpy.sqrt"
],
[
"scipy.sparse.lil_matrix",
"numpy.ones",
"numpy.sqrt",
"numpy.vstack"
]
]
|
marwahaha/QTensor | [
"936d078825a6418f9d32d2c176332422d8a4c137",
"936d078825a6418f9d32d2c176332422d8a4c137"
]
| [
"qtensor/tests/test_simulators.py",
"qtensor/optimisation/RGreedy.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",
"import numpy as np\nimport copy, operator\nfrom qtensor.optimisation.Optimizer import OrderingOptimizer\nfrom qtensor import utils\nfrom functools import reduce\nimport networkx as nx\nimport qtree\n\ndef reducelist(f, lst, x=0):\n prev = x\n for i in lst:\n prev = f(prev, i)\n yield prev\n\nclass RGreedyOptimizer(OrderingOptimizer):\n \"\"\"\n An orderer that greedy selects vertices\n using boltzman probabilities.\n\n \"\"\"\n def __init__(self, *args, temp=0.002, repeats=10, **kwargs):\n super().__init__(*args, **kwargs)\n self.temp = temp\n self.repeats = repeats\n\n def _get_ordering(self, graph, **kwargs):\n node_names = nx.get_node_attributes(graph, 'name')\n node_sizes = nx.get_node_attributes(graph, 'size')\n peo, path = self._get_ordering_ints(graph)\n\n peo = [qtree.optimizer.Var(var, size=node_sizes[var],\n name=node_names[var])\n for var in peo]\n #print('tw=', max(path))\n return peo, path\n\n def _get_ordering_ints(self, old_graph, free_vars=[]):\n best_peo = None\n best_width = np.inf\n best_widths = None\n\n for i in range(self.repeats):\n graph = copy.deepcopy(old_graph)\n peo = []\n widths = []\n while graph.number_of_nodes():\n ngs = np.array(list(\n map(len, map(operator.itemgetter(1), graph.adjacency()))\n ))\n\n weights = np.exp(-(ngs - np.min(ngs))/self.temp)\n #print(ngs)\n #print(weights)\n # 1, 3, 5, 2, 1\n distrib = np.array([0]+list(reducelist(lambda x, y:x+y, weights, 0)))\n #print(distrib)\n # 0, 1, 4, 9, 11, 12\n rnd = np.random.random()*distrib[-1]\n # between 0 and 12 = say, 5\n # find the smallest value that larger than rnd\n bool_map = distrib < rnd\n # True, True, True, False, False, False\n select_map = bool_map[1:] ^ bool_map[:-1]\n selected_elem = np.array(list(graph.nodes))[select_map]\n assert len(selected_elem)==1, 'Error in algorithm, please submit an issue'\n selected_node = selected_elem[0]\n utils.eliminate_node_no_structure(graph, selected_node)\n\n peo.append(int(selected_node))\n widths.append(int(ngs[select_map][0]))\n\n if max(widths) < best_width:\n best_peo = peo\n best_widths = widths\n best_width = max(widths)\n\n return best_peo, best_widths\n"
]
| [
[
"numpy.random.seed",
"numpy.imag",
"numpy.array",
"numpy.real"
],
[
"numpy.random.random",
"numpy.min"
]
]
|
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.array",
"numpy.ones",
"numpy.array_equal",
"numpy.testing.assert_equal"
]
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.