= seqlen[i] else 0.\n return tf.constant(inputs, dtype=dtype), tf.constant(paddings, dtype=dtype)\n\n def _GetGrad(self, l, inputs, paddings):\n in_nmap = py_utils.NestedMap(features=inputs, paddings=paddings)\n out_nmap = l.FPropDefaultTheta(in_nmap)\n loss = tf.reduce_sum(out_nmap.features)\n grads = tf.gradients(\n loss,\n l.vars.Flatten(),\n unconnected_gradients=tf.UnconnectedGradients.ZERO)\n return out_nmap.features, grads\n\n @parameterized.named_parameters(\n ('Base',),\n ('Reordered', 'conv_before_mhsa'),\n ('NoLConv', 'mhsa', False),\n ('NoMhsa', 'conv', True),\n ('NoFFStart', 'mhsa_before_conv', True, False),\n ('Transformer', 'mhsa', False, False),\n )\n def testBasic(self,\n layer_order='mhsa_before_conv',\n has_lconv=True,\n has_fflayer_start=True):\n p = self._GetParams()\n p.layer_order = layer_order\n if not has_lconv:\n p.lconv_tpl = None\n if not has_fflayer_start:\n p.fflayer_start_tpl = None\n\n l = p.Instantiate()\n inputs, paddings = self._GetInputs()\n outputs, grads = self._GetGrad(l, inputs, paddings)\n\n with self.session() as sess:\n tf.global_variables_initializer().run()\n out_vals = sess.run(outputs)\n grad_vals = sess.run(grads)\n print([x.shape for x in out_vals])\n print([g.shape for g in grad_vals])\n\n @parameterized.named_parameters(\n ('F32FPropF32Input', tf.float32, tf.float32),\n ('F32FPropBF16Input', tf.float32, tf.bfloat16),\n ('BF16FPropF32Input', tf.bfloat16, tf.float32),\n ('BF16FPropBF16Input', tf.bfloat16, tf.bfloat16),\n )\n def testFPropDtypes(self, fprop_dtype, input_dtype):\n p = self._GetParams()\n # batch_norm does not support bfloat16 on CPU.\n p.lconv_tpl.conv_norm_layer_tpl = (\n bn_layers.GroupNormLayer.Params().Set(num_groups=2))\n p.cls.SetFPropDtype(p, fprop_dtype)\n\n l = p.Instantiate()\n inputs, paddings = self._GetInputs(dtype=input_dtype)\n outputs, grads = self._GetGrad(l, inputs, paddings)\n\n with self.session() as sess:\n tf.global_variables_initializer().run()\n out_vals = sess.run(outputs)\n grad_vals = sess.run(grads)\n print([x.shape for x in out_vals])\n print([g.shape for g in grad_vals])\n\n @parameterized.named_parameters(\n ('DefaultFp32', [], tf.float32),\n ('RegexDtypeFp16', [(r'.*(fflayer_[01]|linear_start|post)/w$', tf.float16)\n ], tf.float16),\n )\n def testFPropDtypesWithListRegexDtypes(self, regex_dtypes, target_dtype):\n p = self._GetParams()\n p.lconv_tpl.conv_norm_layer_tpl = (\n bn_layers.GroupNormLayer.Params().Set(num_groups=2))\n p.list_regex_dtypes = regex_dtypes\n\n l = p.Instantiate()\n inputs, paddings = self._GetInputs()\n outputs, grads = self._GetGrad(l, inputs, paddings)\n\n with self.session() as sess:\n tf.global_variables_initializer().run()\n out_vals = sess.run(outputs)\n grad_vals = sess.run(grads)\n print([x.shape for x in out_vals])\n print([g.shape for g in grad_vals])\n\n tf.assert_type(l.vars.fflayer_start.fflayer.fc[0].w, target_dtype)\n tf.assert_type(l.vars.fflayer_start.fflayer.fc[1].w, target_dtype)\n tf.assert_type(l.vars.fflayer_end.fflayer.fc[0].w, target_dtype)\n tf.assert_type(l.vars.fflayer_end.fflayer.fc[1].w, target_dtype)\n tf.assert_type(l.vars.lconv.linear_start.w, target_dtype)\n tf.assert_type(l.vars.trans_atten.atten.post.w, target_dtype)\n\n @parameterized.named_parameters(\n ('Start', True, False),\n ('End', False, True),\n ('StartAndEnd', True, True),\n ('None', False, False),\n )\n def testMoEFFLayerClassMethodInitParity(self, use_fflayer_start_moe,\n use_fflayer_end_moe):\n \"\"\"Tests Conformer-MoE initializations via classmethods and explicitly.\"\"\"\n\n num_experts, num_groups, num_devices, per_expert_capacity_dim = 2, 2, 2, 2\n # Create params setting MoEBuilder params explicitly.\n ref_kwargs = dict()\n if use_fflayer_start_moe:\n # Set MoEBuilder params explicitly.\n ref_kwargs['fflayer_start_tpl'] = gshard_builder.MoEBuilder.Params().Set(\n e_dim=num_experts,\n c_dim=per_expert_capacity_dim,\n num_devices=num_devices,\n num_groups=num_groups)\n if use_fflayer_end_moe:\n ref_kwargs['fflayer_end_tpl'] = gshard_builder.MoEBuilder.Params().Set(\n e_dim=num_experts,\n c_dim=per_expert_capacity_dim,\n num_devices=num_devices,\n num_groups=num_groups)\n ref_p = self._GetParams(**ref_kwargs)\n\n # Params setting MoEBuilder params via classmethod.\n moe_kwargs = dict()\n if use_fflayer_start_moe:\n # Set MoEBuilder params via classmethod.\n moe_kwargs['fflayer_start_tpl'] = conformer_layer.GShardMoELayerParams(\n num_devices, num_groups, num_experts, per_expert_capacity_dim)\n if use_fflayer_end_moe:\n moe_kwargs['fflayer_end_tpl'] = conformer_layer.GShardMoELayerParams(\n num_devices, num_groups, num_experts, per_expert_capacity_dim)\n moe_p = self._GetParams(**moe_kwargs)\n # Verify layer params are equal in both cases.\n with self.subTest('testParamsParity'):\n self.assertCountEqual(ref_p.ToText().split('\\n'),\n moe_p.ToText().split('\\n'))\n\n # Test both initializations and verify moe sublayer.\n with self.subTest('testInit'):\n ref_p.name = 'ref_moe_conformer_layer'\n ref_layer = ref_p.Instantiate()\n moe_p.name = 'classmethod_moe_conformer_layer'\n moe_layer = moe_p.Instantiate()\n for layer in (ref_layer, moe_layer):\n if use_fflayer_start_moe:\n self.assertNotIn('fflayer_start', layer.children)\n self.assertIn('fflayer_start_moe', layer.children)\n if use_fflayer_end_moe:\n self.assertNotIn('fflayer_end', layer.children)\n self.assertIn('fflayer_end_moe', layer.children)\n\n @parameterized.named_parameters(\n ('Start', True, False, 0.593693),\n ('End', False, True, 0.4582923),\n ('StartAndEnd', True, True, 1.0213419),\n ('None', False, False, 0.0),\n )\n def testMoEFFLayerFProp(self, use_fflayer_start_moe, use_fflayer_end_moe,\n expected_aux_loss):\n kwargs = {}\n if use_fflayer_start_moe:\n kwargs['fflayer_start_tpl'] = gshard_builder.MoEBuilder.Params().Set(\n e_dim=2, c_dim=2, num_devices=2)\n if use_fflayer_end_moe:\n kwargs['fflayer_end_tpl'] = gshard_builder.MoEBuilder.Params().Set(\n e_dim=2, c_dim=2, num_devices=2)\n p = self._GetParams(**kwargs)\n l = p.Instantiate()\n inputs, paddings = self._GetInputs()\n inputs = tf.convert_to_tensor(inputs)\n paddings = tf.convert_to_tensor(paddings)\n in_nmap = py_utils.NestedMap(features=inputs, paddings=paddings)\n in_nmap.aux_loss = tf.convert_to_tensor(0., py_utils.FPropDtype(p))\n out_nmap = l.FPropDefaultTheta(in_nmap)\n self.assertIn('aux_loss', out_nmap)\n loss = tf.reduce_sum(out_nmap.features) + 0.01 * out_nmap.aux_loss\n grads = tf.gradients(\n loss,\n l.vars.Flatten(),\n unconnected_gradients=tf.UnconnectedGradients.ZERO)\n\n with self.session() as sess:\n tf.global_variables_initializer().run()\n out_vals = sess.run(out_nmap.features)\n grad_vals = sess.run(grads)\n self.assertEqual(out_nmap.aux_loss.shape, ())\n aux_loss = sess.run(out_nmap.aux_loss)\n self.assertAlmostEqual(expected_aux_loss, aux_loss, places=5)\n print([x.shape for x in out_vals])\n print([g.shape for g in grad_vals])\n\n def testRemat(self):\n inputs, paddings = self._GetInputs()\n base_p = self._GetParams()\n base_p.name = 'base'\n base_p.layer_order = 'conv_before_mhsa'\n\n new_p = base_p.Copy()\n new_p.name = 'new'\n new_p.remat = True\n\n base_l = base_p.Instantiate()\n new_l = new_p.Instantiate()\n\n _, base_grads = self._GetGrad(base_l, inputs, paddings)\n base_grads = base_l.vars.Pack(base_grads)\n\n _, new_grads = self._GetGrad(new_l, inputs, paddings)\n new_grads = new_l.vars.Pack(new_grads)\n\n assign_op = [\n tf.assign(dst, src)\n for (src, dst) in zip(base_l.vars.Flatten(), new_l.vars.Flatten())\n ]\n init_op = tf.global_variables_initializer()\n with self.session() as sess:\n sess.run(init_op)\n sess.run(assign_op)\n base_grads_val = sess.run(base_grads)\n new_grads_val = sess.run(new_grads)\n\n for (k, v1), (_, v2) in zip(base_grads_val.FlattenItems(),\n new_grads_val.FlattenItems()):\n self.assertAllClose(v1, v2, msg=k)\n\n @parameterized.named_parameters(\n ('Basic',),\n ('NegativeLocalContext', -1),\n ('NegativeLeftContext', None, -1, None),\n ('NegativeRightContext', None, None, -1),\n ('NegativeContext1', -1, None, -1),\n ('NegativeContext2', None, -1, -1),\n ('NegativeContext3', -1, -1, None),\n ('NegativeContext4', -1, None, -1),\n ('NegativeContext5', -1, -1, -1),\n ('NegativeContext6', None, None, None),\n )\n def testAttenContextParams(self,\n local_context=None,\n left_context=None,\n right_context=None):\n \"\"\"Tests atten context cfg params.\"\"\"\n inputs, paddings = self._GetInputs()\n base_p_kwargs = self._GetCommonParamsKwargs()\n base_p_kwargs['atten_local_context'] = None\n base_p_kwargs['atten_left_context'] = None\n base_p_kwargs['atten_right_context'] = None\n base_p = conformer_layer.ConformerLayer.CommonParams(**base_p_kwargs)\n base_p.name = 'base'\n base_p.layer_order = 'conv_before_mhsa'\n\n new_p_kwargs = self._GetCommonParamsKwargs()\n new_p_kwargs['atten_local_context'] = local_context\n new_p_kwargs['atten_left_context'] = left_context\n new_p_kwargs['atten_right_context'] = right_context\n new_p = conformer_layer.ConformerLayer.CommonParams(**new_p_kwargs)\n new_p.name = 'new'\n new_p.layer_order = 'conv_before_mhsa'\n\n base_l = base_p.Instantiate()\n new_l = new_p.Instantiate()\n\n _, base_grads = self._GetGrad(base_l, inputs, paddings)\n base_grads = base_l.vars.Pack(base_grads)\n\n _, new_grads = self._GetGrad(new_l, inputs, paddings)\n new_grads = new_l.vars.Pack(new_grads)\n\n assign_op = [\n tf.assign(dst, src)\n for (src, dst) in zip(base_l.vars.Flatten(), new_l.vars.Flatten())\n ]\n init_op = tf.global_variables_initializer()\n with self.session() as sess:\n sess.run(init_op)\n sess.run(assign_op)\n base_grads_val = sess.run(base_grads)\n new_grads_val = sess.run(new_grads)\n\n for (k, v1), (_, v2) in zip(base_grads_val.FlattenItems(),\n new_grads_val.FlattenItems()):\n self.assertAllClose(v1, v2, msg=k)\n\n def testCustomAttentionLayer(self):\n p = self._GetParams()\n # Use a custom atten_tpl.\n p.trans_atten_tpl.atten_tpl = (\n batch_major_attention.MultiHeadedFavorAttention.Params().Set(\n num_random_features=4))\n layer = p.Instantiate()\n self.assertIsInstance(layer.trans_atten.atten,\n batch_major_attention.MultiHeadedFavorAttention)\n\n @parameterized.named_parameters(\n ('Basic', 8, 'SWISH', 0.5),\n ('BasicReLU', 16, 'RELU', 1.),\n )\n def testFFlayerParams(self,\n fflayer_hidden_dim=None,\n fflayer_activation=None,\n fflayer_residual_weight=0.5):\n p = self._GetParams(\n fflayer_hidden_dim=fflayer_hidden_dim,\n fflayer_activation=fflayer_activation,\n fflayer_residual_weight=fflayer_residual_weight)\n layer = p.Instantiate()\n\n start_fflayer = layer.fflayer_start\n actual_start_hidden_dim = start_fflayer.params.hidden_dim\n actual_start_activation = start_fflayer.params.activation\n actual_start_residual_weight = start_fflayer.params.residual_weight\n end_fflayer = layer.fflayer_end\n actual_end_hidden_dim = end_fflayer.params.hidden_dim\n actual_end_activation = end_fflayer.params.activation\n actual_end_residual_weight = end_fflayer.params.residual_weight\n\n self.assertEqual(fflayer_hidden_dim, actual_start_hidden_dim)\n self.assertEqual(fflayer_activation, actual_start_activation)\n self.assertEqual(fflayer_residual_weight, actual_start_residual_weight)\n self.assertEqual(fflayer_hidden_dim, actual_end_hidden_dim)\n self.assertEqual(fflayer_activation, actual_end_activation)\n self.assertEqual(fflayer_residual_weight, actual_end_residual_weight)\n\n @parameterized.named_parameters(\n ('shared', True),\n ('not_shared', False),\n )\n def testFFlayerWeightSharing(self, fflayer_weight_sharing):\n p = self._GetParams()\n p.fflayer_weight_sharing = fflayer_weight_sharing\n layer = p.Instantiate()\n\n # FFLayer variables will all have same full name iif weights are shared.\n def _VarNamesDebugString(vars_):\n return py_utils.Transform(lambda x: x.name, vars_).DebugString()\n\n fflayer_start_var_names = _VarNamesDebugString(layer.fflayer_start.vars)\n fflayer_end_var_names = _VarNamesDebugString(layer.fflayer_end.vars)\n\n self.assertEqual(fflayer_weight_sharing,\n (fflayer_start_var_names == fflayer_end_var_names))\n\n def testCommonParamsAbuse(self):\n \"\"\"Checks CommonParams() is not called in __init__().\"\"\"\n p = self._GetParams()\n with mock.patch(\n 'lingvo.core.conformer_layer.ConformerLayer.CommonParams',\n autospec=True) as m1:\n with mock.patch(\n 'lingvo.core.conformer_layer.LConvLayer.CommonParams',\n autospec=True) as m2:\n p.Instantiate()\n self.assertFalse(m1.called)\n self.assertFalse(m2.called)\n\n @parameterized.named_parameters(\n ('WithoutRelPosAtten', False),\n ('WithRelPosAtten', True),\n )\n def testApplyGShard(self, use_relative_atten):\n with self.session() as sess:\n conformer_p = conformer_layer.ConformerLayer.CommonParams(\n input_dim=self.dim,\n atten_num_heads=self.heads,\n atten_local_context=self.context,\n use_relative_atten=use_relative_atten,\n kernel_size=2,\n fflayer_hidden_dim=4 * self.dim)\n conformer_p.name = 'conformer_layer'\n conformer_layer.ApplyGshard(\n conformer_p,\n device_mesh=[1, 2],\n proj_w_split_list=[[0, 1], [1, 0]],\n proj_activation_split_list=[[0, -1, 1], [0, -1, -1]],\n atten_dnh_w_split=[0, 1, -1],\n atten_blnh_activation_split=[0, -1, 1, -1],\n atten_bld_activation_split=[0, -1, -1],\n lconv_df_w_split=[0, 1],\n lconv_hwim_w_split=[-1, -1, 1, -1],\n lconv_fd_w_split=[-1, -1],\n lconv_blf_activation_split=[0, -1, 1],\n lconv_bld_activation_split=[0, -1, -1])\n inputs, paddings = self._GetInputs()\n conformer_l = conformer_p.Instantiate()\n outputs = conformer_l.FProp(\n conformer_l.theta,\n py_utils.NestedMap(\n features=tf.convert_to_tensor(inputs),\n paddings=tf.convert_to_tensor(paddings)))\n tf.logging.info('outputs=%s', outputs)\n tf.global_variables_initializer().run()\n out_vals = sess.run(outputs)\n print([x.shape for x in out_vals.Flatten()])\n\n @parameterized.named_parameters(\n ('Dropout', 'dropout_prob', 0.1),\n ('LayerOrder', 'layer_order', 'conv_before_mhsa'),\n ('FFLayerActivation', 'fflayer_activation', 'GELU'),\n ('UseRelativeAttentionTrue', 'use_relative_atten', True),\n ('UseRelativeAttentionFalse', 'use_relative_atten', False),\n ('IsCausal', 'is_causal', True),\n ('ListRegexDtypes', 'list_regex_dtypes', [('test_regex', tf.float16)]))\n def testCommonParamsSet(self, param_name, param_val):\n \"\"\"Checks values set in CommonParams() correctly.\"\"\"\n\n def _GetMinimalCommonParamsKwargs():\n \"\"\"These args are required to be set to call CommonParams.\"\"\"\n return dict(\n input_dim=2, atten_num_heads=4, kernel_size=3, fflayer_hidden_dim=8)\n\n kwargs = _GetMinimalCommonParamsKwargs()\n kwargs.update({param_name: param_val})\n if param_name == 'is_causal' and param_val:\n kwargs['atten_right_context'] = 0\n kwargs['use_relative_atten'] = False\n p = conformer_layer.ConformerLayer.CommonParams(**kwargs)\n p.name = 'conformer_layer'\n if param_name == 'use_relative_atten':\n atten_cls = p.trans_atten_tpl.atten_tpl.cls\n if param_val:\n self.assertTrue(\n issubclass(atten_cls, batch_major_attention.MultiHeadedAttentionXL),\n msg=atten_cls)\n else:\n self.assertTrue(\n issubclass(atten_cls, batch_major_attention.MultiHeadedAttention),\n msg=atten_cls)\n elif param_name == 'fflayer_activation':\n self.assertEqual(p.fflayer_start_tpl.activation, param_val)\n self.assertEqual(p.fflayer_end_tpl.activation, param_val)\n else:\n self.assertEqual(p.Get(param_name), param_val)\n\n\nclass ConformerLayerStreamStepTest(stream_step_test_base.StreamStepTestBase):\n\n def _GetParams(self, **kwargs):\n input_dim = kwargs['input_dim']\n kernel = kwargs['kernel']\n layer_order = kwargs['layer_order']\n num_heads = kwargs['num_heads']\n left_context = kwargs['left_context']\n right_context = kwargs['right_context']\n ffn_dim = kwargs['ffn_dim']\n # optional params.\n norm_type = kwargs.get('norm_type', 'gn')\n has_lconv = kwargs.get('has_lconv', 'conv2d')\n has_fflayer_start = kwargs.get('has_fflayer_start', True)\n query_stride = kwargs.get('query_stride', 1)\n num_groups = kwargs.get('num_groups', 2)\n\n if layer_order == 'mhsa':\n kernel = None\n has_lconv = False\n p = conformer_layer.ConformerLayer.CommonParams(\n input_dim=input_dim,\n is_causal=True,\n atten_num_heads=num_heads,\n atten_left_context=left_context,\n atten_right_context=right_context,\n use_relative_atten=False,\n query_stride=query_stride,\n fflayer_hidden_dim=ffn_dim,\n kernel_size=kernel,\n layer_order=layer_order)\n if not has_lconv:\n p.lconv_tpl = None\n else:\n if norm_type == 'ln':\n p.lconv_tpl.conv_norm_layer_tpl = lingvo_layers.LayerNorm.Params()\n else:\n p.lconv_tpl.conv_norm_layer_tpl = bn_layers.GroupNormLayer.Params().Set(\n num_groups=num_groups, cumulative=True)\n if has_lconv == 'conv2d':\n p.lconv_tpl.depthwise_conv_tpl = (\n conv_layers_with_time_padding.CausalConv2DLayerWithPadding.Params())\n else:\n assert has_lconv == 'depthwise'\n if not has_fflayer_start:\n p.fflayer_start_tpl = None\n\n p.name = 'conformer'\n return p\n\n def _FProp(self, layer, inputs, paddings):\n return layer.FProp(layer.theta,\n py_utils.NestedMap(features=inputs, paddings=paddings))\n\n def _StreamStep(self, layer, step_inputs, step_paddings, state):\n return layer.StreamStep(layer.theta, step_inputs, step_paddings, state)\n\n def _GetFPropOutput(self, fprop_out):\n return fprop_out.features, fprop_out.paddings\n\n @parameterized.named_parameters(\n {\n 'testcase_name': 'Basic',\n },\n {\n 'testcase_name': 'BasicGN',\n 'norm_type': 'gn'\n },\n {\n 'testcase_name': 'BasicGN1',\n 'norm_type': 'gn',\n 'num_groups': 1\n },\n {\n 'testcase_name': 'BasicGN8',\n 'norm_type': 'gn',\n 'num_groups': 8\n },\n {\n 'testcase_name': 'SkipNorm',\n 'testonly_skip_norm_layers': True\n },\n {\n 'testcase_name': 'SkipNormGN',\n 'testonly_skip_norm_layers': True,\n 'norm_type': 'gn'\n },\n {\n 'testcase_name': 'SkipNormGNR1',\n 'testonly_skip_norm_layers': True,\n 'norm_type': 'gn',\n 'right_context': 1,\n },\n {\n 'testcase_name': 'SkipNormGNR2',\n 'testonly_skip_norm_layers': True,\n 'norm_type': 'gn',\n 'right_context': 2,\n },\n {\n 'testcase_name': 'SkipNormGNStride2',\n 'testonly_skip_norm_layers': True,\n 'norm_type': 'gn',\n 'stride': 2\n },\n {\n 'testcase_name': 'SkipNormGNStride4',\n 'testonly_skip_norm_layers': True,\n 'norm_type': 'gn',\n 'stride': 4\n },\n {\n 'testcase_name': 'SkipNormGNStride2R1',\n 'testonly_skip_norm_layers': True,\n 'norm_type': 'gn',\n 'stride': 2,\n 'right_context': 1\n },\n {\n 'testcase_name': 'SkipNormGNStride4R2',\n 'testonly_skip_norm_layers': True,\n 'norm_type': 'gn',\n 'stride': 4,\n 'right_context': 2\n },\n {\n 'testcase_name': 'Reordered',\n 'layer_order': 'mhsa_before_conv'\n },\n {\n 'testcase_name': 'Conv2D',\n 'has_lconv': 'conv2d',\n },\n {\n 'testcase_name': 'NoLConv',\n 'layer_order': 'mhsa',\n 'has_lconv': False\n },\n {\n 'testcase_name': 'NoMhsa',\n 'layer_order': 'conv'\n },\n {\n 'testcase_name': 'NoFFStart',\n 'layer_order': 'conv_before_mhsa',\n 'has_fflayer_start': False\n },\n {\n 'testcase_name': 'Transformer',\n 'layer_order': 'mhsa',\n 'has_lconv': False,\n 'has_fflayer_start': False\n },\n {\n 'testcase_name': 'TransformerSkipNormR2',\n 'testonly_skip_norm_layers': True,\n 'layer_order': 'mhsa',\n 'has_lconv': False,\n 'has_fflayer_start': False,\n 'right_context': 2,\n },\n {\n 'testcase_name': 'Funnel',\n 'stride': 2,\n 'query_stride': 2,\n },\n {\n 'testcase_name': 'FunnelStride4',\n 'stride': 4,\n 'query_stride': 2,\n },\n )\n def testCommon(self,\n testonly_skip_norm_layers=False,\n norm_type='ln',\n num_groups=2,\n stride=1,\n query_stride=1,\n layer_order='conv_before_mhsa',\n has_lconv='depthwise',\n has_fflayer_start=True,\n right_context=0):\n assert norm_type in ('ln', 'gn'), norm_type\n kwargs = dict(\n input_dim=8,\n kernel=3,\n layer_order=layer_order,\n num_heads=2,\n left_context=3,\n right_context=right_context,\n ffn_dim=4,\n stride=stride,\n query_stride=query_stride,\n norm_type=norm_type,\n has_lconv=has_lconv,\n has_fflayer_start=has_fflayer_start,\n num_groups=num_groups)\n kwargs['tol'] = 1e-5\n with cluster_factory.SetEval(True), flagsaver.flagsaver(\n testonly_skip_norm_layers=testonly_skip_norm_layers):\n self._TestStreamStepHelper(**kwargs)\n\n def testStackingLayerWithRightContext(self):\n tf.random.set_seed(2021)\n kwargs = dict(\n input_dim=8,\n kernel=3,\n num_heads=2,\n left_context=6,\n right_context=3,\n ffn_dim=4,\n stride=2,\n layer_order='mhsa_before_conv',\n num_layers=3)\n with cluster_factory.SetEval(True):\n self._TestRightContextStackingLayersHelper(**kwargs)\n\n\nif __name__ == '__main__':\n tf.test.main()\n","# Lint as: python3\n# 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\"\"\"Attention models.\"\"\"\n\nimport math\nimport lingvo.compat as tf\nfrom lingvo.core import base_layer\nfrom lingvo.core import gshard_utils\nfrom lingvo.core import layers\nfrom lingvo.core import py_utils\nfrom lingvo.core import quant_utils\nfrom lingvo.core import symbolic\n\nimport numpy as np\n\nfrom tensorflow.python.ops import inplace_ops # pylint:disable=g-direct-tensorflow-import\n\n\n# Currently, quantization statistics cannot be accumulated across arbitrary\n# defuns, so we allow them to be disabled. A potentially more robust fix is\n# to save and merge the attention state across the defun boundary as is\n# done in recurrent.py.\ndef _ConditionalCallDefun(cond, f, inputs):\n if not cond:\n return f(inputs)\n return py_utils.CallDefun(f, inputs)\n\n\ndef _ApplyAttentionDropout(params, x):\n \"\"\"Apply attention dropout according to the given parameters.\n\n If `params.atten_dropout_deterministic` is set to True, the dropout will be\n fully deterministic.\n\n Args:\n params: The parameters of attention layer.\n x: A float Tensor on which to apply dropout.\n\n Returns:\n A Tensor with the same shape as `x`.\n \"\"\"\n if params.atten_dropout_prob == 0:\n return x\n\n if params.atten_dropout_deterministic:\n seeds = py_utils.GenerateStepSeedPair(params)\n return py_utils.DeterministicDropout(x, 1.0 - params.atten_dropout_prob,\n seeds)\n else:\n return tf.nn.dropout(\n x, rate=params.atten_dropout_prob, seed=params.random_seed)\n\n\ndef SafeCumprod(x, *args, **kwargs):\n \"\"\"Computes cumprod of x in logspace using cumsum to avoid underflow.\n\n The cumprod function and its gradient can result in numerical instabilities\n when its argument has very small and/or zero values. As long as the argument\n is all positive, we can instead compute the cumulative product as\n exp(cumsum(log(x))). This function can be called identically to\n tf.math.cumprod.\n\n Args:\n x: Tensor to take the cumulative product of.\n *args: Passed on to cumsum; these are identical to those in cumprod.\n **kwargs: Passed on to cumsum; these are identical to those in cumprod.\n\n Returns:\n Cumulative product of x.\n \"\"\"\n with tf.name_scope(None, 'SafeCumprod', [x]):\n x = tf.convert_to_tensor(x, name='x')\n tiny = np.finfo(x.dtype.as_numpy_dtype).tiny\n return tf.exp(\n py_utils.CumSum(\n tf.math.log(tf.clip_by_value(x, tiny, 1)), *args, **kwargs))\n\n\n# pyformat: disable\ndef MonotonicAttentionProb(p_choose_i, previous_attention, mode):\n \"\"\"Compute monotonic attention distribution from choosing probabilities.\n\n Monotonic attention implies that the input sequence is processed in an\n explicitly left-to-right manner when generating the output sequence. In\n addition, once an input sequence element is attended to at a given output\n timestep, elements occurring before it cannot be attended to at subsequent\n output timesteps. This function generates attention distributions according\n to these assumptions. For more information, see `Online and Linear-Time\n Attention by Enforcing Monotonic Alignments`.\n\n Args:\n p_choose_i: Probability of choosing input sequence/memory element i. Should\n be of shape (batch_size, input_sequence_length), and should all be in the\n range [0, 1].\n previous_attention: The attention distribution from the previous output\n timestep. Should be of shape (batch_size, input_sequence_length). For\n the first output timestep, preevious_attention[n] should be [1, 0, 0, ...,\n 0] for all n in [0, ... batch_size - 1].\n mode: How to compute the attention distribution. Must be one of `recursive`,\n `parallel`, or `hard`.\n\n * recursive: uses tf.scan to recursively compute the distribution. This is\n slowest but is exact, general, and does not suffer from numerical\n instabilities.\n * parallel: uses parallelized cumulative-sum and cumulative-product\n operations to compute a closed-form solution to the recurrence relation\n defining the attention distribution. This makes it more efficient than\n 'recursive', but it requires numerical checks which make the\n distribution non-exact. This can be a problem in particular when\n input_sequence_length is long and/or p_choose_i has entries very close\n to 0 or 1.\n * hard: requires that the probabilities in p_choose_i are all either 0 or\n 1, and subsequently uses a more efficient and exact solution.\n\n Returns:\n A tensor of shape (batch_size, input_sequence_length) representing the\n attention distributions for each sequence in the batch.\n\n Raises:\n ValueError: mode is not one of 'recursive', 'parallel', 'hard'.\n \"\"\"\n # pyformat: enable\n # Force things to be tensors\n p_choose_i = tf.convert_to_tensor(p_choose_i, name='p_choose_i')\n previous_attention = tf.convert_to_tensor(\n previous_attention, name='previous_attention')\n if mode == 'recursive':\n batch_size = py_utils.GetShape(p_choose_i)[0]\n tf.logging.info(batch_size)\n # Compute [1, 1 - p_choose_i[0], 1 - p_choose_i[1], ..., 1 - p_choose_i[-2]]\n shifted_1mp_choose_i = tf.concat(\n [tf.ones((batch_size, 1)), 1 - p_choose_i[:, :-1]], 1)\n # Compute attention distribution recursively as\n # q[i] = (1 - p_choose_i[i - 1])*q[i - 1] + previous_attention[i]\n # attention[i] = p_choose_i[i]*q[i]\n attention = p_choose_i * tf.transpose(\n tf.scan(\n # Need to use reshape to remind TF of the shape between loop\n # iterations.\n lambda x, yz: tf.reshape(yz[0] * x + yz[1], (batch_size,)),\n # Loop variables yz[0] and yz[1]\n [\n tf.transpose(shifted_1mp_choose_i),\n tf.transpose(previous_attention)\n ],\n # Initial value of x is just zeros\n tf.zeros((batch_size,))))\n elif mode == 'parallel':\n # SafeCumprod computes cumprod in logspace with numeric checks\n cumprod_1mp_choose_i = SafeCumprod(1 - p_choose_i, axis=1, exclusive=True)\n # Compute recurrence relation solution\n attention = p_choose_i * cumprod_1mp_choose_i * py_utils.CumSum(\n previous_attention /\n # Clip cumprod_1mp to avoid divide-by-zero\n tf.clip_by_value(cumprod_1mp_choose_i, 1e-10, 1.),\n axis=1)\n elif mode == 'hard':\n # Remove any probabilities before the index chosen last time step\n p_choose_i *= tf.cumsum(previous_attention, axis=1)\n # Now, use exclusive cumprod to remove probabilities after the first\n # chosen index, like so:\n # p_choose_i = [0, 0, 0, 1, 1, 0, 1, 1]\n # cumprod(1 - p_choose_i, exclusive=True) = [1, 1, 1, 1, 0, 0, 0, 0]\n # Product of above: [0, 0, 0, 1, 0, 0, 0, 0]\n attention = p_choose_i * tf.math.cumprod(\n 1 - p_choose_i, axis=1, exclusive=True)\n else:\n raise ValueError(\"mode must be 'recursive', 'parallel', or 'hard'.\")\n return attention\n\n\nclass BaseAttentionLayer(quant_utils.QuantizableLayer):\n \"\"\"A base class for all attention layers.\"\"\"\n\n @classmethod\n def Params(cls):\n p = super().Params()\n p.Define('atten_dropout_prob', 0.0,\n 'Probability at which we apply dropout to the attention weights.')\n p.Define(\n 'atten_dropout_deterministic', False,\n 'Whether to dropout in a fully deterministic way, which is more '\n 'suitable for TPU.')\n p.Define('packed_input', False,\n 'If True, each training example may pack multiple sequences.')\n\n p.qdomain.Define('softmax', None, 'QDomain for the internal softmax.')\n p.qdomain.Define(\n 'fullyconnected', None, 'Fully connected layers are fed '\n 'into activation functions which have known input ranges')\n\n return p\n\n def __init__(self, params):\n \"\"\"Constructs a BaseAttentionLayer object.\"\"\"\n if not params.name:\n raise ValueError('params.name is not set.')\n super().__init__(params)\n\n self._source_init_done = False\n\n def _CreateLayerVariables(self):\n super()._CreateLayerVariables()\n self.TrackQTensor('logits', domain='fullyconnected')\n\n def InitForSourcePacked(self,\n theta,\n source_vecs,\n source_contexts,\n source_padding,\n source_segment_id=None):\n \"\"\"Initialize attention for the given source vectors.\n\n Must set `_source_init_done` to True in the function.\n\n Note: `source_segment_id`, if present, should always have the same shape as\n `source_padding`.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n source_vecs: A single tensor of shape [time, batch_size, source_dim].\n source_contexts: A single tensor of shape [time, batch_size, some_dim].\n source_padding: A tensor of shape [time, batch_size].\n source_segment_id: A tensor of shape [time, batch_size]. source_segment_id\n is not None for packed inputs where one training example may pack\n multiple sequences.\n\n Returns:\n A `.NestedMap` object to be passed to ComputeContextVectorWithSource.\n The internal structure of the return value should be considered an\n implementation detail of the attention mechanism and should not be\n inspected or modified by its callers.\n \"\"\"\n self._source_init_done = True\n self._packed_src = self.PackSource(theta, source_vecs, source_contexts,\n source_padding, source_segment_id)\n return self._packed_src\n\n def PackSource(self,\n theta,\n source_vecs,\n source_contexts,\n source_padding,\n source_segment_id=None):\n \"\"\"Packs source vectors.\n\n Does not change attention state.\n\n Note: `source_segment_id`, if present, should always have the same shape as\n `source_padding`.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n source_vecs: A single tensor of shape [time, batch_size, source_dim].\n source_contexts: A single tensor of shape [time, batch_size, some_dim].\n source_padding: A tensor of shape [time, batch_size].\n source_segment_id: A tensor of shape [time, batch_size]. source_segment_id\n is not None for packed inputs where one training example may pack\n multiple sequences.\n\n Returns:\n A `.NestedMap` object to be passed to ComputeContextVectorWithSource.\n The internal structure of the return value should be considered an\n implementation detail of the attention mechanism and should not be\n inspected or modified by its callers.\n \"\"\"\n raise NotImplementedError('Abstract method.')\n\n def ComputeContextVectorWithSource(self,\n theta,\n packed_src,\n query_vec,\n attention_state=None,\n per_step_source_padding=None,\n query_segment_id=None):\n \"\"\"Computes the context vector given the current query output.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n packed_src: A `.NestedMap` object returned by PackSource or\n InitForSourcePacked.\n query_vec: a tensor of shape [batch_size, query_dim].\n attention_state: previous attention state.\n per_step_source_padding: Source sequence padding to apply at this step. If\n not None, it should have shape [target_batch_size, source_length].\n query_segment_id: a tensor of shape [batch_size].\n\n Returns:\n A tuple of 3 elements.\n\n - The attention context vector: [batch_size, context_dim]\n - The attention probability vector: [batch_size, time]\n - The new attention mechanism state: possibly nested tuple of tensors\n with dimensions [target_batch, ...]\n \"\"\"\n raise NotImplementedError('Abstract method.')\n\n def ComputeContextVector(self,\n theta,\n query_vec,\n attention_state=None,\n per_step_source_padding=None,\n query_segment_id=None):\n \"\"\"Computes the context vector given the current query output.\n\n Unlike `ComputeContextVectorWithSource` which explicitly asks for the packed\n source tensors, `ComputeContextVector` uses the class' internal variables.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n query_vec: a tensor of shape [batch_size, query_dim].\n attention_state: previous attention state.\n per_step_source_padding: Source sequence padding to apply at this step. If\n not None, it should be of shape [target_batch_size, source_length].\n query_segment_id: a tensor of shape [batch_size].\n\n Returns:\n A tuple of 3 elements.\n\n - The attention context vector.\n - The attention probability vector.\n - The new attention mechanism state: possibly nested tuple of tensors with\n dimensions [target_batch, ...]\n \"\"\"\n assert self._source_init_done\n return self.ComputeContextVectorWithSource(theta, self._packed_src,\n query_vec, attention_state,\n per_step_source_padding,\n query_segment_id)\n\n def GetInitializationSourceState(self):\n \"\"\"Gets the attention initialization state.\n\n The base class only preserves the `concated_source_vecs`,\n `concated_source_contexts` and `source_padding`. If subclasses use more\n state than this and need to interact with inference code that must\n fetch and reload state, this and `SetInitializationSourceState` must\n be overridden.\n\n Returns:\n A `.NestedMap` of Tensors that can be preserved and reset via\n `SetInitializationSourceState()` at a later point. This allows, for\n example, for attention computations to span session runs.\n \"\"\"\n assert self._source_init_done\n return self._packed_src\n\n def SetInitializationSourceState(self, new_init_state):\n \"\"\"Sets the attention initialization state.\n\n Args:\n new_init_state: A `.NestedMap` matching what was returned from\n `GetInitializationSourceState`, which will return this layer to that\n initialization state.\n \"\"\"\n self._source_init_done = True\n self._packed_src = new_init_state.DeepCopy()\n\n def _PaddedSoftmax(self, logits, padding):\n \"\"\"Performs a softmax as if padding were applied after exponentiation.\n\n The default implementation uses numerical techniques to approximate this\n with a standard `tf.nn.softmax` (using large negative logits for padded\n values). It defers to a `Defun` that may be replaced on low-range\n implementations with a version that is numerically correct.\n\n Args:\n logits: Logits.\n padding: Padding (must be the same shape as logits).\n\n Returns:\n Result of the softmax.\n \"\"\"\n fns = self.fns\n\n if logits.dtype.is_complex:\n logits = tf.abs(logits)\n assert logits.dtype.is_floating\n assert hasattr(logits.dtype, 'max')\n very_negative_logits = (\n tf.ones_like(logits) * logits.dtype.max *\n tf.constant(-0.7, dtype=logits.dtype))\n if self.do_eval:\n very_negative_logits = self.QTensor('logits', very_negative_logits)\n padded_logits = tf.where(padding > 0.0, very_negative_logits, logits)\n # TFLite hardcodes the range of qsoftmax, setting explicitly to avoid\n # incompatible concats.\n return fns.qsoftmax(padded_logits, qdomain='softmax')\n\n def _UpdatePaddingWithPackedInputMask(self, padding, source_segment_ids,\n query_segment_ids):\n \"\"\"Creates an attention mask based on source and query segment ids.\n\n This creates a mask that removes invalid attention, where the query vector\n might assign some weight to neighboring sequences in a packed input example.\n Assumes `n = target_batch // source_batch`.\n\n Args:\n padding: Padding for logits, a tensor of shape [time, n, source_batch].\n source_segment_ids: a tensor of shape [time, source_batch].\n query_segment_ids: a tensor of shape [target_batch].\n\n Returns:\n Logits with mask applied.\n \"\"\"\n # Generating packed input mask for attention padding.\n source_segment_ids = tf.expand_dims(source_segment_ids, 1)\n query_segment_ids = tf.reshape(\n query_segment_ids,\n [1, -1, py_utils.GetShape(source_segment_ids)[2]])\n padding = tf.where(\n tf.equal(source_segment_ids, query_segment_ids), padding,\n tf.ones_like(padding))\n return padding\n\n\nclass AdditiveAttention(BaseAttentionLayer):\n \"\"\"Implements additive attention (also known as \"Bahdanau Attention\").\n\n Described in:\n\n Dzmitry Bahdanau, Kyunghyun Cho, Yoshua Bengio.\n \"Neural Machine Translation by Jointly Learning to Align and Translate.\"\n ICLR 2015.\n https://arxiv.org/abs/1409.0473\n \"\"\"\n\n @classmethod\n def Params(cls):\n \"\"\"Params for this `AdditiveAttention` class.\"\"\"\n p = super().Params()\n p.Define('source_dim', 0, 'Number of source nodes.')\n p.Define('query_dim', 0, 'Number of query nodes.')\n p.Define('hidden_dim', 0, 'Number of hidden nodes.')\n # Fill in reasonable default for params init\n p.params_init = py_utils.WeightInit.GaussianSqrtDim()\n p.Define(\n 'same_batch_size', False,\n 'True iff the source and target sequence has the same batch size.')\n return p\n\n def __init__(self, params):\n \"\"\"Constructs an `AdditiveAttention` object.\"\"\"\n super().__init__(params)\n p = self.params\n\n def AttenProbs(inputs):\n \"\"\"Generates probs.\"\"\"\n source_batch = py_utils.GetShape(inputs.source_padding)[1]\n target_batch = py_utils.GetShape(inputs.per_step_source_padding)[0]\n multiplier = target_batch // source_batch\n\n # Shape of summed is [sl, tb/sb, sb, hidden_dim].\n summed = tf.tanh(inputs.concated_source_vecs + inputs.query_vec_reshaped)\n # logits is of shape [sl * tb/sb * sb, 1]. Computes dot product\n # between v with every rows in 'summed'. Then we reshape the\n # result to be of shape [sl, tb/sb, sb].\n #\n # Another equivalent way is to do:\n # logits = tf.reduce_sum(summed *\n # tf.reshape(v, [1, 1, 1, hidden_dim]), 3)\n logits = py_utils.Matmul(\n tf.reshape(summed, [-1, p.hidden_dim]),\n tf.reshape(inputs.v, [p.hidden_dim, 1]))\n logits = tf.reshape(logits, tf.shape(summed)[:3])\n # Take out the padding states.\n # _source_padding is of shape [source_length, source_batch].\n # reshaped to [source_length, 1, source_batch].\n # per_step_source_padding is reshaped to the same but with 'multiplier'\n # for the second dim.\n source_padding = tf.expand_dims(inputs.source_padding, 1)\n per_step_source_padding = tf.reshape(\n tf.transpose(inputs.per_step_source_padding),\n [-1, multiplier, source_batch])\n source_padding += per_step_source_padding\n\n if p.packed_input:\n source_padding = self._UpdatePaddingWithPackedInputMask(\n source_padding, inputs.source_segment_id, inputs.query_segment_id)\n # Reshape logits to a matrix of shape [target_batch, source_length] and\n # takes the softmax to compute the probabilities.\n logits = tf.transpose(tf.reshape(logits, [-1, target_batch]))\n source_padding = tf.transpose(\n tf.reshape(source_padding, [-1, target_batch]))\n probs = self._PaddedSoftmax(logits, source_padding)\n return probs\n\n # Adds the atten function into the graph's library.\n def Atten(v, w, source_padding, source_segment_id, concated_source_vecs,\n concated_source_contexts, query_vec, query_segment_id,\n per_step_source_padding):\n \"\"\"Computes the attention context vector.\n\n Args:\n v: hidden weight. [hidden_dim, 1].\n w: query weight. [query_dim, hidden_dim].\n source_padding: [source_length, source_batch].\n source_segment_id: [source_lentgh, source_batch]\n concated_source_vecs: [source_length, source_batch, hidden_dim].\n concated_source_contexts: [source_batch, source_length, context_dim]\n query_vec: [target_batch, query_dim]\n query_segment_id: [target_batch]\n per_step_source_padding: [target_batch, source_length]\n Note: concated_source_vecs are the vectors that are used to compute the\n attention score between the query_vec and each concated_source_vec. The\n concated_source_contexts are the vectors that compose the result. The\n attention context vector is computed as a weighted average of the\n concated_source_contexts, using the scores that were computed using\n concated_source_vecs.\n\n Returns:\n attention context vectors and probabilities.\n \"\"\"\n source_batch = py_utils.GetShape(concated_source_vecs)[1]\n target_batch = py_utils.GetShape(query_vec)[0]\n multiplier = target_batch // source_batch\n # concated_source_vecs is reshaped to\n # [source_length, 1, source_batch, hidden_dims]\n concated_source_vecs = tf.expand_dims(concated_source_vecs, 1)\n query_vec_transformed = py_utils.Matmul(query_vec, w)\n\n # query_vec is reshaped to\n # [1, target_batch/source_batch, source_batch, hidden_dims].\n query_vec_reshaped = tf.reshape(\n query_vec_transformed, [1, multiplier, source_batch, p.hidden_dim])\n # probs is of shape [target_batch, source_length]\n probs = py_utils.CallDefun(\n AttenProbs,\n py_utils.NestedMap(\n concated_source_vecs=concated_source_vecs,\n source_padding=source_padding,\n query_vec_reshaped=query_vec_reshaped,\n v=v,\n per_step_source_padding=per_step_source_padding,\n source_segment_id=source_segment_id,\n query_segment_id=query_segment_id))\n probs.set_shape(per_step_source_padding.shape)\n\n # Apply dropout to weights if applicable.\n if not self.do_eval:\n probs = _ApplyAttentionDropout(p, probs)\n\n # Reshape probs to be of shape\n # [target_batch/source_batch, source_batch, source_length]\n probs_reshaped = tf.reshape(probs, [multiplier, source_batch, -1])\n # Transpose probs to be of shape\n # [source_batch, target_batch/source_batch, source_length]\n probs_reshaped = tf.transpose(probs_reshaped, [1, 0, 2])\n # Batched matmul\n # [source_batch, target_batch/source_batch, source_length] *\n # [source_batch, source_length, context_dim] =\n # [source_batch, target_batch/source_batch, context_dim]\n summed = tf.matmul(probs_reshaped, concated_source_contexts)\n\n # summed is of shape\n # [target_batch/source_batch, source_batch, context_dim]\n summed = tf.transpose(summed, [1, 0, 2])\n\n return tf.reshape(summed, [target_batch, -1]), probs\n\n # The source batch size equals to the target batch size.\n def AttenSameBatchSize(v, w, source_padding, source_segment_id,\n concated_source_vecs, concated_source_contexts,\n query_vec, query_segment_id,\n per_step_source_padding):\n \"\"\"Computes the attention context vector.\n\n Args:\n v: hidden weight. [hidden_dim].\n w: query weight. [query_dim, hidden_dim].\n source_padding: [sl, b]\n source_segment_id: [sl, b]\n concated_source_vecs: [sl, b, hidden_dim].\n concated_source_contexts: [b, sl, context_dim]\n query_vec: [b, query_dim]\n query_segment_id: [b]\n per_step_source_padding: [b, sl]\n\n Returns:\n attention context vectors and probabilities.\n \"\"\"\n # TODO(jiaye): support dropout\n if p.atten_dropout_prob != 0:\n raise NotImplementedError('dropout is not supported')\n\n # [b, hidden_dim]\n query_vec = py_utils.Matmul(query_vec, w)\n # [sl, b]\n def AttenProbs(inputs):\n \"\"\"Calculates atten probs with padding.\"\"\"\n # tf.tanh(x+y) shape [sl, b, hidden_dim]\n summed = tf.tanh(inputs.x + inputs.y)\n # [-1, hidden_dim] * [hidden_dim, 1] = [-1, 1]\n res = py_utils.Matmul(\n tf.reshape(summed, [-1, p.hidden_dim]), tf.expand_dims(inputs.v, 1))\n # Reshape res to [sl, b]\n logits = tf.reshape(res, tf.shape(summed)[:2])\n # Take out the padding states. _source_padding is of shape [sl, b].\n source_padding = inputs.source_padding + tf.transpose(\n inputs.per_step_source_padding)\n\n if p.packed_input:\n source_padding = self._UpdatePaddingWithPackedInputMask(\n tf.expand_dims(source_padding, 1), inputs.source_segment_id,\n inputs.query_segment_id)\n source_padding = tf.squeeze(source_padding, 1)\n # [b, sl]\n source_padding = tf.transpose(source_padding)\n logits = tf.transpose(logits)\n # softmax to compute the probabilities. [b, sl]\n probs = self._PaddedSoftmax(logits, source_padding)\n return probs\n\n probs = py_utils.CallDefun(\n AttenProbs,\n py_utils.NestedMap(\n x=concated_source_vecs,\n source_padding=source_padding,\n y=query_vec,\n v=v,\n per_step_source_padding=per_step_source_padding,\n source_segment_id=source_segment_id,\n query_segment_id=query_segment_id))\n probs.set_shape(per_step_source_padding.shape)\n\n # contexts[i, :] is a weighted (probs[i, :]) average of\n # concated_source_vecs[i, :, :].\n # Reshaped probs is of shape [b, 1, sl]\n reshaped_probs = tf.expand_dims(probs, 1)\n # [b, 1, sl] * [b, sl, context_dim] = [b, 1, context_dim]\n contexts = tf.matmul(reshaped_probs, concated_source_contexts)\n # Reshaped context is of shape [b, context_dim]\n contexts = tf.squeeze(contexts, axis=1)\n return contexts, probs\n\n if p.same_batch_size:\n self._ctx_vec = AttenSameBatchSize\n else:\n self._ctx_vec = Atten\n\n def EncodeSource(src_w, vecs, ctxs):\n \"\"\"Prepares source vec and ctx.\"\"\"\n time, batch = py_utils.GetShape(vecs, 2)\n ctxs = py_utils.HasShape(ctxs, [time, batch, -1])\n transformed_vecs = tf.matmul(vecs, src_w)\n transformed_vecs = tf.identity(\n transformed_vecs, name='source_vecs_projected')\n transposed_ctxs = tf.transpose(ctxs, [1, 0, 2])\n transposed_ctxs = tf.identity(transposed_ctxs, name='source_ctx')\n return transformed_vecs, transposed_ctxs\n\n self._encode_source = EncodeSource\n\n def _CreateLayerVariables(self):\n super()._CreateLayerVariables()\n p = self.params\n pc = py_utils.WeightParams(\n shape=[p.source_dim, p.hidden_dim],\n init=p.params_init,\n dtype=p.dtype,\n collections=['AdditiveAttention_vars'])\n self.CreateVariable('source_var', pc)\n\n pc = py_utils.WeightParams(\n shape=[p.query_dim, p.hidden_dim],\n init=p.params_init,\n dtype=p.dtype,\n collections=['AdditiveAttention_vars'])\n self.CreateVariable('query_var', pc)\n\n pc = py_utils.WeightParams(\n shape=[p.hidden_dim],\n init=p.params_init,\n dtype=p.dtype,\n collections=['AdditiveAttention_vars'])\n self.CreateVariable('hidden_var', pc)\n\n def AddGlobalVN(self, theta):\n theta = super().AddGlobalVN(theta)\n theta.source_var = self.AddVN(theta.source_var)\n theta.hidden_var = self.AddVN(theta.hidden_var)\n theta.query_var = self.AddVN(theta.query_var)\n return theta\n\n def PackSource(self,\n theta,\n source_vecs,\n source_contexts,\n source_padding,\n source_segment_id=None):\n \"\"\"Packs source vectors.\n\n Does not change attention state.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n source_vecs: A single tensor of shape [time, batch_size, source_dim].\n source_contexts: A single tensor of shape [time, batch_size, some_dim].\n source_padding: A tensor of shape [time, batch_size].\n source_segment_id: A tensor of shape [time, batch_size].\n\n Returns:\n A NestedMap containing the packed source.\n \"\"\"\n with tf.name_scope(self.params.name):\n if source_segment_id is None:\n source_segment_id = tf.zeros_like(source_padding)\n\n (concated_source_vecs, concated_source_contexts) = (\n self._encode_source(theta.source_var, source_vecs, source_contexts))\n return py_utils.NestedMap(\n # [time, batch_size, hidden_dim].\n source_vecs=concated_source_vecs,\n # [batch_size, time, context_dim].\n # Note the mismatch between `source_vecs` and `source_contexts`. In\n # `source_vecs`, time is the first dim, while it is the second dim in\n # `source_contexts`.\n source_contexts=concated_source_contexts,\n # [time, batch_size].\n source_padding=source_padding,\n # [time, batch_size].\n source_segment_id=source_segment_id)\n\n def ZeroAttentionState(self, source_length, decoder_batch_size):\n p = self.params\n # This is just a dummy state. The first dimension of the state has to match\n # decoder_batch_size.\n zs = tf.zeros([decoder_batch_size, 1], dtype=py_utils.FPropDtype(p))\n return zs\n\n def ComputeContextVectorWithSource(self,\n theta,\n packed_src,\n query_vec,\n attention_state=None,\n per_step_source_padding=None,\n query_segment_id=None):\n \"\"\"Computes the context vector given the current query output.\n\n Note: `packed_src.source_vecs` are the vectors that are used to compute the\n attention score between the `query_vec` and each `packed_src.source_vecs`.\n The `packed_src.source_contexts` are the vectors that compose the result.\n The attention context vector is computed as a weighted average of the\n `packed_src.source_contexts`, using the scores that were computed using\n `packed_src.source_vecs`.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n packed_src: A `.NestedMap` object returned by PackSource or\n InitForSourcePacked.\n query_vec: a tensor of shape [batch_size, query_dim].\n attention_state: previous attention state. It is not used in\n `AdditiveAttention`, and is simply passed through.\n per_step_source_padding: Source sequence padding to apply at this step. If\n not None, it should be of shape [target_batch_size, source_length].\n query_segment_id: a tensor of shape [batch_size]\n\n Returns:\n A tuple of 3 elements.\n\n - The attention context vector: [batch_size, context_dim]\n - The attention probability vector: [batch_size, time]\n - The new attention mechanism state: possibly nested tuple of tensors with\n dimensions [target_batch, ...]\n \"\"\"\n concated_source_vecs = packed_src.source_vecs\n concated_source_contexts = packed_src.source_contexts\n source_padding = packed_src.source_padding\n source_segment_id = packed_src.source_segment_id\n query_batch_size = py_utils.GetShape(query_vec)[0]\n source_length = py_utils.GetShape(source_padding)[0]\n if per_step_source_padding is None:\n zero = tf.constant(0.0, dtype=query_vec.dtype)\n per_step_source_padding = tf.fill([query_batch_size, source_length], zero)\n per_step_source_padding = py_utils.HasShape(\n per_step_source_padding, [query_batch_size, source_length])\n hidden = self.AddVN(theta.hidden_var, per_step=True)\n query = self.AddVN(theta.query_var, per_step=True)\n\n if source_segment_id is None:\n source_segment_id = tf.zeros_like(source_padding)\n if query_segment_id is None:\n query_segment_id = tf.zeros(\n tf.shape(query_vec)[0], dtype=source_padding.dtype)\n\n ctx_vec, prob = self._ctx_vec(hidden, query, source_padding,\n source_segment_id, concated_source_vecs,\n concated_source_contexts, query_vec,\n query_segment_id, per_step_source_padding)\n\n return ctx_vec, prob, attention_state\n\n\nclass DotProductAttention(BaseAttentionLayer):\n \"\"\"Implements dot-product attention (also known as \"Luong Attention\").\n\n Described in:\n\n Minh-Thang Luong, Hieu Pham, Christopher D. Manning.\n \"Effective Approaches to Attention-based Neural Machine Translation.\"\n EMNLP 2015.\n https://arxiv.org/abs/1508.04025\n \"\"\"\n\n @classmethod\n def Params(cls):\n \"\"\"Params for `DotProductAttention`.\"\"\"\n p = super().Params()\n p.Define('source_dim', 0, 'Number of source nodes.')\n p.Define('query_dim', 0, 'Number of query nodes.')\n p.Define('hidden_dim', 0, 'Number of hidden nodes.')\n p.Define(\n 'use_dim_scale', True, 'Whether or not to use per_dim_scale to scale '\n 'the individual dims when calculating attention probabilities. It can '\n 'increase training stability when set to False.')\n return p\n\n def __init__(self, params):\n \"\"\"Constructs a DotProductAttention object.\"\"\"\n super().__init__(params)\n p = self.params\n # TODO(yonghui): relax these constraints.\n assert p.source_dim == p.query_dim\n assert p.source_dim == p.hidden_dim\n\n def AttenProbs(inputs):\n \"\"\"Main attention function.\n\n target_batch = source_batch * n where n is an integer >= 1.\n In this case inputs.query_vec contains:\n -------------------------\n | instance 1 |\n | instance 2 |\n 0 | ... |\n | instance source_batch |\n -------------------------\n | instance 1 |\n | instance 2 |\n 1 | ... |\n | instance source_batch |\n -------------------------\n ...\n -------------------------\n | instance 1 |\n | instance 2 |\n n-1 | ... |\n | instance source_batch |\n -------------------------\n One use case is beam search where n = beam size.\n\n Args:\n inputs: a NestedMap containing:\n - per_dim_scale: [source_dim], a vec to scale individual dims.\n - source_padding: [time, source_batch].\n - concated_source_vecs: [source_batch, time, source_dim].\n - query_vec: [target_batch, source_dim].\n - per_step_source_padding: [target_batch, source_length]\n - source_segment_id: [time, source_batch].\n - query_segment_id: [target_batch].\n\n Returns:\n logits [target_batch, source_time].\n \"\"\"\n source_padding = tf.transpose(inputs.source_padding)\n concated_source_vecs = inputs.concated_source_vecs\n\n logit_scale = tf.stop_gradient(\n tf.math.rsqrt(\n tf.cast(\n py_utils.GetShape(inputs.query_vec)[1],\n dtype=py_utils.FPropDtype(p))))\n source_batch = py_utils.GetShape(concated_source_vecs)[0]\n target_batch = py_utils.GetShape(inputs.query_vec)[0]\n query_vec = inputs.query_vec * inputs.per_dim_scale\n # The n here refers to the \"n\" described in the comment above.\n n = target_batch // source_batch\n query_vec = tf.reshape(query_vec, [n, source_batch, -1])\n # => [source_batch, source_dim, n]\n query_vec = tf.transpose(query_vec, [1, 2, 0])\n # => [n, source_batch, source_sequence_len]\n per_step_source_padding = tf.reshape(inputs.per_step_source_padding,\n [n, source_batch, -1])\n # => [source_batch, source_sequence_len, n]\n per_step_source_padding = tf.transpose(per_step_source_padding, [1, 2, 0])\n # Dot-product part.\n # Calls batch_mat_mul since dim > 2 for per-instance matmul.\n # [source_batch, time, source_dim] * [source_batch, source_dim, n]\n # => [source_batch, time, n]\n concated_source_vecs, query_vec = self.ToAqtActActInputs(\n act_lhs=concated_source_vecs,\n act_rhs=query_vec,\n act_lhs_distribution=quant_utils.QDistribution.SYMMETRIC,\n act_rhs_distribution=quant_utils.QDistribution.SYMMETRIC)\n logits = tf.matmul(concated_source_vecs, query_vec)\n logits = self.FromAqtActActMatmul(logits)\n\n logits *= logit_scale\n # Exclude padding frames.\n # [source_batch, time] => [source_batch, time, 1]\n source_padding = tf.expand_dims(source_padding, 2)\n source_padding += per_step_source_padding\n if p.packed_input:\n source_padding = tf.transpose(source_padding, [1, 2, 0])\n source_padding = self._UpdatePaddingWithPackedInputMask(\n source_padding, inputs.source_segment_id, inputs.query_segment_id)\n source_padding = tf.transpose(source_padding, [1, 2, 0])\n else:\n source_padding = tf.transpose(source_padding, [2, 0, 1])\n\n # => [n, source_batch, time]\n logits = tf.transpose(logits, [2, 0, 1])\n\n # => [n * source_batch, time].\n # This makes logits store content in the same order as query_vec.\n logits = tf.reshape(logits, [target_batch, -1])\n source_padding = tf.reshape(source_padding, [target_batch, -1])\n probs = self._PaddedSoftmax(logits, source_padding)\n return probs\n\n def Atten(per_dim_scale, source_padding, source_segment_id,\n concated_source_vecs, concated_source_contexts, query_vec,\n query_segment_id, per_step_source_padding):\n \"\"\"Main attention function.\n\n Args:\n per_dim_scale: [source_dim], a vec to scale individual dims.\n source_padding: [time, source_batch].\n source_segment_id: [time, source_batch].\n concated_source_vecs: [time, source_batch, source_dim].\n concated_source_contexts: [source_batch, time, context_dim].\n query_vec: [target_batch, source_dim].\n query_segment_id: [target_batch].\n per_step_source_padding: [target_batch, source_length]\n Note: concated_source_vecs are the vectors that are used to compute the\n attention score between the query_vec and each concated_source_vec. The\n concated_source_contexts are the vectors that compose the result. The\n attention context vector is computed as a weighted average of the\n concated_source_contexts, using the scores that were computed using\n concated_source_vecs.\n\n Returns:\n Two tensors:\n\n - context_vector: [target_batch, context_dim].\n - probs: [target_batch, time].\n \"\"\"\n py_utils.assert_shape_match([py_utils.GetShape(concated_source_vecs)[2]],\n [py_utils.GetShape(query_vec)[1]])\n py_utils.assert_shape_match([py_utils.GetShape(concated_source_vecs)[2]],\n [symbolic.ToStatic(p.source_dim)])\n source_batch = py_utils.GetShape(concated_source_vecs)[1]\n target_batch = py_utils.GetShape(query_vec)[0]\n n = target_batch // source_batch\n concated_source_vecs = tf.transpose(concated_source_vecs, [1, 0, 2])\n concated_source_vecs = tf.identity(\n concated_source_vecs, name='concated_source_vecs')\n returned_probs = py_utils.CallDefun(\n AttenProbs,\n py_utils.NestedMap(\n per_dim_scale=per_dim_scale,\n source_padding=source_padding,\n concated_source_vecs=concated_source_vecs,\n query_vec=query_vec,\n per_step_source_padding=per_step_source_padding,\n source_segment_id=source_segment_id,\n query_segment_id=query_segment_id))\n returned_probs.set_shape(per_step_source_padding.shape)\n\n # => [n, source_batch, time].\n probs = tf.reshape(returned_probs, [n, source_batch, -1])\n # => [source_batch, n, time].\n probs = tf.transpose(probs, [1, 0, 2])\n\n # Apply dropout to weights if applicable.\n if not self.do_eval:\n probs = _ApplyAttentionDropout(p, probs)\n\n # Weight each frame with the probability and sum them.\n # [source_batch, n, time] * [source_batch, time, context_dim]\n # => [source_batch, n, context_dim].\n concated_source_contexts = tf.identity(\n concated_source_contexts, name='concated_source_contexts')\n probs, concated_source_contexts = self.ToAqtActActInputs(\n act_lhs=probs,\n act_rhs=concated_source_contexts,\n act_lhs_distribution=quant_utils.QDistribution.POSITIVE,\n act_rhs_distribution=quant_utils.QDistribution.SYMMETRIC)\n\n context_vector = tf.matmul(probs, concated_source_contexts)\n context_vector = self.FromAqtActActMatmul(context_vector)\n\n # => [n, source_batch, context_dim].\n context_vector = tf.transpose(context_vector, [1, 0, 2])\n context_vector = gshard_utils.MeshSplit(context_vector, p.device_mesh,\n p.activation_split_dims_mapping)\n # => [n * source_batch, context_dim].\n context_vector = tf.reshape(context_vector, [target_batch, -1])\n\n return context_vector, returned_probs\n\n self._ctx_vec = Atten\n\n def _CreateLayerVariables(self):\n super()._CreateLayerVariables()\n p = self.params\n\n if p.use_dim_scale:\n pc = py_utils.WeightParams(\n shape=[p.hidden_dim],\n init=py_utils.WeightInit.Constant(0.0),\n dtype=p.dtype,\n collections=['DotProductAttention_vars'])\n\n self.CreateVariable('per_dim_scale', pc)\n\n def PackSource(self,\n theta,\n source_vecs,\n source_contexts,\n source_padding,\n source_segment_id=None):\n \"\"\"Packs source vectors.\n\n Does not change attention state.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n source_vecs: A tensor of shape [time, source_batch, source_dim].\n source_contexts: A tensor of shape [time, source_batch, context_dim].\n source_padding: A tensor of shape [time, source_batch].\n source_segment_id: A tensor of shape [time, source_batch].\n\n Returns:\n A tuple (concated_source_vecs, concated_source_contexts, source_padding)\n where `concated_source_vecs` is a tensor of shape [time, batch_size,\n hidden_dim], `concated_source_contexts` is a tensor of shape\n [batch_size, time, some_dim] and `source_padding` is a tensor of shape\n [time, batch_size].\n \"\"\"\n concated_source_vecs = tf.identity(source_vecs)\n concated_source_contexts = tf.transpose(source_contexts, [1, 0, 2])\n if source_segment_id is None:\n source_segment_id = tf.zeros_like(source_padding)\n return py_utils.NestedMap(\n # [time, batch_size, hidden_dim].\n source_vecs=concated_source_vecs,\n # [batch_size, time, context_dim].\n # Note the mismatch between `source_vecs` and `source_contexts`. In\n # `source_vecs`, time is the first dim, while it is the second dim in\n # `source_contexts`.\n source_contexts=concated_source_contexts,\n # [time, batch_size].\n source_padding=source_padding,\n # [time, batch_size].\n source_segment_id=source_segment_id)\n\n def ZeroAttentionState(self, source_length, decoder_batch_size):\n p = self.params\n # No states to keep track of currently.\n return tf.zeros([decoder_batch_size, 1], dtype=py_utils.FPropDtype(p))\n\n def ComputeContextVectorWithSource(self,\n theta,\n packed_src,\n query_vec,\n attention_state=None,\n per_step_source_padding=None,\n query_segment_id=None):\n \"\"\"Computes the context vector given the current query output.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n packed_src: A `.NestedMap` object returned by PackSource or\n InitForSourcePacked.\n query_vec: a tensor of shape [target_batch, query_dim], where target_batch\n = n * source_batch (e.g., n = num_hyps_per_beam in beamsearch). Along\n the target_batch dimension, there are n groups of consecutive rows, each\n group containing source_batch rows.\n attention_state: previous attention state. It is not used in\n AdditiveAttention, and is simply passed through.\n per_step_source_padding: Source sequence padding to apply at this step. If\n not None, it should be of shape [target_batch, source_length].\n query_segment_id: Query segment id with shape [target_batch].\n\n Returns:\n A tuple of 3 elements.\n\n - The attention context vector: [batch_size, context_dim]\n - The attention probability vector: [batch_size, time]\n - The new attention mechanism state: possibly nested tuple of tensors\n with dimensions [target_batch, ...]\n \"\"\"\n concated_source_vecs = packed_src.source_vecs\n concated_source_contexts = packed_src.source_contexts\n\n source_padding = packed_src.source_padding\n source_segment_id = packed_src.source_segment_id\n query_batch_size = py_utils.GetShape(query_vec)[0]\n source_sequence_length = py_utils.GetShape(source_padding)[0]\n if per_step_source_padding is None:\n zero = tf.constant(0.0, dtype=query_vec.dtype)\n per_step_source_padding = tf.fill(\n [query_batch_size, source_sequence_length], zero)\n per_step_source_padding = py_utils.HasShape(\n per_step_source_padding, [query_batch_size, source_sequence_length])\n if source_segment_id is None:\n source_segment_id = tf.zeros_like(source_padding)\n if query_segment_id is None:\n query_segment_id = tf.zeros(\n py_utils.GetShape(query_vec)[0], dtype=source_padding.dtype)\n\n def ScaleFn(x):\n return tf.nn.softplus(x) / tf.nn.softplus(tf.constant(0.0, dtype=x.dtype))\n\n if self.params.use_dim_scale:\n per_dim_scale_var = theta.per_dim_scale\n else:\n per_dim_scale_var = tf.constant(0.0, dtype=query_vec.dtype)\n\n ctx_vec, prob = self._ctx_vec(\n ScaleFn(per_dim_scale_var), source_padding, source_segment_id,\n concated_source_vecs, concated_source_contexts, query_vec,\n query_segment_id, per_step_source_padding)\n return ctx_vec, prob, attention_state\n\n\ndef _RecursiveReshape(x, shape):\n if x is None:\n return None\n elif isinstance(x, py_utils.NestedMap):\n return x.Transform(lambda y: _RecursiveReshape(y, shape))\n else:\n return tf.reshape(x, shape) if x.shape.ndims == 2 else x\n\n\nclass MultiHeadedAttention(BaseAttentionLayer, quant_utils.QuantizableLayer):\n \"\"\"Attention with multiple attention heads.\n\n Conceptually, the algorithm works as follows:\n\n 1. Source vectors (attention keys) are first projected to vectors of dim\n p.hidden_dim.\n 2. Query vectors are projected to vectors of dim p.hidden_dim as well.\n 3. Context vectors (attention values) are not projected by default, unless\n `enable_ctx_pre_proj` is True.\n 4. Source vectors, query vectors and context vectors are all split into\n p.num_attention_heads chunks.\n 5. The inner atten mechanism is computed separately on each of the chunks.\n 6. Attention contexts from each of the chunk are concatenated to form the\n final context.\n 7. Attention probs from each of the chunk are averaged to form the final\n attention prob.\n \"\"\"\n\n @classmethod\n def Params(cls):\n \"\"\"Params for MultiHeadedAttention.\"\"\"\n p = super().Params()\n p.Define('source_dim', 0, 'Number of source nodes.')\n p.Define('query_dim', 0, 'Number of query nodes.')\n p.Define('context_dim', 0, 'Number of context nodes.')\n p.Define('hidden_dim', 0, 'Number of hidden nodes.')\n p.Define('num_attention_heads', 2, 'Num of attention heads.')\n p.Define(\n 'use_source_vec_as_attention_value', True,\n 'Whether or not to use source_vec as the attention value as well.'\n ' If True, we expect source_vec and source_contexts are the same.')\n p.Define('enable_source_proj', True,\n 'If False, source side linear projection is disabled.')\n p.Define('enable_query_proj', True,\n 'If False, query side linear projection is disabled.')\n p.Define('inner_atten_params', DotProductAttention.Params(),\n 'Params for underlying attention mechanism.')\n p.Define(\n 'enable_ctx_pre_proj', False,\n 'If True, context is pre-projected before processing into'\n ' hidden_dim.')\n p.Define(\n 'enable_ctx_post_proj', False,\n 'If True, computed context is post projected into'\n ' ctx_post_proj_dim.')\n p.Define('ctx_post_proj_dim', 0, 'Number of post projection nodes.')\n p.Define(\n 'num_post_proj', 1, 'Number of post projections, usually the same as '\n 'number of tasks. Each task may choose to use one of the post '\n 'projection layers.')\n p.Define(\n 'proj_init', 'default', 'Initialization approach for projection '\n 'layers:'\n 'uniform: Use uniform initialization. '\n 'default: Use the default Xavier initialization.')\n p.Define(\n 'attention_head_prob_index', -1, 'If > 0, instead of averaging '\n 'the probabilities of all attention heads when returning the '\n 'attention probability, instead return the selected index prob.')\n\n p.Define('use_bias', True, 'Whether to use bias for projection layer.')\n p.Define('enable_per_dim_scale', True,\n 'Whether to use per_dim_scale in inner_atten.')\n\n # Often the attention context output needs to be concated\n # with tensors from another layer. This allows them to share\n # quantization parameters. By convention, all attention layers\n # need to include their context output vectors in this domain.\n p.qdomain.Define('atten_context', None,\n 'Quantization domain for attention context.')\n\n p.params_init = py_utils.WeightInit.Xavier(scale=1.0)\n\n return p\n\n def __init__(self, params):\n \"\"\"Constructs a MultiHeadedAttention object.\"\"\"\n super().__init__(params)\n p = self.params\n assert symbolic.ToStatic(\n p.hidden_dim) % p.num_attention_heads == 0, '%s mod %s != 0' % (\n symbolic.ToStatic(p.hidden_dim), p.num_attention_heads)\n\n if p.proj_init not in ('uniform', 'default'):\n raise ValueError('Unknown proj_init: %s!' % p.proj_init)\n\n att_dim = p.hidden_dim // p.num_attention_heads\n\n att_p = p.inner_atten_params.Set(\n source_dim=att_dim,\n query_dim=att_dim,\n hidden_dim=att_dim,\n dtype=p.dtype,\n atten_dropout_prob=p.atten_dropout_prob,\n atten_dropout_deterministic=p.atten_dropout_deterministic,\n packed_input=p.packed_input)\n\n if att_p.cls == DotProductAttention:\n att_p.use_dim_scale = p.enable_per_dim_scale\n\n if not att_p.name:\n att_p.name = 'inner_att'\n self.CreateChild('atten', att_p)\n if p.attention_head_prob_index >= 0:\n assert p.attention_head_prob_index < p.num_attention_heads\n\n self.CreateAqtWeight(\n 'query_proj',\n shape=[p.query_dim, p.hidden_dim],\n feature_axis=-1,\n legacy_aqt_w_name='query_proj_aqt')\n self.CreateAqtWeight(\n 'source_proj',\n shape=[p.source_dim, p.hidden_dim],\n feature_axis=-1,\n legacy_aqt_w_name='source_proj_aqt')\n self.CreateAqtWeight(\n 'ctx_proj',\n shape=[p.context_dim, p.hidden_dim],\n feature_axis=-1,\n legacy_aqt_w_name='ctx_pre_proj_aqt')\n self.CreateAqtWeight(\n 'ctx_post_proj',\n shape=[p.hidden_dim, p.ctx_post_proj_dim],\n feature_axis=-1,\n legacy_aqt_w_name='ctx_post_proj_aqt')\n\n def _CreateLayerVariables(self):\n super()._CreateLayerVariables()\n p = self.params\n\n def InitProj(layer_dim, bias=False):\n if p.proj_init == 'uniform':\n # Note we also initialize bias with uniform distribution here, following\n # the default Pytorch implementation:\n # https://pytorch.org/docs/stable/nn.html#linear\n proj_init = py_utils.WeightInit.Uniform(scale=np.sqrt(1.0 / layer_dim))\n elif p.proj_init == 'default':\n proj_init = py_utils.WeightInit.Constant(0.0) if bias else p.params_init\n return proj_init\n\n if p.use_bias:\n pc_bias = py_utils.WeightParams(\n shape=[p.hidden_dim],\n init=InitProj(p.hidden_dim, bias=True),\n dtype=p.dtype,\n collections=[self.__class__.__name__ + '_vars'])\n\n if p.enable_source_proj:\n pc = py_utils.WeightParams(\n shape=[p.source_dim, p.hidden_dim],\n init=InitProj(p.source_dim),\n dtype=p.dtype,\n device_mesh=p.device_mesh,\n tensor_split_dims_mapping=p.weight_split_dims_mapping,\n collections=[self.__class__.__name__ + '_vars'])\n self.CreateVariable('source_proj', pc)\n if p.use_bias:\n self.CreateVariable('source_proj_b', pc_bias)\n else:\n assert p.source_dim == p.hidden_dim\n\n if p.enable_query_proj:\n pc = py_utils.WeightParams(\n shape=[p.query_dim, p.hidden_dim],\n init=InitProj(p.query_dim),\n dtype=p.dtype,\n device_mesh=p.device_mesh,\n tensor_split_dims_mapping=p.weight_split_dims_mapping,\n collections=[self.__class__.__name__ + '_vars'])\n self.CreateVariable('query_proj', pc)\n if p.use_bias:\n self.CreateVariable('query_proj_b', pc_bias)\n else:\n assert p.query_dim == p.hidden_dim\n\n if p.enable_ctx_pre_proj and not p.use_source_vec_as_attention_value:\n assert p.context_dim\n pc = py_utils.WeightParams(\n shape=[p.context_dim, p.hidden_dim],\n init=InitProj(p.context_dim),\n dtype=p.dtype,\n device_mesh=p.device_mesh,\n tensor_split_dims_mapping=p.weight_split_dims_mapping,\n collections=[self.__class__.__name__ + '_vars'])\n self.CreateVariable('ctx_proj', pc)\n if p.use_bias:\n self.CreateVariable('ctx_proj_b', pc_bias)\n\n if p.enable_ctx_post_proj:\n assert p.ctx_post_proj_dim\n if p.num_post_proj == 1:\n pc_shape = [p.hidden_dim, p.ctx_post_proj_dim]\n pc_b_shape = [p.ctx_post_proj_dim]\n elif p.num_post_proj > 1:\n pc_shape = [p.hidden_dim, p.ctx_post_proj_dim, p.num_post_proj]\n pc_b_shape = [p.ctx_post_proj_dim, p.num_post_proj]\n else:\n raise ValueError('num_post_proj must > 0!')\n weight_split_dims_mapping = p.weight_split_dims_mapping\n if weight_split_dims_mapping and p.num_post_proj > 1:\n weight_split_dims_mapping = weight_split_dims_mapping + [-1]\n pc = py_utils.WeightParams(\n shape=pc_shape,\n init=InitProj(p.hidden_dim),\n dtype=p.dtype,\n device_mesh=p.device_mesh,\n tensor_split_dims_mapping=weight_split_dims_mapping,\n collections=[self.__class__.__name__ + '_vars'])\n self.CreateVariable('ctx_post_proj', pc)\n if p.use_bias:\n pc_bias_post_proj = py_utils.WeightParams(\n shape=pc_b_shape,\n init=InitProj(p.ctx_post_proj_dim, bias=True),\n dtype=p.dtype,\n collections=[self.__class__.__name__ + '_vars'])\n self.CreateVariable('ctx_post_proj_b', pc_bias_post_proj)\n\n self.TrackQTensor('source_proj_matmul', 'source_proj_add',\n 'query_proj_matmul', 'query_proj_add',\n 'ctx_pre_proj_matmul', 'ctx_pre_proj_add')\n # TODO(suderman): Remove the self.do_eval check below once brop quant within\n # defun is fixed on the training side. This is less than ideal as-is because\n # training will just trend to match downstream quant constraints vs force\n # alignment.\n self.TrackQTensor(\n 'ctx_post_proj_matmul', 'ctx_post_proj_add', domain='atten_context')\n\n @classmethod\n def SetOutputContextDim(cls, p, out_dim):\n p.ctx_post_proj_dim = out_dim\n\n @py_utils.NameScopeDecorator('MultiHeadedAttention/PackSource')\n def PackSource(self,\n theta,\n source_vecs,\n source_contexts,\n source_padding,\n source_segment_id=None):\n \"\"\"Packs source vectors.\n\n Does not change attention state.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n source_vecs: A tensor of shape [time, source_batch, source_dim].\n source_contexts: A tensor of shape [time, source_batch, context_dim].\n source_padding: A tensor of shape [time, source_batch].\n source_segment_id: A tensor of shape [time, source_batch].\n\n Returns:\n A NestedMap representing packed src. It will have the same structure\n as the one returned by the inner atten, except that source_batch will be\n source_batch * num_heads.\n \"\"\"\n\n p = self.params\n fns = self.fns\n if not p.enable_source_proj:\n assert p.source_dim == p.hidden_dim\n if not p.enable_query_proj:\n assert p.query_dim == p.hidden_dim\n with tf.name_scope('init__0'):\n if p.use_source_vec_as_attention_value:\n source_vecs = py_utils.HasShape(source_vecs,\n py_utils.GetShape(source_contexts))\n time_steps, batch_size = py_utils.GetShape(source_padding, 2)\n # source_projected shape [time * source_batch, hidden]\n with tf.name_scope('init__0a'):\n source_vec_depth = py_utils.GetShape(source_vecs)[2]\n with tf.name_scope('init__0b'):\n if p.enable_source_proj:\n source_vecs = tf.reshape(source_vecs, [-1, source_vec_depth])\n source_vecs, w_source_proj = self.ToAqtInputs(\n 'source_proj',\n act=source_vecs,\n weight=theta.source_proj,\n w_feature_axis=-1)\n w_source_proj = self.QWeight(w_source_proj)\n source_projected = (\n fns.qbatchmatmul(\n source_vecs, w_source_proj, qout_name='source_proj_matmul'))\n source_projected = self.FromAqtMatmul('source_proj', source_projected)\n if p.use_bias:\n source_projected = fns.qadd(\n source_projected,\n self.QWeight(theta.source_proj_b),\n qout_name='source_proj_add')\n else:\n source_projected = tf.reshape(source_vecs, [-1, source_vec_depth])\n if p.activation_split_dims_mapping:\n source_projected = gshard_utils.MeshSplit(\n source_projected, p.device_mesh,\n p.activation_split_dims_mapping[1:])\n with tf.name_scope('init__1'):\n num_heads = p.num_attention_heads\n # => [time, source_batch * num_heads, hidden / num_heads]\n source_projected = tf.reshape(source_projected, [\n time_steps, batch_size * num_heads,\n symbolic.ToStatic(p.hidden_dim // num_heads)\n ])\n source_projected = gshard_utils.MeshSplit(source_projected, p.device_mesh,\n p.activation_split_dims_mapping)\n source_projected = self.ProcessProjectionVec(theta, source_projected,\n 'source')\n if p.use_source_vec_as_attention_value:\n source_contexts_reshaped = source_projected\n else:\n if p.enable_ctx_pre_proj:\n source_contexts = tf.reshape(\n source_contexts, [-1, py_utils.GetShape(source_contexts)[2]])\n source_contexts, w_ctx_proj = self.ToAqtInputs(\n 'ctx_proj',\n act=source_contexts,\n weight=theta.ctx_proj,\n w_feature_axis=-1)\n w_ctx_proj = self.QWeight(w_ctx_proj)\n\n source_contexts_projected = fns.qbatchmatmul(\n source_contexts, w_ctx_proj, qout_name='ctx_pre_proj_matmul')\n source_contexts_projected = self.FromAqtMatmul(\n 'ctx_proj', source_contexts_projected)\n if p.use_bias:\n source_contexts_projected = fns.qadd(\n source_contexts_projected,\n self.QWeight(theta.ctx_proj_b),\n qout_name='ctx_pre_proj_add')\n if p.activation_split_dims_mapping:\n source_contexts_projected = gshard_utils.MeshSplit(\n source_contexts_projected, p.device_mesh,\n p.activation_split_dims_mapping[1:])\n else:\n source_contexts_projected = source_contexts\n\n source_context_depth = py_utils.GetShape(source_contexts_projected)[-1]\n source_contexts_reshaped = tf.reshape(source_contexts_projected, [\n time_steps, batch_size * num_heads,\n source_context_depth // num_heads\n ])\n source_contexts_projected = gshard_utils.MeshSplit(\n source_contexts_projected, p.device_mesh,\n p.activation_split_dims_mapping)\n source_contexts_projected = self.ProcessProjectionVec(\n theta, source_contexts_projected, 'ctx')\n\n with tf.name_scope('init__2'):\n source_padding_replicated = tf.reshape(\n tf.tile(\n tf.reshape(source_padding, [time_steps, batch_size, 1]),\n [1, 1, num_heads]), [time_steps, batch_size * num_heads])\n if source_segment_id is None:\n source_segment_id_repl = tf.zeros_like(source_padding_replicated)\n else:\n source_segment_id_repl = tf.reshape(\n tf.tile(\n tf.reshape(source_segment_id, [time_steps, batch_size, 1]),\n [1, 1, num_heads]), [time_steps, batch_size * num_heads])\n\n return self.atten.PackSource(theta.atten, source_projected,\n source_contexts_reshaped,\n source_padding_replicated,\n source_segment_id_repl)\n\n @py_utils.NameScopeDecorator('MultiHeadedAttention/ExtendSourcePacked')\n def ExtendSourcePacked(self,\n theta,\n new_source_vecs,\n new_source_contexts,\n new_source_paddings,\n new_source_segment_ids,\n cached_packed_src,\n t=None):\n \"\"\"Extend cached source_vecs and source_contexts by one more timestep.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n new_source_vecs: A tensor of shape [source_batch, source_dim].\n new_source_contexts: A tensor of shape [source_batch, context_dim].\n new_source_vecs and new_source_contexts are source_vecs and\n source_contexts for the new timestep to be extended.\n new_source_paddings: If not None, a tensor of shape [source_batch].\n source_padding for the new timestep.\n new_source_segment_ids: If not None, a tensor of shape [source_batch].\n source_segment_id for the new timestep.\n cached_packed_src: a `.NestedMap` object, containing already preprocessed\n source_vecs and source_contexts for the previous t-1 steps. To support\n tf.while_loop on TPU (satisfying static shape requirement), instead of\n using tf.concat to update the cached vectors, the time dimension of each\n cached vector is fixed as the max_sequence_length and inplace\n update op is used to update the information for each time step:\n * source_vecs: A tensor of shape [max_sequence_length, source_batch,\n hidden_dim]. [:t, :, :] contains valid preprocessed source_vecs in the\n previous t - 1 timesteps, the rests are invalid data.\n * source_contexts: A tensor of shape [max_sequence_length, source_batch,\n hidden_dim]. [:t, :, :] contains valid preprocessed source_contexts in\n the previous t - 1 timesteps, the rests are invalid data.\n * source_padding: If not None, a tensor of shape [max_sequence_length,\n source_batch, num_heads]. [:t, :, :] contains cached source padding\n for the previous t - 1 timesteps, the rests are invalid data.\n * source_segment_id: If not None, a tensor of shape\n [max_sequence_length, source_batch, num_heads]. [:t, :, :] contains\n cached source segment id for the previous t - 1 timesteps, the rests\n are invalid data.\n When t is None (not running on TPU or the while loop is unrolled):\n * source_vecs: A tensor of shape [t - 1, source_batch, hidden_dim].\n * source_contexts: A tensor of shape [t - 1, source_batch, hidden_dim].\n * source_padding: If not None, a tensor of shape [t - 1, source_batch,\n num_heads], cached source padding for the previous t - 1 timesteps.\n * source_segment_id: If not None, a tensor of shape [t - 1,\n source_batch, num_heads], cached source segment id for the previous t\n - 1 timesteps.\n t: a scalar, the current time step, 0-based.\n\n Returns:\n Extended cached source_vecs, source_contexts, source_paddings, and\n source_segment_ids. The time dimension of each cached state is fixed:\n 'extended_source_vec' is of shape [max_sequence_length, batch_size,\n num_heads * dim];\n 'extended_source_context' is of shape [max_sequence_length, batch_size,\n num_heads * dim];\n 'source_padding' is of shape [max_sequence_length, batch_size, num_heads];\n 'source_segment_id' is of shape [max_sequence_length, batch_size,\n num_heads].\n But only [:(t + 1), :, :] contains valid data.\n If t is not given,\n 'extended_source_vec' is of shape [t, batch_size, num_heads * dim];\n 'extended_source_context' is of shape [t, batch_size, num_heads * dim];\n 'source_padding' is of shape [t, batch_size, num_heads];\n 'source_segment_id' is of shape [t, batch_size, num_heads].\n \"\"\"\n batch_size = py_utils.GetShape(new_source_vecs)[0]\n if new_source_paddings is None:\n new_source_paddings = tf.zeros([batch_size], dtype=new_source_vecs.dtype)\n if new_source_segment_ids is None:\n new_source_segment_ids = tf.zeros([batch_size],\n dtype=new_source_vecs.dtype)\n processed_packed_src = self.InitForSourcePacked(\n theta, tf.expand_dims(new_source_vecs, 0),\n tf.expand_dims(new_source_contexts, 0),\n tf.expand_dims(new_source_paddings, 0),\n tf.expand_dims(new_source_segment_ids, 0))\n extended_packed_src = py_utils.NestedMap()\n for key in ('source_vecs', 'source_contexts', 'source_padding',\n 'source_segment_id'):\n if cached_packed_src.get(key, None) is None:\n extended_packed_src[key] = None\n else:\n if t is not None:\n processed = tf.reshape(processed_packed_src[key], [batch_size, -1])\n # Make sure t is a scaler instead of tensors having shape like [1,].\n # This could happen in cases where function is called by recurrent.py\n # (for example target_sequence_sampler.)\n t = tf.reshape(t, [])\n extended_packed_src[key] = inplace_ops.alias_inplace_update(\n cached_packed_src[key], t, processed)\n else:\n processed = tf.reshape(processed_packed_src[key], [1, batch_size, -1])\n extended_packed_src[key] = tf.concat(\n [cached_packed_src[key], processed], axis=0)\n return extended_packed_src\n\n @py_utils.NameScopeDecorator('MultiHeadedAttention/ZeroAttentionState')\n def ZeroAttentionState(self, source_length, decoder_batch_size):\n zero_att_state = self.atten.ZeroAttentionState(\n source_length, decoder_batch_size * self.params.num_attention_heads)\n # [batch * num_heads, length] => [batch, num_heads * length].\n zero_att_state = _RecursiveReshape(zero_att_state, [decoder_batch_size, -1])\n nested_map_zero_att_state = py_utils.NestedMap(inner=zero_att_state)\n if self.params.attention_head_prob_index >= 0:\n selected_prob_head = tf.zeros([decoder_batch_size, source_length],\n dtype=py_utils.FPropDtype(self.params))\n nested_map_zero_att_state[\n 'selected_attention_head_probs'] = selected_prob_head\n return nested_map_zero_att_state\n\n def ProcessProjectionVec(self, theta, projection_vec, projection_type):\n # no-op for this class but allows subclasses to override to process\n # projected vectors.\n return projection_vec\n\n @py_utils.NameScopeDecorator(\n 'MultiHeadedAttention/ComputeContextVectorWithSource')\n def ComputeContextVectorWithSource(self,\n theta,\n packed_src,\n query_vec,\n attention_state=None,\n per_step_source_padding=None,\n query_segment_id=None,\n atten_idx=None):\n \"\"\"Computes the context vector given the current query output.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n packed_src: A `.NestedMap` object returned by PackSource or\n InitForSourcePacked.\n query_vec: a tensor of shape [target_batch, query_dim].\n attention_state: A NestedMap. 'inner' contains the inner attention\n state. It is not used in AdditiveAttention, and is simply passed\n through. Optionally, if attention_head_prob_index >= 0, then\n 'selected_attention_head_probs' contains the selected attention\n probability head.\n per_step_source_padding: Source sequence padding to apply at this step. If\n not None, it should be of shape [target_batch_size, source_length].\n query_segment_id: a tensor of shape [target_batch].\n atten_idx: If not None, then apply a different attention projection for\n different samples in a batch, each of which may come from different\n tasks. This is usually used in multi-task setting. A tensor of shape\n [target_batch].\n Note: concated_source_vecs are the vectors that are used to compute the\n attention score between the query_vec and each concated_source_vec. The\n concated_source_contexts are the vectors that compose the result. The\n attention context vector is computed as a weighted average of the\n concated_source_contexts, using the scores that were computed using\n concated_source_vecs.\n\n Returns:\n A tuple of 3 elements.\n\n - The attention context vector: [batch_size, context_dim]\n - The attention probability vector: [batch_size, time]\n - The new attention mechanism state: A nested tuple of tensors with\n dimensions [target_batch, ...]. See input 'attention_state' for\n description of items in the nested tuple.\n \"\"\"\n p = self.params\n fns = self.fns\n source_padding = packed_src.source_padding\n source_seq_len = py_utils.GetShape(source_padding)[0]\n num_heads = p.num_attention_heads\n batch_size = py_utils.GetShape(query_vec)[0]\n static_inner_atten_dim = symbolic.ToStatic(p.hidden_dim // num_heads)\n query_vec_projected_shape = [batch_size * num_heads, static_inner_atten_dim]\n\n if p.enable_query_proj:\n query_vec, w_query_proj = self.ToAqtInputs(\n 'query_proj',\n act=query_vec,\n weight=theta.query_proj,\n w_feature_axis=-1)\n w_query_proj = self.QWeight(w_query_proj)\n query_vec_projected = fns.qbatchmatmul(\n query_vec, w_query_proj, qout_name='query_proj_matmul')\n query_vec_projected = self.FromAqtMatmul('query_proj',\n query_vec_projected)\n if p.use_bias:\n query_vec_projected = fns.qadd(\n query_vec_projected,\n self.QWeight(theta.query_proj_b),\n qout_name='query_proj_add')\n query_vec_projected = tf.reshape(query_vec_projected,\n query_vec_projected_shape)\n query_vec_projected = self.ProcessProjectionVec(theta,\n query_vec_projected,\n 'query')\n else:\n query_vec_projected = tf.reshape(query_vec, query_vec_projected_shape)\n if p.activation_split_dims_mapping:\n query_vec_projected = gshard_utils.MeshSplit(\n query_vec_projected, p.device_mesh,\n p.activation_split_dims_mapping[1:])\n\n query_batch_size = py_utils.GetShape(query_vec)[0]\n if query_segment_id is None:\n query_segment_id = tf.zeros(\n query_batch_size * num_heads, dtype=source_padding.dtype)\n else:\n query_segment_id_repl = tf.tile(\n tf.expand_dims(query_segment_id, 1), [1, num_heads])\n query_segment_id = tf.reshape(query_segment_id_repl, [-1])\n\n if per_step_source_padding is None:\n zero = tf.constant(0.0, dtype=query_vec.dtype)\n per_step_source_padding = tf.fill([query_batch_size, source_seq_len],\n zero)\n per_step_source_padding = py_utils.HasShape(\n per_step_source_padding, [query_batch_size, source_seq_len])\n per_step_source_padding = tf.reshape(\n tf.tile(per_step_source_padding, [1, num_heads]), [-1, source_seq_len])\n attention_state = _RecursiveReshape(attention_state,\n [batch_size * num_heads, -1])\n if isinstance(attention_state, py_utils.NestedMap):\n if 'emit_probs' in attention_state:\n inner_state = attention_state\n elif 'inner' in attention_state:\n inner_state = attention_state.inner\n else:\n inner_state = attention_state\n ctx_vec, prob, new_inner_state = self.atten.ComputeContextVectorWithSource(\n theta.atten, packed_src, query_vec_projected, inner_state,\n per_step_source_padding, query_segment_id)\n ctx_vec = tf.reshape(ctx_vec, [batch_size, -1])\n if p.activation_split_dims_mapping:\n ctx_vec = gshard_utils.MeshSplit(ctx_vec, p.device_mesh,\n p.activation_split_dims_mapping[1:])\n if p.enable_ctx_post_proj:\n if atten_idx is None:\n assert p.num_post_proj == 1, (\n 'atten_idx is None, this means there is no need to select '\n 'different post projections, and p.num_post_proj is supposed to be '\n '1. However you set p.num_post_proj=%s .' % p.num_post_proj)\n ctx_vec, w_ctx_post_proj = self.ToAqtInputs(\n 'ctx_post_proj',\n act=ctx_vec,\n weight=theta.ctx_post_proj,\n w_feature_axis=-1)\n w_ctx_post_proj = self.QWeight(w_ctx_post_proj)\n ctx_vec = fns.qbatchmatmul(\n ctx_vec, w_ctx_post_proj, qout_name='ctx_post_proj_matmul')\n ctx_vec = self.FromAqtMatmul('ctx_post_proj', ctx_vec)\n if p.use_bias:\n ctx_vec = fns.qadd(\n ctx_vec,\n self.QWeight(theta.ctx_post_proj_b),\n qout_name='ctx_post_proj_add')\n else:\n assert p.num_post_proj > 1, (\n 'atten_idx is not None, this means there are multiple post '\n 'projections, and p.num_post_proj is supposed to be > 1. However '\n 'you set p.num_post_proj=%s .' % p.num_post_proj)\n bs_range = [tf.range(batch_size)]\n select = tf.transpose(tf.concat([bs_range, [atten_idx]], axis=0))\n # => [batch, dim, num_langs]\n ctx_vec = tf.einsum('ab,bcd->acd', ctx_vec, theta.ctx_post_proj)\n if p.use_bias:\n ctx_vec += tf.expand_dims(theta.ctx_post_proj_b, 0)\n # => [batch, num_langs, dim]\n ctx_vec = tf.transpose(ctx_vec, [0, 2, 1])\n # => [batch, dim]\n ctx_vec = tf.gather_nd(ctx_vec, select)\n ctx_vec = self.ProcessProjectionVec(theta, ctx_vec, 'ctx_post')\n\n # explicitly name this tensor for potential future reference\n multi_headed_atten_prob = tf.reshape(\n prob, [batch_size, num_heads, -1], name='multi_headed_atten_prob')\n prob = self.QRAct(\n tf.reduce_mean(multi_headed_atten_prob, 1),\n quant_utils.QDistribution.SOFTMAX,\n domain='softmax')\n if isinstance(attention_state, py_utils.NestedMap):\n att_state = attention_state\n if 'emit_probs' in attention_state:\n att_state = new_inner_state\n elif 'inner' in attention_state:\n att_state.inner = new_inner_state\n else:\n att_state = new_inner_state\n if p.attention_head_prob_index >= 0:\n selected_prob_head = multi_headed_atten_prob[:, p.\n attention_head_prob_index, :]\n att_state.selected_attention_head_probs = selected_prob_head\n att_state = _RecursiveReshape(att_state, [batch_size, -1])\n return ctx_vec, prob, att_state\n\n @py_utils.NameScopeDecorator(\n 'MultiHeadedAttention/ComputeContextVectorWithAttenProbs')\n def ComputeContextVectorWithAttenProbs(self, theta, packed_context,\n atten_probs):\n \"\"\"Computes the context vector given the attention probailities.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n packed_context: Concated source contexts with shape [ batch_size *\n num_heads, time, context_dim // num_heads].\n atten_probs: The attention probability vector: [batch_size * num_heads,\n time].\n\n Returns:\n The attention context vector shaped [target_batch, source_dim].\n If p.enable_ctx_post_proj is false, source_dim = context_dim,\n otherwise, source_dim = p.ctx_post_proj_dim.\n \"\"\"\n p = self.params\n num_heads = p.num_attention_heads\n # packed_context: [batch_size * num_head, num_style,\n # hidden_dim / num_head]\n # inp: [batch_size * num_head, num_style]\n packed_context = py_utils.with_dependencies([\n py_utils.assert_shape_match([py_utils.GetShape(packed_context)[0]],\n [py_utils.GetShape(atten_probs)[0]])\n ], packed_context)\n b_size = py_utils.GetShape(packed_context)[0] // num_heads\n ctx_vec = tf.reshape(\n tf.matmul(tf.expand_dims(atten_probs, 1), packed_context), [b_size, -1])\n if p.enable_ctx_post_proj:\n ctx_vec_proj = tf.matmul(ctx_vec, theta.ctx_post_proj)\n ctx_vec_proj += theta.ctx_post_proj_b\n ctx_vec_proj = self.ProcessProjectionVec(theta, ctx_vec_proj, 'ctx_post')\n else:\n ctx_vec_proj = ctx_vec\n return ctx_vec_proj, ctx_vec\n\n def PackCachedSource(self, cached_src):\n p = self.params\n concated_source_vecs = cached_src.source_vecs\n concated_source_contexts = cached_src.source_contexts\n source_padding = cached_src.source_padding\n source_segment_id = cached_src.source_segment_id\n batch_size = py_utils.GetShape(concated_source_vecs)[1]\n src_seq_len = py_utils.GetShape(concated_source_vecs)[0]\n num_heads = p.num_attention_heads\n packed_src = py_utils.NestedMap()\n packed_src.source_vecs = tf.reshape(\n concated_source_vecs, [src_seq_len, batch_size * num_heads, -1])\n # TODO(yonghui): Rewrite the following with just one transpose.\n packed_src.source_contexts = tf.transpose(\n tf.reshape(concated_source_contexts,\n [src_seq_len, batch_size * num_heads, -1]), [1, 0, 2])\n if source_padding is not None:\n packed_src.source_padding = tf.reshape(\n source_padding, [src_seq_len, batch_size * num_heads])\n else:\n packed_src.source_padding = tf.zeros(\n [src_seq_len, batch_size * num_heads], dtype=py_utils.FPropDtype(p))\n if source_segment_id is None:\n packed_src.source_segment_id = tf.zeros(\n [src_seq_len, batch_size * num_heads],\n dtype=packed_src.source_padding.dtype)\n else:\n packed_src.source_segment_id = tf.reshape(\n source_segment_id, [src_seq_len, batch_size * num_heads])\n return packed_src\n\n @py_utils.NameScopeDecorator(\n 'MultiHeadedAttention/ComputeContextVectorWithCachedSource')\n def ComputeContextVectorWithCachedSource(self,\n theta,\n cached_src,\n query_vec,\n attention_state=None,\n per_step_source_padding=None,\n query_segment_id=None):\n \"\"\"Same as the ComputeContextVectorWithSource api above, except values ...\n\n in source_vecs, source_contexts and source_padding are ordered differently.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n cached_src: A `.NestedMap` object returned by ExtendSourcePacked.\n query_vec: a tensor of shape [target_batch, query_dim].\n attention_state: previous attention state. It is not used in\n AdditiveAttention, and is simply passed through.\n per_step_source_padding: Source sequence padding to apply at this step. If\n not None, it should be of shape [target_batch_size, source_length].\n query_segment_id: a tensor of shape [target_batch].\n\n Returns:\n A tuple of 3 tensors:\n\n - The attention context vector: [target_batch, source_dim]\n - The attention probability vector: [target_batch, time]\n - The new attention mechanism state: possibly nested tuple of tensors with\n dimensions [target_batch....]\n \"\"\"\n return self.ComputeContextVectorWithSource(\n theta, self.PackCachedSource(cached_src), query_vec, attention_state,\n per_step_source_padding, query_segment_id)\n\n\nclass LocationSensitiveAttention(BaseAttentionLayer):\n \"\"\"An attention that also takes into account previously attended locations.\n\n See section 2.2 of this paper for a description of this technique:\n http://papers.nips.cc/paper/5847-attention-based-models-for-speech-recognition.pdf\n \"\"\"\n\n @classmethod\n def Params(cls):\n \"\"\"Params for this LocationSensitiveAttention class.\"\"\"\n p = super().Params()\n p.Define('source_dim', 0, 'Number of source nodes.')\n p.Define('location_filter_size', 0,\n 'Location filter size, should be an odd number e.g. 31.')\n p.Define('location_num_filters', 0, 'Number of location filters, e.g. 32.')\n p.Define('query_dim', 0, 'Number of query nodes.')\n p.Define('hidden_dim', 0, 'Number of hidden nodes.')\n p.Define(\n 'same_batch_size', False,\n 'True iff the source and target sequence has the same batch size.')\n p.Define(\n 'location_features', ['PREV_PROBS'],\n 'List signals to run the convolutions on. Possible options are: '\n 'PREV_PROBS, CUMULATIVE_PROBS.')\n\n # Often the attention context output needs to be concated\n # with tensors from another layer. This allows them to share\n # quantization parameters. By convention, all attention layers\n # need to include their context output vectors in this domain.\n p.qdomain.Define('atten_context', None,\n 'Quantization domain for attention context.')\n\n # Fill in reasonable default for params init\n p.params_init = py_utils.WeightInit.GaussianSqrtDim()\n return p\n\n def __init__(self, params):\n \"\"\"Constructs an LocationSensitiveAttention object.\"\"\"\n super().__init__(params)\n p = self.params\n self._is_quantized = p.qdomain.default is not None\n assert not p.packed_input, ('Packed input is not supported yet for '\n 'LocationSensitiveAttention.')\n\n if p.atten_dropout_prob != 0:\n raise NotImplementedError('dropout is not supported')\n\n def AttenLogits(inputs):\n \"\"\"Generates logits.\"\"\"\n fns = self.fns\n\n def CollapseOutDim(x):\n return tf.reshape(x, [-1, tf.shape(x)[-1]])\n\n # => [sl, sb, hd]\n location_feats = tf.transpose(inputs.location_feats, [2, 0, 1])\n location_hidden = fns.qmatmul(\n CollapseOutDim(location_feats),\n inputs.location_var,\n qout_name='logits_mul')\n\n sl = py_utils.GetShape(location_feats)[0]\n tb = py_utils.GetShape(location_feats)[1]\n hd = py_utils.GetShape(inputs.location_var)[1]\n location_hidden = tf.reshape(location_hidden, [sl, tb, hd])\n sb = py_utils.GetShape(inputs.query_vec_reshaped)[2]\n bs_mult = py_utils.GetShape(inputs.query_vec_reshaped)[1]\n location_hidden = tf.reshape(location_hidden, [sl, bs_mult, sb, hd])\n\n # Shape of summed is [sl, tb/sb, sb, hidden_dim].\n summed = fns.qadd(\n inputs.concated_source_vecs,\n inputs.query_vec_reshaped,\n qout_name='logits_add')\n summed = fns.qadd(summed, location_hidden, qout_name='logits_bias')\n summed = fns.qtanh(summed)\n # logits is of shape [sl * tb/sb * sb, 1]. Computes dot product\n # between v with every rows in 'summed'. Then we reshape the\n # result to be of shape [sl, tb/sb, sb].\n logits = fns.qmatmul(\n tf.reshape(summed, [-1, p.hidden_dim]),\n tf.reshape(inputs.hidden_v, [p.hidden_dim, 1]),\n qout_name='logits')\n logits = tf.reshape(logits, py_utils.GetShape(summed)[:3])\n return logits\n\n def AttenLogitsSameBatchSize(inputs):\n \"\"\"Generates logits.\n\n Optimized code path for when the target and the source have the same batch\n size.\n\n Args:\n inputs: a NestedMap containing:\n - concated_source_vecs: Tensor of shape [sl, batch, dim]\n - query_vec_transformed: Tensor of shape [batch, dim]\n - hidden_v: Tensor of shape [dim]\n - location_feats: Tensor of shape [batch, location_feature_dim, sl]\n - location_var: Tensor of shape [location_feature_dim, dim]\n\n Returns:\n logits in the shape [sl, batch_size].\n \"\"\"\n\n def CollapseOutDim(x):\n return tf.reshape(x, [-1, tf.shape(x)[-1]])\n\n fns = self.fns\n # => [sl, sb, hd]\n location_feats = tf.transpose(inputs.location_feats, [2, 0, 1])\n location_hidden = fns.qmatmul(\n CollapseOutDim(location_feats),\n inputs.location_var,\n qout_name='logits_mul')\n sl = tf.shape(location_feats)[0]\n tb = tf.shape(location_feats)[1]\n hd = tf.shape(inputs.location_var)[1]\n location_hidden = tf.reshape(location_hidden, [sl, tb, hd])\n\n # Shape of summed is [sl, sb, hidden_dim].\n summed = fns.qadd(\n inputs.concated_source_vecs,\n tf.expand_dims(inputs.query_vec_transformed, 0),\n qout_name='logits_add')\n\n summed = fns.qadd(summed, location_hidden, qout_name='logits_bias')\n summed = fns.qtanh(summed)\n\n # logits is of shape [sl * sb, 1]. Computes dot product\n # between v with every rows in 'summed'. Then we reshape the\n # result to be of shape [sl, tb].\n logits = fns.qmatmul(\n tf.reshape(summed, [-1, p.hidden_dim]),\n tf.reshape(inputs.hidden_v, [p.hidden_dim, 1]),\n qout_name='logits')\n logits = tf.reshape(logits, py_utils.GetShape(summed)[:2])\n return logits\n\n def Atten(hidden_var, query_var, source_padding, concated_source_vecs,\n concated_source_contexts, query_vec, attention_state,\n location_filter_var, location_var, per_step_source_padding):\n \"\"\"Computes the attention context vector.\"\"\"\n p = self.params\n # attention_state shape [batch, len(p.location_features), slen]\n # it contains previous and accumulated attention probabilites.\n attention_state = py_utils.HasShape(attention_state,\n [-1, len(p.location_features), -1])\n\n fns = self.fns\n location_feats = self._ApplyConv(attention_state, location_filter_var)\n\n # concated_source_vecs is of shape [sl, sb, dims]\n # concated_source_contexts is of shape [sb, sl, context_dim]\n # query_vec is of shape [tb, dims]\n sb = py_utils.GetShape(concated_source_vecs)[1]\n tb = py_utils.GetShape(query_vec)[0]\n multiplier = tb // sb\n # concated_source_vecs is reshaped to [sl, 1, sb, hidden_dims]\n concated_source_vecs = tf.expand_dims(concated_source_vecs, 1)\n query_vec_transformed = fns.qmatmul(\n query_vec, query_var, qout_name='atten_matmul')\n # query_vec is reshaped to [1, tb/sb, sb, hidden_dims].\n query_vec_reshaped = tf.reshape(query_vec_transformed,\n [1, multiplier, sb, p.hidden_dim])\n # logits is of shape [sl, tb/sb, sb]\n logits = _ConditionalCallDefun(\n self._is_quantized, AttenLogits,\n py_utils.NestedMap(\n concated_source_vecs=concated_source_vecs,\n query_vec_reshaped=query_vec_reshaped,\n hidden_v=hidden_var,\n location_feats=location_feats,\n location_var=location_var))\n # Take out the padding states.\n # _source_padding is of shape [sl, sb].\n # reshaped to [sl, 1, sb].\n source_padding = tf.expand_dims(source_padding, 1)\n per_step_source_padding = tf.reshape(\n tf.transpose(per_step_source_padding), [-1, multiplier, sb])\n source_padding = tf.add(source_padding, per_step_source_padding)\n source_padding = self.QRAct(source_padding,\n quant_utils.QDistribution.PADDING)\n\n # Reshape logits to a matrix of shape [tb, sl] and takes the\n # softmax to compute the probabilities.\n logits = tf.transpose(tf.reshape(logits, [-1, tb]))\n source_padding = tf.transpose(tf.reshape(source_padding, [-1, tb]))\n probs = self._PaddedSoftmax(logits, source_padding)\n # Reshape probs to be of shape [tb/sb, sb, sl].\n probs_reshaped = tf.reshape(probs, [multiplier, sb, -1])\n # Transpose probs to be of shape [sb, tb/sb, sl]\n probs_reshaped = tf.transpose(probs_reshaped, [1, 0, 2])\n # [sb, tb/sb, sl] * [sb, sl, context_dim] = [sb, tb/sb, context_dim]\n summed = fns.qbatchmatmul(\n tf.cast(probs_reshaped, concated_source_contexts.dtype),\n concated_source_contexts,\n qout_name='atten_context')\n # summed is of shape [tb/sb, sb, context_dim]\n summed = tf.transpose(summed, [1, 0, 2])\n return tf.reshape(summed, [tb, -1]), probs\n\n def AttenSameBatchSize(hidden_var, query_var, source_padding,\n concated_source_vecs, concated_source_contexts,\n query_vec, attention_state, location_filter_var,\n location_var, per_step_source_padding):\n \"\"\"Computes the attention context vector.\n\n Optimized code path for when source and target have the same batch size.\n \"\"\"\n del per_step_source_padding\n p = self.params\n # attention_state shape [batch, len(p.location_features), slen]\n # it contains previous and accumulated attention probabilites.\n attention_state = py_utils.HasShape(attention_state,\n [-1, len(p.location_features), -1])\n\n fns = self.fns\n location_feats = self._ApplyConv(attention_state, location_filter_var)\n query_vec_transformed = fns.qmatmul(\n query_vec, query_var, qout_name='atten_matmul')\n # logits is of shape [sl, sb]\n logits = _ConditionalCallDefun(\n not self._is_quantized, AttenLogitsSameBatchSize,\n py_utils.NestedMap(\n concated_source_vecs=concated_source_vecs,\n query_vec_transformed=query_vec_transformed,\n hidden_v=hidden_var,\n location_feats=location_feats,\n location_var=location_var))\n # => [sl, tb]\n logits.set_shape(source_padding.shape)\n # Reshape logits to a matrix of shape [tb, sl] and takes the\n # softmax to compute the probabilities.\n logits = tf.transpose(logits)\n source_padding = tf.transpose(source_padding)\n probs = self._PaddedSoftmax(logits, source_padding)\n summed = fns.qbatchmatmul(\n tf.cast(tf.expand_dims(probs, 1), concated_source_contexts.dtype),\n concated_source_contexts,\n qout_name='atten_context')\n return tf.squeeze(summed, 1), probs\n\n if p.same_batch_size:\n self._ctx_vec = AttenSameBatchSize\n else:\n self._ctx_vec = Atten\n\n def EncodeSource(src_w, vecs, ctxs):\n fns = self.fns\n time, batch = py_utils.GetShape(vecs, 2)\n ctxs = py_utils.HasShape(ctxs, [time, batch, -1])\n transformed_vecs = tf.reshape(\n fns.qmatmul(\n tf.reshape(vecs, [-1, p.source_dim]),\n src_w,\n qout_name='encode_matmul'), [time, batch, -1])\n transposed_ctxs = tf.transpose(ctxs, [1, 0, 2])\n return transformed_vecs, transposed_ctxs\n\n self._encode_source = EncodeSource\n\n def _CreateLayerVariables(self):\n super()._CreateLayerVariables()\n p = self.params\n\n pc = py_utils.WeightParams(\n shape=[p.source_dim, p.hidden_dim],\n init=p.params_init,\n dtype=p.dtype,\n collections=['LocationSensitiveAttention_vars'])\n self.CreateVariable('source_var', pc)\n\n pc = py_utils.WeightParams(\n shape=[p.query_dim, p.hidden_dim],\n init=p.params_init,\n dtype=p.dtype,\n collections=['LocationSensitiveAttention_vars'])\n self.CreateVariable('query_var', pc)\n\n pc = py_utils.WeightParams(\n shape=[p.hidden_dim],\n init=p.params_init,\n dtype=p.dtype,\n collections=['LocationSensitiveAttention_vars'])\n self.CreateVariable('hidden_var', pc)\n\n assert p.location_filter_size % 2 == 1\n assert p.location_num_filters > 0\n\n location_filter_shape = [\n p.location_filter_size,\n len(p.location_features), p.location_num_filters\n ]\n # TODO(yonghui): Don't hard code how params are initialized.\n location_filter_pc = py_utils.WeightParams(\n shape=location_filter_shape,\n init=py_utils.WeightInit.Uniform(0.05),\n dtype=p.dtype,\n collections=['LocationSensitiveAttention_vars'])\n self.CreateVariable('location_filter_var', location_filter_pc)\n location_var_shape = [p.location_num_filters, p.hidden_dim]\n location_pc = py_utils.WeightParams(\n shape=location_var_shape,\n init=py_utils.WeightInit.Uniform(0.05),\n dtype=p.dtype,\n collections=['LocationSensitiveAttention_vars'])\n self.CreateVariable('location_var', location_pc)\n\n self.TrackQTensor('atten_conv')\n self.TrackQTensor('atten_context', domain='atten_context')\n self.TrackQTensor(\n 'atten_matmul',\n 'logits_add',\n 'encode_matmul',\n 'logits_mul',\n 'logits_bias',\n domain='fullyconnected')\n\n def AddGlobalVN(self, theta):\n theta = super().AddGlobalVN(theta)\n theta.source_var = self.AddVN(theta.source_var)\n theta.hidden_var = self.AddVN(theta.hidden_var)\n theta.query_var = self.AddVN(theta.query_var)\n theta.location_filter_var = self.AddVN(theta.location_filter_var)\n theta.location_var = self.AddVN(theta.location_var)\n return theta\n\n def _ApplyConv(self, attention_state, location_filter_var):\n \"\"\"Applies the convolution on attention state.\"\"\"\n p = self.params\n fns = self.fns\n attention_state_f32 = attention_state\n location_filter_var_f32 = location_filter_var\n if p.dtype != tf.float32:\n attention_state_f32 = tf.cast(attention_state, tf.float32)\n location_filter_var_f32 = tf.cast(location_filter_var, tf.float32)\n data_format = 'NCW'\n if py_utils.use_xla() in ('', 'cpu'):\n # NCW format is not supported on CPU.\n attention_state_f32 = tf.transpose(attention_state_f32, [0, 2, 1])\n data_format = 'NWC'\n location_feats = fns.qconv1d(\n attention_state_f32,\n location_filter_var_f32,\n 1,\n 'SAME',\n data_format=data_format,\n qout_name='atten_conv')\n if py_utils.use_xla() in ('', 'cpu'):\n location_feats = tf.transpose(location_feats, [0, 2, 1])\n if p.dtype != tf.float32:\n location_feats = tf.cast(location_feats, p.dtype)\n # [sb, hd, sl]\n return location_feats\n\n def PackSource(self,\n theta,\n source_vecs,\n source_contexts,\n source_padding,\n source_segment_id=None):\n with tf.name_scope(self.params.name):\n if source_segment_id is None:\n source_segment_id = tf.zeros_like(source_padding)\n (concated_source_vecs, concated_source_contexts) = (\n self._encode_source(\n self.QWeight(theta.source_var), source_vecs, source_contexts))\n return py_utils.NestedMap(\n # [time, batch_size, hidden_dim].\n source_vecs=concated_source_vecs,\n # [batch_size, time, context_dim].\n # Note the mismatch between `source_vecs` and `source_contexts`. In\n # `source_vecs`, time is the first dim, while it is the second dim in\n # `source_contexts`.\n source_contexts=concated_source_contexts,\n # [time, batch_size].\n source_padding=source_padding,\n # [time, batch_size].\n source_segment_id=source_segment_id)\n\n def ZeroAttentionState(self, source_length, decoder_batch_size):\n p = self.params\n dtype = p.dtype.real_dtype\n num_features = len(p.location_features)\n with tf.name_scope(p.name):\n state = tf.concat([\n tf.ones([decoder_batch_size, num_features, 1], dtype=dtype),\n tf.zeros([decoder_batch_size, num_features, source_length - 1],\n dtype=dtype)\n ], 2)\n\n state = self.QRAct(\n state, quant_utils.QDistribution.SOFTMAX, domain='softmax')\n return state\n\n def ComputeContextVectorWithSource(self,\n theta,\n packed_src,\n query_vec,\n attention_state=None,\n per_step_source_padding=None,\n query_segment_id=None):\n \"\"\"Computes the context vector given the current query output.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n packed_src: A `.NestedMap` object returned by PackSource or\n InitForSourcePacked.\n query_vec: a tensor of shape [batch_size, query_dim].\n attention_state: If `params().location_features == ['PREV_PROBS',\n 'CUMULATIVE_PROBS']`, then `attention_state` is a tensor of shape\n [batch_size, 2, src_len].\n\n - attention_state[:, 0, :] contains previous attention probabilities.\n - attention_state[:, 1, :] contains a sum over previous timesteps of\n attention probabilities.\n\n per_step_source_padding: Source sequence padding to apply at this step. If\n not None, it should be of shape [target_batch_size, source_length].\n query_segment_id: Query segment id with shape [batch_size].\n\n Note: concated_source_vecs are the vectors that are used to compute the\n attention score between the query_vec and each concated_source_vec. The\n concated_source_contexts are the vectors that compose the result. The\n attention context vector is computed as a weighted average of the\n concated_source_contexts, using the scores that were computed using\n concated_source_vecs.\n\n Returns:\n A tuple of 3 elements.\n\n - The attention context vector: [batch_size, context_dim]\n - The attention probability vector: [batch_size, time]\n - The new attention mechanism state: possibly nested tuple of tensors with\n dimensions [target_batch, ...]\n \"\"\"\n del query_segment_id\n p = self.params\n concated_source_vecs = packed_src.source_vecs\n concated_source_contexts = packed_src.source_contexts\n source_padding = packed_src.source_padding\n if p.same_batch_size:\n assert per_step_source_padding is None\n query_batch_size = py_utils.GetShape(query_vec)[0]\n source_length = py_utils.GetShape(source_padding)[0]\n if per_step_source_padding is None:\n zero = tf.constant(0.0, dtype=query_vec.dtype)\n per_step_source_padding = tf.fill([query_batch_size, source_length], zero)\n per_step_source_padding = py_utils.HasShape(\n per_step_source_padding, [query_batch_size, source_length])\n hidden = self.AddVN(theta.hidden_var, per_step=True)\n query = self.AddVN(theta.query_var, per_step=True)\n location_filter = self.AddVN(theta.location_filter_var, per_step=True)\n location = self.AddVN(theta.location_var, per_step=True)\n\n ctx_vec, prob = self._ctx_vec(hidden, query, source_padding,\n concated_source_vecs,\n concated_source_contexts, query_vec,\n attention_state, location_filter, location,\n per_step_source_padding)\n\n new_feats = {'PREV_PROBS': prob}\n if 'CUMULATIVE_PROBS' in p.location_features:\n # Quantization must match the _PaddedSoftmax method.\n cum_prob_index = p.location_features.index('CUMULATIVE_PROBS')\n cum_probs = tf.add(prob, attention_state[:, cum_prob_index, :])\n cum_probs = self.QRAct(\n cum_probs, quant_utils.QDistribution.SOFTMAX, domain='softmax')\n new_feats['CUMULATIVE_PROBS'] = cum_probs\n new_attention_state = tf.stack([new_feats[f] for f in p.location_features],\n axis=1)\n return ctx_vec, prob, new_attention_state\n\n\ndef MergeSourcePaddingWithPerStepSourcePadding(source_padding,\n per_step_source_padding, tb):\n \"\"\"Merges source padding with per-step source padding.\n\n Args:\n source_padding: [sl, sb].\n per_step_source_padding: [tb, sl].\n tb: target batch size.\n\n Returns:\n A tensor of shape [tb, sl].\n \"\"\"\n # source_padding is of shape [sl, sb].\n sl = py_utils.GetShape(source_padding)[0]\n sb = py_utils.GetShape(source_padding)[1]\n\n if per_step_source_padding is None:\n zero = tf.constant(0.0, dtype=source_padding.dtype)\n per_step_source_padding = tf.fill([tb, sl], zero)\n per_step_source_padding = py_utils.HasShape(per_step_source_padding, [tb, sl])\n\n # Transpose and reshape source_padding to [1, sb, sl].\n source_padding = tf.expand_dims(tf.transpose(source_padding), 0)\n # Merge source_padding and per_step_source_padding.\n source_padding = tf.maximum(source_padding,\n tf.reshape(per_step_source_padding, [-1, sb, sl]))\n return tf.reshape(source_padding, [tb, -1])\n\n\nclass MonotonicAttention(BaseAttentionLayer):\n \"\"\"An attention mechanism which enforces monotonic alignments.\n\n This layer implements the monotonic attention mechanism described in\n Online and Linear-Time Attention by Enforcing Mononotonic Alignments\n (https://arxiv.org/abs/1704.00784). It is used in exactly the same way as\n AdditiveAttention, but both the attention distribution and the energy function\n are different.\n\n Rather than using a softmax, this mechanism feeds the attention energy into a\n (hard or soft) sigmoid and treats the output as Bernoulli probabilities\n representing the probability of attending to a given entry in the input\n sequence, processed from left-to-right. Based on this interpretation, the\n resulting distribution over input sequence entries is computed with a dynamic\n program. The intended use is to train with soft sigmoids according to the\n expected output (setting param hard_sigmoid=False), then use hard sigmoids at\n test time to allow for online and linear-time decoding. To encourge the train\n and test-time behavior to be similar, noise can optionally be added to the\n sigmoid activations during training (param pre_sigmoid_noise). For the energy\n function, rather than computing::\n\n E = dot(v, tanh(dot(W, query) + dot(W, encoder_states)))\n\n it computes::\n\n E = dot(g*v/||v||, tanh(dot(W, query) + dot(W, encoder_states) + b)) + r\n\n where g and r are scalars and b is a vector, and ||v|| is the L2 norm of v.\n instead. These modifications address the fact that the sigmoids in the\n monotonic attention mechanism are sensitive to offset and a bit harder to\n train compared to the softmax function. It can be helpful to initialize the\n energy bias scalar r to a negative value (param hidden_bias_init).\n \"\"\"\n\n @classmethod\n def Params(cls):\n \"\"\"Params for this MonotonicAttention class.\"\"\"\n p = super().Params()\n p.Define('source_dim', 0, 'Number of source nodes.')\n p.Define('query_dim', 0, 'Number of query nodes.')\n p.Define('hidden_dim', 0, 'Number of hidden nodes.')\n p.Define('pre_sigmoid_noise', 0, 'Standard deviation of pre-sigmoid noise.')\n p.Define('hidden_bias_init', -1, 'Initial value of hidden bias.')\n p.Define('hard_sigmoid', False, 'Whether to use a hard sigmoid.')\n # Fill in reasonable default for params init\n p.params_init = py_utils.WeightInit.GaussianSqrtDim()\n return p\n\n def __init__(self, params):\n \"\"\"Constructs an MonotonicAttention object.\"\"\"\n super().__init__(params)\n p = self.params\n assert not p.packed_input, ('Packed input not supported for Monotonic '\n 'Attention.')\n if p.atten_dropout_prob != 0:\n raise NotImplementedError('dropout is not supported')\n\n # When running eval, don't add pre-sigmoid noise, and use a hard sigmoid to\n # match behavior of online decoding.\n if self.do_eval:\n p.pre_sigmoid_noise = 0.\n p.hard_sigmoid = True\n\n def EncodeSource(src_w, vecs, ctxs):\n time, batch = py_utils.GetShape(vecs, 2)\n ctxs = py_utils.HasShape(ctxs, [time, batch, -1])\n transformed_vecs = tf.reshape(\n py_utils.Matmul(tf.reshape(vecs, [-1, p.source_dim]), src_w),\n [time, batch, -1])\n transposed_ctxs = tf.transpose(ctxs, [1, 0, 2])\n return transformed_vecs, transposed_ctxs\n\n self._encode_source = EncodeSource\n\n def _CreateLayerVariables(self):\n super()._CreateLayerVariables()\n p = self.params\n\n # source is the weight matrix for the memory/encoder states\n pc = py_utils.WeightParams(\n shape=[p.source_dim, p.hidden_dim],\n init=p.params_init,\n dtype=p.dtype,\n collections=['MonotonicAttention_vars'])\n self.CreateVariable('source_var', pc)\n\n # query is the weight matrix for the query/decoder RNN state\n pc = py_utils.WeightParams(\n shape=[p.query_dim, p.hidden_dim],\n init=p.params_init,\n dtype=p.dtype,\n collections=['MonotonicAttention_vars'])\n self.CreateVariable('query_var', pc)\n\n # hidden is the pre-softmax vector which converts from tanh to scalar\n pc = py_utils.WeightParams(\n shape=[p.hidden_dim],\n init=p.params_init,\n dtype=p.dtype,\n collections=['MonotonicAttention_vars'])\n self.CreateVariable('hidden_var', pc)\n\n # energy_bias is the bias vector which appears inside of tanh\n # Initialize the bias vector to all zeros\n pc = py_utils.WeightParams(\n shape=[p.hidden_dim],\n init=py_utils.WeightInit.Constant(0.0),\n dtype=p.dtype,\n collections=['MonotonicAttention_vars'])\n self.CreateVariable('energy_bias_var', pc)\n\n # hidden_scale is the weight normalization scale for hidden\n # Initialize so that the initial scale is 1/sqrt(hidden_dim)\n pc = py_utils.WeightParams(\n shape=[],\n init=py_utils.WeightInit.Constant(1 / np.sqrt(p.hidden_dim)),\n dtype=p.dtype,\n collections=['MonotonicAttention_vars'])\n self.CreateVariable('hidden_scale_var', pc)\n\n # hidden_bias is the bias scalar applied before the sigmoid\n # Use the hidden_bias_init hyperparam to set the initial value\n pc = py_utils.WeightParams(\n shape=[],\n init=py_utils.WeightInit.Constant(p.hidden_bias_init),\n dtype=p.dtype,\n collections=['MonotonicAttention_vars'])\n self.CreateVariable('hidden_bias_var', pc)\n\n def AddGlobalVN(self, theta):\n theta = super().AddGlobalVN(theta)\n theta.source_var = self.AddVN(theta.source_var)\n theta.hidden_var = self.AddVN(theta.hidden_var)\n theta.query_var = self.AddVN(theta.query_var)\n return theta\n\n def PackSource(self,\n theta,\n source_vecs,\n source_contexts,\n source_padding,\n source_segment_id=None):\n with tf.name_scope(self.params.name):\n if source_segment_id is None:\n source_segment_id = tf.zeros_like(source_padding)\n (concated_source_vecs, concated_source_contexts) = (\n self._encode_source(theta.source_var, source_vecs, source_contexts))\n return py_utils.NestedMap(\n # [time, batch_size, hidden_dim].\n source_vecs=concated_source_vecs,\n # [batch_size, time, context_dim].\n # Note the mismatch between `source_vecs` and `source_contexts`. In\n # `source_vecs`, time is the first dim, while it is the second dim in\n # `source_contexts`.\n source_contexts=concated_source_contexts,\n # [time, batch_size].\n source_padding=source_padding,\n # [time, batch_size].\n source_segment_id=source_segment_id)\n\n def ZeroAttentionState(self, source_length, decoder_batch_size):\n p = self.params\n dtype = p.dtype\n with tf.name_scope(p.name):\n # Set initial previous attention to [1, 0, ... 0] to avoid special-casing\n emit_probs = tf.one_hot(\n tf.zeros((decoder_batch_size,), dtype=tf.int32),\n source_length,\n dtype=dtype)\n return py_utils.NestedMap(emit_probs=emit_probs)\n\n def ComputeProbabilities(self, theta, concated_source_vecs,\n merged_source_padding, query_vec, attention_state):\n \"\"\"Computes probabilities of emissions.\"\"\"\n\n # concated_source_contexts is of shape [sb, sl, context_dim]\n # query_vec is of shape [tb, dims]\n sb = tf.shape(concated_source_vecs)[1]\n tb = tf.shape(query_vec)[0]\n multiplier = tb // sb\n\n p = self.params\n\n def AttenLogits(inputs):\n \"\"\"Computes logits from source, query, and variables.\n\n Args:\n inputs: a NestedMap containing:\n - concated_source_vecs: [sl, sb, hidden_dims].\n - query_vec: [tb, query_dim].\n - query_v: [query_dim, hidden_dim]\n - energy_b: [hidden_dim].\n - hidden_v: [hidden_dim].\n - hidden_g: [].\n - hidden_b: [].\n\n Returns:\n logits shaped [tb, sl].\n \"\"\"\n # Apply query matrix to query. Becomes [tb, hidden_dim].\n query_vec_transformed = py_utils.Matmul(\n inputs.query_vec, inputs.query_v, name='query_transformation')\n # query_vec is reshaped to [1, tb/sb, sb, hidden_dim].\n query_vec_reshaped = tf.reshape(query_vec_transformed,\n [1, multiplier, sb, p.hidden_dim])\n\n # [sl, 1, sb, hidden_dim].\n concated_source_vecs = tf.expand_dims(inputs.concated_source_vecs, 1)\n energy_b = tf.reshape(inputs.energy_b, [1, 1, 1, -1])\n # Shape of summed is [sl, tb/sb, sb, hidden_dim].\n summed = tf.tanh(concated_source_vecs + query_vec_reshaped + energy_b)\n hidden_v = inputs.hidden_g * tf.nn.l2_normalize(inputs.hidden_v, axis=0)\n # logits is of shape [sl * tb/sb * sb, 1]. Computes dot product\n # between v with every rows in 'summed'. Then we reshape the\n # result to be of shape [sl, tb/sb, sb].\n #\n # Another equivalent way is to do:\n # logits = tf.reduce_sum(summed *\n # tf.reshape(v, [1, 1, 1, hidden_dim]), 3)\n logits = py_utils.Matmul(\n tf.reshape(summed, [-1, p.hidden_dim]),\n tf.reshape(hidden_v, [p.hidden_dim, 1]))\n logits += inputs.hidden_b\n # [tb, sl].\n logits = tf.transpose(tf.reshape(logits, [-1, tb]), [1, 0])\n return logits\n\n with tf.name_scope('logits'):\n logits = py_utils.CallDefun(\n AttenLogits,\n py_utils.NestedMap(\n concated_source_vecs=concated_source_vecs,\n query_vec=query_vec,\n query_v=theta.query_var,\n energy_b=theta.energy_bias_var,\n hidden_v=theta.hidden_var,\n hidden_g=theta.hidden_scale_var,\n hidden_b=theta.hidden_bias_var))\n\n previous_attention = attention_state.emit_probs\n with tf.name_scope('prob'):\n if self.params.hard_sigmoid:\n # If using a hard sigmoid, just compare against 0\n p_choose_i = tf.cast(tf.greater(logits, 0), logits.dtype)\n # Never choose padded values.\n p_choose_i = tf.where(merged_source_padding > 0.0,\n tf.zeros_like(p_choose_i), p_choose_i)\n # Compute probability distribution assuming hard probabilities\n probs = MonotonicAttentionProb(p_choose_i, previous_attention, 'hard')\n else:\n # Compute pre-sigmoid noise.\n activation_noise = tf.random.stateless_normal(\n py_utils.GetShape(logits),\n py_utils.GenerateStepSeedPair(p),\n dtype=logits.dtype)\n # Compute sigmoid probabilities.\n p_choose_i = tf.nn.sigmoid(logits + self.params.pre_sigmoid_noise *\n activation_noise)\n # Never choose padded values.\n p_choose_i = tf.where(merged_source_padding > 0,\n tf.zeros_like(p_choose_i), p_choose_i)\n # Compute attention distribution\n probs = MonotonicAttentionProb(p_choose_i, previous_attention,\n 'parallel')\n\n # [tb, sl].\n return probs, py_utils.NestedMap(emit_probs=probs)\n\n def ComputeContextVectorWithSource(self,\n theta,\n packed_src,\n query_vec,\n attention_state,\n per_step_source_padding=None,\n query_segment_id=None):\n \"\"\"Computes the context vector given the current query output.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n packed_src: A `.NestedMap` object returned by PackSource or\n InitForSourcePacked.\n query_vec: a tensor of shape [batch_size, query_dim].\n attention_state: The attention probs computed at the previous timestep.\n per_step_source_padding: Source sequence padding to apply at this step. If\n not None, it should be of shape [target_batch_size, source_length].\n query_segment_id: a tensor of shape [batch_size].\n Note: concated_source_vecs are the vectors that are used to compute the\n attention score between the query_vec and each concated_source_vec. The\n concated_source_contexts are the vectors that compose the result. The\n attention context vector is computed as a weighted average of the\n concated_source_contexts, using the scores that were computed using\n concated_source_vecs.\n\n Returns:\n A tuple of 3 elements.\n\n - The attention context vector: [batch_size, context_dim]\n - The attention probability vector: [batch_size, time]\n - The attention probability vector: (again, to be interpreted as state).\n \"\"\"\n del query_segment_id\n concated_source_vecs = packed_src.source_vecs\n concated_source_contexts = packed_src.source_contexts\n source_padding = packed_src.source_padding\n sb = tf.shape(concated_source_vecs)[1]\n tb = tf.shape(query_vec)[0]\n multiplier = tb // sb\n merged_source_padding = MergeSourcePaddingWithPerStepSourcePadding(\n source_padding, per_step_source_padding, tb)\n\n probs, new_state = self.ComputeProbabilities(theta, concated_source_vecs,\n merged_source_padding,\n query_vec, attention_state)\n\n with tf.name_scope('sum'):\n # Reshape probs to be of shape [tb/sb, sb, sl]\n probs_reshaped = tf.reshape(probs, [multiplier, sb, -1])\n # Transpose probs to be of shape [sb, tb/sb, sl]\n probs_reshaped = tf.transpose(probs_reshaped, [1, 0, 2])\n # Batched matmul\n # [sb, tb/sb, sl] * [sb, sl, context_dim] = [sb, tb/sb, context_dim]\n summed = tf.matmul(probs_reshaped, concated_source_contexts)\n # summed is of shape [tb/sb, sb, context_dim]\n summed = tf.transpose(summed, [1, 0, 2])\n ctx_vec = tf.reshape(summed, [tb, -1])\n\n return ctx_vec, probs, new_state\n\n\nclass GmmMonotonicAttention(BaseAttentionLayer):\n \"\"\"A GMM-based monotonic attention module.\n\n Based on \"Generating Sequences With Recurrent Neural Networks\" by Alex Graves.\n Eq [46-51] in https://arxiv.org/abs/1308.0850.\n \"\"\"\n\n @classmethod\n def Params(cls):\n \"\"\"Params for this MonotonicAttention class.\"\"\"\n p = super().Params()\n p.Define('source_dim', 0, 'Number of source nodes.')\n p.Define('query_dim', 0, 'Number of query nodes.')\n p.Define('hidden_dim', 128,\n 'Number of hidden units for the MLP that predicts GMM params.')\n p.Define('max_offset', -1,\n 'Max offset to move attention pointer, Enabled only when > 0.')\n p.Define('num_mixtures', 5, 'Number of location GMM components.')\n p.Define(\n 'normalize_probs', False,\n 'Whether to normalize probabilities computed by GMM. Otherwise, '\n 'the attention weights (i.e. probabilities) may not add up to '\n '1.0.')\n\n # TODO(ngyuzh): find a good initialize for both TTS and ASR. Consider split\n # the layer if it's very sensitive to the initialization\n p.params_init = py_utils.WeightInit.Xavier(0.1)\n return p\n\n def __init__(self, params):\n \"\"\"Constructs a GMM-based monotonic attention module.\"\"\"\n super().__init__(params)\n p = self.params\n if p.atten_dropout_prob != 0:\n raise NotImplementedError('dropout is not supported.')\n\n # TODO(ngyuzh): Compare Sigmoid and other activation functions.\n ff_params = layers.FeedForwardNet.Params().Set(\n name=p.name,\n input_dim=p.query_dim,\n hidden_layer_dims=[p.hidden_dim, p.num_mixtures * 3],\n activation=['SIGMOID', 'NONE'],\n params_init=p.params_init.Copy())\n self.CreateChild('GMM', ff_params)\n\n def ComputeProbs(encoder_positions, priors, means, variances):\n \"\"\"Computes the location GMM probabilities at all encoder positions.\n\n This function assumes that the first 2 dimensions of `priors`, `means`,\n `variances`, and the return value:\n `multiplier (target_batch / source_batch)` and `source_batch` are\n transposed, and `encoder_positions` has only non-one dimensions.\n\n Args:\n encoder_positions: [source_batch, source_length]\n priors: [multiplier, source_batch, num_mixtures]\n means: [multiplier, source_batch, num_mixtures]\n variances: [multiplier, source_batch, num_mixtures]\n\n Returns:\n Probabilities shaped [multiplier, source_batch, source_length].\n \"\"\"\n # [multiplier, source_batch, 1, num_mixtures]\n priors = tf.expand_dims(priors, 2)\n means = tf.expand_dims(means, 2)\n variances = tf.expand_dims(variances, 2)\n epsilon = 1e-8\n\n # [source_batch, source_length, 1]\n encoder_positions = tf.expand_dims(encoder_positions, 2)\n\n # [multiplier, source_batch, source_length, num_mixtures]\n probs = ((priors * tf.math.rsqrt(2 * np.pi * variances + epsilon)) *\n tf.exp(-(encoder_positions - means)**2 /\n (2 * variances + epsilon)))\n\n # [multiplier, source_batch, source_length]\n return tf.reduce_sum(probs, axis=3)\n\n def Atten(source_padding, concated_source_vecs, concated_source_contexts,\n query_vec, priors, means, variances, encoder_positions,\n per_step_source_padding):\n \"\"\"Computes the attention context vector.\n\n Args:\n source_padding: [source_length, source_batch]\n concated_source_vecs: [source_length, source_batch, hidden_dim]\n concated_source_contexts: [source_batch, source_length, context_dim]\n query_vec: [target_batch, query_dim]\n priors: [target_batch, num_mixtures]\n means: [target_batch, num_mixtures]\n variances: [target_batch, num_mixtures]\n encoder_positions: [source_batch, source_length]\n per_step_source_padding: [target_batch, source_length]\n\n Returns:\n Tuple(context vector, atten probs):\n\n - context vector: [target_batch, context_dim]\n - attention probabilities: [target_batch, source_length]\n \"\"\"\n # Note: shape [target_batch] can be converted to\n # [multiplier, source_batch], not [source_batch, multiplier].\n p = self.params\n source_batch = tf.shape(concated_source_vecs)[1]\n target_batch = tf.shape(query_vec)[0]\n multiplier = target_batch // source_batch\n\n # [multiplier, source_batch, num_mixtures]\n priors = tf.reshape(priors, [multiplier, source_batch, p.num_mixtures])\n means = tf.reshape(means, [multiplier, source_batch, p.num_mixtures])\n variances = tf.reshape(variances,\n [multiplier, source_batch, p.num_mixtures])\n\n # [multiplier, source_batch, source_length]\n probs = ComputeProbs(encoder_positions, priors, means, variances)\n\n # [source_batch, source_length]\n source_padding = tf.transpose(source_padding)\n\n # [multiplier, source_batch, source_length]\n per_step_source_padding = tf.reshape(per_step_source_padding,\n [multiplier, source_batch, -1])\n source_padding += per_step_source_padding\n source_padding = tf.minimum(source_padding, 1.0)\n\n # [multiplier, source_batch, source_length]\n probs *= (1.0 - source_padding)\n if p.normalize_probs:\n probs /= tf.maximum(tf.reduce_sum(probs, axis=2, keepdims=True), 1e-12)\n\n # [source_batch, multiplier, source_length]\n probs_transposed = tf.transpose(probs, [1, 0, 2])\n\n # Matmul:\n # [source_batch, multiplier, source_length]\n # @ [source_batch, source_length, context_dim]\n # -> [source_batch, multiplier, context_dim]\n context_vector_transposed = tf.matmul(probs_transposed,\n concated_source_contexts)\n\n # [multiplier, source_batch, context_dim]\n context_vector = tf.transpose(context_vector_transposed, [1, 0, 2])\n\n # [target_batch, context_dim], [target_batch, source_length]\n return (tf.reshape(context_vector, [target_batch, -1]),\n tf.reshape(probs, [target_batch, -1]))\n\n self._ctx_vec = Atten\n\n def EncodeSource(vecs, ctxs):\n # TODO(ngyuzh): combine with content-base attention.\n time, batch = py_utils.GetShape(vecs, 2)\n ctxs = py_utils.HasShape(ctxs, [time, batch, -1])\n transposed_ctxs = tf.transpose(ctxs, [1, 0, 2])\n return vecs, transposed_ctxs\n\n self._encode_source = EncodeSource\n\n def PackSource(self,\n theta,\n source_vecs,\n source_contexts,\n source_padding,\n source_segment_id=None):\n with tf.name_scope(self.params.name):\n if source_segment_id is None:\n source_segment_id = tf.zeros_like(source_padding)\n (concated_source_vecs, concated_source_contexts) = (\n self._encode_source(source_vecs, source_contexts))\n return py_utils.NestedMap(\n # [source_length, source_batch, hidden_dim].\n source_vecs=concated_source_vecs,\n # [source_batch, source_length, context_dim].\n # Note the mismatch between `source_vecs` and `source_contexts`. In\n # `source_vecs`, `source_length` is the first dim, while it is the\n # second dim in `source_contexts`.\n source_contexts=concated_source_contexts,\n # [source_length, source_batch].\n source_padding=source_padding,\n # [source_length, source_batch].\n source_segment_id=source_segment_id)\n\n def ZeroAttentionState(self, source_length, decoder_batch_size):\n p = self.params\n\n # [target_batch, num_mixtures]\n position = tf.zeros([decoder_batch_size, p.num_mixtures], dtype=p.dtype)\n position_offsets = tf.zeros([decoder_batch_size, p.num_mixtures],\n dtype=p.dtype)\n variances = tf.ones([decoder_batch_size, p.num_mixtures], dtype=p.dtype)\n priors = tf.zeros([decoder_batch_size, p.num_mixtures], dtype=p.dtype)\n\n # [target_batch, num_mixtures, 4]\n return tf.stack([position, position_offsets, variances, priors], axis=2)\n\n def ComputeContextVectorWithSource(self,\n theta,\n packed_src,\n query_vec,\n attention_state,\n per_step_source_padding=None,\n query_segment_id=None):\n \"\"\"Computes the context vector given the current query output.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n packed_src: A `.NestedMap` object returned by PackSource or\n InitForSourcePacked.\n query_vec: a tensor of shape [target_batch, query_dim].\n attention_state: previous attention state, a tensor of shape\n [target_batch, num_mixtures, 4].\n - attention_state[:, :, 0] contains previous location\n - attention_state[:, :, 1] contains previous offset.\n - attention_state[:, :, 2] contains previous variance.\n - attention_state[:, :, 3] contains previous prior.\n per_step_source_padding: Source sequence padding to apply at this step. If\n not None, it should be of shape [target_batch, source_length].\n query_segment_id: a tensor of shape [target_batch].\n Note: concated_source_vecs are the vectors that are used to compute the\n attention score between the query_vec and each concated_source_vec. The\n concated_source_contexts are the vectors that compose the result. The\n attention context vector is computed as a weighted average of the\n concated_source_contexts, using the scores that were computed using\n concated_source_vecs.\n\n Returns:\n A tuple of 3 elements.\n\n - The attention context vector: [target_batch, context_dim]\n - The attention probability vector: [target_batch, source_length]\n - The new attention state vector: [target_batch, num_mixtures, 4]\n \"\"\"\n del query_segment_id\n p = self.params\n concated_source_vecs = packed_src.source_vecs\n concated_source_contexts = packed_src.source_contexts\n source_padding = packed_src.source_padding\n\n target_batch = tf.shape(query_vec)[0]\n source_length = tf.shape(source_padding)[0]\n source_batch = tf.shape(source_padding)[1]\n\n # [target_batch, source_length]\n if per_step_source_padding is None:\n per_step_source_padding = tf.zeros([target_batch, source_length],\n dtype=query_vec.dtype)\n per_step_source_padding = py_utils.HasShape(per_step_source_padding,\n [target_batch, source_length])\n\n # [target_batch, num_mixtures * 3]\n out = self.GMM.FProp(theta.GMM, query_vec)\n\n # [target_batch, num_mixtures]\n priors_logits, position_offset_logits, log_variances = tf.split(\n out, 3, axis=1, name='GMM')\n\n log_variances = tf.minimum(log_variances, layers.LOG_SCALE_CLAMP_BOUND)\n variances = tf.exp(log_variances)\n\n priors = tf.nn.softmax(priors_logits)\n\n if p.max_offset > 0:\n position_offset = tf.nn.sigmoid(position_offset_logits)\n position_offset *= p.max_offset\n else:\n position_offset = tf.exp(position_offset_logits)\n\n new_position = attention_state[:, :, 0] + position_offset\n\n # Tile and reshape encoder_positions to [source_batch, source_length]\n # so that it can be evaluated by locations GMMs in a vectorized way.\n encoder_positions = tf.expand_dims(\n tf.cast(tf.range(source_length), tf.float32), 0)\n encoder_positions = tf.tile(encoder_positions, [source_batch, 1])\n\n # [target_batch, context_dim], [target_batch, source_length]\n ctx_vec, prob = self._ctx_vec(source_padding, concated_source_vecs,\n concated_source_contexts, query_vec, priors,\n new_position, variances, encoder_positions,\n per_step_source_padding)\n\n # [target_batch, num_mixtures, 4]\n new_atten_states = tf.stack(\n [new_position, position_offset, variances, priors], axis=2)\n\n return ctx_vec, prob, new_atten_states\n\n\nclass MergerLayer(base_layer.BaseLayer):\n \"\"\"Merges a list of input tensors with various options into a single tensor.\n\n Implements a merger/combiner operator given a list of tensors. The merger\n operator outputs a single tensor with the following options (merger_op):\n\n - atten: Applies attention over the set of input tensors given query vector.\n - mean: Takes the mean of input tensors.\n - concat: Concatenates the input tensors over the last dimension.\n - sum: Sum up all the input tensors.\n - weighted_sum: Use learnt weights to combine input tensors.\n - gated_avg: Learnt input dependent gates are used to average tensors.\n\n This class is expected to be called by multi-source/multi-column models.\n \"\"\"\n\n @classmethod\n def Params(cls):\n \"\"\"Params for this MergerLayer class.\"\"\"\n p = super().Params()\n p.Define('merger_op', None, 'How to merge input tensors.')\n p.Define('source_dim', 0, 'Number of source nodes.')\n p.Define('query_dim', 0, 'Number of query nodes.')\n p.Define('hidden_dim', 0, 'Number of hidden nodes.')\n p.Define('attention_tpl', AdditiveAttention.Params(),\n 'Attention used by the merger layer when merger_op is atten.')\n p.Define(\n 'pre_proj_input_dims', None,\n 'If set, should be a list of depths for the tensors to be merged.'\n ' Setting this will result in a pre-projection to source_dim'\n ' before the merger.')\n p.Define(\n 'pre_proj_output_dims', None,\n 'Should be a list of depths which the input tensors specified in '\n 'pre_proj_input_dims need to be projected to. Should match the length '\n 'of pre_proj_input_dims.')\n p.Define(\n 'proj_tpl',\n layers.ProjectionLayer.Params().Set(\n batch_norm=False, weight_norm=True, has_bias=True),\n 'Configs template for the projection layer.')\n p.Define('gated_avg_tpl', layers.GatedAverageLayer.Params(),\n 'Configs template for the gated average layer.')\n p.Define('num_sources', 0, 'If merger_op=weighted_sum, then must specify '\n 'num of sources.')\n p.Define('post_proj', None,\n 'Post projection for the merged context vector.')\n return p\n\n # Merging operation keys supported by this layer.\n MERGER_OPS = ['mean', 'atten', 'concat', 'sum', 'weighted_sum', 'gated_avg']\n\n def __init__(self, params):\n super().__init__(params)\n p = self.params\n if not p.name:\n raise ValueError('Layer must have a specified name!')\n if p.merger_op not in set(self.MERGER_OPS):\n raise ValueError('Merger op must be one of: ', self.MERGER_OPS)\n\n if p.merger_op == 'atten':\n atten_params = p.attention_tpl.Copy()\n atten_params.source_dim = p.source_dim\n atten_params.query_dim = p.query_dim\n atten_params.hidden_dim = p.hidden_dim\n atten_params.dtype = p.dtype\n if atten_params.params_init is None:\n atten_params.params_init = py_utils.WeightInit.Gaussian(\n 1. / math.sqrt(atten_params.source_dim + atten_params.query_dim),\n seed=p.random_seed)\n self.CreateChild('atten', atten_params)\n\n if p.pre_proj_input_dims:\n if not p.pre_proj_output_dims:\n raise ValueError('Output dims should be specified for projection.')\n if len(p.pre_proj_input_dims) != len(p.pre_proj_output_dims):\n raise ValueError(\n 'Output dims should be the same length as input dims. '\n 'Expected: %s obtained: %s' %\n (len(p.pre_proj_input_dims), len(p.pre_proj_output_dims)))\n pre_proj_params = []\n for i, (pre_proj_input_dim, pre_proj_output_dim) in enumerate(\n zip(p.pre_proj_input_dims, p.pre_proj_output_dims)):\n proj_p = p.proj_tpl.Copy()\n proj_p.name = 'merger_pre_proj_%d' % i\n proj_p.input_dim = pre_proj_input_dim\n proj_p.output_dim = pre_proj_output_dim\n pre_proj_params.append(proj_p)\n self.CreateChildren('pre_proj', pre_proj_params)\n\n if p.merger_op == 'gated_avg':\n assert p.num_sources > 0, ('For merger_op=gated_avg, must specify '\n 'num_sources > 0.')\n params = p.gated_avg_tpl.Copy()\n params.name = 'g_avg_merger'\n params.num_nodes = p.source_dim\n params.num_inputs = p.num_sources\n self.CreateChild('gated_average', params)\n\n if p.post_proj:\n self.CreateChild('post_proj', p.post_proj)\n\n def _CreateLayerVariables(self):\n super()._CreateLayerVariables()\n p = self.params\n\n if p.merger_op == 'weighted_sum':\n assert p.num_sources > 0, ('For merger_op=weighted_sum, must specify '\n 'num_sources > 0.')\n params_init = py_utils.WeightInit.Constant(1.0 / p.num_sources)\n # Weights to be learned.\n pw = py_utils.WeightParams(\n shape=[p.num_sources],\n init=params_init,\n dtype=p.dtype,\n collections=[self.__class__.__name__ + '_vars'])\n self.CreateVariable('sum_weight', pw)\n\n def _child_variable_scope_override(self):\n return {\n **super()._child_variable_scope_override(), 'atten': [],\n 'gated_average': [],\n 'pre_proj': []\n }\n\n def FProp(self, theta, inputs, query_vec=None):\n \"\"\"Combines the list of input tensors into a single tensor.\n\n Args:\n theta: A `.NestedMap` object containing weights' values of this layer and\n its children layers.\n inputs: A list of tensors of shape [..., hidden_dim] or [...,\n [pre_proj_input_dims[i]]] if pre_proj_input_dims is specified.\n query_vec: A tensor of shape [..., hidden_dim].\n\n Returns:\n A tensor of the same shape with input tensors.\n\n Raises:\n ValueError: p.merger_op is not defined.\n \"\"\"\n p = self.params\n n_sources = len(inputs)\n\n if p.pre_proj_input_dims and len(p.pre_proj_input_dims) != n_sources:\n raise ValueError('pre_proj_input_dims must be specified for each input.')\n\n if n_sources == 1:\n return inputs[0]\n\n # Pre-projection operation.\n if p.pre_proj_input_dims:\n for i in range(n_sources):\n inputs[i] = self.pre_proj[i].FProp(theta.pre_proj[i], inputs[i])\n\n tensor_pairs = list(zip(inputs[:-1], inputs[1:]))\n if p.merger_op == 'mean':\n # Simply take the mean, all dims must match.\n with tf.control_dependencies([\n py_utils.assert_shape_match(tf.shape(t1), tf.shape(t2))\n for t1, t2 in tensor_pairs\n ]):\n output = tf.add_n(inputs) / n_sources\n\n elif p.merger_op == 'sum':\n # Sum up all sources, all dims must match.\n with tf.control_dependencies([\n py_utils.assert_shape_match(tf.shape(t1), tf.shape(t2))\n for t1, t2 in tensor_pairs\n ]):\n output = tf.add_n(inputs)\n\n elif p.merger_op == 'weighted_sum':\n # Weighted sum of all sources, all dims must match.\n # For weighted_sum, assume input is a list of rank 3 tensors\n inputs = tf.stack(inputs)\n inputs = py_utils.HasRank(inputs, 4)\n\n with tf.control_dependencies([\n py_utils.assert_shape_match(tf.shape(t1), tf.shape(t2))\n for t1, t2 in tensor_pairs\n ]):\n w = tf.expand_dims(\n tf.expand_dims(tf.expand_dims(theta.sum_weight, 1), 1), 1)\n w = tf.tile(\n w,\n [1,\n tf.shape(inputs)[1],\n tf.shape(inputs)[2],\n tf.shape(inputs)[3]])\n output = tf.reduce_sum(inputs * w, axis=0)\n\n elif p.merger_op == 'atten':\n # Apply attention over the concatenated tensor, all dims must match.\n with tf.control_dependencies([\n py_utils.assert_shape_match(tf.shape(t1), tf.shape(t2))\n for t1, t2 in tensor_pairs\n ]):\n inputs = tf.stack(inputs, axis=0)\n batch_size = tf.shape(inputs)[1]\n paddings = tf.zeros([n_sources, batch_size], dtype=inputs.dtype)\n self.atten.InitForSourcePacked(theta.atten, inputs, inputs, paddings)\n output, _, _ = self.atten.ComputeContextVector(\n theta.atten, tf.reshape(query_vec, [-1, p.query_dim]))\n\n elif p.merger_op == 'concat':\n # Concatenate over the last dim, all dims but last must match.\n with tf.control_dependencies([\n py_utils.assert_equal(tf.shape(t1)[:-1],\n tf.shape(t2)[:-1]) for t1, t2 in tensor_pairs\n ]):\n output = tf.concat(inputs, axis=-1)\n\n elif p.merger_op == 'gated_avg':\n output = self.gated_average.FProp(theta.gated_average, inputs)\n\n else:\n raise ValueError('Unrecognized merge op!')\n\n if p.post_proj:\n output = self.post_proj.FProp(theta.post_proj, output)\n\n return output\n\n\nclass MultiSourceAttention(BaseAttentionLayer):\n \"\"\"Attention with multiple source sub-attentions.\n\n It attends to multiple sources and uses one query as input to generates a\n combined attention context. The dimension of the combined context vector is a\n sum of all source context vectors. Each source attention has its separate\n params and is associated with a source key.\n \"\"\"\n\n @classmethod\n def Params(cls):\n p = super().Params()\n p.Define('source_atten_tpls', None,\n 'A list of (source_key, attention_param) '\n 'pairs.')\n p.Define('source_dim', 0, 'Default source dimension.')\n p.Define(\n 'query_dim', 0, 'Number of query nodes. Child attention params '\n 'must have query_dim less or euqal than 0 or equal to this value.')\n p.Define(\n 'primary_source_key', 'source_0', 'Key for the primary source '\n 'whose attention probabilities will be used as an output.')\n p.Define(\n 'atten_merger_tpl',\n MergerLayer.Params().Set(\n params_init=py_utils.WeightInit.Uniform(0.04), merger_op='sum'),\n 'Params to specify how to merge source attention vectors.')\n return p\n\n def __init__(self, params):\n \"\"\"Constructs an MultiSourceAttention object.\"\"\"\n super().__init__(params)\n p = self.params\n for source_key, atten_p in p.source_atten_tpls:\n child_p = atten_p.Copy()\n if child_p.query_dim <= 0:\n child_p.query_dim = p.query_dim\n else:\n assert child_p.query_dim == p.query_dim\n if child_p.source_dim <= 0:\n child_p.source_dim = p.source_dim\n self.CreateChild('atten_%s' % source_key, child_p)\n\n # Initialize source context vector merging layer.\n merger_p = p.atten_merger_tpl.Copy()\n merger_p.name = 'atten_merger'\n merger_p.source_dim = p.source_dim\n merger_p.query_dim = p.query_dim\n self.CreateChild('atten_merger', merger_p)\n\n def PackSource(self,\n theta,\n source_vecs,\n source_contexts,\n source_padding,\n source_segment_id=None):\n p = self.params\n with tf.name_scope(self.params.name):\n packed_src = py_utils.NestedMap()\n for source_key, _ in p.source_atten_tpls:\n packed_src[source_key] = (\n self.children['atten_%s' % source_key].InitForSourcePacked(\n theta['atten_%s' % source_key], source_vecs[source_key],\n source_contexts[source_key], source_padding[source_key],\n source_segment_id[source_key] if source_segment_id else None))\n return packed_src\n\n def ZeroAttentionState(self, source_seq_length, decoder_batch_size):\n p = self.params\n with tf.name_scope(self.params.name):\n return py_utils.NestedMap({\n source_key: getattr(self, 'atten_%s' % source_key).ZeroAttentionState(\n source_seq_length[source_key], decoder_batch_size)\n for source_key, _ in p.source_atten_tpls\n })\n\n def ComputeContextVectorWithSource(self,\n theta,\n packed_src,\n query_vec,\n attention_state=None,\n per_step_source_padding=None,\n query_segment_id=None):\n p = self.params\n assert per_step_source_padding is None\n with tf.name_scope(self.params.name):\n result_map = py_utils.NestedMap()\n for source_key, _ in p.source_atten_tpls:\n result_map[source_key] = (\n self.children['atten_%s' %\n source_key].ComputeContextVectorWithSource(\n theta.get('atten_%s' % source_key),\n packed_src[source_key], query_vec,\n attention_state[source_key]\n if attention_state else None,\n per_step_source_padding, query_segment_id))\n return self._CombineContext(theta, result_map, query_vec)\n\n def _CombineContext(self, theta, context_map, query_vec):\n ctxs = context_map.Flatten()\n combined_context = (\n self.atten_merger.FProp(theta.atten_merger, [ctx for ctx, _, _ in ctxs],\n query_vec))\n return (\n combined_context,\n # Return atten_probs of the primary source.\n # TODO(huk): Maybe return a NestedMap.\n context_map[self.params.primary_source_key][1],\n py_utils.NestedMap({\n src_key: context_map[src_key][2]\n for src_key, _ in self.params.source_atten_tpls\n }))\n"],"string":"[\n \"# Lint as: python3\\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\\\"\\\"\\\"Evaluation loop for lingvo Jax model.\\\"\\\"\\\"\\n\\nimport contextlib\\nimport functools\\nimport hashlib\\nimport os\\nimport time\\nfrom typing import List, Optional, Sequence\\n\\nfrom absl import logging\\nimport jax\\nfrom jax.experimental import maps\\nfrom jax.experimental import mesh_utils\\nfrom lingvo.jax import base_input\\nfrom lingvo.jax import base_layer\\nfrom lingvo.jax import base_metrics\\nfrom lingvo.jax import base_model_params\\nfrom lingvo.jax import base_task\\nfrom lingvo.jax import checkpoint_pb2\\nfrom lingvo.jax import model_utils\\nfrom lingvo.jax import py_utils\\nfrom lingvo.jax import pytypes\\nfrom lingvo.jax import summary_utils\\nfrom lingvo.jax import train_states\\nfrom lingvo.jax import trainer_lib\\nimport tensorflow.compat.v2 as tf\\n\\nfrom lingvo.jax import checkpoints\\nfrom lingvo.jax import io_utils\\n\\nBaseModelParamsT = base_model_params.BaseModelParamsT\\nCheckpointType = checkpoint_pb2.CheckpointType\\nInstantiableParams = py_utils.InstantiableParams\\nNestedMap = py_utils.NestedMap\\nJTensor = pytypes.JTensor\\nNestedJTensor = pytypes.NestedJTensor\\nTrainState = train_states.TrainState\\nSummaryWriter = tf.summary.SummaryWriter\\n\\n\\ndef maybe_ema(model_states):\\n \\\"\\\"\\\"Finds the ema state from optimizer states.\\\"\\\"\\\"\\n if not model_states.opt_states:\\n return model_states\\n for i in range(len(model_states.opt_states[0])):\\n if 'ema' in model_states.opt_states[0][i]:\\n return TrainState(\\n step=model_states.step,\\n mdl_vars=model_states.opt_states[0][i].ema,\\n opt_states={})\\n return model_states\\n\\n\\ndef evaluate(\\n model_name: str,\\n job_log_dir: Optional[str],\\n multi_host_checkpointing: Optional[bool],\\n maybe_use_persistence_checkpointing: bool,\\n) -> None:\\n \\\"\\\"\\\"Runs the evaluation loop on the entire eval data set.\\n\\n Args:\\n model_name: The name of the model from the registry to evaluate.\\n job_log_dir: The directory for the job logs.\\n multi_host_checkpointing: Whether to use multi-host checkpointing.\\n maybe_use_persistence_checkpointing: If set, it will try to use\\n persistence-based checkpointing if suitable.\\n \\\"\\\"\\\"\\n model_config = model_utils.get_model(model_name)()\\n task_p = model_config.task()\\n model_p = task_p.model\\n eval_input_p = [v for v in model_config.datasets() if not v.is_training]\\n for inp in eval_input_p:\\n inp.num_infeed_hosts = jax.process_count()\\n inp.infeed_host_index = jax.process_index()\\n\\n if model_p.device_mesh is not None:\\n checkpoint_type = checkpoints.retrieve_checkpoint_type(\\n multi_host_checkpointing, maybe_use_persistence_checkpointing, task_p)\\n evaluate_spmd_model(task_p, eval_input_p, job_log_dir, checkpoint_type)\\n else:\\n evaluate_pmap_model(task_p, eval_input_p, job_log_dir)\\n\\n\\ndef evaluate_pmap_model(\\n task_p: InstantiableParams,\\n eval_input_p: Sequence[InstantiableParams],\\n job_log_dir: Optional[str],\\n) -> None:\\n \\\"\\\"\\\"Runs the evaluation loop on the entire test dataset for PMAP model.\\n\\n Args:\\n task_p: Params for the task encapsulating the data parallel model.\\n eval_input_p: List of params for the eval data input pipelines.\\n job_log_dir: Directory for the job logs.\\n \\\"\\\"\\\"\\n logging.info('Using pmap for data parallelism.')\\n jax_task = task_p.Instantiate()\\n eval_input_pipelines = [input_p.Instantiate() for input_p in eval_input_p]\\n # TODO(shafey): Retrieve the seeds from the model definition instead.\\n prng_key = jax.random.PRNGKey(1234)\\n prng_key, init_key = jax.random.split(prng_key)\\n\\n checkpoint_dir = os.path.join(job_log_dir, 'checkpoints')\\n # Restore flax checkpoints still required bak variables in TrainState\\n # TODO(pax): add is_eval=True to initialize_model_state\\n model_states = trainer_lib.initialize_model_state(jax_task, init_key)\\n # Pmap does not use GDA, and so global_mesh and mesh_axes are None.\\n model_states = checkpoints.restore_checkpoint(model_states, checkpoint_dir)\\n replicated_model_states = trainer_lib.replicate_model_state(model_states)\\n logging.info('replicated_model_states: %s',\\n jax.tree_map(lambda x: x.shape, replicated_model_states))\\n # From now on, different replicas should use different random seeds.\\n # Here, each process will have its unique prng_key.\\n # prng_key will be further split so that each core on a host will get\\n # different prng_key.\\n prng_key = jax.random.fold_in(prng_key, jax.process_index())\\n logging.info('root prng_key: %s', prng_key)\\n\\n def eval_step(mdl_states, prng_key, inputs):\\n mdl_states = trainer_lib.train_state_for_eval_step(mdl_states)\\n return trainer_lib.eval_step_single_learner(\\n jax_task,\\n mdl_states,\\n prng_key,\\n inputs,\\n data_parallel_axis_name='batch',\\n fprop_dtype=jax_task.model.fprop_dtype)\\n\\n num_devices = jax.local_device_count()\\n prng_key, eval_key = jax.random.split(prng_key)\\n eval_prng_seed = jax.random.split(eval_key, num=num_devices)\\n logging.info('eval prng_seed: %s', eval_prng_seed)\\n\\n p_eval_step = jax.pmap(eval_step, axis_name='batch')\\n\\n logging.info('Evaluation loop starting...')\\n summary_base_dir = os.path.join(job_log_dir, 'summaries')\\n summary_eval_dirs = [\\n os.path.join(summary_base_dir, f'eval_test_{split}')\\n for split, _ in enumerate(eval_input_p)\\n ]\\n\\n num_steps = [\\n -1 if p.reset_for_eval else p.eval_loop_num_batches for p in eval_input_p\\n ]\\n last_checkpoint = checkpoints.latest_checkpoint(checkpoint_dir)\\n with contextlib.ExitStack() as exit_stack:\\n eval_summary_writers = [\\n exit_stack.enter_context(summary_utils.get_summary_writer(d))\\n for d in summary_eval_dirs\\n ]\\n\\n while True:\\n step_i = int(jax.device_get(replicated_model_states.step)[0])\\n eval_step = functools.partial(p_eval_step,\\n maybe_ema(replicated_model_states),\\n eval_prng_seed)\\n # Run the eval loop.\\n model_utils.run_eval_loop_over_test_splits(\\n num_steps,\\n eval_step,\\n eval_summary_writers,\\n step_i,\\n eval_input_pipelines,\\n reshard_inputs=True)\\n # If the last check point evaluated matches max train steps, exit.\\n if last_checkpoint is not None:\\n last_ckpt_step = checkpoints.get_step_from_checkpoint_asset(\\n last_checkpoint)\\n exceeded_ckpt = last_ckpt_step + task_p.train.save_interval_steps\\n if exceeded_ckpt >= task_p.train.num_train_steps:\\n break\\n # Release replicated_model_states.\\n del replicated_model_states\\n new_checkpoint = checkpoints.latest_checkpoint(checkpoint_dir)\\n while new_checkpoint == last_checkpoint:\\n # Sleep for a minute.\\n time.sleep(60)\\n new_checkpoint = checkpoints.latest_checkpoint(checkpoint_dir)\\n # There must be a new checkpoint here.\\n logging.info('Found new checkpoint: %s', new_checkpoint)\\n model_states = checkpoints.restore_checkpoint(model_states,\\n checkpoint_dir)\\n replicated_model_states = trainer_lib.replicate_model_state(model_states)\\n last_checkpoint = new_checkpoint\\n\\n\\ndef evaluate_spmd_model(\\n task_p: InstantiableParams,\\n eval_input_p: Sequence[InstantiableParams],\\n job_log_dir: Optional[str],\\n checkpoint_type: CheckpointType,\\n) -> None:\\n \\\"\\\"\\\"Runs the evaluation loop on the entire test dataset for SPMD model.\\n\\n Args:\\n task_p: Params of the task encapsulating an SPMD model.\\n eval_input_p: List of Params for the eval data pipelines.\\n job_log_dir: Directory for the job logs.\\n checkpoint_type: Type of model checkpointing method to use.\\n \\\"\\\"\\\"\\n logging.info('Using SPMD sharding for model parallelism.')\\n eval_input_pipelines = [input_p.Instantiate() for input_p in eval_input_p]\\n # TODO(bf-jax): Retrieve the seeds from the model definition instead.\\n prng_key = jax.random.PRNGKey(1234)\\n prng_key, init_key = jax.random.split(prng_key)\\n\\n checkpoint_dir = os.path.join(job_log_dir, 'checkpoints')\\n # Note that GDA checkpoint requires all processes to participate in\\n # checkpointing but it does not require a separate checkpoint_dir per process.\\n if checkpoint_type == CheckpointType.CHECKPOINT_MULTI_HOST_FLAX:\\n checkpoint_task_dir = os.path.join(checkpoint_dir,\\n f'{jax.process_index():03d}')\\n else:\\n checkpoint_task_dir = checkpoint_dir\\n\\n multi_host_checkpointing = bool(checkpoint_type in {\\n CheckpointType.CHECKPOINT_MULTI_HOST_FLAX, CheckpointType.CHECKPOINT_GDA\\n })\\n\\n def get_shape_dtype(x):\\n y = jax.ShapeDtypeStruct(x.shape, x.dtype)\\n return y\\n\\n # Do not ues eval_input_pipelines[0] directly.\\n sample_model_inputs = eval_input_p[0].Instantiate().get_next()\\n inputs_shape = tf.nest.map_structure(get_shape_dtype, sample_model_inputs)\\n\\n jax_task = task_p.Instantiate()\\n model_p = task_p.model\\n mesh_shape = model_p.device_mesh.shape\\n device_mesh = mesh_utils.create_device_mesh(mesh_shape)\\n logging.info('device_mesh: %s', device_mesh)\\n global_mesh = maps.Mesh(device_mesh, model_p.mesh_axis_names)\\n use_gda_checkpoint = jax.config.jax_parallel_functions_output_gda\\n with global_mesh:\\n jax_task.model.instantiate_variable_configs()\\n # Restore flax checkpoints still required backward variables in TrainState\\n # TODO(pax): set is_eval=True for all ckpt types.\\n if use_gda_checkpoint:\\n partitioned_specs = jax_task.create_train_state_partition_specs(\\n jax_task.model.vars, discard_opt_states=True)\\n partitioned_train_state = checkpoints.restore_checkpoint(\\n None,\\n checkpoint_task_dir,\\n global_mesh=global_mesh,\\n checkpoint_type=checkpoint_type,\\n state_specs=partitioned_specs)\\n eval_step, inputs_partition_specs = (\\n trainer_lib.get_partitioned_spmd_model_step_fn(\\n jax_task,\\n init_key,\\n partitioned_specs,\\n inputs_shape,\\n is_eval=True))\\n else:\\n (partitioned_train_state, partitioned_specs, inputs_partition_specs, _,\\n eval_step, _) = trainer_lib.partition_spmd_model(task_p, init_key,\\n inputs_shape)\\n partitioned_train_state = checkpoints.restore_checkpoint(\\n partitioned_train_state,\\n checkpoint_task_dir,\\n global_mesh=global_mesh,\\n checkpoint_type=checkpoint_type,\\n state_specs=partitioned_specs)\\n\\n logging.info('partitioned_train_state: %s',\\n jax.tree_map(lambda x: x.shape, partitioned_train_state))\\n if multi_host_checkpointing:\\n py_utils.sync_global_devices(f'checkpointer:restored:{checkpoint_dir}')\\n\\n # We do not fold in jax.process_index in contrast to the pmap version and\\n # use a single global key instead to rely on pjit to split for different\\n # replicas.\\n logging.info('root prng_key: %s', prng_key)\\n prng_key, eval_key = jax.random.split(prng_key)\\n logging.info('eval prng_key: %s', eval_key)\\n\\n logging.info('Evaluation loop starting...')\\n summary_base_dir = os.path.join(job_log_dir, 'summaries')\\n summary_eval_dirs = [\\n os.path.join(summary_base_dir, f'eval_{split}')\\n for split, _ in enumerate(eval_input_p)\\n ]\\n\\n num_steps = [-1 if p.reset_for_eval else 1 for p in eval_input_p]\\n last_checkpoint = checkpoints.latest_checkpoint(checkpoint_dir)\\n with contextlib.ExitStack() as exit_stack:\\n eval_summary_writers = [\\n exit_stack.enter_context(summary_utils.get_summary_writer(d))\\n for d in summary_eval_dirs\\n ]\\n while True:\\n step_i = int(jax.device_get(partitioned_train_state.step))\\n eval_step_fn = functools.partial(\\n eval_step,\\n trainer_lib.train_state_for_eval_step(partitioned_train_state),\\n eval_key)\\n # Run the eval loop.\\n model_utils.run_eval_loop_over_test_splits(\\n num_steps,\\n eval_step_fn,\\n eval_summary_writers,\\n step_i,\\n eval_input_pipelines,\\n inputs_partition_specs,\\n inputs_shape,\\n global_mesh,\\n reshard_inputs=False)\\n # If the last check point evaluated matches max train steps, exit.\\n if last_checkpoint is not None:\\n last_ckpt_step = checkpoints.get_step_from_checkpoint_asset(\\n last_checkpoint)\\n exceeded_ckpt = last_ckpt_step + task_p.train.save_interval_steps\\n if exceeded_ckpt >= task_p.train.num_train_steps:\\n break\\n new_checkpoint = checkpoints.latest_checkpoint(checkpoint_dir)\\n while new_checkpoint == last_checkpoint:\\n # Sleep for a minute.\\n time.sleep(60)\\n new_checkpoint = checkpoints.latest_checkpoint(checkpoint_dir)\\n # There must be a new checkpoint here.\\n logging.info('Found new checkpoint: %s', new_checkpoint)\\n partitioned_train_state = checkpoints.restore_checkpoint(\\n None if use_gda_checkpoint else partitioned_train_state,\\n checkpoint_task_dir,\\n global_mesh=global_mesh,\\n checkpoint_type=checkpoint_type,\\n state_specs=partitioned_specs)\\n if multi_host_checkpointing:\\n py_utils.sync_global_devices(\\n f'checkpointer:restored:{checkpoint_dir}')\\n last_checkpoint = new_checkpoint\\n\\n\\ndef decode(\\n model_name: str,\\n job_log_dir: Optional[str],\\n multi_host_checkpointing: Optional[bool],\\n maybe_use_persistence_checkpointing: bool,\\n restore_checkpoint_dir: Optional[str],\\n restore_checkpoint_step: Optional[int],\\n continuous_decode: bool,\\n) -> None:\\n \\\"\\\"\\\"Runs decoding once on the decoder datasets.\\n\\n Args:\\n model_name: The name of the model from the registry to evaluate.\\n job_log_dir: The directory for the job logs.\\n multi_host_checkpointing: Whether to use multi-host checkpointing.\\n maybe_use_persistence_checkpointing: If set, it will try to use\\n persistence-based checkpointing if suitable.\\n restore_checkpoint_dir: The directory from which to restore checkpoint.\\n restore_checkpoint_step: If set, the checkpoint step to restore. If unset,\\n try to restore from the latest checkpoint if any.\\n continuous_decode: whether to continuously decode on the latest ckpt.\\n \\\"\\\"\\\"\\n logging.info('running decode_once on model %s restored from %s', model_name,\\n restore_checkpoint_dir)\\n model_config = model_utils.get_model(model_name)()\\n task_p = model_config.task()\\n model_p = task_p.model\\n decoder_inputs = model_config.decoder_datasets()\\n if not decoder_inputs:\\n return\\n for inp in decoder_inputs:\\n inp.num_infeed_hosts = jax.process_count()\\n inp.infeed_host_index = jax.process_index()\\n\\n if model_p.device_mesh is not None:\\n if continuous_decode:\\n raise NotImplementedError('http://b/214589358: not supported')\\n checkpoint_type = checkpoints.retrieve_checkpoint_type(\\n multi_host_checkpointing, maybe_use_persistence_checkpointing, task_p)\\n decode_once_spmd_model(task_p, decoder_inputs, job_log_dir, checkpoint_type,\\n restore_checkpoint_dir, restore_checkpoint_step)\\n else:\\n decode_pmap_model(task_p, decoder_inputs, job_log_dir,\\n restore_checkpoint_dir, restore_checkpoint_step,\\n continuous_decode)\\n\\n\\ndef _get_dir_names(input_p: Sequence[InstantiableParams]) -> Sequence[str]:\\n \\\"\\\"\\\"Returns a list of same length for parent dir names for each dataset.\\\"\\\"\\\"\\n uniq_names = set()\\n ret = []\\n for idx, p in enumerate(input_p):\\n name = p.name or f'decode_test_{idx}'\\n if p.name and p.name in uniq_names:\\n name = f'{p.name}_{idx}'\\n if name in uniq_names:\\n suffix = hashlib.md5(name.encode()).hexdigest()[-5:]\\n name = f'{name}_{suffix}'\\n assert name not in uniq_names\\n uniq_names.add(name)\\n ret.append(name)\\n return ret\\n\\n\\ndef _get_step(step: base_layer.JTensorOrPartitionSpec) -> int:\\n \\\"\\\"\\\"Returns an int for the current global step.\\\"\\\"\\\"\\n if step.ndim == 0:\\n return jax.device_get(step)\\n if step.ndim == 1:\\n return jax.device_get(step[0])\\n raise ValueError(\\n f'Expecting a replicated 1D global step (got ndim=`{step.ndim}`).')\\n\\n\\ndef _get_filename(step: base_layer.JTensorOrPartitionSpec) -> str:\\n \\\"\\\"\\\"Returns a filename for the given step.\\\"\\\"\\\"\\n step_num = _get_step(step)\\n return f'decoder_out_{step_num}_shard_{jax.process_index()}'\\n\\n\\ndef decode_pmap_model(\\n task_p: InstantiableParams,\\n input_p: Sequence[InstantiableParams],\\n job_log_dir: Optional[str],\\n restore_checkpoint_dir: Optional[str],\\n restore_checkpoint_step: Optional[int],\\n continuous_decode: bool,\\n) -> None:\\n \\\"\\\"\\\"Runs the decoding on the entire decoder datasets for a PMAP model.\\n\\n Args:\\n task_p: Params of the task encapsulating a the data parallel model.\\n input_p: List of input params to be decoded.\\n job_log_dir: Directory for the job logs.\\n restore_checkpoint_dir: The directory from which to restore checkpoint. If\\n None, uses job_log_dir.\\n restore_checkpoint_step: If set, the checkpoint step to restore. If unset,\\n try to restore from the latest checkpoint if any.\\n continuous_decode: whether to continuously decode on the latest ckpt.\\n \\\"\\\"\\\"\\n if continuous_decode and restore_checkpoint_step is not None:\\n raise ValueError('Continuous decoding mode requires restore_checkpoint_step'\\n '=None, actual restore_checkpoint_step='\\n f'{restore_checkpoint_step}')\\n restore_checkpoint_dir = restore_checkpoint_dir or os.path.join(\\n job_log_dir, 'checkpoints')\\n\\n # TODO(shafey): Retrieve the seeds from the model definition instead.\\n prng_key = jax.random.PRNGKey(1234)\\n prng_key, init_key = jax.random.split(prng_key)\\n\\n # From now on, different replicas should use different random seeds.\\n # Here, each process will have its unique prng_key.\\n # prng_key will be further split so that each core on a host will get\\n # different prng_key.\\n prng_key = jax.random.fold_in(prng_key, jax.process_index())\\n logging.info('root prng_key: %s', prng_key)\\n prng_key, eval_key = jax.random.split(prng_key)\\n prng_seed = jax.random.split(eval_key, num=jax.local_device_count())\\n logging.info('decoder prng_seed: %s', prng_seed)\\n\\n inputs = [p.Instantiate() for p in input_p]\\n summary_base_dir = os.path.join(job_log_dir, 'summaries')\\n dirnames = _get_dir_names(input_p)\\n summary_decode_dirs = [\\n os.path.join(summary_base_dir, f'decode_test_{dirnames[split]}')\\n for split, _ in enumerate(input_p)\\n ]\\n with contextlib.ExitStack() as exit_stack:\\n summary_writers = [\\n exit_stack.enter_context(summary_utils.get_summary_writer(d))\\n for d in summary_decode_dirs\\n ]\\n\\n jax_task = task_p.Instantiate()\\n # Restore flax checkpoints still required bak variables in TrainState\\n # TODO(pax): add is_eval=True to initialize_model_state\\n model_states = trainer_lib.initialize_model_state(jax_task, init_key)\\n model_states = checkpoints.restore_checkpoint(\\n model_states, restore_checkpoint_dir, step=restore_checkpoint_step)\\n replicated_model_states = trainer_lib.replicate_model_state(model_states)\\n logging.info('replicated_model_states: %s',\\n jax.tree_map(lambda x: x.shape, replicated_model_states))\\n last_checkpoint = checkpoints.latest_checkpoint(restore_checkpoint_dir)\\n\\n while True:\\n _decode_once_pmap_model(jax_task, task_p, inputs, input_p, prng_seed,\\n job_log_dir, replicated_model_states,\\n summary_writers)\\n if not continuous_decode:\\n break\\n if last_checkpoint is not None:\\n last_ckpt_step = int(last_checkpoint.split('_')[-1])\\n exceeded_ckpt = last_ckpt_step + task_p.train.save_interval_steps\\n if exceeded_ckpt >= task_p.train.num_train_steps:\\n break\\n # Release replicated_model_states.\\n del replicated_model_states\\n new_checkpoint = checkpoints.latest_checkpoint(restore_checkpoint_dir)\\n while new_checkpoint == last_checkpoint:\\n time.sleep(60)\\n new_checkpoint = checkpoints.latest_checkpoint(restore_checkpoint_dir)\\n logging.info('Found new checkpoint: %s', new_checkpoint)\\n model_states = checkpoints.restore_checkpoint(model_states,\\n restore_checkpoint_dir)\\n replicated_model_states = trainer_lib.replicate_model_state(model_states)\\n last_checkpoint = new_checkpoint\\n\\n\\ndef _decode_once_pmap_model(\\n jax_task: base_task.SingleTask,\\n task_p: InstantiableParams,\\n inputs: List[base_input.BaseInput],\\n input_p: Sequence[InstantiableParams],\\n prng_seed: JTensor,\\n job_log_dir: Optional[str],\\n replicated_model_states: train_states.TrainState,\\n summary_writers: List[SummaryWriter],\\n) -> None:\\n \\\"\\\"\\\"Runs the decoding on the entire decoder datasets for a PMAP model.\\n\\n Args:\\n jax_task: instantiated model from task_p.\\n task_p: Params for the task encapsulating a data parallel model.\\n inputs: instantiated inputs.\\n input_p: List of input params to be decoded.\\n prng_seed: The prng seed used for decoding.\\n job_log_dir: Directory for the job logs.\\n replicated_model_states: A TrainState object.\\n summary_writers: The summary writer objects to log summaries.\\n \\\"\\\"\\\"\\n model = jax_task.model\\n model_p = task_p.model\\n metrics_p = task_p.metrics\\n if not metrics_p:\\n metrics_p = base_metrics.MeanMetrics.Params()\\n decode_metrics = metrics_p.Instantiate()\\n process_decode_metrics = metrics_p.Instantiate()\\n\\n step_i = _get_step(replicated_model_states.step)\\n pmap_axis_name = 'batch'\\n\\n def decode_step(mdl_states, prng_key, inputs):\\n mdl_states = trainer_lib.train_state_for_eval_step(mdl_states)\\n metrics, out = trainer_lib.decode_step(model, mdl_states, prng_key, inputs,\\n model_p.fprop_dtype)\\n metrics = decode_metrics.aggregate(metrics)\\n return metrics, out\\n\\n # As an example, suppose the output leaf from trainer_lib.decoder_step()\\n # for each core has shape: [per_core_batch_size, decoding_length].\\n # In the all_gather we set tiled=True, so the output chunks are all\\n # concatenated into the existing batch axis, so we get shape\\n # [num_cores x per_core_batch_size, decoding_length].\\n # In the pmap call we set out_axes=None to not have to manually unreplicate,\\n # so the output of pmap_decode_step() will have the same shape.\\n #\\n # Example code snippet showing this:\\n # # shape (8, 3, 2)\\n # x = jnp.tile(jnp.arange(8)[:, None, None],[1, 3, 2])\\n # # shape (24, 2)\\n # z = jax.pmap(\\n # lambda y: jax.lax.all_gather(y+1, axis_name='i', tiled=True),\\n # axis_name='i', out_axes=None)(x)\\n #\\n # We only aggregate metrics, not `out`, hence the tuple for out_axes.\\n pmap_decode_step = jax.pmap(\\n decode_step, axis_name=pmap_axis_name, out_axes=(None, 0))\\n decode_step_func = functools.partial(pmap_decode_step,\\n maybe_ema(replicated_model_states),\\n prng_seed)\\n\\n num_steps = [\\n -1 if p.reset_for_eval else p.eval_loop_num_batches for p in input_p\\n ]\\n decodes = [list() for _ in input_p]\\n for split, num_split_steps in enumerate(num_steps):\\n logging.info('Start decoding on input %s', input_p[split].name)\\n step_num = 0\\n while num_split_steps < 0 or step_num < num_split_steps:\\n step_num += 1\\n try:\\n batch = inputs[split].get_next()\\n except (tf.errors.OutOfRangeError, StopIteration):\\n inputs[split].reset()\\n break\\n batch = tf.nest.map_structure(py_utils.reshard, batch)\\n batch_metrics, out = decode_step_func(batch)\\n # we store the metric directly as it has already been aggregated in\\n # side decode_step_fun\\n decode_metrics.store(batch_metrics)\\n logging.info('Finished decoding input batch %d', step_num)\\n\\n out = tf.nest.map_structure(py_utils.unshard, out)\\n process_metrics, processed = model.process_decode_out(inputs[split], out)\\n decodes[split].extend(processed)\\n logging.info('Finished processing decoded input batch %d', step_num)\\n\\n # Reshard the metrics for pmap.\\n process_decode_metrics.update(process_metrics)\\n\\n with summary_writers[split].as_default():\\n decode_metrics.summarize(step_i, 'decode_metrics')\\n process_decode_metrics.summarize(step_i, 'process_decode_metrics')\\n\\n basedir = os.path.join(job_log_dir, 'decoder_out')\\n dirnames = _get_dir_names(input_p)\\n filename = _get_filename(replicated_model_states.step)\\n for s in dirnames:\\n dir_path = os.path.join(basedir, s)\\n if not tf.io.gfile.exists(dir_path):\\n tf.io.gfile.makedirs(dir_path)\\n filenames = [os.path.join(basedir, s, filename) for s in dirnames]\\n for split, output_file in enumerate(filenames):\\n logging.info('Writing decoder output to %s with %d entries', output_file,\\n len(decodes[split]))\\n io_utils.WriteKeyValuePairs(output_file, decodes[split])\\n\\n\\ndef decode_once_spmd_model(\\n task_p: InstantiableParams,\\n input_p: Sequence[InstantiableParams],\\n job_log_dir: Optional[str],\\n checkpoint_type: CheckpointType,\\n restore_checkpoint_dir: str,\\n restore_checkpoint_step: Optional[int],\\n) -> None:\\n \\\"\\\"\\\"Runs the decoding once on the entire decoder datasets for SPMD model.\\n\\n Args:\\n task_p: Params for the task that encapsulates an SPMD model.\\n input_p: List of input params to be decoded.\\n job_log_dir: Directory for the job logs.\\n checkpoint_type: Type of model checkpointing method to use.\\n restore_checkpoint_dir: The directory from which to restore checkpoint.\\n restore_checkpoint_step: If set, the checkpoint step to restore. If unset,\\n try to restore from the latest checkpoint if any.\\n \\\"\\\"\\\"\\n # TODO(bf-jax): Retrieve the seeds from the model definition instead.\\n prng_key = jax.random.PRNGKey(1234)\\n prng_key, init_key = jax.random.split(prng_key)\\n\\n if restore_checkpoint_dir:\\n restore_checkpoint_parent_dir = restore_checkpoint_dir\\n if checkpoint_type == CheckpointType.CHECKPOINT_MULTI_HOST_FLAX:\\n # TODO(zhouwk): add sanity check on number of subdirs and number of\\n # processes and fail early if unequal.\\n restore_checkpoint_dir = os.path.join(restore_checkpoint_dir,\\n f'{jax.process_index():03d}')\\n\\n multi_host_checkpointing = bool(checkpoint_type in {\\n CheckpointType.CHECKPOINT_MULTI_HOST_FLAX, CheckpointType.CHECKPOINT_GDA\\n })\\n\\n sample_inputs = input_p[0].Instantiate().get_next()\\n inputs_shape = tf.nest.map_structure(py_utils.get_global_input_shape_dtype,\\n sample_inputs)\\n\\n model_p = task_p.model\\n # TODO(b/198356509): This is a hack for now as we need to change some\\n # annotations for mode='decode'. A future cl will move this logic\\n # to a more generic model_p.update_sharding_params_v1(mode='decode').\\n model_p.lm = model_p.lm.cls.set_sharding_params_v1(\\n model_p.lm,\\n replica_axis=model_p.lm.mesh_axis_names[0],\\n data_axis=model_p.lm.mesh_axis_names[1],\\n mdl_axis=model_p.lm.mesh_axis_names[2],\\n device_ids_mesh=model_p.lm.device_mesh,\\n mesh_axis_names=model_p.lm.mesh_axis_names,\\n mode='decode')\\n\\n mesh_shape = model_p.device_mesh.shape\\n device_mesh = mesh_utils.create_device_mesh(mesh_shape)\\n logging.info('device_mesh: %s', device_mesh)\\n jax_task = task_p.Instantiate()\\n global_mesh = maps.Mesh(device_mesh, model_p.mesh_axis_names)\\n with global_mesh:\\n if restore_checkpoint_dir:\\n model = jax_task.model\\n model.instantiate_variable_configs()\\n # Get the metadata from variables instead of actually instantiating them.\\n partitioned_specs = jax_task.create_train_state_partition_specs(\\n model.vars, discard_opt_states=True)\\n # Instantiate the TrainState directly from the checkpoint.\\n partitioned_train_state = checkpoints.restore_checkpoint(\\n None,\\n restore_checkpoint_dir,\\n global_mesh=global_mesh,\\n checkpoint_type=checkpoint_type,\\n state_specs=partitioned_specs,\\n step=restore_checkpoint_step)\\n if multi_host_checkpointing:\\n py_utils.sync_global_devices(\\n f'checkpointer:restored:{restore_checkpoint_parent_dir}')\\n decode_step_fn, inputs_partition_spec = (\\n trainer_lib.get_partitioned_spmd_model_decode_fn(\\n jax_task, init_key, partitioned_specs, inputs_shape))\\n else:\\n # When restore is not specified, randomly initiate the train_state.\\n (partitioned_train_state, inputs_partition_spec, partitioned_specs,\\n decode_step_fn) = trainer_lib.partition_spmd_model_decode(\\n task_p, init_key, inputs_shape)\\n logging.info('partitioned_train_state: %s',\\n jax.tree_map(lambda x: x.shape, partitioned_train_state))\\n # We do not fold in jax.process_index in contrast to the pmap version and\\n # use a single global key instead to rely on pjit to split for different\\n # replicas.\\n logging.info('root prng_key: %s', prng_key)\\n prng_key, decode_key = jax.random.split(prng_key)\\n logging.info('eval prng_key: %s', decode_key)\\n spmd_decode_step_fn = functools.partial(\\n decode_step_fn,\\n trainer_lib.train_state_for_eval_step(partitioned_train_state),\\n decode_key)\\n\\n num_steps = [\\n -1 if p.reset_for_eval else p.eval_loop_num_batches for p in input_p\\n ]\\n inputs = [p.Instantiate() for p in input_p]\\n decodes = [list() for _ in input_p]\\n process_id = jax.process_index()\\n\\n for split, num_split_steps in enumerate(num_steps):\\n logging.info('Start decoding on input %s', input_p[split].name)\\n step_num = 0\\n while num_split_steps < 0 or step_num < num_split_steps:\\n step_num += 1\\n try:\\n batch = inputs[split].get_next()\\n except (tf.errors.OutOfRangeError, StopIteration):\\n break\\n if jax.config.jax_parallel_functions_output_gda:\\n batch = py_utils.create_gda(batch, inputs_shape, global_mesh,\\n inputs_partition_spec)\\n _, out = spmd_decode_step_fn(batch)\\n # Output is fully replicated now, so it's ok to unreplicate it by\\n # retrieving from device 0 only.\\n out = py_utils.maybe_unreplicate_gda(out)\\n global_batch_size = next(iter(out.values())).shape[0]\\n logging.info('Finished decoding input batch %d with %d examples',\\n step_num, global_batch_size)\\n # Manually shard the output per each jax process.\\n # We require that all fields in the output is batch major.\\n if global_batch_size % jax.process_count() != 0:\\n raise ValueError(f'Global batch size {global_batch_size} must divide '\\n f'jax process count {jax.process_count()}')\\n for k, v in out.items():\\n if v.shape[0] != global_batch_size:\\n raise ValueError('We require that all fields in the decode output '\\n 'to have batch size as the first dim, got shape='\\n f'{v.shape} with key={k}, expect batch size = '\\n f'{global_batch_size}')\\n per_process_batch_size = global_batch_size // jax.process_count()\\n\\n def shard(x, per_process_batch_size=per_process_batch_size):\\n return x[(process_id *\\n per_process_batch_size):((process_id + 1) *\\n per_process_batch_size)]\\n\\n out = jax.tree_map(shard, out)\\n _, processed = jax_task.model.process_decode_out(inputs[split], out)\\n decodes[split].extend(processed)\\n logging.info('Finished processing decoded input batch %d', step_num)\\n\\n basedir = os.path.join(job_log_dir, 'decoder_out')\\n dirnames = _get_dir_names(input_p)\\n filename = _get_filename(\\n py_utils.maybe_unreplicate_gda(partitioned_train_state.step))\\n for s in dirnames:\\n dir_path = os.path.join(basedir, s)\\n if not tf.io.gfile.exists(dir_path):\\n tf.io.gfile.makedirs(dir_path)\\n filenames = [os.path.join(basedir, s, filename) for s in dirnames]\\n for split, output_file in enumerate(filenames):\\n logging.info('Writing decoder output to %s with %d entries', output_file,\\n len(decodes[split]))\\n io_utils.WriteKeyValuePairs(output_file, decodes[split])\\n\",\n \"# Lint as: python3\\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\\\"\\\"\\\"Base classes for the lingvo Jax input layers.\\\"\\\"\\\"\\n\\nimport copy\\nfrom typing import List, Optional\\n\\nfrom absl import logging\\nfrom lingvo.core import cluster_factory\\nfrom lingvo.core import datasource\\nfrom lingvo.jax import py_utils\\nfrom lingvo.jax import pytypes\\nimport tensorflow.compat.v2 as tf\\n\\nNestedMap = py_utils.NestedMap\\nNestedJTensor = pytypes.NestedJTensor\\nInstantiableParams = py_utils.InstantiableParams\\nParamsT = pytypes.ParamsT\\n\\n\\nclass BaseInputParams(InstantiableParams):\\n \\\"\\\"\\\"A convenient base type for the params of a dataset.\\\"\\\"\\\"\\n\\n def __init__(self, cls) -> None:\\n super().__init__(cls)\\n self.Define('name', 'input', 'Name of this input dataset.')\\n\\n self.Define(\\n 'batch_size', None, 'The (Jax per process) Batch size. '\\n 'Each call to get_next() returns a batch with this '\\n 'batch size.')\\n\\n # Sharding behavior.\\n self.Define(\\n 'num_infeed_hosts', 1,\\n 'Usually set to jax.process_count(). Implementation must '\\n 'ensure that the data is sharded into this many shard.')\\n self.Define(\\n 'infeed_host_index', 0,\\n 'Usually set to jax.process_index(). Implementation must '\\n 'ensure that each instance returns a shard with this index.')\\n\\n # Deterministic randomness.\\n self.Define(\\n 'input_random_seed', None,\\n 'If set, implementation must ensure that this is used to seed '\\n 'randomness, e.g. when shuffling in a deterministic manner.')\\n\\n self.Define(\\n 'reset_for_eval', False,\\n 'If set, eval will continue until tf.errors.OutOfRange is raised, '\\n 'and reset() will called for each eval. Implementation must ensure that'\\n ' all variant p.infeed_host_index instances raise after the same number'\\n ' of calls to get_next() to ensure synchronization across hosts. If not'\\n ' set, get_next() must never raise.')\\n self.Define(\\n 'eval_loop_num_batches', 1,\\n 'Num of batches to process per eval loop. Must be >= 1. This value'\\n ' is ignored if reset_for_eval is set True, in which case, this value'\\n ' is dynamically determined by the number of available batches. If '\\n ' reset_for_eval is set to False, then each eval loop will process'\\n ' this many batches. Metrics over those batches will be aggregated'\\n ' and then reported.')\\n self.Define('is_training', False,\\n 'Whether or not this dataset is used for model traning.')\\n\\n\\nclass BaseInput:\\n \\\"\\\"\\\"Base class for Jax input classes.\\n\\n During Lingvo Jax's train, on each host an input instance will be\\n created (input_p.Instantiate()), and then get_next() is iteratively\\n called in eager mode to generate one batch of data for each step\\n of train/eval/etc.\\n\\n If supported, for eval, reset() is called after each eval step.\\n See p.reset_for_eval below.\\n\\n A tf.data based input should inherit this class directly and implement\\n get_next() and reset(). For an example of how to handle sharding for both\\n training and eval data, please refer to the implementation of\\n TFRecordBertInput at tasks/lm/input_generator.py.\\n\\n If there is already an Lingvo TF input generator that one would like to\\n use directly, please use LingvoInputAdaptor below.\\n \\\"\\\"\\\"\\n _VALIDATE_BATCH_SIZE_NOT_NONE = True\\n\\n @classmethod\\n def Params(cls) -> InstantiableParams: # pylint:disable=invalid-name\\n \\\"\\\"\\\"Common Params for all inputs.\\\"\\\"\\\"\\n return BaseInputParams(cls)\\n\\n def __init__(self, p: ParamsT) -> None:\\n if self._VALIDATE_BATCH_SIZE_NOT_NONE and (p.batch_size is None):\\n raise ValueError('Must specify p.batch_size.')\\n self._params = p.Copy()\\n\\n @property\\n def params(self) -> ParamsT:\\n return self._params\\n\\n def get_next(self) -> NestedJTensor:\\n raise NotImplementedError\\n\\n def reset(self) -> None:\\n pass\\n\\n def ids_to_strings(self,\\n ids: pytypes.NpTensor,\\n lengths: pytypes.NpTensor,\\n key: Optional[str] = None) -> List[str]:\\n \\\"\\\"\\\"Converts int ids into strings.\\n\\n Args:\\n ids: A matrix of shape [batch, seqlen], each row is a sequence to be\\n converted.\\n lengths: A vector of shape [batch]. lens[i] is the sequence length of the\\n i-th row. Only the first lens[i] tokens in ids[i, :] are valid tokens.\\n key: Optional argument to specify whether a tokenizer to use is the source\\n or target. This is useful for example in a sequence model where the\\n source and targets have different tokenizers. For the source corpus the\\n key should be `src` while for the target corpus the key should be `tgt`.\\n\\n Returns:\\n A list strings of shape [batch]. The converted texts.\\n \\\"\\\"\\\"\\n raise NotImplementedError\\n\\n\\nclass LingvoInputAdaptor(BaseInput):\\n \\\"\\\"\\\"Syntactic sugar for adapting a Lingvo style input for Jax.\\n\\n This should be able to wrap any Lingvo TF input generator to be used in\\n Lingvo Jax. Remember to set `p.is_training=True` on the training dataset.\\n\\n Some usage caveats below.\\n\\n For eval, `p.num_samples` or other similar params like samples_per_summary are\\n completely ignored by Lingvo Jax. Caller should instead set `p.num_batches` to\\n (p.num_samples // batch_size) with `p.reset_for_eval=True` so that each eval\\n step reads (approximately) one epoch of eval data. This might not be needed if\\n the input already is finite (e.g. with p.repeat_count=1).\\n\\n When multiple infeed hosts are used, one must take care to ensure that the\\n Lingvo input either already uses InfeedContextScope for proper sharding, or\\n alternatively do not use the same random seed on all hosts. In other words,\\n one must avoid the failure case where each host emits identical training data.\\n See also p.allow_fixed_file_random_seed below.\\n \\\"\\\"\\\"\\n _VALIDATE_BATCH_SIZE_NOT_NONE = False\\n _VALIDATE_BATCH_SIZE_NONE = True\\n\\n @classmethod\\n def Params(cls) -> InstantiableParams:\\n p = super().Params()\\n p.Define('input', None, 'Params of a Lingvo input generator.')\\n p.Define(\\n 'num_batches', None,\\n 'If specified and positive, raises tf.errors.OutOfRange after this many'\\n ' batches have been produced. This forces a raise after get_next() is '\\n 'called this many times, to support p.reset_for_eval=True.')\\n p.Define(\\n 'allow_fixed_file_random_seed', False,\\n 'If not set, disallows a fixed, non-zero p.input.file_random_seed. '\\n 'We disallow by default to avoid having identical input batches across '\\n 'different infeed hosts. If set, random seeds are adjusted by '\\n 'p.infeed_host_index to ensure different random seeds.')\\n p.Define(\\n 'cluster_do_eval', False,\\n 'Whether to set cluster.do_eval to True for non-training data. '\\n 'Note that if set to True, this will change '\\n 'cluster.require_sequential_input_order to True as a result. '\\n 'Ignored when p.is_training is True.')\\n return p\\n\\n def __init__(self, p):\\n if self._VALIDATE_BATCH_SIZE_NONE and p.batch_size is not None:\\n raise ValueError('LingvoInputAdaptor does not support p.batch_size. '\\n 'Please specify batch size on p.input, e.g. with '\\n 'p.input.bucket_batch_limit = [4] or '\\n 'p.input.args.batch=4, depeding the Lingvo input '\\n f'used. Currently: p.batch_size={p.batch_size}, '\\n 'it must be None.')\\n super().__init__(p)\\n self._cluster = copy.deepcopy(cluster_factory.Current())\\n # For Lingvo's Cluster context that may impact the behavior of this input\\n # generator, we always set use_tpu to True, and optionally set do_eval\\n # for non-training data when configured to do so. All other Cluster params\\n # use the default value.\\n self._cluster.params.xla_device = 'tpu'\\n self._cluster.params.enable_asserts = False\\n # This indirectly sets cluster.require_sequential_input_order as well.\\n self._cluster.params.do_eval = (not p.is_training and p.cluster_do_eval)\\n self._initialize()\\n\\n def _initialize(self) -> None:\\n \\\"\\\"\\\"Initializes the relevant fields of this adaptor input.\\\"\\\"\\\"\\n p = self.params\\n if hasattr(p.input, 'file_random_seed') and p.input.file_random_seed:\\n if not p.allow_fixed_file_random_seed:\\n raise ValueError(\\n 'Training data using fixed non-zero file_random_seed: '\\n f'p.input.file_random_seed={p.input.file_random_seed}. '\\n 'This means each host *might* infeed identical batches. You can set '\\n 'p.input.file_random_seed = 0, or if certain this is intended, '\\n 'suppress this error by setting p.allow_fixed_file_random_seed = '\\n 'True.')\\n # Make sure each host uses a different random seed.\\n p.input.file_random_seed += p.infeed_host_index\\n # We make self.input public so that users can access its methods like\\n # IdsToStrings if needed.\\n with py_utils.infeed_context_scope(\\n infeed_host_index=p.infeed_host_index,\\n num_infeed_hosts=p.num_infeed_hosts), self._cluster:\\n self.input = p.input.Instantiate()\\n\\n if hasattr(self.input, 'datasource') and isinstance(\\n self.input.datasource, datasource.TFDatasetSource):\\n # For the special case when the input is implemented by a tf.data.Dataset,\\n # call eagerly. Using tf.function may result in returning duplicate\\n # batches.\\n self._get_next_fn = self._get_batch\\n else:\\n self._get_next_fn = tf.function(self._get_batch)\\n self._num_batches_produced = 0\\n\\n def _get_batch(self) -> NestedMap:\\n p = self.params\\n with py_utils.infeed_context_scope(\\n infeed_host_index=p.infeed_host_index,\\n num_infeed_hosts=p.num_infeed_hosts), self._cluster:\\n ret = self.input.GetPreprocessedInputBatch()\\n # Remove unsupported string (byte) array from input.\\n return ret.Filter(lambda v: v.dtype != tf.string)\\n\\n def get_next(self) -> NestedJTensor:\\n p = self.params\\n if p.num_batches is not None and p.num_batches > 0:\\n if self._num_batches_produced >= p.num_batches:\\n raise tf.errors.OutOfRangeError(\\n node_def=None,\\n op=None,\\n message=f'num_batches exceeding {self._num_batches_produced}')\\n self._num_batches_produced += 1\\n ret = self._get_next_fn()\\n return tf.nest.map_structure(lambda x: x.numpy(), ret)\\n\\n def reset(self) -> None:\\n if hasattr(self.input, 'datasource') and isinstance(\\n self.input.datasource, datasource.TFDatasetSource):\\n self.input.datasource.Reset()\\n # reset counter to 0.\\n self._num_batches_produced = 0\\n return\\n # reinstantiate the input and retrace self._get_batch.\\n self._initialize()\\n\\n def ids_to_strings(self,\\n ids: pytypes.NpTensor,\\n lengths: pytypes.NpTensor,\\n key: Optional[str] = None) -> List[str]:\\n \\\"\\\"\\\"Converts int ids into strings.\\\"\\\"\\\"\\n bytes_list = self.input.IdsToStrings(ids, lengths, key=key).numpy()\\n return [b.decode('utf-8') for b in bytes_list]\\n\\n\\nclass LingvoInputAdaptorNewBatchSize(LingvoInputAdaptor):\\n \\\"\\\"\\\"A similar adapter as LingvoInputAdaptor supporting a new batch size.\\n\\n LingvoInputAdaptor uses the batch size specified by the underlying Lingvo\\n input. This class, however, allows specifying a smaller p.batch_size.\\n This can be useful when the Lingvo input expects a large batch size,\\n but the user wants a smaller batch size, e.g. when the Lingvo input uses\\n a fixed packing factor to do packing, which can more efficiently pack with\\n more data.\\n\\n We require that the batch size of the underlying Lingvo input must divide\\n p.batch_size. Internally this class acts as a cache, retrieving the large\\n batches from the parent class size, and consuming it by slicing it to the\\n smaller batch size specified by the user.\\n\\n Example usage:\\n p = ChangeBatchSizeInput.Params().Set(...)\\n p.input.packing_factor = 3.5\\n p.input.bucket_batch_limit = [4096]\\n p.batch_size = 4\\n \\\"\\\"\\\"\\n _VALIDATE_BATCH_SIZE_NOT_NONE = True\\n _VALIDATE_BATCH_SIZE_NONE = False\\n\\n def __init__(self, p):\\n super().__init__(p)\\n self._current_batch = super().get_next()\\n self._inner_batch_size = next(iter(self._current_batch.values())).shape[0]\\n logging.info(\\n 'The wrapped Lingvo input has batch size %d, the actual input '\\n 'has batch size %d.', self._inner_batch_size, p.batch_size)\\n if self._inner_batch_size % p.batch_size != 0:\\n raise ValueError(f'Lingvo input batch size {self._inner_batch_size} '\\n 'must be a multiple of p.batch_size={p.batch_size}.')\\n self._current_batch_index = 0\\n\\n def get_next(self):\\n p = self.params\\n if self._current_batch_index >= self._inner_batch_size:\\n self._current_batch = super().get_next()\\n self._current_batch_index = 0\\n\\n def _get_subrows(b):\\n start = self._current_batch_index\\n return b[start:start + p.batch_size]\\n\\n ret = tf.nest.map_structure(_get_subrows, self._current_batch)\\n self._current_batch_index += p.batch_size\\n return ret\\n\\n def reset(self):\\n super().reset()\\n self._current_batch = super().get_next()\\n self._current_batch_index = 0\\n\",\n \"# Lint as: python3\\n# Copyright 2020 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 conformer layers as in https://arxiv.org/abs/2005.08100.\\\"\\\"\\\"\\n# Lint as: PY3\\nfrom unittest import mock\\nfrom absl.testing import flagsaver\\nfrom absl.testing import parameterized\\n\\nfrom lingvo import compat as tf\\nfrom lingvo.core import batch_major_attention\\nfrom lingvo.core import bn_layers\\nfrom lingvo.core import cluster_factory\\nfrom lingvo.core import conformer_layer\\nfrom lingvo.core import conv_layers_with_time_padding\\nfrom lingvo.core import gshard_builder\\nfrom lingvo.core import layers as lingvo_layers\\nfrom lingvo.core import py_utils\\nfrom lingvo.core import stream_step_test_base\\nfrom lingvo.core import test_utils\\n\\nimport numpy as np\\n\\n\\nclass LConvLayerTest(test_utils.TestCase, parameterized.TestCase):\\n\\n @parameterized.named_parameters(\\n ('BN',),\\n ('GN', 'gn'),\\n )\\n def testBasic(self, norm='bn'):\\n batch_size, seqlen, dim = 2, 16, 4\\n inputs = tf.zeros([batch_size, seqlen, dim])\\n paddings = tf.zeros([batch_size, seqlen])\\n\\n p = conformer_layer.LConvLayer.CommonParams(input_dim=dim, kernel_size=3)\\n p.name = 'lconv_layer'\\n if norm == 'gn':\\n # default is bn\\n p.conv_norm_layer_tpl = (\\n bn_layers.GroupNormLayer.Params().Set(num_groups=2))\\n elif norm != 'bn':\\n raise ValueError('Only gn and bn are supported.')\\n\\n l = p.Instantiate()\\n outputs = l.FPropDefaultTheta(inputs, paddings)\\n\\n with self.session() as sess:\\n tf.global_variables_initializer().run()\\n out_vals = sess.run(outputs)\\n print([x.shape for x in out_vals])\\n\\n\\nclass LConvLayerStreamStepTest(stream_step_test_base.StreamStepTestBase):\\n\\n def _GetParams(self, **kwargs):\\n input_dim = kwargs['input_dim']\\n kernel = kwargs['kernel']\\n norm_type = kwargs['norm_type']\\n\\n p = conformer_layer.LConvLayer.CommonParams(\\n input_dim=input_dim, is_causal=True, kernel_size=kernel)\\n if norm_type == 'ln':\\n p.conv_norm_layer_tpl = lingvo_layers.LayerNorm.Params()\\n else:\\n p.conv_norm_layer_tpl = bn_layers.GroupNormLayer.Params().Set(\\n num_groups=2, cumulative=True)\\n p.name = 'lconv'\\n return p\\n\\n def _FProp(self, layer, inputs, paddings):\\n return layer.FProp(layer.theta, inputs, paddings)\\n\\n def _StreamStep(self, layer, step_inputs, step_paddings, state):\\n return layer.StreamStep(layer.theta, step_inputs, step_paddings, state)\\n\\n def _GetFPropOutput(self, fprop_out):\\n return fprop_out[0], fprop_out[1]\\n\\n @parameterized.named_parameters(\\n ('Basic',),\\n ('BasicGN', False, 'gn'),\\n ('SkipNorm', True),\\n )\\n def testLeftContext(self, testonly_skip_norm_layers=False, norm_type='ln'):\\n with flagsaver.flagsaver(testonly_skip_norm_layers=testonly_skip_norm_layers\\n ), cluster_factory.SetEval(True):\\n assert norm_type in ('ln', 'gn')\\n input_dim, kernel = 2, 3\\n self._TestStreamStepHelper(\\n num_heads=2, input_dim=input_dim, kernel=kernel, norm_type=norm_type)\\n\\n\\nclass ConformerLayerTest(test_utils.TestCase, parameterized.TestCase):\\n\\n def __init__(self, *args):\\n super().__init__(*args)\\n self.batch_size = 2\\n self.maxlen = 32\\n self.dim = 4\\n self.heads = 2\\n self.context = 2\\n\\n def _GetCommonParamsKwargs(self):\\n return dict(\\n input_dim=self.dim,\\n atten_num_heads=self.heads,\\n atten_left_context=self.context + 1,\\n atten_right_context=self.context,\\n kernel_size=3,\\n fflayer_hidden_dim=4 * self.dim)\\n\\n def _GetParams(self, **custom_kwargs):\\n kwargs = self._GetCommonParamsKwargs()\\n kwargs.update(custom_kwargs)\\n p = conformer_layer.ConformerLayer.CommonParams(**kwargs)\\n p.name = 'conformer_layer'\\n return p\\n\\n def _GetInputs(self, dtype=tf.float32):\\n inputs = np.random.rand(self.batch_size, self.maxlen,\\n self.dim).astype(np.float32)\\n paddings = np.zeros((self.batch_size, self.maxlen), np.float32)\\n\\n seqlen = np.random.randint(0, self.maxlen, size=(self.batch_size,))\\n for i in range(self.batch_size):\\n for j in range(self.maxlen):\\n paddings[i][j] = 1. if j >= seqlen[i] else 0.\\n return tf.constant(inputs, dtype=dtype), tf.constant(paddings, dtype=dtype)\\n\\n def _GetGrad(self, l, inputs, paddings):\\n in_nmap = py_utils.NestedMap(features=inputs, paddings=paddings)\\n out_nmap = l.FPropDefaultTheta(in_nmap)\\n loss = tf.reduce_sum(out_nmap.features)\\n grads = tf.gradients(\\n loss,\\n l.vars.Flatten(),\\n unconnected_gradients=tf.UnconnectedGradients.ZERO)\\n return out_nmap.features, grads\\n\\n @parameterized.named_parameters(\\n ('Base',),\\n ('Reordered', 'conv_before_mhsa'),\\n ('NoLConv', 'mhsa', False),\\n ('NoMhsa', 'conv', True),\\n ('NoFFStart', 'mhsa_before_conv', True, False),\\n ('Transformer', 'mhsa', False, False),\\n )\\n def testBasic(self,\\n layer_order='mhsa_before_conv',\\n has_lconv=True,\\n has_fflayer_start=True):\\n p = self._GetParams()\\n p.layer_order = layer_order\\n if not has_lconv:\\n p.lconv_tpl = None\\n if not has_fflayer_start:\\n p.fflayer_start_tpl = None\\n\\n l = p.Instantiate()\\n inputs, paddings = self._GetInputs()\\n outputs, grads = self._GetGrad(l, inputs, paddings)\\n\\n with self.session() as sess:\\n tf.global_variables_initializer().run()\\n out_vals = sess.run(outputs)\\n grad_vals = sess.run(grads)\\n print([x.shape for x in out_vals])\\n print([g.shape for g in grad_vals])\\n\\n @parameterized.named_parameters(\\n ('F32FPropF32Input', tf.float32, tf.float32),\\n ('F32FPropBF16Input', tf.float32, tf.bfloat16),\\n ('BF16FPropF32Input', tf.bfloat16, tf.float32),\\n ('BF16FPropBF16Input', tf.bfloat16, tf.bfloat16),\\n )\\n def testFPropDtypes(self, fprop_dtype, input_dtype):\\n p = self._GetParams()\\n # batch_norm does not support bfloat16 on CPU.\\n p.lconv_tpl.conv_norm_layer_tpl = (\\n bn_layers.GroupNormLayer.Params().Set(num_groups=2))\\n p.cls.SetFPropDtype(p, fprop_dtype)\\n\\n l = p.Instantiate()\\n inputs, paddings = self._GetInputs(dtype=input_dtype)\\n outputs, grads = self._GetGrad(l, inputs, paddings)\\n\\n with self.session() as sess:\\n tf.global_variables_initializer().run()\\n out_vals = sess.run(outputs)\\n grad_vals = sess.run(grads)\\n print([x.shape for x in out_vals])\\n print([g.shape for g in grad_vals])\\n\\n @parameterized.named_parameters(\\n ('DefaultFp32', [], tf.float32),\\n ('RegexDtypeFp16', [(r'.*(fflayer_[01]|linear_start|post)/w$', tf.float16)\\n ], tf.float16),\\n )\\n def testFPropDtypesWithListRegexDtypes(self, regex_dtypes, target_dtype):\\n p = self._GetParams()\\n p.lconv_tpl.conv_norm_layer_tpl = (\\n bn_layers.GroupNormLayer.Params().Set(num_groups=2))\\n p.list_regex_dtypes = regex_dtypes\\n\\n l = p.Instantiate()\\n inputs, paddings = self._GetInputs()\\n outputs, grads = self._GetGrad(l, inputs, paddings)\\n\\n with self.session() as sess:\\n tf.global_variables_initializer().run()\\n out_vals = sess.run(outputs)\\n grad_vals = sess.run(grads)\\n print([x.shape for x in out_vals])\\n print([g.shape for g in grad_vals])\\n\\n tf.assert_type(l.vars.fflayer_start.fflayer.fc[0].w, target_dtype)\\n tf.assert_type(l.vars.fflayer_start.fflayer.fc[1].w, target_dtype)\\n tf.assert_type(l.vars.fflayer_end.fflayer.fc[0].w, target_dtype)\\n tf.assert_type(l.vars.fflayer_end.fflayer.fc[1].w, target_dtype)\\n tf.assert_type(l.vars.lconv.linear_start.w, target_dtype)\\n tf.assert_type(l.vars.trans_atten.atten.post.w, target_dtype)\\n\\n @parameterized.named_parameters(\\n ('Start', True, False),\\n ('End', False, True),\\n ('StartAndEnd', True, True),\\n ('None', False, False),\\n )\\n def testMoEFFLayerClassMethodInitParity(self, use_fflayer_start_moe,\\n use_fflayer_end_moe):\\n \\\"\\\"\\\"Tests Conformer-MoE initializations via classmethods and explicitly.\\\"\\\"\\\"\\n\\n num_experts, num_groups, num_devices, per_expert_capacity_dim = 2, 2, 2, 2\\n # Create params setting MoEBuilder params explicitly.\\n ref_kwargs = dict()\\n if use_fflayer_start_moe:\\n # Set MoEBuilder params explicitly.\\n ref_kwargs['fflayer_start_tpl'] = gshard_builder.MoEBuilder.Params().Set(\\n e_dim=num_experts,\\n c_dim=per_expert_capacity_dim,\\n num_devices=num_devices,\\n num_groups=num_groups)\\n if use_fflayer_end_moe:\\n ref_kwargs['fflayer_end_tpl'] = gshard_builder.MoEBuilder.Params().Set(\\n e_dim=num_experts,\\n c_dim=per_expert_capacity_dim,\\n num_devices=num_devices,\\n num_groups=num_groups)\\n ref_p = self._GetParams(**ref_kwargs)\\n\\n # Params setting MoEBuilder params via classmethod.\\n moe_kwargs = dict()\\n if use_fflayer_start_moe:\\n # Set MoEBuilder params via classmethod.\\n moe_kwargs['fflayer_start_tpl'] = conformer_layer.GShardMoELayerParams(\\n num_devices, num_groups, num_experts, per_expert_capacity_dim)\\n if use_fflayer_end_moe:\\n moe_kwargs['fflayer_end_tpl'] = conformer_layer.GShardMoELayerParams(\\n num_devices, num_groups, num_experts, per_expert_capacity_dim)\\n moe_p = self._GetParams(**moe_kwargs)\\n # Verify layer params are equal in both cases.\\n with self.subTest('testParamsParity'):\\n self.assertCountEqual(ref_p.ToText().split('\\\\n'),\\n moe_p.ToText().split('\\\\n'))\\n\\n # Test both initializations and verify moe sublayer.\\n with self.subTest('testInit'):\\n ref_p.name = 'ref_moe_conformer_layer'\\n ref_layer = ref_p.Instantiate()\\n moe_p.name = 'classmethod_moe_conformer_layer'\\n moe_layer = moe_p.Instantiate()\\n for layer in (ref_layer, moe_layer):\\n if use_fflayer_start_moe:\\n self.assertNotIn('fflayer_start', layer.children)\\n self.assertIn('fflayer_start_moe', layer.children)\\n if use_fflayer_end_moe:\\n self.assertNotIn('fflayer_end', layer.children)\\n self.assertIn('fflayer_end_moe', layer.children)\\n\\n @parameterized.named_parameters(\\n ('Start', True, False, 0.593693),\\n ('End', False, True, 0.4582923),\\n ('StartAndEnd', True, True, 1.0213419),\\n ('None', False, False, 0.0),\\n )\\n def testMoEFFLayerFProp(self, use_fflayer_start_moe, use_fflayer_end_moe,\\n expected_aux_loss):\\n kwargs = {}\\n if use_fflayer_start_moe:\\n kwargs['fflayer_start_tpl'] = gshard_builder.MoEBuilder.Params().Set(\\n e_dim=2, c_dim=2, num_devices=2)\\n if use_fflayer_end_moe:\\n kwargs['fflayer_end_tpl'] = gshard_builder.MoEBuilder.Params().Set(\\n e_dim=2, c_dim=2, num_devices=2)\\n p = self._GetParams(**kwargs)\\n l = p.Instantiate()\\n inputs, paddings = self._GetInputs()\\n inputs = tf.convert_to_tensor(inputs)\\n paddings = tf.convert_to_tensor(paddings)\\n in_nmap = py_utils.NestedMap(features=inputs, paddings=paddings)\\n in_nmap.aux_loss = tf.convert_to_tensor(0., py_utils.FPropDtype(p))\\n out_nmap = l.FPropDefaultTheta(in_nmap)\\n self.assertIn('aux_loss', out_nmap)\\n loss = tf.reduce_sum(out_nmap.features) + 0.01 * out_nmap.aux_loss\\n grads = tf.gradients(\\n loss,\\n l.vars.Flatten(),\\n unconnected_gradients=tf.UnconnectedGradients.ZERO)\\n\\n with self.session() as sess:\\n tf.global_variables_initializer().run()\\n out_vals = sess.run(out_nmap.features)\\n grad_vals = sess.run(grads)\\n self.assertEqual(out_nmap.aux_loss.shape, ())\\n aux_loss = sess.run(out_nmap.aux_loss)\\n self.assertAlmostEqual(expected_aux_loss, aux_loss, places=5)\\n print([x.shape for x in out_vals])\\n print([g.shape for g in grad_vals])\\n\\n def testRemat(self):\\n inputs, paddings = self._GetInputs()\\n base_p = self._GetParams()\\n base_p.name = 'base'\\n base_p.layer_order = 'conv_before_mhsa'\\n\\n new_p = base_p.Copy()\\n new_p.name = 'new'\\n new_p.remat = True\\n\\n base_l = base_p.Instantiate()\\n new_l = new_p.Instantiate()\\n\\n _, base_grads = self._GetGrad(base_l, inputs, paddings)\\n base_grads = base_l.vars.Pack(base_grads)\\n\\n _, new_grads = self._GetGrad(new_l, inputs, paddings)\\n new_grads = new_l.vars.Pack(new_grads)\\n\\n assign_op = [\\n tf.assign(dst, src)\\n for (src, dst) in zip(base_l.vars.Flatten(), new_l.vars.Flatten())\\n ]\\n init_op = tf.global_variables_initializer()\\n with self.session() as sess:\\n sess.run(init_op)\\n sess.run(assign_op)\\n base_grads_val = sess.run(base_grads)\\n new_grads_val = sess.run(new_grads)\\n\\n for (k, v1), (_, v2) in zip(base_grads_val.FlattenItems(),\\n new_grads_val.FlattenItems()):\\n self.assertAllClose(v1, v2, msg=k)\\n\\n @parameterized.named_parameters(\\n ('Basic',),\\n ('NegativeLocalContext', -1),\\n ('NegativeLeftContext', None, -1, None),\\n ('NegativeRightContext', None, None, -1),\\n ('NegativeContext1', -1, None, -1),\\n ('NegativeContext2', None, -1, -1),\\n ('NegativeContext3', -1, -1, None),\\n ('NegativeContext4', -1, None, -1),\\n ('NegativeContext5', -1, -1, -1),\\n ('NegativeContext6', None, None, None),\\n )\\n def testAttenContextParams(self,\\n local_context=None,\\n left_context=None,\\n right_context=None):\\n \\\"\\\"\\\"Tests atten context cfg params.\\\"\\\"\\\"\\n inputs, paddings = self._GetInputs()\\n base_p_kwargs = self._GetCommonParamsKwargs()\\n base_p_kwargs['atten_local_context'] = None\\n base_p_kwargs['atten_left_context'] = None\\n base_p_kwargs['atten_right_context'] = None\\n base_p = conformer_layer.ConformerLayer.CommonParams(**base_p_kwargs)\\n base_p.name = 'base'\\n base_p.layer_order = 'conv_before_mhsa'\\n\\n new_p_kwargs = self._GetCommonParamsKwargs()\\n new_p_kwargs['atten_local_context'] = local_context\\n new_p_kwargs['atten_left_context'] = left_context\\n new_p_kwargs['atten_right_context'] = right_context\\n new_p = conformer_layer.ConformerLayer.CommonParams(**new_p_kwargs)\\n new_p.name = 'new'\\n new_p.layer_order = 'conv_before_mhsa'\\n\\n base_l = base_p.Instantiate()\\n new_l = new_p.Instantiate()\\n\\n _, base_grads = self._GetGrad(base_l, inputs, paddings)\\n base_grads = base_l.vars.Pack(base_grads)\\n\\n _, new_grads = self._GetGrad(new_l, inputs, paddings)\\n new_grads = new_l.vars.Pack(new_grads)\\n\\n assign_op = [\\n tf.assign(dst, src)\\n for (src, dst) in zip(base_l.vars.Flatten(), new_l.vars.Flatten())\\n ]\\n init_op = tf.global_variables_initializer()\\n with self.session() as sess:\\n sess.run(init_op)\\n sess.run(assign_op)\\n base_grads_val = sess.run(base_grads)\\n new_grads_val = sess.run(new_grads)\\n\\n for (k, v1), (_, v2) in zip(base_grads_val.FlattenItems(),\\n new_grads_val.FlattenItems()):\\n self.assertAllClose(v1, v2, msg=k)\\n\\n def testCustomAttentionLayer(self):\\n p = self._GetParams()\\n # Use a custom atten_tpl.\\n p.trans_atten_tpl.atten_tpl = (\\n batch_major_attention.MultiHeadedFavorAttention.Params().Set(\\n num_random_features=4))\\n layer = p.Instantiate()\\n self.assertIsInstance(layer.trans_atten.atten,\\n batch_major_attention.MultiHeadedFavorAttention)\\n\\n @parameterized.named_parameters(\\n ('Basic', 8, 'SWISH', 0.5),\\n ('BasicReLU', 16, 'RELU', 1.),\\n )\\n def testFFlayerParams(self,\\n fflayer_hidden_dim=None,\\n fflayer_activation=None,\\n fflayer_residual_weight=0.5):\\n p = self._GetParams(\\n fflayer_hidden_dim=fflayer_hidden_dim,\\n fflayer_activation=fflayer_activation,\\n fflayer_residual_weight=fflayer_residual_weight)\\n layer = p.Instantiate()\\n\\n start_fflayer = layer.fflayer_start\\n actual_start_hidden_dim = start_fflayer.params.hidden_dim\\n actual_start_activation = start_fflayer.params.activation\\n actual_start_residual_weight = start_fflayer.params.residual_weight\\n end_fflayer = layer.fflayer_end\\n actual_end_hidden_dim = end_fflayer.params.hidden_dim\\n actual_end_activation = end_fflayer.params.activation\\n actual_end_residual_weight = end_fflayer.params.residual_weight\\n\\n self.assertEqual(fflayer_hidden_dim, actual_start_hidden_dim)\\n self.assertEqual(fflayer_activation, actual_start_activation)\\n self.assertEqual(fflayer_residual_weight, actual_start_residual_weight)\\n self.assertEqual(fflayer_hidden_dim, actual_end_hidden_dim)\\n self.assertEqual(fflayer_activation, actual_end_activation)\\n self.assertEqual(fflayer_residual_weight, actual_end_residual_weight)\\n\\n @parameterized.named_parameters(\\n ('shared', True),\\n ('not_shared', False),\\n )\\n def testFFlayerWeightSharing(self, fflayer_weight_sharing):\\n p = self._GetParams()\\n p.fflayer_weight_sharing = fflayer_weight_sharing\\n layer = p.Instantiate()\\n\\n # FFLayer variables will all have same full name iif weights are shared.\\n def _VarNamesDebugString(vars_):\\n return py_utils.Transform(lambda x: x.name, vars_).DebugString()\\n\\n fflayer_start_var_names = _VarNamesDebugString(layer.fflayer_start.vars)\\n fflayer_end_var_names = _VarNamesDebugString(layer.fflayer_end.vars)\\n\\n self.assertEqual(fflayer_weight_sharing,\\n (fflayer_start_var_names == fflayer_end_var_names))\\n\\n def testCommonParamsAbuse(self):\\n \\\"\\\"\\\"Checks CommonParams() is not called in __init__().\\\"\\\"\\\"\\n p = self._GetParams()\\n with mock.patch(\\n 'lingvo.core.conformer_layer.ConformerLayer.CommonParams',\\n autospec=True) as m1:\\n with mock.patch(\\n 'lingvo.core.conformer_layer.LConvLayer.CommonParams',\\n autospec=True) as m2:\\n p.Instantiate()\\n self.assertFalse(m1.called)\\n self.assertFalse(m2.called)\\n\\n @parameterized.named_parameters(\\n ('WithoutRelPosAtten', False),\\n ('WithRelPosAtten', True),\\n )\\n def testApplyGShard(self, use_relative_atten):\\n with self.session() as sess:\\n conformer_p = conformer_layer.ConformerLayer.CommonParams(\\n input_dim=self.dim,\\n atten_num_heads=self.heads,\\n atten_local_context=self.context,\\n use_relative_atten=use_relative_atten,\\n kernel_size=2,\\n fflayer_hidden_dim=4 * self.dim)\\n conformer_p.name = 'conformer_layer'\\n conformer_layer.ApplyGshard(\\n conformer_p,\\n device_mesh=[1, 2],\\n proj_w_split_list=[[0, 1], [1, 0]],\\n proj_activation_split_list=[[0, -1, 1], [0, -1, -1]],\\n atten_dnh_w_split=[0, 1, -1],\\n atten_blnh_activation_split=[0, -1, 1, -1],\\n atten_bld_activation_split=[0, -1, -1],\\n lconv_df_w_split=[0, 1],\\n lconv_hwim_w_split=[-1, -1, 1, -1],\\n lconv_fd_w_split=[-1, -1],\\n lconv_blf_activation_split=[0, -1, 1],\\n lconv_bld_activation_split=[0, -1, -1])\\n inputs, paddings = self._GetInputs()\\n conformer_l = conformer_p.Instantiate()\\n outputs = conformer_l.FProp(\\n conformer_l.theta,\\n py_utils.NestedMap(\\n features=tf.convert_to_tensor(inputs),\\n paddings=tf.convert_to_tensor(paddings)))\\n tf.logging.info('outputs=%s', outputs)\\n tf.global_variables_initializer().run()\\n out_vals = sess.run(outputs)\\n print([x.shape for x in out_vals.Flatten()])\\n\\n @parameterized.named_parameters(\\n ('Dropout', 'dropout_prob', 0.1),\\n ('LayerOrder', 'layer_order', 'conv_before_mhsa'),\\n ('FFLayerActivation', 'fflayer_activation', 'GELU'),\\n ('UseRelativeAttentionTrue', 'use_relative_atten', True),\\n ('UseRelativeAttentionFalse', 'use_relative_atten', False),\\n ('IsCausal', 'is_causal', True),\\n ('ListRegexDtypes', 'list_regex_dtypes', [('test_regex', tf.float16)]))\\n def testCommonParamsSet(self, param_name, param_val):\\n \\\"\\\"\\\"Checks values set in CommonParams() correctly.\\\"\\\"\\\"\\n\\n def _GetMinimalCommonParamsKwargs():\\n \\\"\\\"\\\"These args are required to be set to call CommonParams.\\\"\\\"\\\"\\n return dict(\\n input_dim=2, atten_num_heads=4, kernel_size=3, fflayer_hidden_dim=8)\\n\\n kwargs = _GetMinimalCommonParamsKwargs()\\n kwargs.update({param_name: param_val})\\n if param_name == 'is_causal' and param_val:\\n kwargs['atten_right_context'] = 0\\n kwargs['use_relative_atten'] = False\\n p = conformer_layer.ConformerLayer.CommonParams(**kwargs)\\n p.name = 'conformer_layer'\\n if param_name == 'use_relative_atten':\\n atten_cls = p.trans_atten_tpl.atten_tpl.cls\\n if param_val:\\n self.assertTrue(\\n issubclass(atten_cls, batch_major_attention.MultiHeadedAttentionXL),\\n msg=atten_cls)\\n else:\\n self.assertTrue(\\n issubclass(atten_cls, batch_major_attention.MultiHeadedAttention),\\n msg=atten_cls)\\n elif param_name == 'fflayer_activation':\\n self.assertEqual(p.fflayer_start_tpl.activation, param_val)\\n self.assertEqual(p.fflayer_end_tpl.activation, param_val)\\n else:\\n self.assertEqual(p.Get(param_name), param_val)\\n\\n\\nclass ConformerLayerStreamStepTest(stream_step_test_base.StreamStepTestBase):\\n\\n def _GetParams(self, **kwargs):\\n input_dim = kwargs['input_dim']\\n kernel = kwargs['kernel']\\n layer_order = kwargs['layer_order']\\n num_heads = kwargs['num_heads']\\n left_context = kwargs['left_context']\\n right_context = kwargs['right_context']\\n ffn_dim = kwargs['ffn_dim']\\n # optional params.\\n norm_type = kwargs.get('norm_type', 'gn')\\n has_lconv = kwargs.get('has_lconv', 'conv2d')\\n has_fflayer_start = kwargs.get('has_fflayer_start', True)\\n query_stride = kwargs.get('query_stride', 1)\\n num_groups = kwargs.get('num_groups', 2)\\n\\n if layer_order == 'mhsa':\\n kernel = None\\n has_lconv = False\\n p = conformer_layer.ConformerLayer.CommonParams(\\n input_dim=input_dim,\\n is_causal=True,\\n atten_num_heads=num_heads,\\n atten_left_context=left_context,\\n atten_right_context=right_context,\\n use_relative_atten=False,\\n query_stride=query_stride,\\n fflayer_hidden_dim=ffn_dim,\\n kernel_size=kernel,\\n layer_order=layer_order)\\n if not has_lconv:\\n p.lconv_tpl = None\\n else:\\n if norm_type == 'ln':\\n p.lconv_tpl.conv_norm_layer_tpl = lingvo_layers.LayerNorm.Params()\\n else:\\n p.lconv_tpl.conv_norm_layer_tpl = bn_layers.GroupNormLayer.Params().Set(\\n num_groups=num_groups, cumulative=True)\\n if has_lconv == 'conv2d':\\n p.lconv_tpl.depthwise_conv_tpl = (\\n conv_layers_with_time_padding.CausalConv2DLayerWithPadding.Params())\\n else:\\n assert has_lconv == 'depthwise'\\n if not has_fflayer_start:\\n p.fflayer_start_tpl = None\\n\\n p.name = 'conformer'\\n return p\\n\\n def _FProp(self, layer, inputs, paddings):\\n return layer.FProp(layer.theta,\\n py_utils.NestedMap(features=inputs, paddings=paddings))\\n\\n def _StreamStep(self, layer, step_inputs, step_paddings, state):\\n return layer.StreamStep(layer.theta, step_inputs, step_paddings, state)\\n\\n def _GetFPropOutput(self, fprop_out):\\n return fprop_out.features, fprop_out.paddings\\n\\n @parameterized.named_parameters(\\n {\\n 'testcase_name': 'Basic',\\n },\\n {\\n 'testcase_name': 'BasicGN',\\n 'norm_type': 'gn'\\n },\\n {\\n 'testcase_name': 'BasicGN1',\\n 'norm_type': 'gn',\\n 'num_groups': 1\\n },\\n {\\n 'testcase_name': 'BasicGN8',\\n 'norm_type': 'gn',\\n 'num_groups': 8\\n },\\n {\\n 'testcase_name': 'SkipNorm',\\n 'testonly_skip_norm_layers': True\\n },\\n {\\n 'testcase_name': 'SkipNormGN',\\n 'testonly_skip_norm_layers': True,\\n 'norm_type': 'gn'\\n },\\n {\\n 'testcase_name': 'SkipNormGNR1',\\n 'testonly_skip_norm_layers': True,\\n 'norm_type': 'gn',\\n 'right_context': 1,\\n },\\n {\\n 'testcase_name': 'SkipNormGNR2',\\n 'testonly_skip_norm_layers': True,\\n 'norm_type': 'gn',\\n 'right_context': 2,\\n },\\n {\\n 'testcase_name': 'SkipNormGNStride2',\\n 'testonly_skip_norm_layers': True,\\n 'norm_type': 'gn',\\n 'stride': 2\\n },\\n {\\n 'testcase_name': 'SkipNormGNStride4',\\n 'testonly_skip_norm_layers': True,\\n 'norm_type': 'gn',\\n 'stride': 4\\n },\\n {\\n 'testcase_name': 'SkipNormGNStride2R1',\\n 'testonly_skip_norm_layers': True,\\n 'norm_type': 'gn',\\n 'stride': 2,\\n 'right_context': 1\\n },\\n {\\n 'testcase_name': 'SkipNormGNStride4R2',\\n 'testonly_skip_norm_layers': True,\\n 'norm_type': 'gn',\\n 'stride': 4,\\n 'right_context': 2\\n },\\n {\\n 'testcase_name': 'Reordered',\\n 'layer_order': 'mhsa_before_conv'\\n },\\n {\\n 'testcase_name': 'Conv2D',\\n 'has_lconv': 'conv2d',\\n },\\n {\\n 'testcase_name': 'NoLConv',\\n 'layer_order': 'mhsa',\\n 'has_lconv': False\\n },\\n {\\n 'testcase_name': 'NoMhsa',\\n 'layer_order': 'conv'\\n },\\n {\\n 'testcase_name': 'NoFFStart',\\n 'layer_order': 'conv_before_mhsa',\\n 'has_fflayer_start': False\\n },\\n {\\n 'testcase_name': 'Transformer',\\n 'layer_order': 'mhsa',\\n 'has_lconv': False,\\n 'has_fflayer_start': False\\n },\\n {\\n 'testcase_name': 'TransformerSkipNormR2',\\n 'testonly_skip_norm_layers': True,\\n 'layer_order': 'mhsa',\\n 'has_lconv': False,\\n 'has_fflayer_start': False,\\n 'right_context': 2,\\n },\\n {\\n 'testcase_name': 'Funnel',\\n 'stride': 2,\\n 'query_stride': 2,\\n },\\n {\\n 'testcase_name': 'FunnelStride4',\\n 'stride': 4,\\n 'query_stride': 2,\\n },\\n )\\n def testCommon(self,\\n testonly_skip_norm_layers=False,\\n norm_type='ln',\\n num_groups=2,\\n stride=1,\\n query_stride=1,\\n layer_order='conv_before_mhsa',\\n has_lconv='depthwise',\\n has_fflayer_start=True,\\n right_context=0):\\n assert norm_type in ('ln', 'gn'), norm_type\\n kwargs = dict(\\n input_dim=8,\\n kernel=3,\\n layer_order=layer_order,\\n num_heads=2,\\n left_context=3,\\n right_context=right_context,\\n ffn_dim=4,\\n stride=stride,\\n query_stride=query_stride,\\n norm_type=norm_type,\\n has_lconv=has_lconv,\\n has_fflayer_start=has_fflayer_start,\\n num_groups=num_groups)\\n kwargs['tol'] = 1e-5\\n with cluster_factory.SetEval(True), flagsaver.flagsaver(\\n testonly_skip_norm_layers=testonly_skip_norm_layers):\\n self._TestStreamStepHelper(**kwargs)\\n\\n def testStackingLayerWithRightContext(self):\\n tf.random.set_seed(2021)\\n kwargs = dict(\\n input_dim=8,\\n kernel=3,\\n num_heads=2,\\n left_context=6,\\n right_context=3,\\n ffn_dim=4,\\n stride=2,\\n layer_order='mhsa_before_conv',\\n num_layers=3)\\n with cluster_factory.SetEval(True):\\n self._TestRightContextStackingLayersHelper(**kwargs)\\n\\n\\nif __name__ == '__main__':\\n tf.test.main()\\n\",\n \"# Lint as: python3\\n# 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\\\"\\\"\\\"Attention models.\\\"\\\"\\\"\\n\\nimport math\\nimport lingvo.compat as tf\\nfrom lingvo.core import base_layer\\nfrom lingvo.core import gshard_utils\\nfrom lingvo.core import layers\\nfrom lingvo.core import py_utils\\nfrom lingvo.core import quant_utils\\nfrom lingvo.core import symbolic\\n\\nimport numpy as np\\n\\nfrom tensorflow.python.ops import inplace_ops # pylint:disable=g-direct-tensorflow-import\\n\\n\\n# Currently, quantization statistics cannot be accumulated across arbitrary\\n# defuns, so we allow them to be disabled. A potentially more robust fix is\\n# to save and merge the attention state across the defun boundary as is\\n# done in recurrent.py.\\ndef _ConditionalCallDefun(cond, f, inputs):\\n if not cond:\\n return f(inputs)\\n return py_utils.CallDefun(f, inputs)\\n\\n\\ndef _ApplyAttentionDropout(params, x):\\n \\\"\\\"\\\"Apply attention dropout according to the given parameters.\\n\\n If `params.atten_dropout_deterministic` is set to True, the dropout will be\\n fully deterministic.\\n\\n Args:\\n params: The parameters of attention layer.\\n x: A float Tensor on which to apply dropout.\\n\\n Returns:\\n A Tensor with the same shape as `x`.\\n \\\"\\\"\\\"\\n if params.atten_dropout_prob == 0:\\n return x\\n\\n if params.atten_dropout_deterministic:\\n seeds = py_utils.GenerateStepSeedPair(params)\\n return py_utils.DeterministicDropout(x, 1.0 - params.atten_dropout_prob,\\n seeds)\\n else:\\n return tf.nn.dropout(\\n x, rate=params.atten_dropout_prob, seed=params.random_seed)\\n\\n\\ndef SafeCumprod(x, *args, **kwargs):\\n \\\"\\\"\\\"Computes cumprod of x in logspace using cumsum to avoid underflow.\\n\\n The cumprod function and its gradient can result in numerical instabilities\\n when its argument has very small and/or zero values. As long as the argument\\n is all positive, we can instead compute the cumulative product as\\n exp(cumsum(log(x))). This function can be called identically to\\n tf.math.cumprod.\\n\\n Args:\\n x: Tensor to take the cumulative product of.\\n *args: Passed on to cumsum; these are identical to those in cumprod.\\n **kwargs: Passed on to cumsum; these are identical to those in cumprod.\\n\\n Returns:\\n Cumulative product of x.\\n \\\"\\\"\\\"\\n with tf.name_scope(None, 'SafeCumprod', [x]):\\n x = tf.convert_to_tensor(x, name='x')\\n tiny = np.finfo(x.dtype.as_numpy_dtype).tiny\\n return tf.exp(\\n py_utils.CumSum(\\n tf.math.log(tf.clip_by_value(x, tiny, 1)), *args, **kwargs))\\n\\n\\n# pyformat: disable\\ndef MonotonicAttentionProb(p_choose_i, previous_attention, mode):\\n \\\"\\\"\\\"Compute monotonic attention distribution from choosing probabilities.\\n\\n Monotonic attention implies that the input sequence is processed in an\\n explicitly left-to-right manner when generating the output sequence. In\\n addition, once an input sequence element is attended to at a given output\\n timestep, elements occurring before it cannot be attended to at subsequent\\n output timesteps. This function generates attention distributions according\\n to these assumptions. For more information, see `Online and Linear-Time\\n Attention by Enforcing Monotonic Alignments`.\\n\\n Args:\\n p_choose_i: Probability of choosing input sequence/memory element i. Should\\n be of shape (batch_size, input_sequence_length), and should all be in the\\n range [0, 1].\\n previous_attention: The attention distribution from the previous output\\n timestep. Should be of shape (batch_size, input_sequence_length). For\\n the first output timestep, preevious_attention[n] should be [1, 0, 0, ...,\\n 0] for all n in [0, ... batch_size - 1].\\n mode: How to compute the attention distribution. Must be one of `recursive`,\\n `parallel`, or `hard`.\\n\\n * recursive: uses tf.scan to recursively compute the distribution. This is\\n slowest but is exact, general, and does not suffer from numerical\\n instabilities.\\n * parallel: uses parallelized cumulative-sum and cumulative-product\\n operations to compute a closed-form solution to the recurrence relation\\n defining the attention distribution. This makes it more efficient than\\n 'recursive', but it requires numerical checks which make the\\n distribution non-exact. This can be a problem in particular when\\n input_sequence_length is long and/or p_choose_i has entries very close\\n to 0 or 1.\\n * hard: requires that the probabilities in p_choose_i are all either 0 or\\n 1, and subsequently uses a more efficient and exact solution.\\n\\n Returns:\\n A tensor of shape (batch_size, input_sequence_length) representing the\\n attention distributions for each sequence in the batch.\\n\\n Raises:\\n ValueError: mode is not one of 'recursive', 'parallel', 'hard'.\\n \\\"\\\"\\\"\\n # pyformat: enable\\n # Force things to be tensors\\n p_choose_i = tf.convert_to_tensor(p_choose_i, name='p_choose_i')\\n previous_attention = tf.convert_to_tensor(\\n previous_attention, name='previous_attention')\\n if mode == 'recursive':\\n batch_size = py_utils.GetShape(p_choose_i)[0]\\n tf.logging.info(batch_size)\\n # Compute [1, 1 - p_choose_i[0], 1 - p_choose_i[1], ..., 1 - p_choose_i[-2]]\\n shifted_1mp_choose_i = tf.concat(\\n [tf.ones((batch_size, 1)), 1 - p_choose_i[:, :-1]], 1)\\n # Compute attention distribution recursively as\\n # q[i] = (1 - p_choose_i[i - 1])*q[i - 1] + previous_attention[i]\\n # attention[i] = p_choose_i[i]*q[i]\\n attention = p_choose_i * tf.transpose(\\n tf.scan(\\n # Need to use reshape to remind TF of the shape between loop\\n # iterations.\\n lambda x, yz: tf.reshape(yz[0] * x + yz[1], (batch_size,)),\\n # Loop variables yz[0] and yz[1]\\n [\\n tf.transpose(shifted_1mp_choose_i),\\n tf.transpose(previous_attention)\\n ],\\n # Initial value of x is just zeros\\n tf.zeros((batch_size,))))\\n elif mode == 'parallel':\\n # SafeCumprod computes cumprod in logspace with numeric checks\\n cumprod_1mp_choose_i = SafeCumprod(1 - p_choose_i, axis=1, exclusive=True)\\n # Compute recurrence relation solution\\n attention = p_choose_i * cumprod_1mp_choose_i * py_utils.CumSum(\\n previous_attention /\\n # Clip cumprod_1mp to avoid divide-by-zero\\n tf.clip_by_value(cumprod_1mp_choose_i, 1e-10, 1.),\\n axis=1)\\n elif mode == 'hard':\\n # Remove any probabilities before the index chosen last time step\\n p_choose_i *= tf.cumsum(previous_attention, axis=1)\\n # Now, use exclusive cumprod to remove probabilities after the first\\n # chosen index, like so:\\n # p_choose_i = [0, 0, 0, 1, 1, 0, 1, 1]\\n # cumprod(1 - p_choose_i, exclusive=True) = [1, 1, 1, 1, 0, 0, 0, 0]\\n # Product of above: [0, 0, 0, 1, 0, 0, 0, 0]\\n attention = p_choose_i * tf.math.cumprod(\\n 1 - p_choose_i, axis=1, exclusive=True)\\n else:\\n raise ValueError(\\\"mode must be 'recursive', 'parallel', or 'hard'.\\\")\\n return attention\\n\\n\\nclass BaseAttentionLayer(quant_utils.QuantizableLayer):\\n \\\"\\\"\\\"A base class for all attention layers.\\\"\\\"\\\"\\n\\n @classmethod\\n def Params(cls):\\n p = super().Params()\\n p.Define('atten_dropout_prob', 0.0,\\n 'Probability at which we apply dropout to the attention weights.')\\n p.Define(\\n 'atten_dropout_deterministic', False,\\n 'Whether to dropout in a fully deterministic way, which is more '\\n 'suitable for TPU.')\\n p.Define('packed_input', False,\\n 'If True, each training example may pack multiple sequences.')\\n\\n p.qdomain.Define('softmax', None, 'QDomain for the internal softmax.')\\n p.qdomain.Define(\\n 'fullyconnected', None, 'Fully connected layers are fed '\\n 'into activation functions which have known input ranges')\\n\\n return p\\n\\n def __init__(self, params):\\n \\\"\\\"\\\"Constructs a BaseAttentionLayer object.\\\"\\\"\\\"\\n if not params.name:\\n raise ValueError('params.name is not set.')\\n super().__init__(params)\\n\\n self._source_init_done = False\\n\\n def _CreateLayerVariables(self):\\n super()._CreateLayerVariables()\\n self.TrackQTensor('logits', domain='fullyconnected')\\n\\n def InitForSourcePacked(self,\\n theta,\\n source_vecs,\\n source_contexts,\\n source_padding,\\n source_segment_id=None):\\n \\\"\\\"\\\"Initialize attention for the given source vectors.\\n\\n Must set `_source_init_done` to True in the function.\\n\\n Note: `source_segment_id`, if present, should always have the same shape as\\n `source_padding`.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n source_vecs: A single tensor of shape [time, batch_size, source_dim].\\n source_contexts: A single tensor of shape [time, batch_size, some_dim].\\n source_padding: A tensor of shape [time, batch_size].\\n source_segment_id: A tensor of shape [time, batch_size]. source_segment_id\\n is not None for packed inputs where one training example may pack\\n multiple sequences.\\n\\n Returns:\\n A `.NestedMap` object to be passed to ComputeContextVectorWithSource.\\n The internal structure of the return value should be considered an\\n implementation detail of the attention mechanism and should not be\\n inspected or modified by its callers.\\n \\\"\\\"\\\"\\n self._source_init_done = True\\n self._packed_src = self.PackSource(theta, source_vecs, source_contexts,\\n source_padding, source_segment_id)\\n return self._packed_src\\n\\n def PackSource(self,\\n theta,\\n source_vecs,\\n source_contexts,\\n source_padding,\\n source_segment_id=None):\\n \\\"\\\"\\\"Packs source vectors.\\n\\n Does not change attention state.\\n\\n Note: `source_segment_id`, if present, should always have the same shape as\\n `source_padding`.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n source_vecs: A single tensor of shape [time, batch_size, source_dim].\\n source_contexts: A single tensor of shape [time, batch_size, some_dim].\\n source_padding: A tensor of shape [time, batch_size].\\n source_segment_id: A tensor of shape [time, batch_size]. source_segment_id\\n is not None for packed inputs where one training example may pack\\n multiple sequences.\\n\\n Returns:\\n A `.NestedMap` object to be passed to ComputeContextVectorWithSource.\\n The internal structure of the return value should be considered an\\n implementation detail of the attention mechanism and should not be\\n inspected or modified by its callers.\\n \\\"\\\"\\\"\\n raise NotImplementedError('Abstract method.')\\n\\n def ComputeContextVectorWithSource(self,\\n theta,\\n packed_src,\\n query_vec,\\n attention_state=None,\\n per_step_source_padding=None,\\n query_segment_id=None):\\n \\\"\\\"\\\"Computes the context vector given the current query output.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n packed_src: A `.NestedMap` object returned by PackSource or\\n InitForSourcePacked.\\n query_vec: a tensor of shape [batch_size, query_dim].\\n attention_state: previous attention state.\\n per_step_source_padding: Source sequence padding to apply at this step. If\\n not None, it should have shape [target_batch_size, source_length].\\n query_segment_id: a tensor of shape [batch_size].\\n\\n Returns:\\n A tuple of 3 elements.\\n\\n - The attention context vector: [batch_size, context_dim]\\n - The attention probability vector: [batch_size, time]\\n - The new attention mechanism state: possibly nested tuple of tensors\\n with dimensions [target_batch, ...]\\n \\\"\\\"\\\"\\n raise NotImplementedError('Abstract method.')\\n\\n def ComputeContextVector(self,\\n theta,\\n query_vec,\\n attention_state=None,\\n per_step_source_padding=None,\\n query_segment_id=None):\\n \\\"\\\"\\\"Computes the context vector given the current query output.\\n\\n Unlike `ComputeContextVectorWithSource` which explicitly asks for the packed\\n source tensors, `ComputeContextVector` uses the class' internal variables.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n query_vec: a tensor of shape [batch_size, query_dim].\\n attention_state: previous attention state.\\n per_step_source_padding: Source sequence padding to apply at this step. If\\n not None, it should be of shape [target_batch_size, source_length].\\n query_segment_id: a tensor of shape [batch_size].\\n\\n Returns:\\n A tuple of 3 elements.\\n\\n - The attention context vector.\\n - The attention probability vector.\\n - The new attention mechanism state: possibly nested tuple of tensors with\\n dimensions [target_batch, ...]\\n \\\"\\\"\\\"\\n assert self._source_init_done\\n return self.ComputeContextVectorWithSource(theta, self._packed_src,\\n query_vec, attention_state,\\n per_step_source_padding,\\n query_segment_id)\\n\\n def GetInitializationSourceState(self):\\n \\\"\\\"\\\"Gets the attention initialization state.\\n\\n The base class only preserves the `concated_source_vecs`,\\n `concated_source_contexts` and `source_padding`. If subclasses use more\\n state than this and need to interact with inference code that must\\n fetch and reload state, this and `SetInitializationSourceState` must\\n be overridden.\\n\\n Returns:\\n A `.NestedMap` of Tensors that can be preserved and reset via\\n `SetInitializationSourceState()` at a later point. This allows, for\\n example, for attention computations to span session runs.\\n \\\"\\\"\\\"\\n assert self._source_init_done\\n return self._packed_src\\n\\n def SetInitializationSourceState(self, new_init_state):\\n \\\"\\\"\\\"Sets the attention initialization state.\\n\\n Args:\\n new_init_state: A `.NestedMap` matching what was returned from\\n `GetInitializationSourceState`, which will return this layer to that\\n initialization state.\\n \\\"\\\"\\\"\\n self._source_init_done = True\\n self._packed_src = new_init_state.DeepCopy()\\n\\n def _PaddedSoftmax(self, logits, padding):\\n \\\"\\\"\\\"Performs a softmax as if padding were applied after exponentiation.\\n\\n The default implementation uses numerical techniques to approximate this\\n with a standard `tf.nn.softmax` (using large negative logits for padded\\n values). It defers to a `Defun` that may be replaced on low-range\\n implementations with a version that is numerically correct.\\n\\n Args:\\n logits: Logits.\\n padding: Padding (must be the same shape as logits).\\n\\n Returns:\\n Result of the softmax.\\n \\\"\\\"\\\"\\n fns = self.fns\\n\\n if logits.dtype.is_complex:\\n logits = tf.abs(logits)\\n assert logits.dtype.is_floating\\n assert hasattr(logits.dtype, 'max')\\n very_negative_logits = (\\n tf.ones_like(logits) * logits.dtype.max *\\n tf.constant(-0.7, dtype=logits.dtype))\\n if self.do_eval:\\n very_negative_logits = self.QTensor('logits', very_negative_logits)\\n padded_logits = tf.where(padding > 0.0, very_negative_logits, logits)\\n # TFLite hardcodes the range of qsoftmax, setting explicitly to avoid\\n # incompatible concats.\\n return fns.qsoftmax(padded_logits, qdomain='softmax')\\n\\n def _UpdatePaddingWithPackedInputMask(self, padding, source_segment_ids,\\n query_segment_ids):\\n \\\"\\\"\\\"Creates an attention mask based on source and query segment ids.\\n\\n This creates a mask that removes invalid attention, where the query vector\\n might assign some weight to neighboring sequences in a packed input example.\\n Assumes `n = target_batch // source_batch`.\\n\\n Args:\\n padding: Padding for logits, a tensor of shape [time, n, source_batch].\\n source_segment_ids: a tensor of shape [time, source_batch].\\n query_segment_ids: a tensor of shape [target_batch].\\n\\n Returns:\\n Logits with mask applied.\\n \\\"\\\"\\\"\\n # Generating packed input mask for attention padding.\\n source_segment_ids = tf.expand_dims(source_segment_ids, 1)\\n query_segment_ids = tf.reshape(\\n query_segment_ids,\\n [1, -1, py_utils.GetShape(source_segment_ids)[2]])\\n padding = tf.where(\\n tf.equal(source_segment_ids, query_segment_ids), padding,\\n tf.ones_like(padding))\\n return padding\\n\\n\\nclass AdditiveAttention(BaseAttentionLayer):\\n \\\"\\\"\\\"Implements additive attention (also known as \\\"Bahdanau Attention\\\").\\n\\n Described in:\\n\\n Dzmitry Bahdanau, Kyunghyun Cho, Yoshua Bengio.\\n \\\"Neural Machine Translation by Jointly Learning to Align and Translate.\\\"\\n ICLR 2015.\\n https://arxiv.org/abs/1409.0473\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def Params(cls):\\n \\\"\\\"\\\"Params for this `AdditiveAttention` class.\\\"\\\"\\\"\\n p = super().Params()\\n p.Define('source_dim', 0, 'Number of source nodes.')\\n p.Define('query_dim', 0, 'Number of query nodes.')\\n p.Define('hidden_dim', 0, 'Number of hidden nodes.')\\n # Fill in reasonable default for params init\\n p.params_init = py_utils.WeightInit.GaussianSqrtDim()\\n p.Define(\\n 'same_batch_size', False,\\n 'True iff the source and target sequence has the same batch size.')\\n return p\\n\\n def __init__(self, params):\\n \\\"\\\"\\\"Constructs an `AdditiveAttention` object.\\\"\\\"\\\"\\n super().__init__(params)\\n p = self.params\\n\\n def AttenProbs(inputs):\\n \\\"\\\"\\\"Generates probs.\\\"\\\"\\\"\\n source_batch = py_utils.GetShape(inputs.source_padding)[1]\\n target_batch = py_utils.GetShape(inputs.per_step_source_padding)[0]\\n multiplier = target_batch // source_batch\\n\\n # Shape of summed is [sl, tb/sb, sb, hidden_dim].\\n summed = tf.tanh(inputs.concated_source_vecs + inputs.query_vec_reshaped)\\n # logits is of shape [sl * tb/sb * sb, 1]. Computes dot product\\n # between v with every rows in 'summed'. Then we reshape the\\n # result to be of shape [sl, tb/sb, sb].\\n #\\n # Another equivalent way is to do:\\n # logits = tf.reduce_sum(summed *\\n # tf.reshape(v, [1, 1, 1, hidden_dim]), 3)\\n logits = py_utils.Matmul(\\n tf.reshape(summed, [-1, p.hidden_dim]),\\n tf.reshape(inputs.v, [p.hidden_dim, 1]))\\n logits = tf.reshape(logits, tf.shape(summed)[:3])\\n # Take out the padding states.\\n # _source_padding is of shape [source_length, source_batch].\\n # reshaped to [source_length, 1, source_batch].\\n # per_step_source_padding is reshaped to the same but with 'multiplier'\\n # for the second dim.\\n source_padding = tf.expand_dims(inputs.source_padding, 1)\\n per_step_source_padding = tf.reshape(\\n tf.transpose(inputs.per_step_source_padding),\\n [-1, multiplier, source_batch])\\n source_padding += per_step_source_padding\\n\\n if p.packed_input:\\n source_padding = self._UpdatePaddingWithPackedInputMask(\\n source_padding, inputs.source_segment_id, inputs.query_segment_id)\\n # Reshape logits to a matrix of shape [target_batch, source_length] and\\n # takes the softmax to compute the probabilities.\\n logits = tf.transpose(tf.reshape(logits, [-1, target_batch]))\\n source_padding = tf.transpose(\\n tf.reshape(source_padding, [-1, target_batch]))\\n probs = self._PaddedSoftmax(logits, source_padding)\\n return probs\\n\\n # Adds the atten function into the graph's library.\\n def Atten(v, w, source_padding, source_segment_id, concated_source_vecs,\\n concated_source_contexts, query_vec, query_segment_id,\\n per_step_source_padding):\\n \\\"\\\"\\\"Computes the attention context vector.\\n\\n Args:\\n v: hidden weight. [hidden_dim, 1].\\n w: query weight. [query_dim, hidden_dim].\\n source_padding: [source_length, source_batch].\\n source_segment_id: [source_lentgh, source_batch]\\n concated_source_vecs: [source_length, source_batch, hidden_dim].\\n concated_source_contexts: [source_batch, source_length, context_dim]\\n query_vec: [target_batch, query_dim]\\n query_segment_id: [target_batch]\\n per_step_source_padding: [target_batch, source_length]\\n Note: concated_source_vecs are the vectors that are used to compute the\\n attention score between the query_vec and each concated_source_vec. The\\n concated_source_contexts are the vectors that compose the result. The\\n attention context vector is computed as a weighted average of the\\n concated_source_contexts, using the scores that were computed using\\n concated_source_vecs.\\n\\n Returns:\\n attention context vectors and probabilities.\\n \\\"\\\"\\\"\\n source_batch = py_utils.GetShape(concated_source_vecs)[1]\\n target_batch = py_utils.GetShape(query_vec)[0]\\n multiplier = target_batch // source_batch\\n # concated_source_vecs is reshaped to\\n # [source_length, 1, source_batch, hidden_dims]\\n concated_source_vecs = tf.expand_dims(concated_source_vecs, 1)\\n query_vec_transformed = py_utils.Matmul(query_vec, w)\\n\\n # query_vec is reshaped to\\n # [1, target_batch/source_batch, source_batch, hidden_dims].\\n query_vec_reshaped = tf.reshape(\\n query_vec_transformed, [1, multiplier, source_batch, p.hidden_dim])\\n # probs is of shape [target_batch, source_length]\\n probs = py_utils.CallDefun(\\n AttenProbs,\\n py_utils.NestedMap(\\n concated_source_vecs=concated_source_vecs,\\n source_padding=source_padding,\\n query_vec_reshaped=query_vec_reshaped,\\n v=v,\\n per_step_source_padding=per_step_source_padding,\\n source_segment_id=source_segment_id,\\n query_segment_id=query_segment_id))\\n probs.set_shape(per_step_source_padding.shape)\\n\\n # Apply dropout to weights if applicable.\\n if not self.do_eval:\\n probs = _ApplyAttentionDropout(p, probs)\\n\\n # Reshape probs to be of shape\\n # [target_batch/source_batch, source_batch, source_length]\\n probs_reshaped = tf.reshape(probs, [multiplier, source_batch, -1])\\n # Transpose probs to be of shape\\n # [source_batch, target_batch/source_batch, source_length]\\n probs_reshaped = tf.transpose(probs_reshaped, [1, 0, 2])\\n # Batched matmul\\n # [source_batch, target_batch/source_batch, source_length] *\\n # [source_batch, source_length, context_dim] =\\n # [source_batch, target_batch/source_batch, context_dim]\\n summed = tf.matmul(probs_reshaped, concated_source_contexts)\\n\\n # summed is of shape\\n # [target_batch/source_batch, source_batch, context_dim]\\n summed = tf.transpose(summed, [1, 0, 2])\\n\\n return tf.reshape(summed, [target_batch, -1]), probs\\n\\n # The source batch size equals to the target batch size.\\n def AttenSameBatchSize(v, w, source_padding, source_segment_id,\\n concated_source_vecs, concated_source_contexts,\\n query_vec, query_segment_id,\\n per_step_source_padding):\\n \\\"\\\"\\\"Computes the attention context vector.\\n\\n Args:\\n v: hidden weight. [hidden_dim].\\n w: query weight. [query_dim, hidden_dim].\\n source_padding: [sl, b]\\n source_segment_id: [sl, b]\\n concated_source_vecs: [sl, b, hidden_dim].\\n concated_source_contexts: [b, sl, context_dim]\\n query_vec: [b, query_dim]\\n query_segment_id: [b]\\n per_step_source_padding: [b, sl]\\n\\n Returns:\\n attention context vectors and probabilities.\\n \\\"\\\"\\\"\\n # TODO(jiaye): support dropout\\n if p.atten_dropout_prob != 0:\\n raise NotImplementedError('dropout is not supported')\\n\\n # [b, hidden_dim]\\n query_vec = py_utils.Matmul(query_vec, w)\\n # [sl, b]\\n def AttenProbs(inputs):\\n \\\"\\\"\\\"Calculates atten probs with padding.\\\"\\\"\\\"\\n # tf.tanh(x+y) shape [sl, b, hidden_dim]\\n summed = tf.tanh(inputs.x + inputs.y)\\n # [-1, hidden_dim] * [hidden_dim, 1] = [-1, 1]\\n res = py_utils.Matmul(\\n tf.reshape(summed, [-1, p.hidden_dim]), tf.expand_dims(inputs.v, 1))\\n # Reshape res to [sl, b]\\n logits = tf.reshape(res, tf.shape(summed)[:2])\\n # Take out the padding states. _source_padding is of shape [sl, b].\\n source_padding = inputs.source_padding + tf.transpose(\\n inputs.per_step_source_padding)\\n\\n if p.packed_input:\\n source_padding = self._UpdatePaddingWithPackedInputMask(\\n tf.expand_dims(source_padding, 1), inputs.source_segment_id,\\n inputs.query_segment_id)\\n source_padding = tf.squeeze(source_padding, 1)\\n # [b, sl]\\n source_padding = tf.transpose(source_padding)\\n logits = tf.transpose(logits)\\n # softmax to compute the probabilities. [b, sl]\\n probs = self._PaddedSoftmax(logits, source_padding)\\n return probs\\n\\n probs = py_utils.CallDefun(\\n AttenProbs,\\n py_utils.NestedMap(\\n x=concated_source_vecs,\\n source_padding=source_padding,\\n y=query_vec,\\n v=v,\\n per_step_source_padding=per_step_source_padding,\\n source_segment_id=source_segment_id,\\n query_segment_id=query_segment_id))\\n probs.set_shape(per_step_source_padding.shape)\\n\\n # contexts[i, :] is a weighted (probs[i, :]) average of\\n # concated_source_vecs[i, :, :].\\n # Reshaped probs is of shape [b, 1, sl]\\n reshaped_probs = tf.expand_dims(probs, 1)\\n # [b, 1, sl] * [b, sl, context_dim] = [b, 1, context_dim]\\n contexts = tf.matmul(reshaped_probs, concated_source_contexts)\\n # Reshaped context is of shape [b, context_dim]\\n contexts = tf.squeeze(contexts, axis=1)\\n return contexts, probs\\n\\n if p.same_batch_size:\\n self._ctx_vec = AttenSameBatchSize\\n else:\\n self._ctx_vec = Atten\\n\\n def EncodeSource(src_w, vecs, ctxs):\\n \\\"\\\"\\\"Prepares source vec and ctx.\\\"\\\"\\\"\\n time, batch = py_utils.GetShape(vecs, 2)\\n ctxs = py_utils.HasShape(ctxs, [time, batch, -1])\\n transformed_vecs = tf.matmul(vecs, src_w)\\n transformed_vecs = tf.identity(\\n transformed_vecs, name='source_vecs_projected')\\n transposed_ctxs = tf.transpose(ctxs, [1, 0, 2])\\n transposed_ctxs = tf.identity(transposed_ctxs, name='source_ctx')\\n return transformed_vecs, transposed_ctxs\\n\\n self._encode_source = EncodeSource\\n\\n def _CreateLayerVariables(self):\\n super()._CreateLayerVariables()\\n p = self.params\\n pc = py_utils.WeightParams(\\n shape=[p.source_dim, p.hidden_dim],\\n init=p.params_init,\\n dtype=p.dtype,\\n collections=['AdditiveAttention_vars'])\\n self.CreateVariable('source_var', pc)\\n\\n pc = py_utils.WeightParams(\\n shape=[p.query_dim, p.hidden_dim],\\n init=p.params_init,\\n dtype=p.dtype,\\n collections=['AdditiveAttention_vars'])\\n self.CreateVariable('query_var', pc)\\n\\n pc = py_utils.WeightParams(\\n shape=[p.hidden_dim],\\n init=p.params_init,\\n dtype=p.dtype,\\n collections=['AdditiveAttention_vars'])\\n self.CreateVariable('hidden_var', pc)\\n\\n def AddGlobalVN(self, theta):\\n theta = super().AddGlobalVN(theta)\\n theta.source_var = self.AddVN(theta.source_var)\\n theta.hidden_var = self.AddVN(theta.hidden_var)\\n theta.query_var = self.AddVN(theta.query_var)\\n return theta\\n\\n def PackSource(self,\\n theta,\\n source_vecs,\\n source_contexts,\\n source_padding,\\n source_segment_id=None):\\n \\\"\\\"\\\"Packs source vectors.\\n\\n Does not change attention state.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n source_vecs: A single tensor of shape [time, batch_size, source_dim].\\n source_contexts: A single tensor of shape [time, batch_size, some_dim].\\n source_padding: A tensor of shape [time, batch_size].\\n source_segment_id: A tensor of shape [time, batch_size].\\n\\n Returns:\\n A NestedMap containing the packed source.\\n \\\"\\\"\\\"\\n with tf.name_scope(self.params.name):\\n if source_segment_id is None:\\n source_segment_id = tf.zeros_like(source_padding)\\n\\n (concated_source_vecs, concated_source_contexts) = (\\n self._encode_source(theta.source_var, source_vecs, source_contexts))\\n return py_utils.NestedMap(\\n # [time, batch_size, hidden_dim].\\n source_vecs=concated_source_vecs,\\n # [batch_size, time, context_dim].\\n # Note the mismatch between `source_vecs` and `source_contexts`. In\\n # `source_vecs`, time is the first dim, while it is the second dim in\\n # `source_contexts`.\\n source_contexts=concated_source_contexts,\\n # [time, batch_size].\\n source_padding=source_padding,\\n # [time, batch_size].\\n source_segment_id=source_segment_id)\\n\\n def ZeroAttentionState(self, source_length, decoder_batch_size):\\n p = self.params\\n # This is just a dummy state. The first dimension of the state has to match\\n # decoder_batch_size.\\n zs = tf.zeros([decoder_batch_size, 1], dtype=py_utils.FPropDtype(p))\\n return zs\\n\\n def ComputeContextVectorWithSource(self,\\n theta,\\n packed_src,\\n query_vec,\\n attention_state=None,\\n per_step_source_padding=None,\\n query_segment_id=None):\\n \\\"\\\"\\\"Computes the context vector given the current query output.\\n\\n Note: `packed_src.source_vecs` are the vectors that are used to compute the\\n attention score between the `query_vec` and each `packed_src.source_vecs`.\\n The `packed_src.source_contexts` are the vectors that compose the result.\\n The attention context vector is computed as a weighted average of the\\n `packed_src.source_contexts`, using the scores that were computed using\\n `packed_src.source_vecs`.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n packed_src: A `.NestedMap` object returned by PackSource or\\n InitForSourcePacked.\\n query_vec: a tensor of shape [batch_size, query_dim].\\n attention_state: previous attention state. It is not used in\\n `AdditiveAttention`, and is simply passed through.\\n per_step_source_padding: Source sequence padding to apply at this step. If\\n not None, it should be of shape [target_batch_size, source_length].\\n query_segment_id: a tensor of shape [batch_size]\\n\\n Returns:\\n A tuple of 3 elements.\\n\\n - The attention context vector: [batch_size, context_dim]\\n - The attention probability vector: [batch_size, time]\\n - The new attention mechanism state: possibly nested tuple of tensors with\\n dimensions [target_batch, ...]\\n \\\"\\\"\\\"\\n concated_source_vecs = packed_src.source_vecs\\n concated_source_contexts = packed_src.source_contexts\\n source_padding = packed_src.source_padding\\n source_segment_id = packed_src.source_segment_id\\n query_batch_size = py_utils.GetShape(query_vec)[0]\\n source_length = py_utils.GetShape(source_padding)[0]\\n if per_step_source_padding is None:\\n zero = tf.constant(0.0, dtype=query_vec.dtype)\\n per_step_source_padding = tf.fill([query_batch_size, source_length], zero)\\n per_step_source_padding = py_utils.HasShape(\\n per_step_source_padding, [query_batch_size, source_length])\\n hidden = self.AddVN(theta.hidden_var, per_step=True)\\n query = self.AddVN(theta.query_var, per_step=True)\\n\\n if source_segment_id is None:\\n source_segment_id = tf.zeros_like(source_padding)\\n if query_segment_id is None:\\n query_segment_id = tf.zeros(\\n tf.shape(query_vec)[0], dtype=source_padding.dtype)\\n\\n ctx_vec, prob = self._ctx_vec(hidden, query, source_padding,\\n source_segment_id, concated_source_vecs,\\n concated_source_contexts, query_vec,\\n query_segment_id, per_step_source_padding)\\n\\n return ctx_vec, prob, attention_state\\n\\n\\nclass DotProductAttention(BaseAttentionLayer):\\n \\\"\\\"\\\"Implements dot-product attention (also known as \\\"Luong Attention\\\").\\n\\n Described in:\\n\\n Minh-Thang Luong, Hieu Pham, Christopher D. Manning.\\n \\\"Effective Approaches to Attention-based Neural Machine Translation.\\\"\\n EMNLP 2015.\\n https://arxiv.org/abs/1508.04025\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def Params(cls):\\n \\\"\\\"\\\"Params for `DotProductAttention`.\\\"\\\"\\\"\\n p = super().Params()\\n p.Define('source_dim', 0, 'Number of source nodes.')\\n p.Define('query_dim', 0, 'Number of query nodes.')\\n p.Define('hidden_dim', 0, 'Number of hidden nodes.')\\n p.Define(\\n 'use_dim_scale', True, 'Whether or not to use per_dim_scale to scale '\\n 'the individual dims when calculating attention probabilities. It can '\\n 'increase training stability when set to False.')\\n return p\\n\\n def __init__(self, params):\\n \\\"\\\"\\\"Constructs a DotProductAttention object.\\\"\\\"\\\"\\n super().__init__(params)\\n p = self.params\\n # TODO(yonghui): relax these constraints.\\n assert p.source_dim == p.query_dim\\n assert p.source_dim == p.hidden_dim\\n\\n def AttenProbs(inputs):\\n \\\"\\\"\\\"Main attention function.\\n\\n target_batch = source_batch * n where n is an integer >= 1.\\n In this case inputs.query_vec contains:\\n -------------------------\\n | instance 1 |\\n | instance 2 |\\n 0 | ... |\\n | instance source_batch |\\n -------------------------\\n | instance 1 |\\n | instance 2 |\\n 1 | ... |\\n | instance source_batch |\\n -------------------------\\n ...\\n -------------------------\\n | instance 1 |\\n | instance 2 |\\n n-1 | ... |\\n | instance source_batch |\\n -------------------------\\n One use case is beam search where n = beam size.\\n\\n Args:\\n inputs: a NestedMap containing:\\n - per_dim_scale: [source_dim], a vec to scale individual dims.\\n - source_padding: [time, source_batch].\\n - concated_source_vecs: [source_batch, time, source_dim].\\n - query_vec: [target_batch, source_dim].\\n - per_step_source_padding: [target_batch, source_length]\\n - source_segment_id: [time, source_batch].\\n - query_segment_id: [target_batch].\\n\\n Returns:\\n logits [target_batch, source_time].\\n \\\"\\\"\\\"\\n source_padding = tf.transpose(inputs.source_padding)\\n concated_source_vecs = inputs.concated_source_vecs\\n\\n logit_scale = tf.stop_gradient(\\n tf.math.rsqrt(\\n tf.cast(\\n py_utils.GetShape(inputs.query_vec)[1],\\n dtype=py_utils.FPropDtype(p))))\\n source_batch = py_utils.GetShape(concated_source_vecs)[0]\\n target_batch = py_utils.GetShape(inputs.query_vec)[0]\\n query_vec = inputs.query_vec * inputs.per_dim_scale\\n # The n here refers to the \\\"n\\\" described in the comment above.\\n n = target_batch // source_batch\\n query_vec = tf.reshape(query_vec, [n, source_batch, -1])\\n # => [source_batch, source_dim, n]\\n query_vec = tf.transpose(query_vec, [1, 2, 0])\\n # => [n, source_batch, source_sequence_len]\\n per_step_source_padding = tf.reshape(inputs.per_step_source_padding,\\n [n, source_batch, -1])\\n # => [source_batch, source_sequence_len, n]\\n per_step_source_padding = tf.transpose(per_step_source_padding, [1, 2, 0])\\n # Dot-product part.\\n # Calls batch_mat_mul since dim > 2 for per-instance matmul.\\n # [source_batch, time, source_dim] * [source_batch, source_dim, n]\\n # => [source_batch, time, n]\\n concated_source_vecs, query_vec = self.ToAqtActActInputs(\\n act_lhs=concated_source_vecs,\\n act_rhs=query_vec,\\n act_lhs_distribution=quant_utils.QDistribution.SYMMETRIC,\\n act_rhs_distribution=quant_utils.QDistribution.SYMMETRIC)\\n logits = tf.matmul(concated_source_vecs, query_vec)\\n logits = self.FromAqtActActMatmul(logits)\\n\\n logits *= logit_scale\\n # Exclude padding frames.\\n # [source_batch, time] => [source_batch, time, 1]\\n source_padding = tf.expand_dims(source_padding, 2)\\n source_padding += per_step_source_padding\\n if p.packed_input:\\n source_padding = tf.transpose(source_padding, [1, 2, 0])\\n source_padding = self._UpdatePaddingWithPackedInputMask(\\n source_padding, inputs.source_segment_id, inputs.query_segment_id)\\n source_padding = tf.transpose(source_padding, [1, 2, 0])\\n else:\\n source_padding = tf.transpose(source_padding, [2, 0, 1])\\n\\n # => [n, source_batch, time]\\n logits = tf.transpose(logits, [2, 0, 1])\\n\\n # => [n * source_batch, time].\\n # This makes logits store content in the same order as query_vec.\\n logits = tf.reshape(logits, [target_batch, -1])\\n source_padding = tf.reshape(source_padding, [target_batch, -1])\\n probs = self._PaddedSoftmax(logits, source_padding)\\n return probs\\n\\n def Atten(per_dim_scale, source_padding, source_segment_id,\\n concated_source_vecs, concated_source_contexts, query_vec,\\n query_segment_id, per_step_source_padding):\\n \\\"\\\"\\\"Main attention function.\\n\\n Args:\\n per_dim_scale: [source_dim], a vec to scale individual dims.\\n source_padding: [time, source_batch].\\n source_segment_id: [time, source_batch].\\n concated_source_vecs: [time, source_batch, source_dim].\\n concated_source_contexts: [source_batch, time, context_dim].\\n query_vec: [target_batch, source_dim].\\n query_segment_id: [target_batch].\\n per_step_source_padding: [target_batch, source_length]\\n Note: concated_source_vecs are the vectors that are used to compute the\\n attention score between the query_vec and each concated_source_vec. The\\n concated_source_contexts are the vectors that compose the result. The\\n attention context vector is computed as a weighted average of the\\n concated_source_contexts, using the scores that were computed using\\n concated_source_vecs.\\n\\n Returns:\\n Two tensors:\\n\\n - context_vector: [target_batch, context_dim].\\n - probs: [target_batch, time].\\n \\\"\\\"\\\"\\n py_utils.assert_shape_match([py_utils.GetShape(concated_source_vecs)[2]],\\n [py_utils.GetShape(query_vec)[1]])\\n py_utils.assert_shape_match([py_utils.GetShape(concated_source_vecs)[2]],\\n [symbolic.ToStatic(p.source_dim)])\\n source_batch = py_utils.GetShape(concated_source_vecs)[1]\\n target_batch = py_utils.GetShape(query_vec)[0]\\n n = target_batch // source_batch\\n concated_source_vecs = tf.transpose(concated_source_vecs, [1, 0, 2])\\n concated_source_vecs = tf.identity(\\n concated_source_vecs, name='concated_source_vecs')\\n returned_probs = py_utils.CallDefun(\\n AttenProbs,\\n py_utils.NestedMap(\\n per_dim_scale=per_dim_scale,\\n source_padding=source_padding,\\n concated_source_vecs=concated_source_vecs,\\n query_vec=query_vec,\\n per_step_source_padding=per_step_source_padding,\\n source_segment_id=source_segment_id,\\n query_segment_id=query_segment_id))\\n returned_probs.set_shape(per_step_source_padding.shape)\\n\\n # => [n, source_batch, time].\\n probs = tf.reshape(returned_probs, [n, source_batch, -1])\\n # => [source_batch, n, time].\\n probs = tf.transpose(probs, [1, 0, 2])\\n\\n # Apply dropout to weights if applicable.\\n if not self.do_eval:\\n probs = _ApplyAttentionDropout(p, probs)\\n\\n # Weight each frame with the probability and sum them.\\n # [source_batch, n, time] * [source_batch, time, context_dim]\\n # => [source_batch, n, context_dim].\\n concated_source_contexts = tf.identity(\\n concated_source_contexts, name='concated_source_contexts')\\n probs, concated_source_contexts = self.ToAqtActActInputs(\\n act_lhs=probs,\\n act_rhs=concated_source_contexts,\\n act_lhs_distribution=quant_utils.QDistribution.POSITIVE,\\n act_rhs_distribution=quant_utils.QDistribution.SYMMETRIC)\\n\\n context_vector = tf.matmul(probs, concated_source_contexts)\\n context_vector = self.FromAqtActActMatmul(context_vector)\\n\\n # => [n, source_batch, context_dim].\\n context_vector = tf.transpose(context_vector, [1, 0, 2])\\n context_vector = gshard_utils.MeshSplit(context_vector, p.device_mesh,\\n p.activation_split_dims_mapping)\\n # => [n * source_batch, context_dim].\\n context_vector = tf.reshape(context_vector, [target_batch, -1])\\n\\n return context_vector, returned_probs\\n\\n self._ctx_vec = Atten\\n\\n def _CreateLayerVariables(self):\\n super()._CreateLayerVariables()\\n p = self.params\\n\\n if p.use_dim_scale:\\n pc = py_utils.WeightParams(\\n shape=[p.hidden_dim],\\n init=py_utils.WeightInit.Constant(0.0),\\n dtype=p.dtype,\\n collections=['DotProductAttention_vars'])\\n\\n self.CreateVariable('per_dim_scale', pc)\\n\\n def PackSource(self,\\n theta,\\n source_vecs,\\n source_contexts,\\n source_padding,\\n source_segment_id=None):\\n \\\"\\\"\\\"Packs source vectors.\\n\\n Does not change attention state.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n source_vecs: A tensor of shape [time, source_batch, source_dim].\\n source_contexts: A tensor of shape [time, source_batch, context_dim].\\n source_padding: A tensor of shape [time, source_batch].\\n source_segment_id: A tensor of shape [time, source_batch].\\n\\n Returns:\\n A tuple (concated_source_vecs, concated_source_contexts, source_padding)\\n where `concated_source_vecs` is a tensor of shape [time, batch_size,\\n hidden_dim], `concated_source_contexts` is a tensor of shape\\n [batch_size, time, some_dim] and `source_padding` is a tensor of shape\\n [time, batch_size].\\n \\\"\\\"\\\"\\n concated_source_vecs = tf.identity(source_vecs)\\n concated_source_contexts = tf.transpose(source_contexts, [1, 0, 2])\\n if source_segment_id is None:\\n source_segment_id = tf.zeros_like(source_padding)\\n return py_utils.NestedMap(\\n # [time, batch_size, hidden_dim].\\n source_vecs=concated_source_vecs,\\n # [batch_size, time, context_dim].\\n # Note the mismatch between `source_vecs` and `source_contexts`. In\\n # `source_vecs`, time is the first dim, while it is the second dim in\\n # `source_contexts`.\\n source_contexts=concated_source_contexts,\\n # [time, batch_size].\\n source_padding=source_padding,\\n # [time, batch_size].\\n source_segment_id=source_segment_id)\\n\\n def ZeroAttentionState(self, source_length, decoder_batch_size):\\n p = self.params\\n # No states to keep track of currently.\\n return tf.zeros([decoder_batch_size, 1], dtype=py_utils.FPropDtype(p))\\n\\n def ComputeContextVectorWithSource(self,\\n theta,\\n packed_src,\\n query_vec,\\n attention_state=None,\\n per_step_source_padding=None,\\n query_segment_id=None):\\n \\\"\\\"\\\"Computes the context vector given the current query output.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n packed_src: A `.NestedMap` object returned by PackSource or\\n InitForSourcePacked.\\n query_vec: a tensor of shape [target_batch, query_dim], where target_batch\\n = n * source_batch (e.g., n = num_hyps_per_beam in beamsearch). Along\\n the target_batch dimension, there are n groups of consecutive rows, each\\n group containing source_batch rows.\\n attention_state: previous attention state. It is not used in\\n AdditiveAttention, and is simply passed through.\\n per_step_source_padding: Source sequence padding to apply at this step. If\\n not None, it should be of shape [target_batch, source_length].\\n query_segment_id: Query segment id with shape [target_batch].\\n\\n Returns:\\n A tuple of 3 elements.\\n\\n - The attention context vector: [batch_size, context_dim]\\n - The attention probability vector: [batch_size, time]\\n - The new attention mechanism state: possibly nested tuple of tensors\\n with dimensions [target_batch, ...]\\n \\\"\\\"\\\"\\n concated_source_vecs = packed_src.source_vecs\\n concated_source_contexts = packed_src.source_contexts\\n\\n source_padding = packed_src.source_padding\\n source_segment_id = packed_src.source_segment_id\\n query_batch_size = py_utils.GetShape(query_vec)[0]\\n source_sequence_length = py_utils.GetShape(source_padding)[0]\\n if per_step_source_padding is None:\\n zero = tf.constant(0.0, dtype=query_vec.dtype)\\n per_step_source_padding = tf.fill(\\n [query_batch_size, source_sequence_length], zero)\\n per_step_source_padding = py_utils.HasShape(\\n per_step_source_padding, [query_batch_size, source_sequence_length])\\n if source_segment_id is None:\\n source_segment_id = tf.zeros_like(source_padding)\\n if query_segment_id is None:\\n query_segment_id = tf.zeros(\\n py_utils.GetShape(query_vec)[0], dtype=source_padding.dtype)\\n\\n def ScaleFn(x):\\n return tf.nn.softplus(x) / tf.nn.softplus(tf.constant(0.0, dtype=x.dtype))\\n\\n if self.params.use_dim_scale:\\n per_dim_scale_var = theta.per_dim_scale\\n else:\\n per_dim_scale_var = tf.constant(0.0, dtype=query_vec.dtype)\\n\\n ctx_vec, prob = self._ctx_vec(\\n ScaleFn(per_dim_scale_var), source_padding, source_segment_id,\\n concated_source_vecs, concated_source_contexts, query_vec,\\n query_segment_id, per_step_source_padding)\\n return ctx_vec, prob, attention_state\\n\\n\\ndef _RecursiveReshape(x, shape):\\n if x is None:\\n return None\\n elif isinstance(x, py_utils.NestedMap):\\n return x.Transform(lambda y: _RecursiveReshape(y, shape))\\n else:\\n return tf.reshape(x, shape) if x.shape.ndims == 2 else x\\n\\n\\nclass MultiHeadedAttention(BaseAttentionLayer, quant_utils.QuantizableLayer):\\n \\\"\\\"\\\"Attention with multiple attention heads.\\n\\n Conceptually, the algorithm works as follows:\\n\\n 1. Source vectors (attention keys) are first projected to vectors of dim\\n p.hidden_dim.\\n 2. Query vectors are projected to vectors of dim p.hidden_dim as well.\\n 3. Context vectors (attention values) are not projected by default, unless\\n `enable_ctx_pre_proj` is True.\\n 4. Source vectors, query vectors and context vectors are all split into\\n p.num_attention_heads chunks.\\n 5. The inner atten mechanism is computed separately on each of the chunks.\\n 6. Attention contexts from each of the chunk are concatenated to form the\\n final context.\\n 7. Attention probs from each of the chunk are averaged to form the final\\n attention prob.\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def Params(cls):\\n \\\"\\\"\\\"Params for MultiHeadedAttention.\\\"\\\"\\\"\\n p = super().Params()\\n p.Define('source_dim', 0, 'Number of source nodes.')\\n p.Define('query_dim', 0, 'Number of query nodes.')\\n p.Define('context_dim', 0, 'Number of context nodes.')\\n p.Define('hidden_dim', 0, 'Number of hidden nodes.')\\n p.Define('num_attention_heads', 2, 'Num of attention heads.')\\n p.Define(\\n 'use_source_vec_as_attention_value', True,\\n 'Whether or not to use source_vec as the attention value as well.'\\n ' If True, we expect source_vec and source_contexts are the same.')\\n p.Define('enable_source_proj', True,\\n 'If False, source side linear projection is disabled.')\\n p.Define('enable_query_proj', True,\\n 'If False, query side linear projection is disabled.')\\n p.Define('inner_atten_params', DotProductAttention.Params(),\\n 'Params for underlying attention mechanism.')\\n p.Define(\\n 'enable_ctx_pre_proj', False,\\n 'If True, context is pre-projected before processing into'\\n ' hidden_dim.')\\n p.Define(\\n 'enable_ctx_post_proj', False,\\n 'If True, computed context is post projected into'\\n ' ctx_post_proj_dim.')\\n p.Define('ctx_post_proj_dim', 0, 'Number of post projection nodes.')\\n p.Define(\\n 'num_post_proj', 1, 'Number of post projections, usually the same as '\\n 'number of tasks. Each task may choose to use one of the post '\\n 'projection layers.')\\n p.Define(\\n 'proj_init', 'default', 'Initialization approach for projection '\\n 'layers:'\\n 'uniform: Use uniform initialization. '\\n 'default: Use the default Xavier initialization.')\\n p.Define(\\n 'attention_head_prob_index', -1, 'If > 0, instead of averaging '\\n 'the probabilities of all attention heads when returning the '\\n 'attention probability, instead return the selected index prob.')\\n\\n p.Define('use_bias', True, 'Whether to use bias for projection layer.')\\n p.Define('enable_per_dim_scale', True,\\n 'Whether to use per_dim_scale in inner_atten.')\\n\\n # Often the attention context output needs to be concated\\n # with tensors from another layer. This allows them to share\\n # quantization parameters. By convention, all attention layers\\n # need to include their context output vectors in this domain.\\n p.qdomain.Define('atten_context', None,\\n 'Quantization domain for attention context.')\\n\\n p.params_init = py_utils.WeightInit.Xavier(scale=1.0)\\n\\n return p\\n\\n def __init__(self, params):\\n \\\"\\\"\\\"Constructs a MultiHeadedAttention object.\\\"\\\"\\\"\\n super().__init__(params)\\n p = self.params\\n assert symbolic.ToStatic(\\n p.hidden_dim) % p.num_attention_heads == 0, '%s mod %s != 0' % (\\n symbolic.ToStatic(p.hidden_dim), p.num_attention_heads)\\n\\n if p.proj_init not in ('uniform', 'default'):\\n raise ValueError('Unknown proj_init: %s!' % p.proj_init)\\n\\n att_dim = p.hidden_dim // p.num_attention_heads\\n\\n att_p = p.inner_atten_params.Set(\\n source_dim=att_dim,\\n query_dim=att_dim,\\n hidden_dim=att_dim,\\n dtype=p.dtype,\\n atten_dropout_prob=p.atten_dropout_prob,\\n atten_dropout_deterministic=p.atten_dropout_deterministic,\\n packed_input=p.packed_input)\\n\\n if att_p.cls == DotProductAttention:\\n att_p.use_dim_scale = p.enable_per_dim_scale\\n\\n if not att_p.name:\\n att_p.name = 'inner_att'\\n self.CreateChild('atten', att_p)\\n if p.attention_head_prob_index >= 0:\\n assert p.attention_head_prob_index < p.num_attention_heads\\n\\n self.CreateAqtWeight(\\n 'query_proj',\\n shape=[p.query_dim, p.hidden_dim],\\n feature_axis=-1,\\n legacy_aqt_w_name='query_proj_aqt')\\n self.CreateAqtWeight(\\n 'source_proj',\\n shape=[p.source_dim, p.hidden_dim],\\n feature_axis=-1,\\n legacy_aqt_w_name='source_proj_aqt')\\n self.CreateAqtWeight(\\n 'ctx_proj',\\n shape=[p.context_dim, p.hidden_dim],\\n feature_axis=-1,\\n legacy_aqt_w_name='ctx_pre_proj_aqt')\\n self.CreateAqtWeight(\\n 'ctx_post_proj',\\n shape=[p.hidden_dim, p.ctx_post_proj_dim],\\n feature_axis=-1,\\n legacy_aqt_w_name='ctx_post_proj_aqt')\\n\\n def _CreateLayerVariables(self):\\n super()._CreateLayerVariables()\\n p = self.params\\n\\n def InitProj(layer_dim, bias=False):\\n if p.proj_init == 'uniform':\\n # Note we also initialize bias with uniform distribution here, following\\n # the default Pytorch implementation:\\n # https://pytorch.org/docs/stable/nn.html#linear\\n proj_init = py_utils.WeightInit.Uniform(scale=np.sqrt(1.0 / layer_dim))\\n elif p.proj_init == 'default':\\n proj_init = py_utils.WeightInit.Constant(0.0) if bias else p.params_init\\n return proj_init\\n\\n if p.use_bias:\\n pc_bias = py_utils.WeightParams(\\n shape=[p.hidden_dim],\\n init=InitProj(p.hidden_dim, bias=True),\\n dtype=p.dtype,\\n collections=[self.__class__.__name__ + '_vars'])\\n\\n if p.enable_source_proj:\\n pc = py_utils.WeightParams(\\n shape=[p.source_dim, p.hidden_dim],\\n init=InitProj(p.source_dim),\\n dtype=p.dtype,\\n device_mesh=p.device_mesh,\\n tensor_split_dims_mapping=p.weight_split_dims_mapping,\\n collections=[self.__class__.__name__ + '_vars'])\\n self.CreateVariable('source_proj', pc)\\n if p.use_bias:\\n self.CreateVariable('source_proj_b', pc_bias)\\n else:\\n assert p.source_dim == p.hidden_dim\\n\\n if p.enable_query_proj:\\n pc = py_utils.WeightParams(\\n shape=[p.query_dim, p.hidden_dim],\\n init=InitProj(p.query_dim),\\n dtype=p.dtype,\\n device_mesh=p.device_mesh,\\n tensor_split_dims_mapping=p.weight_split_dims_mapping,\\n collections=[self.__class__.__name__ + '_vars'])\\n self.CreateVariable('query_proj', pc)\\n if p.use_bias:\\n self.CreateVariable('query_proj_b', pc_bias)\\n else:\\n assert p.query_dim == p.hidden_dim\\n\\n if p.enable_ctx_pre_proj and not p.use_source_vec_as_attention_value:\\n assert p.context_dim\\n pc = py_utils.WeightParams(\\n shape=[p.context_dim, p.hidden_dim],\\n init=InitProj(p.context_dim),\\n dtype=p.dtype,\\n device_mesh=p.device_mesh,\\n tensor_split_dims_mapping=p.weight_split_dims_mapping,\\n collections=[self.__class__.__name__ + '_vars'])\\n self.CreateVariable('ctx_proj', pc)\\n if p.use_bias:\\n self.CreateVariable('ctx_proj_b', pc_bias)\\n\\n if p.enable_ctx_post_proj:\\n assert p.ctx_post_proj_dim\\n if p.num_post_proj == 1:\\n pc_shape = [p.hidden_dim, p.ctx_post_proj_dim]\\n pc_b_shape = [p.ctx_post_proj_dim]\\n elif p.num_post_proj > 1:\\n pc_shape = [p.hidden_dim, p.ctx_post_proj_dim, p.num_post_proj]\\n pc_b_shape = [p.ctx_post_proj_dim, p.num_post_proj]\\n else:\\n raise ValueError('num_post_proj must > 0!')\\n weight_split_dims_mapping = p.weight_split_dims_mapping\\n if weight_split_dims_mapping and p.num_post_proj > 1:\\n weight_split_dims_mapping = weight_split_dims_mapping + [-1]\\n pc = py_utils.WeightParams(\\n shape=pc_shape,\\n init=InitProj(p.hidden_dim),\\n dtype=p.dtype,\\n device_mesh=p.device_mesh,\\n tensor_split_dims_mapping=weight_split_dims_mapping,\\n collections=[self.__class__.__name__ + '_vars'])\\n self.CreateVariable('ctx_post_proj', pc)\\n if p.use_bias:\\n pc_bias_post_proj = py_utils.WeightParams(\\n shape=pc_b_shape,\\n init=InitProj(p.ctx_post_proj_dim, bias=True),\\n dtype=p.dtype,\\n collections=[self.__class__.__name__ + '_vars'])\\n self.CreateVariable('ctx_post_proj_b', pc_bias_post_proj)\\n\\n self.TrackQTensor('source_proj_matmul', 'source_proj_add',\\n 'query_proj_matmul', 'query_proj_add',\\n 'ctx_pre_proj_matmul', 'ctx_pre_proj_add')\\n # TODO(suderman): Remove the self.do_eval check below once brop quant within\\n # defun is fixed on the training side. This is less than ideal as-is because\\n # training will just trend to match downstream quant constraints vs force\\n # alignment.\\n self.TrackQTensor(\\n 'ctx_post_proj_matmul', 'ctx_post_proj_add', domain='atten_context')\\n\\n @classmethod\\n def SetOutputContextDim(cls, p, out_dim):\\n p.ctx_post_proj_dim = out_dim\\n\\n @py_utils.NameScopeDecorator('MultiHeadedAttention/PackSource')\\n def PackSource(self,\\n theta,\\n source_vecs,\\n source_contexts,\\n source_padding,\\n source_segment_id=None):\\n \\\"\\\"\\\"Packs source vectors.\\n\\n Does not change attention state.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n source_vecs: A tensor of shape [time, source_batch, source_dim].\\n source_contexts: A tensor of shape [time, source_batch, context_dim].\\n source_padding: A tensor of shape [time, source_batch].\\n source_segment_id: A tensor of shape [time, source_batch].\\n\\n Returns:\\n A NestedMap representing packed src. It will have the same structure\\n as the one returned by the inner atten, except that source_batch will be\\n source_batch * num_heads.\\n \\\"\\\"\\\"\\n\\n p = self.params\\n fns = self.fns\\n if not p.enable_source_proj:\\n assert p.source_dim == p.hidden_dim\\n if not p.enable_query_proj:\\n assert p.query_dim == p.hidden_dim\\n with tf.name_scope('init__0'):\\n if p.use_source_vec_as_attention_value:\\n source_vecs = py_utils.HasShape(source_vecs,\\n py_utils.GetShape(source_contexts))\\n time_steps, batch_size = py_utils.GetShape(source_padding, 2)\\n # source_projected shape [time * source_batch, hidden]\\n with tf.name_scope('init__0a'):\\n source_vec_depth = py_utils.GetShape(source_vecs)[2]\\n with tf.name_scope('init__0b'):\\n if p.enable_source_proj:\\n source_vecs = tf.reshape(source_vecs, [-1, source_vec_depth])\\n source_vecs, w_source_proj = self.ToAqtInputs(\\n 'source_proj',\\n act=source_vecs,\\n weight=theta.source_proj,\\n w_feature_axis=-1)\\n w_source_proj = self.QWeight(w_source_proj)\\n source_projected = (\\n fns.qbatchmatmul(\\n source_vecs, w_source_proj, qout_name='source_proj_matmul'))\\n source_projected = self.FromAqtMatmul('source_proj', source_projected)\\n if p.use_bias:\\n source_projected = fns.qadd(\\n source_projected,\\n self.QWeight(theta.source_proj_b),\\n qout_name='source_proj_add')\\n else:\\n source_projected = tf.reshape(source_vecs, [-1, source_vec_depth])\\n if p.activation_split_dims_mapping:\\n source_projected = gshard_utils.MeshSplit(\\n source_projected, p.device_mesh,\\n p.activation_split_dims_mapping[1:])\\n with tf.name_scope('init__1'):\\n num_heads = p.num_attention_heads\\n # => [time, source_batch * num_heads, hidden / num_heads]\\n source_projected = tf.reshape(source_projected, [\\n time_steps, batch_size * num_heads,\\n symbolic.ToStatic(p.hidden_dim // num_heads)\\n ])\\n source_projected = gshard_utils.MeshSplit(source_projected, p.device_mesh,\\n p.activation_split_dims_mapping)\\n source_projected = self.ProcessProjectionVec(theta, source_projected,\\n 'source')\\n if p.use_source_vec_as_attention_value:\\n source_contexts_reshaped = source_projected\\n else:\\n if p.enable_ctx_pre_proj:\\n source_contexts = tf.reshape(\\n source_contexts, [-1, py_utils.GetShape(source_contexts)[2]])\\n source_contexts, w_ctx_proj = self.ToAqtInputs(\\n 'ctx_proj',\\n act=source_contexts,\\n weight=theta.ctx_proj,\\n w_feature_axis=-1)\\n w_ctx_proj = self.QWeight(w_ctx_proj)\\n\\n source_contexts_projected = fns.qbatchmatmul(\\n source_contexts, w_ctx_proj, qout_name='ctx_pre_proj_matmul')\\n source_contexts_projected = self.FromAqtMatmul(\\n 'ctx_proj', source_contexts_projected)\\n if p.use_bias:\\n source_contexts_projected = fns.qadd(\\n source_contexts_projected,\\n self.QWeight(theta.ctx_proj_b),\\n qout_name='ctx_pre_proj_add')\\n if p.activation_split_dims_mapping:\\n source_contexts_projected = gshard_utils.MeshSplit(\\n source_contexts_projected, p.device_mesh,\\n p.activation_split_dims_mapping[1:])\\n else:\\n source_contexts_projected = source_contexts\\n\\n source_context_depth = py_utils.GetShape(source_contexts_projected)[-1]\\n source_contexts_reshaped = tf.reshape(source_contexts_projected, [\\n time_steps, batch_size * num_heads,\\n source_context_depth // num_heads\\n ])\\n source_contexts_projected = gshard_utils.MeshSplit(\\n source_contexts_projected, p.device_mesh,\\n p.activation_split_dims_mapping)\\n source_contexts_projected = self.ProcessProjectionVec(\\n theta, source_contexts_projected, 'ctx')\\n\\n with tf.name_scope('init__2'):\\n source_padding_replicated = tf.reshape(\\n tf.tile(\\n tf.reshape(source_padding, [time_steps, batch_size, 1]),\\n [1, 1, num_heads]), [time_steps, batch_size * num_heads])\\n if source_segment_id is None:\\n source_segment_id_repl = tf.zeros_like(source_padding_replicated)\\n else:\\n source_segment_id_repl = tf.reshape(\\n tf.tile(\\n tf.reshape(source_segment_id, [time_steps, batch_size, 1]),\\n [1, 1, num_heads]), [time_steps, batch_size * num_heads])\\n\\n return self.atten.PackSource(theta.atten, source_projected,\\n source_contexts_reshaped,\\n source_padding_replicated,\\n source_segment_id_repl)\\n\\n @py_utils.NameScopeDecorator('MultiHeadedAttention/ExtendSourcePacked')\\n def ExtendSourcePacked(self,\\n theta,\\n new_source_vecs,\\n new_source_contexts,\\n new_source_paddings,\\n new_source_segment_ids,\\n cached_packed_src,\\n t=None):\\n \\\"\\\"\\\"Extend cached source_vecs and source_contexts by one more timestep.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n new_source_vecs: A tensor of shape [source_batch, source_dim].\\n new_source_contexts: A tensor of shape [source_batch, context_dim].\\n new_source_vecs and new_source_contexts are source_vecs and\\n source_contexts for the new timestep to be extended.\\n new_source_paddings: If not None, a tensor of shape [source_batch].\\n source_padding for the new timestep.\\n new_source_segment_ids: If not None, a tensor of shape [source_batch].\\n source_segment_id for the new timestep.\\n cached_packed_src: a `.NestedMap` object, containing already preprocessed\\n source_vecs and source_contexts for the previous t-1 steps. To support\\n tf.while_loop on TPU (satisfying static shape requirement), instead of\\n using tf.concat to update the cached vectors, the time dimension of each\\n cached vector is fixed as the max_sequence_length and inplace\\n update op is used to update the information for each time step:\\n * source_vecs: A tensor of shape [max_sequence_length, source_batch,\\n hidden_dim]. [:t, :, :] contains valid preprocessed source_vecs in the\\n previous t - 1 timesteps, the rests are invalid data.\\n * source_contexts: A tensor of shape [max_sequence_length, source_batch,\\n hidden_dim]. [:t, :, :] contains valid preprocessed source_contexts in\\n the previous t - 1 timesteps, the rests are invalid data.\\n * source_padding: If not None, a tensor of shape [max_sequence_length,\\n source_batch, num_heads]. [:t, :, :] contains cached source padding\\n for the previous t - 1 timesteps, the rests are invalid data.\\n * source_segment_id: If not None, a tensor of shape\\n [max_sequence_length, source_batch, num_heads]. [:t, :, :] contains\\n cached source segment id for the previous t - 1 timesteps, the rests\\n are invalid data.\\n When t is None (not running on TPU or the while loop is unrolled):\\n * source_vecs: A tensor of shape [t - 1, source_batch, hidden_dim].\\n * source_contexts: A tensor of shape [t - 1, source_batch, hidden_dim].\\n * source_padding: If not None, a tensor of shape [t - 1, source_batch,\\n num_heads], cached source padding for the previous t - 1 timesteps.\\n * source_segment_id: If not None, a tensor of shape [t - 1,\\n source_batch, num_heads], cached source segment id for the previous t\\n - 1 timesteps.\\n t: a scalar, the current time step, 0-based.\\n\\n Returns:\\n Extended cached source_vecs, source_contexts, source_paddings, and\\n source_segment_ids. The time dimension of each cached state is fixed:\\n 'extended_source_vec' is of shape [max_sequence_length, batch_size,\\n num_heads * dim];\\n 'extended_source_context' is of shape [max_sequence_length, batch_size,\\n num_heads * dim];\\n 'source_padding' is of shape [max_sequence_length, batch_size, num_heads];\\n 'source_segment_id' is of shape [max_sequence_length, batch_size,\\n num_heads].\\n But only [:(t + 1), :, :] contains valid data.\\n If t is not given,\\n 'extended_source_vec' is of shape [t, batch_size, num_heads * dim];\\n 'extended_source_context' is of shape [t, batch_size, num_heads * dim];\\n 'source_padding' is of shape [t, batch_size, num_heads];\\n 'source_segment_id' is of shape [t, batch_size, num_heads].\\n \\\"\\\"\\\"\\n batch_size = py_utils.GetShape(new_source_vecs)[0]\\n if new_source_paddings is None:\\n new_source_paddings = tf.zeros([batch_size], dtype=new_source_vecs.dtype)\\n if new_source_segment_ids is None:\\n new_source_segment_ids = tf.zeros([batch_size],\\n dtype=new_source_vecs.dtype)\\n processed_packed_src = self.InitForSourcePacked(\\n theta, tf.expand_dims(new_source_vecs, 0),\\n tf.expand_dims(new_source_contexts, 0),\\n tf.expand_dims(new_source_paddings, 0),\\n tf.expand_dims(new_source_segment_ids, 0))\\n extended_packed_src = py_utils.NestedMap()\\n for key in ('source_vecs', 'source_contexts', 'source_padding',\\n 'source_segment_id'):\\n if cached_packed_src.get(key, None) is None:\\n extended_packed_src[key] = None\\n else:\\n if t is not None:\\n processed = tf.reshape(processed_packed_src[key], [batch_size, -1])\\n # Make sure t is a scaler instead of tensors having shape like [1,].\\n # This could happen in cases where function is called by recurrent.py\\n # (for example target_sequence_sampler.)\\n t = tf.reshape(t, [])\\n extended_packed_src[key] = inplace_ops.alias_inplace_update(\\n cached_packed_src[key], t, processed)\\n else:\\n processed = tf.reshape(processed_packed_src[key], [1, batch_size, -1])\\n extended_packed_src[key] = tf.concat(\\n [cached_packed_src[key], processed], axis=0)\\n return extended_packed_src\\n\\n @py_utils.NameScopeDecorator('MultiHeadedAttention/ZeroAttentionState')\\n def ZeroAttentionState(self, source_length, decoder_batch_size):\\n zero_att_state = self.atten.ZeroAttentionState(\\n source_length, decoder_batch_size * self.params.num_attention_heads)\\n # [batch * num_heads, length] => [batch, num_heads * length].\\n zero_att_state = _RecursiveReshape(zero_att_state, [decoder_batch_size, -1])\\n nested_map_zero_att_state = py_utils.NestedMap(inner=zero_att_state)\\n if self.params.attention_head_prob_index >= 0:\\n selected_prob_head = tf.zeros([decoder_batch_size, source_length],\\n dtype=py_utils.FPropDtype(self.params))\\n nested_map_zero_att_state[\\n 'selected_attention_head_probs'] = selected_prob_head\\n return nested_map_zero_att_state\\n\\n def ProcessProjectionVec(self, theta, projection_vec, projection_type):\\n # no-op for this class but allows subclasses to override to process\\n # projected vectors.\\n return projection_vec\\n\\n @py_utils.NameScopeDecorator(\\n 'MultiHeadedAttention/ComputeContextVectorWithSource')\\n def ComputeContextVectorWithSource(self,\\n theta,\\n packed_src,\\n query_vec,\\n attention_state=None,\\n per_step_source_padding=None,\\n query_segment_id=None,\\n atten_idx=None):\\n \\\"\\\"\\\"Computes the context vector given the current query output.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n packed_src: A `.NestedMap` object returned by PackSource or\\n InitForSourcePacked.\\n query_vec: a tensor of shape [target_batch, query_dim].\\n attention_state: A NestedMap. 'inner' contains the inner attention\\n state. It is not used in AdditiveAttention, and is simply passed\\n through. Optionally, if attention_head_prob_index >= 0, then\\n 'selected_attention_head_probs' contains the selected attention\\n probability head.\\n per_step_source_padding: Source sequence padding to apply at this step. If\\n not None, it should be of shape [target_batch_size, source_length].\\n query_segment_id: a tensor of shape [target_batch].\\n atten_idx: If not None, then apply a different attention projection for\\n different samples in a batch, each of which may come from different\\n tasks. This is usually used in multi-task setting. A tensor of shape\\n [target_batch].\\n Note: concated_source_vecs are the vectors that are used to compute the\\n attention score between the query_vec and each concated_source_vec. The\\n concated_source_contexts are the vectors that compose the result. The\\n attention context vector is computed as a weighted average of the\\n concated_source_contexts, using the scores that were computed using\\n concated_source_vecs.\\n\\n Returns:\\n A tuple of 3 elements.\\n\\n - The attention context vector: [batch_size, context_dim]\\n - The attention probability vector: [batch_size, time]\\n - The new attention mechanism state: A nested tuple of tensors with\\n dimensions [target_batch, ...]. See input 'attention_state' for\\n description of items in the nested tuple.\\n \\\"\\\"\\\"\\n p = self.params\\n fns = self.fns\\n source_padding = packed_src.source_padding\\n source_seq_len = py_utils.GetShape(source_padding)[0]\\n num_heads = p.num_attention_heads\\n batch_size = py_utils.GetShape(query_vec)[0]\\n static_inner_atten_dim = symbolic.ToStatic(p.hidden_dim // num_heads)\\n query_vec_projected_shape = [batch_size * num_heads, static_inner_atten_dim]\\n\\n if p.enable_query_proj:\\n query_vec, w_query_proj = self.ToAqtInputs(\\n 'query_proj',\\n act=query_vec,\\n weight=theta.query_proj,\\n w_feature_axis=-1)\\n w_query_proj = self.QWeight(w_query_proj)\\n query_vec_projected = fns.qbatchmatmul(\\n query_vec, w_query_proj, qout_name='query_proj_matmul')\\n query_vec_projected = self.FromAqtMatmul('query_proj',\\n query_vec_projected)\\n if p.use_bias:\\n query_vec_projected = fns.qadd(\\n query_vec_projected,\\n self.QWeight(theta.query_proj_b),\\n qout_name='query_proj_add')\\n query_vec_projected = tf.reshape(query_vec_projected,\\n query_vec_projected_shape)\\n query_vec_projected = self.ProcessProjectionVec(theta,\\n query_vec_projected,\\n 'query')\\n else:\\n query_vec_projected = tf.reshape(query_vec, query_vec_projected_shape)\\n if p.activation_split_dims_mapping:\\n query_vec_projected = gshard_utils.MeshSplit(\\n query_vec_projected, p.device_mesh,\\n p.activation_split_dims_mapping[1:])\\n\\n query_batch_size = py_utils.GetShape(query_vec)[0]\\n if query_segment_id is None:\\n query_segment_id = tf.zeros(\\n query_batch_size * num_heads, dtype=source_padding.dtype)\\n else:\\n query_segment_id_repl = tf.tile(\\n tf.expand_dims(query_segment_id, 1), [1, num_heads])\\n query_segment_id = tf.reshape(query_segment_id_repl, [-1])\\n\\n if per_step_source_padding is None:\\n zero = tf.constant(0.0, dtype=query_vec.dtype)\\n per_step_source_padding = tf.fill([query_batch_size, source_seq_len],\\n zero)\\n per_step_source_padding = py_utils.HasShape(\\n per_step_source_padding, [query_batch_size, source_seq_len])\\n per_step_source_padding = tf.reshape(\\n tf.tile(per_step_source_padding, [1, num_heads]), [-1, source_seq_len])\\n attention_state = _RecursiveReshape(attention_state,\\n [batch_size * num_heads, -1])\\n if isinstance(attention_state, py_utils.NestedMap):\\n if 'emit_probs' in attention_state:\\n inner_state = attention_state\\n elif 'inner' in attention_state:\\n inner_state = attention_state.inner\\n else:\\n inner_state = attention_state\\n ctx_vec, prob, new_inner_state = self.atten.ComputeContextVectorWithSource(\\n theta.atten, packed_src, query_vec_projected, inner_state,\\n per_step_source_padding, query_segment_id)\\n ctx_vec = tf.reshape(ctx_vec, [batch_size, -1])\\n if p.activation_split_dims_mapping:\\n ctx_vec = gshard_utils.MeshSplit(ctx_vec, p.device_mesh,\\n p.activation_split_dims_mapping[1:])\\n if p.enable_ctx_post_proj:\\n if atten_idx is None:\\n assert p.num_post_proj == 1, (\\n 'atten_idx is None, this means there is no need to select '\\n 'different post projections, and p.num_post_proj is supposed to be '\\n '1. However you set p.num_post_proj=%s .' % p.num_post_proj)\\n ctx_vec, w_ctx_post_proj = self.ToAqtInputs(\\n 'ctx_post_proj',\\n act=ctx_vec,\\n weight=theta.ctx_post_proj,\\n w_feature_axis=-1)\\n w_ctx_post_proj = self.QWeight(w_ctx_post_proj)\\n ctx_vec = fns.qbatchmatmul(\\n ctx_vec, w_ctx_post_proj, qout_name='ctx_post_proj_matmul')\\n ctx_vec = self.FromAqtMatmul('ctx_post_proj', ctx_vec)\\n if p.use_bias:\\n ctx_vec = fns.qadd(\\n ctx_vec,\\n self.QWeight(theta.ctx_post_proj_b),\\n qout_name='ctx_post_proj_add')\\n else:\\n assert p.num_post_proj > 1, (\\n 'atten_idx is not None, this means there are multiple post '\\n 'projections, and p.num_post_proj is supposed to be > 1. However '\\n 'you set p.num_post_proj=%s .' % p.num_post_proj)\\n bs_range = [tf.range(batch_size)]\\n select = tf.transpose(tf.concat([bs_range, [atten_idx]], axis=0))\\n # => [batch, dim, num_langs]\\n ctx_vec = tf.einsum('ab,bcd->acd', ctx_vec, theta.ctx_post_proj)\\n if p.use_bias:\\n ctx_vec += tf.expand_dims(theta.ctx_post_proj_b, 0)\\n # => [batch, num_langs, dim]\\n ctx_vec = tf.transpose(ctx_vec, [0, 2, 1])\\n # => [batch, dim]\\n ctx_vec = tf.gather_nd(ctx_vec, select)\\n ctx_vec = self.ProcessProjectionVec(theta, ctx_vec, 'ctx_post')\\n\\n # explicitly name this tensor for potential future reference\\n multi_headed_atten_prob = tf.reshape(\\n prob, [batch_size, num_heads, -1], name='multi_headed_atten_prob')\\n prob = self.QRAct(\\n tf.reduce_mean(multi_headed_atten_prob, 1),\\n quant_utils.QDistribution.SOFTMAX,\\n domain='softmax')\\n if isinstance(attention_state, py_utils.NestedMap):\\n att_state = attention_state\\n if 'emit_probs' in attention_state:\\n att_state = new_inner_state\\n elif 'inner' in attention_state:\\n att_state.inner = new_inner_state\\n else:\\n att_state = new_inner_state\\n if p.attention_head_prob_index >= 0:\\n selected_prob_head = multi_headed_atten_prob[:, p.\\n attention_head_prob_index, :]\\n att_state.selected_attention_head_probs = selected_prob_head\\n att_state = _RecursiveReshape(att_state, [batch_size, -1])\\n return ctx_vec, prob, att_state\\n\\n @py_utils.NameScopeDecorator(\\n 'MultiHeadedAttention/ComputeContextVectorWithAttenProbs')\\n def ComputeContextVectorWithAttenProbs(self, theta, packed_context,\\n atten_probs):\\n \\\"\\\"\\\"Computes the context vector given the attention probailities.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n packed_context: Concated source contexts with shape [ batch_size *\\n num_heads, time, context_dim // num_heads].\\n atten_probs: The attention probability vector: [batch_size * num_heads,\\n time].\\n\\n Returns:\\n The attention context vector shaped [target_batch, source_dim].\\n If p.enable_ctx_post_proj is false, source_dim = context_dim,\\n otherwise, source_dim = p.ctx_post_proj_dim.\\n \\\"\\\"\\\"\\n p = self.params\\n num_heads = p.num_attention_heads\\n # packed_context: [batch_size * num_head, num_style,\\n # hidden_dim / num_head]\\n # inp: [batch_size * num_head, num_style]\\n packed_context = py_utils.with_dependencies([\\n py_utils.assert_shape_match([py_utils.GetShape(packed_context)[0]],\\n [py_utils.GetShape(atten_probs)[0]])\\n ], packed_context)\\n b_size = py_utils.GetShape(packed_context)[0] // num_heads\\n ctx_vec = tf.reshape(\\n tf.matmul(tf.expand_dims(atten_probs, 1), packed_context), [b_size, -1])\\n if p.enable_ctx_post_proj:\\n ctx_vec_proj = tf.matmul(ctx_vec, theta.ctx_post_proj)\\n ctx_vec_proj += theta.ctx_post_proj_b\\n ctx_vec_proj = self.ProcessProjectionVec(theta, ctx_vec_proj, 'ctx_post')\\n else:\\n ctx_vec_proj = ctx_vec\\n return ctx_vec_proj, ctx_vec\\n\\n def PackCachedSource(self, cached_src):\\n p = self.params\\n concated_source_vecs = cached_src.source_vecs\\n concated_source_contexts = cached_src.source_contexts\\n source_padding = cached_src.source_padding\\n source_segment_id = cached_src.source_segment_id\\n batch_size = py_utils.GetShape(concated_source_vecs)[1]\\n src_seq_len = py_utils.GetShape(concated_source_vecs)[0]\\n num_heads = p.num_attention_heads\\n packed_src = py_utils.NestedMap()\\n packed_src.source_vecs = tf.reshape(\\n concated_source_vecs, [src_seq_len, batch_size * num_heads, -1])\\n # TODO(yonghui): Rewrite the following with just one transpose.\\n packed_src.source_contexts = tf.transpose(\\n tf.reshape(concated_source_contexts,\\n [src_seq_len, batch_size * num_heads, -1]), [1, 0, 2])\\n if source_padding is not None:\\n packed_src.source_padding = tf.reshape(\\n source_padding, [src_seq_len, batch_size * num_heads])\\n else:\\n packed_src.source_padding = tf.zeros(\\n [src_seq_len, batch_size * num_heads], dtype=py_utils.FPropDtype(p))\\n if source_segment_id is None:\\n packed_src.source_segment_id = tf.zeros(\\n [src_seq_len, batch_size * num_heads],\\n dtype=packed_src.source_padding.dtype)\\n else:\\n packed_src.source_segment_id = tf.reshape(\\n source_segment_id, [src_seq_len, batch_size * num_heads])\\n return packed_src\\n\\n @py_utils.NameScopeDecorator(\\n 'MultiHeadedAttention/ComputeContextVectorWithCachedSource')\\n def ComputeContextVectorWithCachedSource(self,\\n theta,\\n cached_src,\\n query_vec,\\n attention_state=None,\\n per_step_source_padding=None,\\n query_segment_id=None):\\n \\\"\\\"\\\"Same as the ComputeContextVectorWithSource api above, except values ...\\n\\n in source_vecs, source_contexts and source_padding are ordered differently.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n cached_src: A `.NestedMap` object returned by ExtendSourcePacked.\\n query_vec: a tensor of shape [target_batch, query_dim].\\n attention_state: previous attention state. It is not used in\\n AdditiveAttention, and is simply passed through.\\n per_step_source_padding: Source sequence padding to apply at this step. If\\n not None, it should be of shape [target_batch_size, source_length].\\n query_segment_id: a tensor of shape [target_batch].\\n\\n Returns:\\n A tuple of 3 tensors:\\n\\n - The attention context vector: [target_batch, source_dim]\\n - The attention probability vector: [target_batch, time]\\n - The new attention mechanism state: possibly nested tuple of tensors with\\n dimensions [target_batch....]\\n \\\"\\\"\\\"\\n return self.ComputeContextVectorWithSource(\\n theta, self.PackCachedSource(cached_src), query_vec, attention_state,\\n per_step_source_padding, query_segment_id)\\n\\n\\nclass LocationSensitiveAttention(BaseAttentionLayer):\\n \\\"\\\"\\\"An attention that also takes into account previously attended locations.\\n\\n See section 2.2 of this paper for a description of this technique:\\n http://papers.nips.cc/paper/5847-attention-based-models-for-speech-recognition.pdf\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def Params(cls):\\n \\\"\\\"\\\"Params for this LocationSensitiveAttention class.\\\"\\\"\\\"\\n p = super().Params()\\n p.Define('source_dim', 0, 'Number of source nodes.')\\n p.Define('location_filter_size', 0,\\n 'Location filter size, should be an odd number e.g. 31.')\\n p.Define('location_num_filters', 0, 'Number of location filters, e.g. 32.')\\n p.Define('query_dim', 0, 'Number of query nodes.')\\n p.Define('hidden_dim', 0, 'Number of hidden nodes.')\\n p.Define(\\n 'same_batch_size', False,\\n 'True iff the source and target sequence has the same batch size.')\\n p.Define(\\n 'location_features', ['PREV_PROBS'],\\n 'List signals to run the convolutions on. Possible options are: '\\n 'PREV_PROBS, CUMULATIVE_PROBS.')\\n\\n # Often the attention context output needs to be concated\\n # with tensors from another layer. This allows them to share\\n # quantization parameters. By convention, all attention layers\\n # need to include their context output vectors in this domain.\\n p.qdomain.Define('atten_context', None,\\n 'Quantization domain for attention context.')\\n\\n # Fill in reasonable default for params init\\n p.params_init = py_utils.WeightInit.GaussianSqrtDim()\\n return p\\n\\n def __init__(self, params):\\n \\\"\\\"\\\"Constructs an LocationSensitiveAttention object.\\\"\\\"\\\"\\n super().__init__(params)\\n p = self.params\\n self._is_quantized = p.qdomain.default is not None\\n assert not p.packed_input, ('Packed input is not supported yet for '\\n 'LocationSensitiveAttention.')\\n\\n if p.atten_dropout_prob != 0:\\n raise NotImplementedError('dropout is not supported')\\n\\n def AttenLogits(inputs):\\n \\\"\\\"\\\"Generates logits.\\\"\\\"\\\"\\n fns = self.fns\\n\\n def CollapseOutDim(x):\\n return tf.reshape(x, [-1, tf.shape(x)[-1]])\\n\\n # => [sl, sb, hd]\\n location_feats = tf.transpose(inputs.location_feats, [2, 0, 1])\\n location_hidden = fns.qmatmul(\\n CollapseOutDim(location_feats),\\n inputs.location_var,\\n qout_name='logits_mul')\\n\\n sl = py_utils.GetShape(location_feats)[0]\\n tb = py_utils.GetShape(location_feats)[1]\\n hd = py_utils.GetShape(inputs.location_var)[1]\\n location_hidden = tf.reshape(location_hidden, [sl, tb, hd])\\n sb = py_utils.GetShape(inputs.query_vec_reshaped)[2]\\n bs_mult = py_utils.GetShape(inputs.query_vec_reshaped)[1]\\n location_hidden = tf.reshape(location_hidden, [sl, bs_mult, sb, hd])\\n\\n # Shape of summed is [sl, tb/sb, sb, hidden_dim].\\n summed = fns.qadd(\\n inputs.concated_source_vecs,\\n inputs.query_vec_reshaped,\\n qout_name='logits_add')\\n summed = fns.qadd(summed, location_hidden, qout_name='logits_bias')\\n summed = fns.qtanh(summed)\\n # logits is of shape [sl * tb/sb * sb, 1]. Computes dot product\\n # between v with every rows in 'summed'. Then we reshape the\\n # result to be of shape [sl, tb/sb, sb].\\n logits = fns.qmatmul(\\n tf.reshape(summed, [-1, p.hidden_dim]),\\n tf.reshape(inputs.hidden_v, [p.hidden_dim, 1]),\\n qout_name='logits')\\n logits = tf.reshape(logits, py_utils.GetShape(summed)[:3])\\n return logits\\n\\n def AttenLogitsSameBatchSize(inputs):\\n \\\"\\\"\\\"Generates logits.\\n\\n Optimized code path for when the target and the source have the same batch\\n size.\\n\\n Args:\\n inputs: a NestedMap containing:\\n - concated_source_vecs: Tensor of shape [sl, batch, dim]\\n - query_vec_transformed: Tensor of shape [batch, dim]\\n - hidden_v: Tensor of shape [dim]\\n - location_feats: Tensor of shape [batch, location_feature_dim, sl]\\n - location_var: Tensor of shape [location_feature_dim, dim]\\n\\n Returns:\\n logits in the shape [sl, batch_size].\\n \\\"\\\"\\\"\\n\\n def CollapseOutDim(x):\\n return tf.reshape(x, [-1, tf.shape(x)[-1]])\\n\\n fns = self.fns\\n # => [sl, sb, hd]\\n location_feats = tf.transpose(inputs.location_feats, [2, 0, 1])\\n location_hidden = fns.qmatmul(\\n CollapseOutDim(location_feats),\\n inputs.location_var,\\n qout_name='logits_mul')\\n sl = tf.shape(location_feats)[0]\\n tb = tf.shape(location_feats)[1]\\n hd = tf.shape(inputs.location_var)[1]\\n location_hidden = tf.reshape(location_hidden, [sl, tb, hd])\\n\\n # Shape of summed is [sl, sb, hidden_dim].\\n summed = fns.qadd(\\n inputs.concated_source_vecs,\\n tf.expand_dims(inputs.query_vec_transformed, 0),\\n qout_name='logits_add')\\n\\n summed = fns.qadd(summed, location_hidden, qout_name='logits_bias')\\n summed = fns.qtanh(summed)\\n\\n # logits is of shape [sl * sb, 1]. Computes dot product\\n # between v with every rows in 'summed'. Then we reshape the\\n # result to be of shape [sl, tb].\\n logits = fns.qmatmul(\\n tf.reshape(summed, [-1, p.hidden_dim]),\\n tf.reshape(inputs.hidden_v, [p.hidden_dim, 1]),\\n qout_name='logits')\\n logits = tf.reshape(logits, py_utils.GetShape(summed)[:2])\\n return logits\\n\\n def Atten(hidden_var, query_var, source_padding, concated_source_vecs,\\n concated_source_contexts, query_vec, attention_state,\\n location_filter_var, location_var, per_step_source_padding):\\n \\\"\\\"\\\"Computes the attention context vector.\\\"\\\"\\\"\\n p = self.params\\n # attention_state shape [batch, len(p.location_features), slen]\\n # it contains previous and accumulated attention probabilites.\\n attention_state = py_utils.HasShape(attention_state,\\n [-1, len(p.location_features), -1])\\n\\n fns = self.fns\\n location_feats = self._ApplyConv(attention_state, location_filter_var)\\n\\n # concated_source_vecs is of shape [sl, sb, dims]\\n # concated_source_contexts is of shape [sb, sl, context_dim]\\n # query_vec is of shape [tb, dims]\\n sb = py_utils.GetShape(concated_source_vecs)[1]\\n tb = py_utils.GetShape(query_vec)[0]\\n multiplier = tb // sb\\n # concated_source_vecs is reshaped to [sl, 1, sb, hidden_dims]\\n concated_source_vecs = tf.expand_dims(concated_source_vecs, 1)\\n query_vec_transformed = fns.qmatmul(\\n query_vec, query_var, qout_name='atten_matmul')\\n # query_vec is reshaped to [1, tb/sb, sb, hidden_dims].\\n query_vec_reshaped = tf.reshape(query_vec_transformed,\\n [1, multiplier, sb, p.hidden_dim])\\n # logits is of shape [sl, tb/sb, sb]\\n logits = _ConditionalCallDefun(\\n self._is_quantized, AttenLogits,\\n py_utils.NestedMap(\\n concated_source_vecs=concated_source_vecs,\\n query_vec_reshaped=query_vec_reshaped,\\n hidden_v=hidden_var,\\n location_feats=location_feats,\\n location_var=location_var))\\n # Take out the padding states.\\n # _source_padding is of shape [sl, sb].\\n # reshaped to [sl, 1, sb].\\n source_padding = tf.expand_dims(source_padding, 1)\\n per_step_source_padding = tf.reshape(\\n tf.transpose(per_step_source_padding), [-1, multiplier, sb])\\n source_padding = tf.add(source_padding, per_step_source_padding)\\n source_padding = self.QRAct(source_padding,\\n quant_utils.QDistribution.PADDING)\\n\\n # Reshape logits to a matrix of shape [tb, sl] and takes the\\n # softmax to compute the probabilities.\\n logits = tf.transpose(tf.reshape(logits, [-1, tb]))\\n source_padding = tf.transpose(tf.reshape(source_padding, [-1, tb]))\\n probs = self._PaddedSoftmax(logits, source_padding)\\n # Reshape probs to be of shape [tb/sb, sb, sl].\\n probs_reshaped = tf.reshape(probs, [multiplier, sb, -1])\\n # Transpose probs to be of shape [sb, tb/sb, sl]\\n probs_reshaped = tf.transpose(probs_reshaped, [1, 0, 2])\\n # [sb, tb/sb, sl] * [sb, sl, context_dim] = [sb, tb/sb, context_dim]\\n summed = fns.qbatchmatmul(\\n tf.cast(probs_reshaped, concated_source_contexts.dtype),\\n concated_source_contexts,\\n qout_name='atten_context')\\n # summed is of shape [tb/sb, sb, context_dim]\\n summed = tf.transpose(summed, [1, 0, 2])\\n return tf.reshape(summed, [tb, -1]), probs\\n\\n def AttenSameBatchSize(hidden_var, query_var, source_padding,\\n concated_source_vecs, concated_source_contexts,\\n query_vec, attention_state, location_filter_var,\\n location_var, per_step_source_padding):\\n \\\"\\\"\\\"Computes the attention context vector.\\n\\n Optimized code path for when source and target have the same batch size.\\n \\\"\\\"\\\"\\n del per_step_source_padding\\n p = self.params\\n # attention_state shape [batch, len(p.location_features), slen]\\n # it contains previous and accumulated attention probabilites.\\n attention_state = py_utils.HasShape(attention_state,\\n [-1, len(p.location_features), -1])\\n\\n fns = self.fns\\n location_feats = self._ApplyConv(attention_state, location_filter_var)\\n query_vec_transformed = fns.qmatmul(\\n query_vec, query_var, qout_name='atten_matmul')\\n # logits is of shape [sl, sb]\\n logits = _ConditionalCallDefun(\\n not self._is_quantized, AttenLogitsSameBatchSize,\\n py_utils.NestedMap(\\n concated_source_vecs=concated_source_vecs,\\n query_vec_transformed=query_vec_transformed,\\n hidden_v=hidden_var,\\n location_feats=location_feats,\\n location_var=location_var))\\n # => [sl, tb]\\n logits.set_shape(source_padding.shape)\\n # Reshape logits to a matrix of shape [tb, sl] and takes the\\n # softmax to compute the probabilities.\\n logits = tf.transpose(logits)\\n source_padding = tf.transpose(source_padding)\\n probs = self._PaddedSoftmax(logits, source_padding)\\n summed = fns.qbatchmatmul(\\n tf.cast(tf.expand_dims(probs, 1), concated_source_contexts.dtype),\\n concated_source_contexts,\\n qout_name='atten_context')\\n return tf.squeeze(summed, 1), probs\\n\\n if p.same_batch_size:\\n self._ctx_vec = AttenSameBatchSize\\n else:\\n self._ctx_vec = Atten\\n\\n def EncodeSource(src_w, vecs, ctxs):\\n fns = self.fns\\n time, batch = py_utils.GetShape(vecs, 2)\\n ctxs = py_utils.HasShape(ctxs, [time, batch, -1])\\n transformed_vecs = tf.reshape(\\n fns.qmatmul(\\n tf.reshape(vecs, [-1, p.source_dim]),\\n src_w,\\n qout_name='encode_matmul'), [time, batch, -1])\\n transposed_ctxs = tf.transpose(ctxs, [1, 0, 2])\\n return transformed_vecs, transposed_ctxs\\n\\n self._encode_source = EncodeSource\\n\\n def _CreateLayerVariables(self):\\n super()._CreateLayerVariables()\\n p = self.params\\n\\n pc = py_utils.WeightParams(\\n shape=[p.source_dim, p.hidden_dim],\\n init=p.params_init,\\n dtype=p.dtype,\\n collections=['LocationSensitiveAttention_vars'])\\n self.CreateVariable('source_var', pc)\\n\\n pc = py_utils.WeightParams(\\n shape=[p.query_dim, p.hidden_dim],\\n init=p.params_init,\\n dtype=p.dtype,\\n collections=['LocationSensitiveAttention_vars'])\\n self.CreateVariable('query_var', pc)\\n\\n pc = py_utils.WeightParams(\\n shape=[p.hidden_dim],\\n init=p.params_init,\\n dtype=p.dtype,\\n collections=['LocationSensitiveAttention_vars'])\\n self.CreateVariable('hidden_var', pc)\\n\\n assert p.location_filter_size % 2 == 1\\n assert p.location_num_filters > 0\\n\\n location_filter_shape = [\\n p.location_filter_size,\\n len(p.location_features), p.location_num_filters\\n ]\\n # TODO(yonghui): Don't hard code how params are initialized.\\n location_filter_pc = py_utils.WeightParams(\\n shape=location_filter_shape,\\n init=py_utils.WeightInit.Uniform(0.05),\\n dtype=p.dtype,\\n collections=['LocationSensitiveAttention_vars'])\\n self.CreateVariable('location_filter_var', location_filter_pc)\\n location_var_shape = [p.location_num_filters, p.hidden_dim]\\n location_pc = py_utils.WeightParams(\\n shape=location_var_shape,\\n init=py_utils.WeightInit.Uniform(0.05),\\n dtype=p.dtype,\\n collections=['LocationSensitiveAttention_vars'])\\n self.CreateVariable('location_var', location_pc)\\n\\n self.TrackQTensor('atten_conv')\\n self.TrackQTensor('atten_context', domain='atten_context')\\n self.TrackQTensor(\\n 'atten_matmul',\\n 'logits_add',\\n 'encode_matmul',\\n 'logits_mul',\\n 'logits_bias',\\n domain='fullyconnected')\\n\\n def AddGlobalVN(self, theta):\\n theta = super().AddGlobalVN(theta)\\n theta.source_var = self.AddVN(theta.source_var)\\n theta.hidden_var = self.AddVN(theta.hidden_var)\\n theta.query_var = self.AddVN(theta.query_var)\\n theta.location_filter_var = self.AddVN(theta.location_filter_var)\\n theta.location_var = self.AddVN(theta.location_var)\\n return theta\\n\\n def _ApplyConv(self, attention_state, location_filter_var):\\n \\\"\\\"\\\"Applies the convolution on attention state.\\\"\\\"\\\"\\n p = self.params\\n fns = self.fns\\n attention_state_f32 = attention_state\\n location_filter_var_f32 = location_filter_var\\n if p.dtype != tf.float32:\\n attention_state_f32 = tf.cast(attention_state, tf.float32)\\n location_filter_var_f32 = tf.cast(location_filter_var, tf.float32)\\n data_format = 'NCW'\\n if py_utils.use_xla() in ('', 'cpu'):\\n # NCW format is not supported on CPU.\\n attention_state_f32 = tf.transpose(attention_state_f32, [0, 2, 1])\\n data_format = 'NWC'\\n location_feats = fns.qconv1d(\\n attention_state_f32,\\n location_filter_var_f32,\\n 1,\\n 'SAME',\\n data_format=data_format,\\n qout_name='atten_conv')\\n if py_utils.use_xla() in ('', 'cpu'):\\n location_feats = tf.transpose(location_feats, [0, 2, 1])\\n if p.dtype != tf.float32:\\n location_feats = tf.cast(location_feats, p.dtype)\\n # [sb, hd, sl]\\n return location_feats\\n\\n def PackSource(self,\\n theta,\\n source_vecs,\\n source_contexts,\\n source_padding,\\n source_segment_id=None):\\n with tf.name_scope(self.params.name):\\n if source_segment_id is None:\\n source_segment_id = tf.zeros_like(source_padding)\\n (concated_source_vecs, concated_source_contexts) = (\\n self._encode_source(\\n self.QWeight(theta.source_var), source_vecs, source_contexts))\\n return py_utils.NestedMap(\\n # [time, batch_size, hidden_dim].\\n source_vecs=concated_source_vecs,\\n # [batch_size, time, context_dim].\\n # Note the mismatch between `source_vecs` and `source_contexts`. In\\n # `source_vecs`, time is the first dim, while it is the second dim in\\n # `source_contexts`.\\n source_contexts=concated_source_contexts,\\n # [time, batch_size].\\n source_padding=source_padding,\\n # [time, batch_size].\\n source_segment_id=source_segment_id)\\n\\n def ZeroAttentionState(self, source_length, decoder_batch_size):\\n p = self.params\\n dtype = p.dtype.real_dtype\\n num_features = len(p.location_features)\\n with tf.name_scope(p.name):\\n state = tf.concat([\\n tf.ones([decoder_batch_size, num_features, 1], dtype=dtype),\\n tf.zeros([decoder_batch_size, num_features, source_length - 1],\\n dtype=dtype)\\n ], 2)\\n\\n state = self.QRAct(\\n state, quant_utils.QDistribution.SOFTMAX, domain='softmax')\\n return state\\n\\n def ComputeContextVectorWithSource(self,\\n theta,\\n packed_src,\\n query_vec,\\n attention_state=None,\\n per_step_source_padding=None,\\n query_segment_id=None):\\n \\\"\\\"\\\"Computes the context vector given the current query output.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n packed_src: A `.NestedMap` object returned by PackSource or\\n InitForSourcePacked.\\n query_vec: a tensor of shape [batch_size, query_dim].\\n attention_state: If `params().location_features == ['PREV_PROBS',\\n 'CUMULATIVE_PROBS']`, then `attention_state` is a tensor of shape\\n [batch_size, 2, src_len].\\n\\n - attention_state[:, 0, :] contains previous attention probabilities.\\n - attention_state[:, 1, :] contains a sum over previous timesteps of\\n attention probabilities.\\n\\n per_step_source_padding: Source sequence padding to apply at this step. If\\n not None, it should be of shape [target_batch_size, source_length].\\n query_segment_id: Query segment id with shape [batch_size].\\n\\n Note: concated_source_vecs are the vectors that are used to compute the\\n attention score between the query_vec and each concated_source_vec. The\\n concated_source_contexts are the vectors that compose the result. The\\n attention context vector is computed as a weighted average of the\\n concated_source_contexts, using the scores that were computed using\\n concated_source_vecs.\\n\\n Returns:\\n A tuple of 3 elements.\\n\\n - The attention context vector: [batch_size, context_dim]\\n - The attention probability vector: [batch_size, time]\\n - The new attention mechanism state: possibly nested tuple of tensors with\\n dimensions [target_batch, ...]\\n \\\"\\\"\\\"\\n del query_segment_id\\n p = self.params\\n concated_source_vecs = packed_src.source_vecs\\n concated_source_contexts = packed_src.source_contexts\\n source_padding = packed_src.source_padding\\n if p.same_batch_size:\\n assert per_step_source_padding is None\\n query_batch_size = py_utils.GetShape(query_vec)[0]\\n source_length = py_utils.GetShape(source_padding)[0]\\n if per_step_source_padding is None:\\n zero = tf.constant(0.0, dtype=query_vec.dtype)\\n per_step_source_padding = tf.fill([query_batch_size, source_length], zero)\\n per_step_source_padding = py_utils.HasShape(\\n per_step_source_padding, [query_batch_size, source_length])\\n hidden = self.AddVN(theta.hidden_var, per_step=True)\\n query = self.AddVN(theta.query_var, per_step=True)\\n location_filter = self.AddVN(theta.location_filter_var, per_step=True)\\n location = self.AddVN(theta.location_var, per_step=True)\\n\\n ctx_vec, prob = self._ctx_vec(hidden, query, source_padding,\\n concated_source_vecs,\\n concated_source_contexts, query_vec,\\n attention_state, location_filter, location,\\n per_step_source_padding)\\n\\n new_feats = {'PREV_PROBS': prob}\\n if 'CUMULATIVE_PROBS' in p.location_features:\\n # Quantization must match the _PaddedSoftmax method.\\n cum_prob_index = p.location_features.index('CUMULATIVE_PROBS')\\n cum_probs = tf.add(prob, attention_state[:, cum_prob_index, :])\\n cum_probs = self.QRAct(\\n cum_probs, quant_utils.QDistribution.SOFTMAX, domain='softmax')\\n new_feats['CUMULATIVE_PROBS'] = cum_probs\\n new_attention_state = tf.stack([new_feats[f] for f in p.location_features],\\n axis=1)\\n return ctx_vec, prob, new_attention_state\\n\\n\\ndef MergeSourcePaddingWithPerStepSourcePadding(source_padding,\\n per_step_source_padding, tb):\\n \\\"\\\"\\\"Merges source padding with per-step source padding.\\n\\n Args:\\n source_padding: [sl, sb].\\n per_step_source_padding: [tb, sl].\\n tb: target batch size.\\n\\n Returns:\\n A tensor of shape [tb, sl].\\n \\\"\\\"\\\"\\n # source_padding is of shape [sl, sb].\\n sl = py_utils.GetShape(source_padding)[0]\\n sb = py_utils.GetShape(source_padding)[1]\\n\\n if per_step_source_padding is None:\\n zero = tf.constant(0.0, dtype=source_padding.dtype)\\n per_step_source_padding = tf.fill([tb, sl], zero)\\n per_step_source_padding = py_utils.HasShape(per_step_source_padding, [tb, sl])\\n\\n # Transpose and reshape source_padding to [1, sb, sl].\\n source_padding = tf.expand_dims(tf.transpose(source_padding), 0)\\n # Merge source_padding and per_step_source_padding.\\n source_padding = tf.maximum(source_padding,\\n tf.reshape(per_step_source_padding, [-1, sb, sl]))\\n return tf.reshape(source_padding, [tb, -1])\\n\\n\\nclass MonotonicAttention(BaseAttentionLayer):\\n \\\"\\\"\\\"An attention mechanism which enforces monotonic alignments.\\n\\n This layer implements the monotonic attention mechanism described in\\n Online and Linear-Time Attention by Enforcing Mononotonic Alignments\\n (https://arxiv.org/abs/1704.00784). It is used in exactly the same way as\\n AdditiveAttention, but both the attention distribution and the energy function\\n are different.\\n\\n Rather than using a softmax, this mechanism feeds the attention energy into a\\n (hard or soft) sigmoid and treats the output as Bernoulli probabilities\\n representing the probability of attending to a given entry in the input\\n sequence, processed from left-to-right. Based on this interpretation, the\\n resulting distribution over input sequence entries is computed with a dynamic\\n program. The intended use is to train with soft sigmoids according to the\\n expected output (setting param hard_sigmoid=False), then use hard sigmoids at\\n test time to allow for online and linear-time decoding. To encourge the train\\n and test-time behavior to be similar, noise can optionally be added to the\\n sigmoid activations during training (param pre_sigmoid_noise). For the energy\\n function, rather than computing::\\n\\n E = dot(v, tanh(dot(W, query) + dot(W, encoder_states)))\\n\\n it computes::\\n\\n E = dot(g*v/||v||, tanh(dot(W, query) + dot(W, encoder_states) + b)) + r\\n\\n where g and r are scalars and b is a vector, and ||v|| is the L2 norm of v.\\n instead. These modifications address the fact that the sigmoids in the\\n monotonic attention mechanism are sensitive to offset and a bit harder to\\n train compared to the softmax function. It can be helpful to initialize the\\n energy bias scalar r to a negative value (param hidden_bias_init).\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def Params(cls):\\n \\\"\\\"\\\"Params for this MonotonicAttention class.\\\"\\\"\\\"\\n p = super().Params()\\n p.Define('source_dim', 0, 'Number of source nodes.')\\n p.Define('query_dim', 0, 'Number of query nodes.')\\n p.Define('hidden_dim', 0, 'Number of hidden nodes.')\\n p.Define('pre_sigmoid_noise', 0, 'Standard deviation of pre-sigmoid noise.')\\n p.Define('hidden_bias_init', -1, 'Initial value of hidden bias.')\\n p.Define('hard_sigmoid', False, 'Whether to use a hard sigmoid.')\\n # Fill in reasonable default for params init\\n p.params_init = py_utils.WeightInit.GaussianSqrtDim()\\n return p\\n\\n def __init__(self, params):\\n \\\"\\\"\\\"Constructs an MonotonicAttention object.\\\"\\\"\\\"\\n super().__init__(params)\\n p = self.params\\n assert not p.packed_input, ('Packed input not supported for Monotonic '\\n 'Attention.')\\n if p.atten_dropout_prob != 0:\\n raise NotImplementedError('dropout is not supported')\\n\\n # When running eval, don't add pre-sigmoid noise, and use a hard sigmoid to\\n # match behavior of online decoding.\\n if self.do_eval:\\n p.pre_sigmoid_noise = 0.\\n p.hard_sigmoid = True\\n\\n def EncodeSource(src_w, vecs, ctxs):\\n time, batch = py_utils.GetShape(vecs, 2)\\n ctxs = py_utils.HasShape(ctxs, [time, batch, -1])\\n transformed_vecs = tf.reshape(\\n py_utils.Matmul(tf.reshape(vecs, [-1, p.source_dim]), src_w),\\n [time, batch, -1])\\n transposed_ctxs = tf.transpose(ctxs, [1, 0, 2])\\n return transformed_vecs, transposed_ctxs\\n\\n self._encode_source = EncodeSource\\n\\n def _CreateLayerVariables(self):\\n super()._CreateLayerVariables()\\n p = self.params\\n\\n # source is the weight matrix for the memory/encoder states\\n pc = py_utils.WeightParams(\\n shape=[p.source_dim, p.hidden_dim],\\n init=p.params_init,\\n dtype=p.dtype,\\n collections=['MonotonicAttention_vars'])\\n self.CreateVariable('source_var', pc)\\n\\n # query is the weight matrix for the query/decoder RNN state\\n pc = py_utils.WeightParams(\\n shape=[p.query_dim, p.hidden_dim],\\n init=p.params_init,\\n dtype=p.dtype,\\n collections=['MonotonicAttention_vars'])\\n self.CreateVariable('query_var', pc)\\n\\n # hidden is the pre-softmax vector which converts from tanh to scalar\\n pc = py_utils.WeightParams(\\n shape=[p.hidden_dim],\\n init=p.params_init,\\n dtype=p.dtype,\\n collections=['MonotonicAttention_vars'])\\n self.CreateVariable('hidden_var', pc)\\n\\n # energy_bias is the bias vector which appears inside of tanh\\n # Initialize the bias vector to all zeros\\n pc = py_utils.WeightParams(\\n shape=[p.hidden_dim],\\n init=py_utils.WeightInit.Constant(0.0),\\n dtype=p.dtype,\\n collections=['MonotonicAttention_vars'])\\n self.CreateVariable('energy_bias_var', pc)\\n\\n # hidden_scale is the weight normalization scale for hidden\\n # Initialize so that the initial scale is 1/sqrt(hidden_dim)\\n pc = py_utils.WeightParams(\\n shape=[],\\n init=py_utils.WeightInit.Constant(1 / np.sqrt(p.hidden_dim)),\\n dtype=p.dtype,\\n collections=['MonotonicAttention_vars'])\\n self.CreateVariable('hidden_scale_var', pc)\\n\\n # hidden_bias is the bias scalar applied before the sigmoid\\n # Use the hidden_bias_init hyperparam to set the initial value\\n pc = py_utils.WeightParams(\\n shape=[],\\n init=py_utils.WeightInit.Constant(p.hidden_bias_init),\\n dtype=p.dtype,\\n collections=['MonotonicAttention_vars'])\\n self.CreateVariable('hidden_bias_var', pc)\\n\\n def AddGlobalVN(self, theta):\\n theta = super().AddGlobalVN(theta)\\n theta.source_var = self.AddVN(theta.source_var)\\n theta.hidden_var = self.AddVN(theta.hidden_var)\\n theta.query_var = self.AddVN(theta.query_var)\\n return theta\\n\\n def PackSource(self,\\n theta,\\n source_vecs,\\n source_contexts,\\n source_padding,\\n source_segment_id=None):\\n with tf.name_scope(self.params.name):\\n if source_segment_id is None:\\n source_segment_id = tf.zeros_like(source_padding)\\n (concated_source_vecs, concated_source_contexts) = (\\n self._encode_source(theta.source_var, source_vecs, source_contexts))\\n return py_utils.NestedMap(\\n # [time, batch_size, hidden_dim].\\n source_vecs=concated_source_vecs,\\n # [batch_size, time, context_dim].\\n # Note the mismatch between `source_vecs` and `source_contexts`. In\\n # `source_vecs`, time is the first dim, while it is the second dim in\\n # `source_contexts`.\\n source_contexts=concated_source_contexts,\\n # [time, batch_size].\\n source_padding=source_padding,\\n # [time, batch_size].\\n source_segment_id=source_segment_id)\\n\\n def ZeroAttentionState(self, source_length, decoder_batch_size):\\n p = self.params\\n dtype = p.dtype\\n with tf.name_scope(p.name):\\n # Set initial previous attention to [1, 0, ... 0] to avoid special-casing\\n emit_probs = tf.one_hot(\\n tf.zeros((decoder_batch_size,), dtype=tf.int32),\\n source_length,\\n dtype=dtype)\\n return py_utils.NestedMap(emit_probs=emit_probs)\\n\\n def ComputeProbabilities(self, theta, concated_source_vecs,\\n merged_source_padding, query_vec, attention_state):\\n \\\"\\\"\\\"Computes probabilities of emissions.\\\"\\\"\\\"\\n\\n # concated_source_contexts is of shape [sb, sl, context_dim]\\n # query_vec is of shape [tb, dims]\\n sb = tf.shape(concated_source_vecs)[1]\\n tb = tf.shape(query_vec)[0]\\n multiplier = tb // sb\\n\\n p = self.params\\n\\n def AttenLogits(inputs):\\n \\\"\\\"\\\"Computes logits from source, query, and variables.\\n\\n Args:\\n inputs: a NestedMap containing:\\n - concated_source_vecs: [sl, sb, hidden_dims].\\n - query_vec: [tb, query_dim].\\n - query_v: [query_dim, hidden_dim]\\n - energy_b: [hidden_dim].\\n - hidden_v: [hidden_dim].\\n - hidden_g: [].\\n - hidden_b: [].\\n\\n Returns:\\n logits shaped [tb, sl].\\n \\\"\\\"\\\"\\n # Apply query matrix to query. Becomes [tb, hidden_dim].\\n query_vec_transformed = py_utils.Matmul(\\n inputs.query_vec, inputs.query_v, name='query_transformation')\\n # query_vec is reshaped to [1, tb/sb, sb, hidden_dim].\\n query_vec_reshaped = tf.reshape(query_vec_transformed,\\n [1, multiplier, sb, p.hidden_dim])\\n\\n # [sl, 1, sb, hidden_dim].\\n concated_source_vecs = tf.expand_dims(inputs.concated_source_vecs, 1)\\n energy_b = tf.reshape(inputs.energy_b, [1, 1, 1, -1])\\n # Shape of summed is [sl, tb/sb, sb, hidden_dim].\\n summed = tf.tanh(concated_source_vecs + query_vec_reshaped + energy_b)\\n hidden_v = inputs.hidden_g * tf.nn.l2_normalize(inputs.hidden_v, axis=0)\\n # logits is of shape [sl * tb/sb * sb, 1]. Computes dot product\\n # between v with every rows in 'summed'. Then we reshape the\\n # result to be of shape [sl, tb/sb, sb].\\n #\\n # Another equivalent way is to do:\\n # logits = tf.reduce_sum(summed *\\n # tf.reshape(v, [1, 1, 1, hidden_dim]), 3)\\n logits = py_utils.Matmul(\\n tf.reshape(summed, [-1, p.hidden_dim]),\\n tf.reshape(hidden_v, [p.hidden_dim, 1]))\\n logits += inputs.hidden_b\\n # [tb, sl].\\n logits = tf.transpose(tf.reshape(logits, [-1, tb]), [1, 0])\\n return logits\\n\\n with tf.name_scope('logits'):\\n logits = py_utils.CallDefun(\\n AttenLogits,\\n py_utils.NestedMap(\\n concated_source_vecs=concated_source_vecs,\\n query_vec=query_vec,\\n query_v=theta.query_var,\\n energy_b=theta.energy_bias_var,\\n hidden_v=theta.hidden_var,\\n hidden_g=theta.hidden_scale_var,\\n hidden_b=theta.hidden_bias_var))\\n\\n previous_attention = attention_state.emit_probs\\n with tf.name_scope('prob'):\\n if self.params.hard_sigmoid:\\n # If using a hard sigmoid, just compare against 0\\n p_choose_i = tf.cast(tf.greater(logits, 0), logits.dtype)\\n # Never choose padded values.\\n p_choose_i = tf.where(merged_source_padding > 0.0,\\n tf.zeros_like(p_choose_i), p_choose_i)\\n # Compute probability distribution assuming hard probabilities\\n probs = MonotonicAttentionProb(p_choose_i, previous_attention, 'hard')\\n else:\\n # Compute pre-sigmoid noise.\\n activation_noise = tf.random.stateless_normal(\\n py_utils.GetShape(logits),\\n py_utils.GenerateStepSeedPair(p),\\n dtype=logits.dtype)\\n # Compute sigmoid probabilities.\\n p_choose_i = tf.nn.sigmoid(logits + self.params.pre_sigmoid_noise *\\n activation_noise)\\n # Never choose padded values.\\n p_choose_i = tf.where(merged_source_padding > 0,\\n tf.zeros_like(p_choose_i), p_choose_i)\\n # Compute attention distribution\\n probs = MonotonicAttentionProb(p_choose_i, previous_attention,\\n 'parallel')\\n\\n # [tb, sl].\\n return probs, py_utils.NestedMap(emit_probs=probs)\\n\\n def ComputeContextVectorWithSource(self,\\n theta,\\n packed_src,\\n query_vec,\\n attention_state,\\n per_step_source_padding=None,\\n query_segment_id=None):\\n \\\"\\\"\\\"Computes the context vector given the current query output.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n packed_src: A `.NestedMap` object returned by PackSource or\\n InitForSourcePacked.\\n query_vec: a tensor of shape [batch_size, query_dim].\\n attention_state: The attention probs computed at the previous timestep.\\n per_step_source_padding: Source sequence padding to apply at this step. If\\n not None, it should be of shape [target_batch_size, source_length].\\n query_segment_id: a tensor of shape [batch_size].\\n Note: concated_source_vecs are the vectors that are used to compute the\\n attention score between the query_vec and each concated_source_vec. The\\n concated_source_contexts are the vectors that compose the result. The\\n attention context vector is computed as a weighted average of the\\n concated_source_contexts, using the scores that were computed using\\n concated_source_vecs.\\n\\n Returns:\\n A tuple of 3 elements.\\n\\n - The attention context vector: [batch_size, context_dim]\\n - The attention probability vector: [batch_size, time]\\n - The attention probability vector: (again, to be interpreted as state).\\n \\\"\\\"\\\"\\n del query_segment_id\\n concated_source_vecs = packed_src.source_vecs\\n concated_source_contexts = packed_src.source_contexts\\n source_padding = packed_src.source_padding\\n sb = tf.shape(concated_source_vecs)[1]\\n tb = tf.shape(query_vec)[0]\\n multiplier = tb // sb\\n merged_source_padding = MergeSourcePaddingWithPerStepSourcePadding(\\n source_padding, per_step_source_padding, tb)\\n\\n probs, new_state = self.ComputeProbabilities(theta, concated_source_vecs,\\n merged_source_padding,\\n query_vec, attention_state)\\n\\n with tf.name_scope('sum'):\\n # Reshape probs to be of shape [tb/sb, sb, sl]\\n probs_reshaped = tf.reshape(probs, [multiplier, sb, -1])\\n # Transpose probs to be of shape [sb, tb/sb, sl]\\n probs_reshaped = tf.transpose(probs_reshaped, [1, 0, 2])\\n # Batched matmul\\n # [sb, tb/sb, sl] * [sb, sl, context_dim] = [sb, tb/sb, context_dim]\\n summed = tf.matmul(probs_reshaped, concated_source_contexts)\\n # summed is of shape [tb/sb, sb, context_dim]\\n summed = tf.transpose(summed, [1, 0, 2])\\n ctx_vec = tf.reshape(summed, [tb, -1])\\n\\n return ctx_vec, probs, new_state\\n\\n\\nclass GmmMonotonicAttention(BaseAttentionLayer):\\n \\\"\\\"\\\"A GMM-based monotonic attention module.\\n\\n Based on \\\"Generating Sequences With Recurrent Neural Networks\\\" by Alex Graves.\\n Eq [46-51] in https://arxiv.org/abs/1308.0850.\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def Params(cls):\\n \\\"\\\"\\\"Params for this MonotonicAttention class.\\\"\\\"\\\"\\n p = super().Params()\\n p.Define('source_dim', 0, 'Number of source nodes.')\\n p.Define('query_dim', 0, 'Number of query nodes.')\\n p.Define('hidden_dim', 128,\\n 'Number of hidden units for the MLP that predicts GMM params.')\\n p.Define('max_offset', -1,\\n 'Max offset to move attention pointer, Enabled only when > 0.')\\n p.Define('num_mixtures', 5, 'Number of location GMM components.')\\n p.Define(\\n 'normalize_probs', False,\\n 'Whether to normalize probabilities computed by GMM. Otherwise, '\\n 'the attention weights (i.e. probabilities) may not add up to '\\n '1.0.')\\n\\n # TODO(ngyuzh): find a good initialize for both TTS and ASR. Consider split\\n # the layer if it's very sensitive to the initialization\\n p.params_init = py_utils.WeightInit.Xavier(0.1)\\n return p\\n\\n def __init__(self, params):\\n \\\"\\\"\\\"Constructs a GMM-based monotonic attention module.\\\"\\\"\\\"\\n super().__init__(params)\\n p = self.params\\n if p.atten_dropout_prob != 0:\\n raise NotImplementedError('dropout is not supported.')\\n\\n # TODO(ngyuzh): Compare Sigmoid and other activation functions.\\n ff_params = layers.FeedForwardNet.Params().Set(\\n name=p.name,\\n input_dim=p.query_dim,\\n hidden_layer_dims=[p.hidden_dim, p.num_mixtures * 3],\\n activation=['SIGMOID', 'NONE'],\\n params_init=p.params_init.Copy())\\n self.CreateChild('GMM', ff_params)\\n\\n def ComputeProbs(encoder_positions, priors, means, variances):\\n \\\"\\\"\\\"Computes the location GMM probabilities at all encoder positions.\\n\\n This function assumes that the first 2 dimensions of `priors`, `means`,\\n `variances`, and the return value:\\n `multiplier (target_batch / source_batch)` and `source_batch` are\\n transposed, and `encoder_positions` has only non-one dimensions.\\n\\n Args:\\n encoder_positions: [source_batch, source_length]\\n priors: [multiplier, source_batch, num_mixtures]\\n means: [multiplier, source_batch, num_mixtures]\\n variances: [multiplier, source_batch, num_mixtures]\\n\\n Returns:\\n Probabilities shaped [multiplier, source_batch, source_length].\\n \\\"\\\"\\\"\\n # [multiplier, source_batch, 1, num_mixtures]\\n priors = tf.expand_dims(priors, 2)\\n means = tf.expand_dims(means, 2)\\n variances = tf.expand_dims(variances, 2)\\n epsilon = 1e-8\\n\\n # [source_batch, source_length, 1]\\n encoder_positions = tf.expand_dims(encoder_positions, 2)\\n\\n # [multiplier, source_batch, source_length, num_mixtures]\\n probs = ((priors * tf.math.rsqrt(2 * np.pi * variances + epsilon)) *\\n tf.exp(-(encoder_positions - means)**2 /\\n (2 * variances + epsilon)))\\n\\n # [multiplier, source_batch, source_length]\\n return tf.reduce_sum(probs, axis=3)\\n\\n def Atten(source_padding, concated_source_vecs, concated_source_contexts,\\n query_vec, priors, means, variances, encoder_positions,\\n per_step_source_padding):\\n \\\"\\\"\\\"Computes the attention context vector.\\n\\n Args:\\n source_padding: [source_length, source_batch]\\n concated_source_vecs: [source_length, source_batch, hidden_dim]\\n concated_source_contexts: [source_batch, source_length, context_dim]\\n query_vec: [target_batch, query_dim]\\n priors: [target_batch, num_mixtures]\\n means: [target_batch, num_mixtures]\\n variances: [target_batch, num_mixtures]\\n encoder_positions: [source_batch, source_length]\\n per_step_source_padding: [target_batch, source_length]\\n\\n Returns:\\n Tuple(context vector, atten probs):\\n\\n - context vector: [target_batch, context_dim]\\n - attention probabilities: [target_batch, source_length]\\n \\\"\\\"\\\"\\n # Note: shape [target_batch] can be converted to\\n # [multiplier, source_batch], not [source_batch, multiplier].\\n p = self.params\\n source_batch = tf.shape(concated_source_vecs)[1]\\n target_batch = tf.shape(query_vec)[0]\\n multiplier = target_batch // source_batch\\n\\n # [multiplier, source_batch, num_mixtures]\\n priors = tf.reshape(priors, [multiplier, source_batch, p.num_mixtures])\\n means = tf.reshape(means, [multiplier, source_batch, p.num_mixtures])\\n variances = tf.reshape(variances,\\n [multiplier, source_batch, p.num_mixtures])\\n\\n # [multiplier, source_batch, source_length]\\n probs = ComputeProbs(encoder_positions, priors, means, variances)\\n\\n # [source_batch, source_length]\\n source_padding = tf.transpose(source_padding)\\n\\n # [multiplier, source_batch, source_length]\\n per_step_source_padding = tf.reshape(per_step_source_padding,\\n [multiplier, source_batch, -1])\\n source_padding += per_step_source_padding\\n source_padding = tf.minimum(source_padding, 1.0)\\n\\n # [multiplier, source_batch, source_length]\\n probs *= (1.0 - source_padding)\\n if p.normalize_probs:\\n probs /= tf.maximum(tf.reduce_sum(probs, axis=2, keepdims=True), 1e-12)\\n\\n # [source_batch, multiplier, source_length]\\n probs_transposed = tf.transpose(probs, [1, 0, 2])\\n\\n # Matmul:\\n # [source_batch, multiplier, source_length]\\n # @ [source_batch, source_length, context_dim]\\n # -> [source_batch, multiplier, context_dim]\\n context_vector_transposed = tf.matmul(probs_transposed,\\n concated_source_contexts)\\n\\n # [multiplier, source_batch, context_dim]\\n context_vector = tf.transpose(context_vector_transposed, [1, 0, 2])\\n\\n # [target_batch, context_dim], [target_batch, source_length]\\n return (tf.reshape(context_vector, [target_batch, -1]),\\n tf.reshape(probs, [target_batch, -1]))\\n\\n self._ctx_vec = Atten\\n\\n def EncodeSource(vecs, ctxs):\\n # TODO(ngyuzh): combine with content-base attention.\\n time, batch = py_utils.GetShape(vecs, 2)\\n ctxs = py_utils.HasShape(ctxs, [time, batch, -1])\\n transposed_ctxs = tf.transpose(ctxs, [1, 0, 2])\\n return vecs, transposed_ctxs\\n\\n self._encode_source = EncodeSource\\n\\n def PackSource(self,\\n theta,\\n source_vecs,\\n source_contexts,\\n source_padding,\\n source_segment_id=None):\\n with tf.name_scope(self.params.name):\\n if source_segment_id is None:\\n source_segment_id = tf.zeros_like(source_padding)\\n (concated_source_vecs, concated_source_contexts) = (\\n self._encode_source(source_vecs, source_contexts))\\n return py_utils.NestedMap(\\n # [source_length, source_batch, hidden_dim].\\n source_vecs=concated_source_vecs,\\n # [source_batch, source_length, context_dim].\\n # Note the mismatch between `source_vecs` and `source_contexts`. In\\n # `source_vecs`, `source_length` is the first dim, while it is the\\n # second dim in `source_contexts`.\\n source_contexts=concated_source_contexts,\\n # [source_length, source_batch].\\n source_padding=source_padding,\\n # [source_length, source_batch].\\n source_segment_id=source_segment_id)\\n\\n def ZeroAttentionState(self, source_length, decoder_batch_size):\\n p = self.params\\n\\n # [target_batch, num_mixtures]\\n position = tf.zeros([decoder_batch_size, p.num_mixtures], dtype=p.dtype)\\n position_offsets = tf.zeros([decoder_batch_size, p.num_mixtures],\\n dtype=p.dtype)\\n variances = tf.ones([decoder_batch_size, p.num_mixtures], dtype=p.dtype)\\n priors = tf.zeros([decoder_batch_size, p.num_mixtures], dtype=p.dtype)\\n\\n # [target_batch, num_mixtures, 4]\\n return tf.stack([position, position_offsets, variances, priors], axis=2)\\n\\n def ComputeContextVectorWithSource(self,\\n theta,\\n packed_src,\\n query_vec,\\n attention_state,\\n per_step_source_padding=None,\\n query_segment_id=None):\\n \\\"\\\"\\\"Computes the context vector given the current query output.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n packed_src: A `.NestedMap` object returned by PackSource or\\n InitForSourcePacked.\\n query_vec: a tensor of shape [target_batch, query_dim].\\n attention_state: previous attention state, a tensor of shape\\n [target_batch, num_mixtures, 4].\\n - attention_state[:, :, 0] contains previous location\\n - attention_state[:, :, 1] contains previous offset.\\n - attention_state[:, :, 2] contains previous variance.\\n - attention_state[:, :, 3] contains previous prior.\\n per_step_source_padding: Source sequence padding to apply at this step. If\\n not None, it should be of shape [target_batch, source_length].\\n query_segment_id: a tensor of shape [target_batch].\\n Note: concated_source_vecs are the vectors that are used to compute the\\n attention score between the query_vec and each concated_source_vec. The\\n concated_source_contexts are the vectors that compose the result. The\\n attention context vector is computed as a weighted average of the\\n concated_source_contexts, using the scores that were computed using\\n concated_source_vecs.\\n\\n Returns:\\n A tuple of 3 elements.\\n\\n - The attention context vector: [target_batch, context_dim]\\n - The attention probability vector: [target_batch, source_length]\\n - The new attention state vector: [target_batch, num_mixtures, 4]\\n \\\"\\\"\\\"\\n del query_segment_id\\n p = self.params\\n concated_source_vecs = packed_src.source_vecs\\n concated_source_contexts = packed_src.source_contexts\\n source_padding = packed_src.source_padding\\n\\n target_batch = tf.shape(query_vec)[0]\\n source_length = tf.shape(source_padding)[0]\\n source_batch = tf.shape(source_padding)[1]\\n\\n # [target_batch, source_length]\\n if per_step_source_padding is None:\\n per_step_source_padding = tf.zeros([target_batch, source_length],\\n dtype=query_vec.dtype)\\n per_step_source_padding = py_utils.HasShape(per_step_source_padding,\\n [target_batch, source_length])\\n\\n # [target_batch, num_mixtures * 3]\\n out = self.GMM.FProp(theta.GMM, query_vec)\\n\\n # [target_batch, num_mixtures]\\n priors_logits, position_offset_logits, log_variances = tf.split(\\n out, 3, axis=1, name='GMM')\\n\\n log_variances = tf.minimum(log_variances, layers.LOG_SCALE_CLAMP_BOUND)\\n variances = tf.exp(log_variances)\\n\\n priors = tf.nn.softmax(priors_logits)\\n\\n if p.max_offset > 0:\\n position_offset = tf.nn.sigmoid(position_offset_logits)\\n position_offset *= p.max_offset\\n else:\\n position_offset = tf.exp(position_offset_logits)\\n\\n new_position = attention_state[:, :, 0] + position_offset\\n\\n # Tile and reshape encoder_positions to [source_batch, source_length]\\n # so that it can be evaluated by locations GMMs in a vectorized way.\\n encoder_positions = tf.expand_dims(\\n tf.cast(tf.range(source_length), tf.float32), 0)\\n encoder_positions = tf.tile(encoder_positions, [source_batch, 1])\\n\\n # [target_batch, context_dim], [target_batch, source_length]\\n ctx_vec, prob = self._ctx_vec(source_padding, concated_source_vecs,\\n concated_source_contexts, query_vec, priors,\\n new_position, variances, encoder_positions,\\n per_step_source_padding)\\n\\n # [target_batch, num_mixtures, 4]\\n new_atten_states = tf.stack(\\n [new_position, position_offset, variances, priors], axis=2)\\n\\n return ctx_vec, prob, new_atten_states\\n\\n\\nclass MergerLayer(base_layer.BaseLayer):\\n \\\"\\\"\\\"Merges a list of input tensors with various options into a single tensor.\\n\\n Implements a merger/combiner operator given a list of tensors. The merger\\n operator outputs a single tensor with the following options (merger_op):\\n\\n - atten: Applies attention over the set of input tensors given query vector.\\n - mean: Takes the mean of input tensors.\\n - concat: Concatenates the input tensors over the last dimension.\\n - sum: Sum up all the input tensors.\\n - weighted_sum: Use learnt weights to combine input tensors.\\n - gated_avg: Learnt input dependent gates are used to average tensors.\\n\\n This class is expected to be called by multi-source/multi-column models.\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def Params(cls):\\n \\\"\\\"\\\"Params for this MergerLayer class.\\\"\\\"\\\"\\n p = super().Params()\\n p.Define('merger_op', None, 'How to merge input tensors.')\\n p.Define('source_dim', 0, 'Number of source nodes.')\\n p.Define('query_dim', 0, 'Number of query nodes.')\\n p.Define('hidden_dim', 0, 'Number of hidden nodes.')\\n p.Define('attention_tpl', AdditiveAttention.Params(),\\n 'Attention used by the merger layer when merger_op is atten.')\\n p.Define(\\n 'pre_proj_input_dims', None,\\n 'If set, should be a list of depths for the tensors to be merged.'\\n ' Setting this will result in a pre-projection to source_dim'\\n ' before the merger.')\\n p.Define(\\n 'pre_proj_output_dims', None,\\n 'Should be a list of depths which the input tensors specified in '\\n 'pre_proj_input_dims need to be projected to. Should match the length '\\n 'of pre_proj_input_dims.')\\n p.Define(\\n 'proj_tpl',\\n layers.ProjectionLayer.Params().Set(\\n batch_norm=False, weight_norm=True, has_bias=True),\\n 'Configs template for the projection layer.')\\n p.Define('gated_avg_tpl', layers.GatedAverageLayer.Params(),\\n 'Configs template for the gated average layer.')\\n p.Define('num_sources', 0, 'If merger_op=weighted_sum, then must specify '\\n 'num of sources.')\\n p.Define('post_proj', None,\\n 'Post projection for the merged context vector.')\\n return p\\n\\n # Merging operation keys supported by this layer.\\n MERGER_OPS = ['mean', 'atten', 'concat', 'sum', 'weighted_sum', 'gated_avg']\\n\\n def __init__(self, params):\\n super().__init__(params)\\n p = self.params\\n if not p.name:\\n raise ValueError('Layer must have a specified name!')\\n if p.merger_op not in set(self.MERGER_OPS):\\n raise ValueError('Merger op must be one of: ', self.MERGER_OPS)\\n\\n if p.merger_op == 'atten':\\n atten_params = p.attention_tpl.Copy()\\n atten_params.source_dim = p.source_dim\\n atten_params.query_dim = p.query_dim\\n atten_params.hidden_dim = p.hidden_dim\\n atten_params.dtype = p.dtype\\n if atten_params.params_init is None:\\n atten_params.params_init = py_utils.WeightInit.Gaussian(\\n 1. / math.sqrt(atten_params.source_dim + atten_params.query_dim),\\n seed=p.random_seed)\\n self.CreateChild('atten', atten_params)\\n\\n if p.pre_proj_input_dims:\\n if not p.pre_proj_output_dims:\\n raise ValueError('Output dims should be specified for projection.')\\n if len(p.pre_proj_input_dims) != len(p.pre_proj_output_dims):\\n raise ValueError(\\n 'Output dims should be the same length as input dims. '\\n 'Expected: %s obtained: %s' %\\n (len(p.pre_proj_input_dims), len(p.pre_proj_output_dims)))\\n pre_proj_params = []\\n for i, (pre_proj_input_dim, pre_proj_output_dim) in enumerate(\\n zip(p.pre_proj_input_dims, p.pre_proj_output_dims)):\\n proj_p = p.proj_tpl.Copy()\\n proj_p.name = 'merger_pre_proj_%d' % i\\n proj_p.input_dim = pre_proj_input_dim\\n proj_p.output_dim = pre_proj_output_dim\\n pre_proj_params.append(proj_p)\\n self.CreateChildren('pre_proj', pre_proj_params)\\n\\n if p.merger_op == 'gated_avg':\\n assert p.num_sources > 0, ('For merger_op=gated_avg, must specify '\\n 'num_sources > 0.')\\n params = p.gated_avg_tpl.Copy()\\n params.name = 'g_avg_merger'\\n params.num_nodes = p.source_dim\\n params.num_inputs = p.num_sources\\n self.CreateChild('gated_average', params)\\n\\n if p.post_proj:\\n self.CreateChild('post_proj', p.post_proj)\\n\\n def _CreateLayerVariables(self):\\n super()._CreateLayerVariables()\\n p = self.params\\n\\n if p.merger_op == 'weighted_sum':\\n assert p.num_sources > 0, ('For merger_op=weighted_sum, must specify '\\n 'num_sources > 0.')\\n params_init = py_utils.WeightInit.Constant(1.0 / p.num_sources)\\n # Weights to be learned.\\n pw = py_utils.WeightParams(\\n shape=[p.num_sources],\\n init=params_init,\\n dtype=p.dtype,\\n collections=[self.__class__.__name__ + '_vars'])\\n self.CreateVariable('sum_weight', pw)\\n\\n def _child_variable_scope_override(self):\\n return {\\n **super()._child_variable_scope_override(), 'atten': [],\\n 'gated_average': [],\\n 'pre_proj': []\\n }\\n\\n def FProp(self, theta, inputs, query_vec=None):\\n \\\"\\\"\\\"Combines the list of input tensors into a single tensor.\\n\\n Args:\\n theta: A `.NestedMap` object containing weights' values of this layer and\\n its children layers.\\n inputs: A list of tensors of shape [..., hidden_dim] or [...,\\n [pre_proj_input_dims[i]]] if pre_proj_input_dims is specified.\\n query_vec: A tensor of shape [..., hidden_dim].\\n\\n Returns:\\n A tensor of the same shape with input tensors.\\n\\n Raises:\\n ValueError: p.merger_op is not defined.\\n \\\"\\\"\\\"\\n p = self.params\\n n_sources = len(inputs)\\n\\n if p.pre_proj_input_dims and len(p.pre_proj_input_dims) != n_sources:\\n raise ValueError('pre_proj_input_dims must be specified for each input.')\\n\\n if n_sources == 1:\\n return inputs[0]\\n\\n # Pre-projection operation.\\n if p.pre_proj_input_dims:\\n for i in range(n_sources):\\n inputs[i] = self.pre_proj[i].FProp(theta.pre_proj[i], inputs[i])\\n\\n tensor_pairs = list(zip(inputs[:-1], inputs[1:]))\\n if p.merger_op == 'mean':\\n # Simply take the mean, all dims must match.\\n with tf.control_dependencies([\\n py_utils.assert_shape_match(tf.shape(t1), tf.shape(t2))\\n for t1, t2 in tensor_pairs\\n ]):\\n output = tf.add_n(inputs) / n_sources\\n\\n elif p.merger_op == 'sum':\\n # Sum up all sources, all dims must match.\\n with tf.control_dependencies([\\n py_utils.assert_shape_match(tf.shape(t1), tf.shape(t2))\\n for t1, t2 in tensor_pairs\\n ]):\\n output = tf.add_n(inputs)\\n\\n elif p.merger_op == 'weighted_sum':\\n # Weighted sum of all sources, all dims must match.\\n # For weighted_sum, assume input is a list of rank 3 tensors\\n inputs = tf.stack(inputs)\\n inputs = py_utils.HasRank(inputs, 4)\\n\\n with tf.control_dependencies([\\n py_utils.assert_shape_match(tf.shape(t1), tf.shape(t2))\\n for t1, t2 in tensor_pairs\\n ]):\\n w = tf.expand_dims(\\n tf.expand_dims(tf.expand_dims(theta.sum_weight, 1), 1), 1)\\n w = tf.tile(\\n w,\\n [1,\\n tf.shape(inputs)[1],\\n tf.shape(inputs)[2],\\n tf.shape(inputs)[3]])\\n output = tf.reduce_sum(inputs * w, axis=0)\\n\\n elif p.merger_op == 'atten':\\n # Apply attention over the concatenated tensor, all dims must match.\\n with tf.control_dependencies([\\n py_utils.assert_shape_match(tf.shape(t1), tf.shape(t2))\\n for t1, t2 in tensor_pairs\\n ]):\\n inputs = tf.stack(inputs, axis=0)\\n batch_size = tf.shape(inputs)[1]\\n paddings = tf.zeros([n_sources, batch_size], dtype=inputs.dtype)\\n self.atten.InitForSourcePacked(theta.atten, inputs, inputs, paddings)\\n output, _, _ = self.atten.ComputeContextVector(\\n theta.atten, tf.reshape(query_vec, [-1, p.query_dim]))\\n\\n elif p.merger_op == 'concat':\\n # Concatenate over the last dim, all dims but last must match.\\n with tf.control_dependencies([\\n py_utils.assert_equal(tf.shape(t1)[:-1],\\n tf.shape(t2)[:-1]) for t1, t2 in tensor_pairs\\n ]):\\n output = tf.concat(inputs, axis=-1)\\n\\n elif p.merger_op == 'gated_avg':\\n output = self.gated_average.FProp(theta.gated_average, inputs)\\n\\n else:\\n raise ValueError('Unrecognized merge op!')\\n\\n if p.post_proj:\\n output = self.post_proj.FProp(theta.post_proj, output)\\n\\n return output\\n\\n\\nclass MultiSourceAttention(BaseAttentionLayer):\\n \\\"\\\"\\\"Attention with multiple source sub-attentions.\\n\\n It attends to multiple sources and uses one query as input to generates a\\n combined attention context. The dimension of the combined context vector is a\\n sum of all source context vectors. Each source attention has its separate\\n params and is associated with a source key.\\n \\\"\\\"\\\"\\n\\n @classmethod\\n def Params(cls):\\n p = super().Params()\\n p.Define('source_atten_tpls', None,\\n 'A list of (source_key, attention_param) '\\n 'pairs.')\\n p.Define('source_dim', 0, 'Default source dimension.')\\n p.Define(\\n 'query_dim', 0, 'Number of query nodes. Child attention params '\\n 'must have query_dim less or euqal than 0 or equal to this value.')\\n p.Define(\\n 'primary_source_key', 'source_0', 'Key for the primary source '\\n 'whose attention probabilities will be used as an output.')\\n p.Define(\\n 'atten_merger_tpl',\\n MergerLayer.Params().Set(\\n params_init=py_utils.WeightInit.Uniform(0.04), merger_op='sum'),\\n 'Params to specify how to merge source attention vectors.')\\n return p\\n\\n def __init__(self, params):\\n \\\"\\\"\\\"Constructs an MultiSourceAttention object.\\\"\\\"\\\"\\n super().__init__(params)\\n p = self.params\\n for source_key, atten_p in p.source_atten_tpls:\\n child_p = atten_p.Copy()\\n if child_p.query_dim <= 0:\\n child_p.query_dim = p.query_dim\\n else:\\n assert child_p.query_dim == p.query_dim\\n if child_p.source_dim <= 0:\\n child_p.source_dim = p.source_dim\\n self.CreateChild('atten_%s' % source_key, child_p)\\n\\n # Initialize source context vector merging layer.\\n merger_p = p.atten_merger_tpl.Copy()\\n merger_p.name = 'atten_merger'\\n merger_p.source_dim = p.source_dim\\n merger_p.query_dim = p.query_dim\\n self.CreateChild('atten_merger', merger_p)\\n\\n def PackSource(self,\\n theta,\\n source_vecs,\\n source_contexts,\\n source_padding,\\n source_segment_id=None):\\n p = self.params\\n with tf.name_scope(self.params.name):\\n packed_src = py_utils.NestedMap()\\n for source_key, _ in p.source_atten_tpls:\\n packed_src[source_key] = (\\n self.children['atten_%s' % source_key].InitForSourcePacked(\\n theta['atten_%s' % source_key], source_vecs[source_key],\\n source_contexts[source_key], source_padding[source_key],\\n source_segment_id[source_key] if source_segment_id else None))\\n return packed_src\\n\\n def ZeroAttentionState(self, source_seq_length, decoder_batch_size):\\n p = self.params\\n with tf.name_scope(self.params.name):\\n return py_utils.NestedMap({\\n source_key: getattr(self, 'atten_%s' % source_key).ZeroAttentionState(\\n source_seq_length[source_key], decoder_batch_size)\\n for source_key, _ in p.source_atten_tpls\\n })\\n\\n def ComputeContextVectorWithSource(self,\\n theta,\\n packed_src,\\n query_vec,\\n attention_state=None,\\n per_step_source_padding=None,\\n query_segment_id=None):\\n p = self.params\\n assert per_step_source_padding is None\\n with tf.name_scope(self.params.name):\\n result_map = py_utils.NestedMap()\\n for source_key, _ in p.source_atten_tpls:\\n result_map[source_key] = (\\n self.children['atten_%s' %\\n source_key].ComputeContextVectorWithSource(\\n theta.get('atten_%s' % source_key),\\n packed_src[source_key], query_vec,\\n attention_state[source_key]\\n if attention_state else None,\\n per_step_source_padding, query_segment_id))\\n return self._CombineContext(theta, result_map, query_vec)\\n\\n def _CombineContext(self, theta, context_map, query_vec):\\n ctxs = context_map.Flatten()\\n combined_context = (\\n self.atten_merger.FProp(theta.atten_merger, [ctx for ctx, _, _ in ctxs],\\n query_vec))\\n return (\\n combined_context,\\n # Return atten_probs of the primary source.\\n # TODO(huk): Maybe return a NestedMap.\\n context_map[self.params.primary_source_key][1],\\n py_utils.NestedMap({\\n src_key: context_map[src_key][2]\\n for src_key, _ in self.params.source_atten_tpls\\n }))\\n\"\n]","isConversational":false},"apis":{"kind":"list like","value":[["tensorflow.compat.v2.nest.map_structure","tensorflow.compat.v2.io.gfile.exists","tensorflow.compat.v2.io.gfile.makedirs"],["tensorflow.compat.v2.nest.map_structure","tensorflow.compat.v2.function","tensorflow.compat.v2.errors.OutOfRangeError"],["numpy.zeros","numpy.random.rand","numpy.random.randint"],["tensorflow.python.ops.inplace_ops.alias_inplace_update","numpy.sqrt","numpy.finfo"]],"string":"[\n [\n \"tensorflow.compat.v2.nest.map_structure\",\n \"tensorflow.compat.v2.io.gfile.exists\",\n \"tensorflow.compat.v2.io.gfile.makedirs\"\n ],\n [\n \"tensorflow.compat.v2.nest.map_structure\",\n \"tensorflow.compat.v2.function\",\n \"tensorflow.compat.v2.errors.OutOfRangeError\"\n ],\n [\n \"numpy.zeros\",\n \"numpy.random.rand\",\n \"numpy.random.randint\"\n ],\n [\n \"tensorflow.python.ops.inplace_ops.alias_inplace_update\",\n \"numpy.sqrt\",\n \"numpy.finfo\"\n ]\n]","isConversational":false},"possible_versions":{"kind":"list like","value":[{"matplotlib":[],"numpy":[],"pandas":[],"scipy":[],"tensorflow":[]},{"matplotlib":[],"numpy":[],"pandas":[],"scipy":[],"tensorflow":[]},{"matplotlib":[],"numpy":[],"pandas":[],"scipy":[],"tensorflow":[]},{"matplotlib":[],"numpy":[],"pandas":[],"scipy":[],"tensorflow":["1.10","2.7","1.12","2.6","2.2","1.13","2.3","2.4","2.9","2.5","2.8","2.10"]}],"string":"[\n {\n \"matplotlib\": [],\n \"numpy\": [],\n \"pandas\": [],\n \"scipy\": [],\n \"tensorflow\": []\n },\n {\n \"matplotlib\": [],\n \"numpy\": [],\n \"pandas\": [],\n \"scipy\": [],\n \"tensorflow\": []\n },\n {\n \"matplotlib\": [],\n \"numpy\": [],\n \"pandas\": [],\n \"scipy\": [],\n \"tensorflow\": []\n },\n {\n \"matplotlib\": [],\n \"numpy\": [],\n \"pandas\": [],\n \"scipy\": [],\n \"tensorflow\": [\n \"1.10\",\n \"2.7\",\n \"1.12\",\n \"2.6\",\n \"2.2\",\n \"1.13\",\n \"2.3\",\n \"2.4\",\n \"2.9\",\n \"2.5\",\n \"2.8\",\n \"2.10\"\n ]\n }\n]","isConversational":false}}},{"rowIdx":2596,"cells":{"repo_name":{"kind":"string","value":"pakesson/scaml"},"hexsha":{"kind":"list like","value":["c69d422d6839d75a81426c81fd8d570fa421744b"],"string":"[\n \"c69d422d6839d75a81426c81fd8d570fa421744b\"\n]","isConversational":false},"file_path":{"kind":"list like","value":["explain.py"],"string":"[\n \"explain.py\"\n]","isConversational":false},"code":{"kind":"list like","value":["#!/usr/bin/env python\n\nimport sys\nimport math\nimport numpy as np\n\nfrom tensorflow.keras.models import load_model\n\nfrom aes import aes_sbox, aes_sbox_inv\n\nimport matplotlib\nmatplotlib.use('TkAgg')\nimport matplotlib.pyplot as plt\n\ndef get_label(plaintext, key, index):\n return aes_sbox[plaintext[index] ^ key[index]]\n\nnum_classes = 256\nattack_byte = 0\nstart_trace_to_attack = 100\nnumber_of_traces_to_attack = 25\nnumber_of_traces_to_explain = 5\nocclusion_size = 1\n\ndef apply_occlusion(sample, x, occlusion_size=1, occlusion_value=0):\n occluded_sample = np.array(sample, copy=True)\n occluded_sample[x:x+occlusion_size, :] = occlusion_value\n return occluded_sample\n\ndef get_occlusion_sensitivity(samples, model, class_index, occlusion_size=1):\n print(\"Generating occlusion sensitivity maps...\")\n\n confidence_map = np.zeros(math.ceil(samples[0].shape[0] / occlusion_size))\n sensitivity_map = np.zeros(math.ceil(samples[0].shape[0] / occlusion_size))\n\n for idx, sample in enumerate(samples):\n print(f\" Sample {idx}\")\n\n occlusion_value = np.mean(sample)\n\n occlusions = [\n apply_occlusion(sample, x, occlusion_size, occlusion_value)\n for x in range(0, sample.shape[0], occlusion_size)\n ]\n\n predictions = model.predict(np.array(occlusions), batch_size=32)\n target_class_predictions = [\n prediction[class_index[idx]] for prediction in predictions\n ]\n\n for x, confidence in zip(range(sensitivity_map.shape[0]), target_class_predictions):\n confidence_map[x] += confidence\n\n # Mean confidence value\n confidence_map = confidence_map / samples.shape[0]\n sensitivity_map = 1 - confidence_map\n\n # Scale back up\n result = np.zeros(samples[0].shape[0])\n for x in range(result.shape[0]):\n result[x] = sensitivity_map[x // occlusion_size]\n\n return result\n\ndef explain(data, model, class_index, occlusion_size=1):\n # Make sure the data shape is (num_traces, num_points_per_trace, x)\n if len(data.shape) == 2:\n data = data.reshape((1, data.shape[0], data.shape[1]))\n class_index = class_index.reshape((1, class_index.shape[0], class_index.shape[1]))\n elif len(data.shape) != 3:\n raise ValueError(\"unsupported data shape\")\n\n # Generate one map for all samples\n return get_occlusion_sensitivity(data, model, class_index, occlusion_size)\n\nif __name__ == '__main__':\n if len(sys.argv) != 4:\n print(\"Usage:\")\n print(f\" {sys.argv[0]} <model filename> <trace filename> <sensitivity map filename>\")\n exit()\n\n model_filename = sys.argv[1]\n trace_filename = sys.argv[2]\n sensitivity_map_filename = sys.argv[3]\n\n model = load_model(model_filename)\n print(\"Input shape: \" + str(model.input_shape))\n\n traces = np.load(trace_filename)\n\n print(traces.files)\n\n trace_array = traces['trace_array']\n textin_array = traces['textin_array']\n known_keys = traces['known_keys']\n\n trace_array = trace_array.reshape((trace_array.shape[0], trace_array.shape[1], 1))\n\n # Run an initial prediction before we try to explain anything\n result = model.predict(trace_array[start_trace_to_attack:start_trace_to_attack+number_of_traces_to_attack, :, :])\n\n log10_sum_prediction = np.zeros(num_classes)\n for k in range(number_of_traces_to_attack):\n plaintext = textin_array[start_trace_to_attack+k, attack_byte]\n prediction = result[k]\n for l in range(num_classes):\n key_byte_index = (aes_sbox_inv[l] ^ plaintext)\n log10_sum_prediction[key_byte_index] += np.log10(prediction[l] + 1e-22)\n\n print(\"Best key byte guess: \" + str(np.argmax(log10_sum_prediction)))\n print(\"known_keys[0]: \" + str(known_keys[0]))\n\n # Run explainer\n data = trace_array[start_trace_to_attack:start_trace_to_attack+number_of_traces_to_explain, :, :]\n key_index = np.argmax(log10_sum_prediction)\n class_index = aes_sbox[textin_array[start_trace_to_attack:start_trace_to_attack+number_of_traces_to_explain, attack_byte] ^ key_index]\n\n sensitivity_map = explain(data, model, class_index, occlusion_size)\n\n # Save results\n np.savez_compressed(sensitivity_map_filename, sensitivity_map=sensitivity_map)\n\n # Visualize the results\n fig = plt.figure()\n plt.title(f\"Occlusion sensitivity for key byte {attack_byte} in trace {start_trace_to_attack}\")\n ax = fig.gca()\n x = np.linspace(0, sensitivity_map.shape[0]-1, sensitivity_map.shape[0])\n for i in range(0, sensitivity_map.shape[0]-1, occlusion_size):\n color = (sensitivity_map[i]-min(sensitivity_map))/np.ptp(sensitivity_map)\n ax.plot(x[i:i+occlusion_size+1], data[0, i:i+occlusion_size+1, 0], color=plt.cm.plasma(color))\n plt.show()\n"],"string":"[\n \"#!/usr/bin/env python\\n\\nimport sys\\nimport math\\nimport numpy as np\\n\\nfrom tensorflow.keras.models import load_model\\n\\nfrom aes import aes_sbox, aes_sbox_inv\\n\\nimport matplotlib\\nmatplotlib.use('TkAgg')\\nimport matplotlib.pyplot as plt\\n\\ndef get_label(plaintext, key, index):\\n return aes_sbox[plaintext[index] ^ key[index]]\\n\\nnum_classes = 256\\nattack_byte = 0\\nstart_trace_to_attack = 100\\nnumber_of_traces_to_attack = 25\\nnumber_of_traces_to_explain = 5\\nocclusion_size = 1\\n\\ndef apply_occlusion(sample, x, occlusion_size=1, occlusion_value=0):\\n occluded_sample = np.array(sample, copy=True)\\n occluded_sample[x:x+occlusion_size, :] = occlusion_value\\n return occluded_sample\\n\\ndef get_occlusion_sensitivity(samples, model, class_index, occlusion_size=1):\\n print(\\\"Generating occlusion sensitivity maps...\\\")\\n\\n confidence_map = np.zeros(math.ceil(samples[0].shape[0] / occlusion_size))\\n sensitivity_map = np.zeros(math.ceil(samples[0].shape[0] / occlusion_size))\\n\\n for idx, sample in enumerate(samples):\\n print(f\\\" Sample {idx}\\\")\\n\\n occlusion_value = np.mean(sample)\\n\\n occlusions = [\\n apply_occlusion(sample, x, occlusion_size, occlusion_value)\\n for x in range(0, sample.shape[0], occlusion_size)\\n ]\\n\\n predictions = model.predict(np.array(occlusions), batch_size=32)\\n target_class_predictions = [\\n prediction[class_index[idx]] for prediction in predictions\\n ]\\n\\n for x, confidence in zip(range(sensitivity_map.shape[0]), target_class_predictions):\\n confidence_map[x] += confidence\\n\\n # Mean confidence value\\n confidence_map = confidence_map / samples.shape[0]\\n sensitivity_map = 1 - confidence_map\\n\\n # Scale back up\\n result = np.zeros(samples[0].shape[0])\\n for x in range(result.shape[0]):\\n result[x] = sensitivity_map[x // occlusion_size]\\n\\n return result\\n\\ndef explain(data, model, class_index, occlusion_size=1):\\n # Make sure the data shape is (num_traces, num_points_per_trace, x)\\n if len(data.shape) == 2:\\n data = data.reshape((1, data.shape[0], data.shape[1]))\\n class_index = class_index.reshape((1, class_index.shape[0], class_index.shape[1]))\\n elif len(data.shape) != 3:\\n raise ValueError(\\\"unsupported data shape\\\")\\n\\n # Generate one map for all samples\\n return get_occlusion_sensitivity(data, model, class_index, occlusion_size)\\n\\nif __name__ == '__main__':\\n if len(sys.argv) != 4:\\n print(\\\"Usage:\\\")\\n print(f\\\" {sys.argv[0]} <model filename> <trace filename> <sensitivity map filename>\\\")\\n exit()\\n\\n model_filename = sys.argv[1]\\n trace_filename = sys.argv[2]\\n sensitivity_map_filename = sys.argv[3]\\n\\n model = load_model(model_filename)\\n print(\\\"Input shape: \\\" + str(model.input_shape))\\n\\n traces = np.load(trace_filename)\\n\\n print(traces.files)\\n\\n trace_array = traces['trace_array']\\n textin_array = traces['textin_array']\\n known_keys = traces['known_keys']\\n\\n trace_array = trace_array.reshape((trace_array.shape[0], trace_array.shape[1], 1))\\n\\n # Run an initial prediction before we try to explain anything\\n result = model.predict(trace_array[start_trace_to_attack:start_trace_to_attack+number_of_traces_to_attack, :, :])\\n\\n log10_sum_prediction = np.zeros(num_classes)\\n for k in range(number_of_traces_to_attack):\\n plaintext = textin_array[start_trace_to_attack+k, attack_byte]\\n prediction = result[k]\\n for l in range(num_classes):\\n key_byte_index = (aes_sbox_inv[l] ^ plaintext)\\n log10_sum_prediction[key_byte_index] += np.log10(prediction[l] + 1e-22)\\n\\n print(\\\"Best key byte guess: \\\" + str(np.argmax(log10_sum_prediction)))\\n print(\\\"known_keys[0]: \\\" + str(known_keys[0]))\\n\\n # Run explainer\\n data = trace_array[start_trace_to_attack:start_trace_to_attack+number_of_traces_to_explain, :, :]\\n key_index = np.argmax(log10_sum_prediction)\\n class_index = aes_sbox[textin_array[start_trace_to_attack:start_trace_to_attack+number_of_traces_to_explain, attack_byte] ^ key_index]\\n\\n sensitivity_map = explain(data, model, class_index, occlusion_size)\\n\\n # Save results\\n np.savez_compressed(sensitivity_map_filename, sensitivity_map=sensitivity_map)\\n\\n # Visualize the results\\n fig = plt.figure()\\n plt.title(f\\\"Occlusion sensitivity for key byte {attack_byte} in trace {start_trace_to_attack}\\\")\\n ax = fig.gca()\\n x = np.linspace(0, sensitivity_map.shape[0]-1, sensitivity_map.shape[0])\\n for i in range(0, sensitivity_map.shape[0]-1, occlusion_size):\\n color = (sensitivity_map[i]-min(sensitivity_map))/np.ptp(sensitivity_map)\\n ax.plot(x[i:i+occlusion_size+1], data[0, i:i+occlusion_size+1, 0], color=plt.cm.plasma(color))\\n plt.show()\\n\"\n]","isConversational":false},"apis":{"kind":"list like","value":[["tensorflow.keras.models.load_model","matplotlib.pyplot.cm.plasma","matplotlib.pyplot.title","numpy.linspace","matplotlib.use","numpy.ptp","numpy.savez_compressed","numpy.argmax","numpy.mean","numpy.log10","numpy.load","numpy.array","numpy.zeros","matplotlib.pyplot.show","matplotlib.pyplot.figure"]],"string":"[\n [\n \"tensorflow.keras.models.load_model\",\n \"matplotlib.pyplot.cm.plasma\",\n \"matplotlib.pyplot.title\",\n \"numpy.linspace\",\n \"matplotlib.use\",\n \"numpy.ptp\",\n \"numpy.savez_compressed\",\n \"numpy.argmax\",\n \"numpy.mean\",\n \"numpy.log10\",\n \"numpy.load\",\n \"numpy.array\",\n \"numpy.zeros\",\n \"matplotlib.pyplot.show\",\n \"matplotlib.pyplot.figure\"\n ]\n]","isConversational":false},"possible_versions":{"kind":"list like","value":[{"matplotlib":[],"numpy":[],"pandas":[],"scipy":[],"tensorflow":["1.10","2.7","2.2","2.3","2.4","2.5","2.6"]}],"string":"[\n {\n \"matplotlib\": [],\n \"numpy\": [],\n \"pandas\": [],\n \"scipy\": [],\n \"tensorflow\": [\n \"1.10\",\n \"2.7\",\n \"2.2\",\n \"2.3\",\n \"2.4\",\n \"2.5\",\n \"2.6\"\n ]\n }\n]","isConversational":false}}},{"rowIdx":2597,"cells":{"repo_name":{"kind":"string","value":"diegomrsantos/Python-Baseball"},"hexsha":{"kind":"list like","value":["4543df7a4d74e82106a3e8481553149c447d8ab6"],"string":"[\n \"4543df7a4d74e82106a3e8481553149c447d8ab6\"\n]","isConversational":false},"file_path":{"kind":"list like","value":["stats/attendance.py"],"string":"[\n \"stats/attendance.py\"\n]","isConversational":false},"code":{"kind":"list like","value":["import pandas as pd\nimport matplotlib.pyplot as plt\nfrom data import games\n\ninfo_filter = games['type'] == 'info'\nattendance_filter = games['multi2'] == 'attendance'\nattendance = games.loc[info_filter & attendance_filter, ['year', 'multi3']]\n\nattendance.columns = ['year', 'attendance']\n\nattendance.loc[:, 'attendance'] = pd.to_numeric(attendance.loc[:, 'attendance'])\n\nattendance.plot(x='year', y='attendance', figsize=(15, 7), kind='bar')\nplt.xlabel('Year')\nplt.ylabel('Attendance')\nplt.axhline(y=attendance['attendance'].mean(), label='Mean', linestyle='--', color='green')\nplt.show()\n"],"string":"[\n \"import pandas as pd\\nimport matplotlib.pyplot as plt\\nfrom data import games\\n\\ninfo_filter = games['type'] == 'info'\\nattendance_filter = games['multi2'] == 'attendance'\\nattendance = games.loc[info_filter & attendance_filter, ['year', 'multi3']]\\n\\nattendance.columns = ['year', 'attendance']\\n\\nattendance.loc[:, 'attendance'] = pd.to_numeric(attendance.loc[:, 'attendance'])\\n\\nattendance.plot(x='year', y='attendance', figsize=(15, 7), kind='bar')\\nplt.xlabel('Year')\\nplt.ylabel('Attendance')\\nplt.axhline(y=attendance['attendance'].mean(), label='Mean', linestyle='--', color='green')\\nplt.show()\\n\"\n]","isConversational":false},"apis":{"kind":"list like","value":[["matplotlib.pyplot.xlabel","matplotlib.pyplot.show","pandas.to_numeric","matplotlib.pyplot.ylabel"]],"string":"[\n [\n \"matplotlib.pyplot.xlabel\",\n \"matplotlib.pyplot.show\",\n \"pandas.to_numeric\",\n \"matplotlib.pyplot.ylabel\"\n ]\n]","isConversational":false},"possible_versions":{"kind":"list like","value":[{"matplotlib":[],"numpy":[],"pandas":["0.23","0.21","2.0","1.4","0.19","1.1","1.5","1.2","0.24","0.20","1.0","0.25","1.3"],"scipy":[],"tensorflow":[]}],"string":"[\n {\n \"matplotlib\": [],\n \"numpy\": [],\n \"pandas\": [\n \"0.23\",\n \"0.21\",\n \"2.0\",\n \"1.4\",\n \"0.19\",\n \"1.1\",\n \"1.5\",\n \"1.2\",\n \"0.24\",\n \"0.20\",\n \"1.0\",\n \"0.25\",\n \"1.3\"\n ],\n \"scipy\": [],\n \"tensorflow\": []\n }\n]","isConversational":false}}},{"rowIdx":2598,"cells":{"repo_name":{"kind":"string","value":"rperi/trustworthy-asv-fairness"},"hexsha":{"kind":"list like","value":["15df69a8f3f8ad5262002c9e3d12aa12ea8f1c6f"],"string":"[\n \"15df69a8f3f8ad5262002c9e3d12aa12ea8f1c6f\"\n]","isConversational":false},"file_path":{"kind":"list like","value":["evaluate/evaluate_FDR.py"],"string":"[\n \"evaluate/evaluate_FDR.py\"\n]","isConversational":false},"code":{"kind":"list like","value":["import numpy as np\nimport pandas as pd\nimport os\nimport pdb\nfrom scipy.spatial.distance import cosine\nfrom sklearn.metrics import roc_curve, confusion_matrix\nimport sys\nfrom tqdm import tqdm\nfrom sklearn.metrics import auc\nimport argparse\n\nfprs = [0.01,0.02,0.03,0.04,0.05,0.06,0.07,0.08,0.09,0.1,0.2,0.3,0.4,0.5]\ngroups = ['male_male','female_female']\nomegas = [0.0, 0.25, 0.5, 0.75, 1.0]\nemb_map = {}\nxvec_map = {}\n\ndef compute_scores(df_, eer_threshold_overall=0, agnostic_FLAG=False, emb_FLAG=True):\n if emb_FLAG:\n emb_mapping = emb_map\n else:\n emb_mapping = xvec_map\n similarity_scores= []\n labels = []\n for idx, row in tqdm(enumerate(df_.iterrows())):\n enrol = row[1]['audio_1']\n test = row[1]['audio_2']\n label = row[1]['label']\n if not enrol in emb_mapping.keys():\n print(enrol)\n if not test in emb_mapping.keys():\n print(test)\n\n sim = 1 - cosine(emb_mapping[enrol],emb_mapping[test])\n\n similarity_scores.append(sim)\n labels.append(label)\n fpr, tpr, threshold = roc_curve(labels, similarity_scores)\n fnr = 1 - tpr\n eer_threshold = threshold[np.nanargmin(np.absolute((fnr - fpr)))]\n eer1 = fpr[np.nanargmin(np.absolute((fnr - fpr)))]\n eer2 = fnr[np.nanargmin(np.absolute((fnr - fpr)))]\n eer = np.mean((eer1,eer2))\n\n sim = np.array(similarity_scores)\n labels = np.array(labels)\n if not agnostic_FLAG:\n fpr, fnr = compute_fpr_fnr(sim, labels, eer_threshold_overall)\n return sim, labels, eer, fpr, fnr\n else:\n return sim, labels, eer, eer_threshold\n\ndef compute_fpr_fnr(sim,labels_e1, thresh):\n\n preds = np.zeros(labels_e1.shape[0])\n preds[sim > thresh] = 1\n tn, fp, fn, tp = confusion_matrix(labels_e1, preds).ravel()\n fpr = fp/(fp+tn)\n fnr = fn/(fn+tp)\n return fpr, fnr\n\ndef compute_fdr(fprs, fnrs, omega=0.5):\n A = np.absolute(fprs[0]-fprs[1])\n B = np.absolute(fnrs[0]-fnrs[1])\n \n return 1 - (omega*A + (1-omega)*B)\n\ndef compute_auFDR(fpr_ov, tpr_ov, threshold_ov, sim_g0, sim_g1, labels_g0, labels_g1, \n score_dir, emb_FLAG=True, omega=0.5):\n # FDRs at various thersholds\n fdrs = []\n fnrs = []\n for fpr in tqdm(fprs):\n thresh = threshold_ov[np.nanargmin(np.absolute((fpr_ov-fpr)))]\n fnr = 1 - tpr_ov[np.nanargmin(np.absolute((fpr_ov-fpr)))]\n fpr_g0, fnr_g0 = compute_fpr_fnr(sim_g0, labels_g0, thresh)\n fpr_g1, fnr_g1 = compute_fpr_fnr(sim_g1, labels_g1, thresh)\n fdr = compute_fdr((fpr_g0, fpr_g1), (fnr_g0, fnr_g1), float(omega))\n fdrs.append(np.round(fdr*100,2))\n fnrs.append(np.round(fnr*100,2))\n auFDR = auc([x*100 for x in fprs], fdrs)\n auFDR_10 = auc([x*100 for x in fprs[0:10]], fdrs[0:10])\n df = pd.DataFrame(zip(fprs,fdrs, fnrs), columns=['fpr','fdr', 'fnr'])\n if emb_FLAG:\n print(\"Alpha = {} auFDR auFDR_10\".format(omega))\n print(\"Embeddings: {} {}\\n\".format(auFDR, auFDR_10))\n df.to_csv(os.path.join(score_dir, 'fdr_at_fpr_gender_omega_{}.csv'.format(omega)), index=None)\n else:\n print(\"Alpha = {} auFDR auFDR_10\".format(omega))\n print(\"xvectors: {} {}\\n\".format(auFDR, auFDR_10))\n df.to_csv(os.path.join(score_dir, 'fdr_at_fpr_gender_omega_{}.csv'.format(omega)), index=None)\n return auFDR, auFDR_10\n\ndef main(args):\n xvec_FLAG = args.eval_xvector\n\n # Creating necessary trials for gender-specific evaluations \n trial_dir = args.trials_root\n trials = os.path.join(trial_dir, 'Test-Combined.csv')\n df = pd.read_csv(trials)\n df['label'] = pd.to_numeric(df['label'])\n\n df_m = df.loc[df[\"gender_1\"]=='male']\n df_f = df.loc[df[\"gender_1\"]=='female']\n df_m_m = df_m.loc[df_m[\"gender_2\"]=='male']\n df_f_f = df_f.loc[df_f[\"gender_2\"]=='female']\n \n if not os.path.exists(os.path.join(trial_dir,'Test-male-all.csv')):\n df_m.to_csv(os.path.join(trial_dir,'Test-male-all.csv'), index=None)\n if not os.path.exists(os.path.join(trial_dir,'Test-female-all.csv')):\n df_f.to_csv(os.path.join(trial_dir,'Test-female-all.csv'), index=None)\n if not os.path.exists(os.path.join(trial_dir,'Test-male-male.csv')):\n df_m_m.to_csv(os.path.join(trial_dir,'Test-male-male.csv'), index=None)\n if not os.path.exists(os.path.join(trial_dir,'Test-female-female.csv')):\n df_f_f.to_csv(os.path.join(trial_dir,'Test-female-female.csv'), index=None)\n\n # Create directories to save ASV scores\n scores_dir_base = args.scores_root\n scores_dir_xvec = os.path.join(scores_dir_base,'baseline')\n scores_dir = os.path.join(scores_dir_base,'{}'.format(args.mode))\n os.makedirs(scores_dir_xvec, exist_ok=True)\n os.makedirs(scores_dir, exist_ok=True)\n\n # Load extracted embeddings and xvectors\n test_utts = np.load(os.path.join(args.data_root,'test_utts.npy'))\n \n pred_dir = args.pred_root\n e1 = np.load(os.path.join(pred_dir,'emb1.npy'))\n for idx, utt in enumerate(test_utts):\n emb_map[utt] = e1[idx,:]\n if xvec_FLAG:\n xvec = np.load(os.path.join(args.data_root,'test_data.npy'))\n for idx, utt in enumerate(test_utts):\n xvec_map[utt] = xvec[idx,:]\n\n\n # Gender-agnostic scoring\n print(\"Computing Gender-agnostic scores\")\n if os.path.exists(os.path.join(scores_dir_xvec, 'sim_xvec_overall.npy')) and os.path.exists(os.path.join(scores_dir, 'sim_e1_overall.npy')) and os.path.exists(os.path.join(scores_dir_xvec, 'labels_overall.npy')):\n sim_e1_ov = np.load(os.path.join(scores_dir, 'sim_e1_overall.npy'))\n labels_ov = np.load(os.path.join(scores_dir_xvec, 'labels_overall.npy'))\n fpr, tpr, threshold = roc_curve(labels_ov, sim_e1_ov)\n fnr = 1 - tpr\n eer_threshold_e1_ov = threshold[np.nanargmin(np.absolute((fnr - fpr)))]\n eer_e1_ov = fpr[np.nanargmin(np.absolute((fnr - fpr))) ]\n\n if xvec_FLAG:\n sim_xvec_ov = np.load(os.path.join(scores_dir_xvec, 'sim_xvec_overall.npy'))\n fpr, tpr, threshold = roc_curve(labels_ov, sim_xvec_ov)\n fnr = 1 - tpr\n eer_threshold_xvec_ov = threshold[np.nanargmin(np.absolute((fnr - fpr)))]\n eer_xvec_ov = fpr[np.nanargmin(np.absolute((fnr - fpr)))]\n print(\"Done scoring Gender-agnostic trials\")\n else:\n sim_e1_ov, labels_ov, eer_e1_ov, eer_threshold_e1_ov = compute_scores(df, agnostic_FLAG=True)\n np.save(os.path.join(scores_dir, 'sim_e1_overall'), sim_e1_ov)\n np.save(os.path.join(scores_dir_xvec, 'labels_overall'), labels_ov)\n if xvec_FLAG:\n sim_xvec_ov, labels_xvec_ov, eer_xvec_ov, eer_threshold_xvec_ov = compute_scores(df, agnostic_FLAG=True, emb_FLAG=False)\n np.save(os.path.join(scores_dir_xvec, 'sim_xvec_overall'), sim_xvec_ov)\n print(\"Done scoring Gender-agnostic trials\")\n\n #Gender-specific scoring\n print(\"Computing Gender-specific scores\")\n if (not os.path.exists(os.path.join(scores_dir, 'sim_e1_male_male.npy'))) or (not os.path.exists(os.path.join(scores_dir, 'sim_e1_female_female.npy'))):\n sim_e1_m, labels_e1_m, eer_e1_m, fpr_e1_m, fnr_e1_m = compute_scores(df_m_m, eer_threshold_e1_ov)\n sim_e1_f, labels_e1_f, eer_e1_f, fpr_e1_f, fnr_e1_f = compute_scores(df_f_f, eer_threshold_e1_ov)\n np.save(os.path.join(scores_dir, 'sim_e1_male_male'), sim_e1_m)\n np.save(os.path.join(scores_dir, 'sim_e1_female_female'), sim_e1_f)\n np.save(os.path.join(scores_dir_xvec, 'labels_male_male'), labels_e1_m)\n np.save(os.path.join(scores_dir_xvec, 'labels_female_female'), labels_e1_f)\n \n print(\"EER_all EER_Male EER_Female\")\n print(\"Embeddings: {} {} {}\\n\".format(np.round(eer_e1_ov*100,2), np.round(eer_e1_m*100,2), np.round(eer_e1_f*100,2)))\n \n sim_e1_g0 = sim_e1_m\n sim_e1_g1 = sim_e1_f\n labels_g0 = labels_e1_m\n labels_g1 = labels_e1_f\n print(\"Done scoring Gender-specific trials\")\n else:\n sim_e1 = []\n labels = []\n for group in groups:\n sim_e1.append(np.load(os.path.join(scores_dir, 'sim_e1_{}.npy'.format(group))))\n labels.append(np.load(os.path.join(scores_dir_xvec, 'labels_{}.npy'.format(group))))\n sim_e1_g0 = sim_e1[0]\n sim_e1_g1 = sim_e1[1]\n labels_g0 = labels[0]\n labels_g1 = labels[1]\n print(\"Done scoring Gender-specific trials\")\n if xvec_FLAG:\n if (not os.path.exists(os.path.join(scores_dir_xvec, 'sim_xvec_male_male.npy'))) or (not os.path.exists(os.path.join(scores_dir_xvec, 'sim_xvec_female_female.npy'))):\n print(\"Computing Gender-specific scores for x-vectors\")\n sim_xvec_m, labels_xvec_m, eer_xvec_m, fpr_xvec_m, fnr_xvec_m = compute_scores(df_m_m, eer_threshold_xvec_ov, emb_FLAG=False)\n sim_xvec_f, labels_xvec_f, eer_xvec_f, fpr_xvec_f, fnr_xvec_f = compute_scores(df_f_f, eer_threshold_xvec_ov, emb_FLAG=False)\n np.save(os.path.join(scores_dir_xvec, 'sim_xvec_male_male'), sim_xvec_m)\n np.save(os.path.join(scores_dir_xvec, 'sim_xvec_female_female'), sim_xvec_f)\n sim_xvec_g0 = sim_xvec_m\n sim_xvec_g1 = sim_xvec_f\n print(\"x-vector: {} {} {}\\n\".format(np.round(eer_xvec_ov*100,2), np.round(eer_xvec_m*100,2),np.round(eer_xvec_f*100,2)))\n print(\"Done scoring Gender-specific trials for x-vectors\")\n else:\n sim_xvec = []\n for group in groups:\n sim_xvec.append(np.load(os.path.join(scores_dir_xvec, 'sim_xvec_{}.npy'.format(group))))\n sim_xvec_g0 = sim_xvec[0]\n sim_xvec_g1 = sim_xvec[1]\n print(\"Done scoring Gender-specific trials for x-vectors\")\n\n # Compute area under FDR-FPR curve\n fpr_ov, tpr_ov, threshold_ov = roc_curve(labels_ov, sim_e1_ov)\n aus, au10s = [], []\n for omega in omegas:\n au, au10 = compute_auFDR(fpr_ov, tpr_ov, threshold_ov, sim_e1_g0, sim_e1_g1, labels_g0, labels_g1, scores_dir, emb_FLAG=True, omega=omega)\n aus.append(au)\n au10s.append(au10)\n df = pd.DataFrame(zip(omegas,aus, au10s), columns=['omega','au', 'au10'])\n df.to_csv(os.path.join(scores_dir, 'au_fdrs.csv'), index=None)\n\n if xvec_FLAG:\n fpr_ov, tpr_ov, threshold_ov = roc_curve(labels_ov, sim_xvec_ov)\n aus, aus10 = [],[]\n for omega in omegas:\n compute_auFDR(fpr_ov, tpr_ov, threshold_ov, sim_xvec_g0, sim_xvec_g1, labels_g0, labels_g1, scores_dir_xvec, emb_FLAG=False, omega=omega)\n aus.append(au)\n au10s.append(au10)\n df = pd.DataFrame(zip(omegas,aus, au10s), columns=['omega','au', 'au10'])\n df.to_csv(os.path.join(scores_dir_xvec, 'aufdrs.csv'), index=None)\n pdb.set_trace()\nif __name__=='__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument('--mode', type=str, required=True)\n parser.add_argument('--trials_root', type=str, required=True,\n help=\"Directory containing Test-Combined.csv\")\n\n parser.add_argument('--data_root', type=str, required=True,\n help=\"Directory containing test_utts.npy\")\n\n parser.add_argument('--pred_root', type=str, required=True,\n help=\"Directory containing Extracted embeddings\")\n\n parser.add_argument('--scores_root', type=str, required=True,\n help=\"Directory to save ASV scores\")\n parser.add_argument('--eval_xvector', default=False, action='store_true')\n args = parser.parse_args()\n main(args)\n\n"],"string":"[\n \"import numpy as np\\nimport pandas as pd\\nimport os\\nimport pdb\\nfrom scipy.spatial.distance import cosine\\nfrom sklearn.metrics import roc_curve, confusion_matrix\\nimport sys\\nfrom tqdm import tqdm\\nfrom sklearn.metrics import auc\\nimport argparse\\n\\nfprs = [0.01,0.02,0.03,0.04,0.05,0.06,0.07,0.08,0.09,0.1,0.2,0.3,0.4,0.5]\\ngroups = ['male_male','female_female']\\nomegas = [0.0, 0.25, 0.5, 0.75, 1.0]\\nemb_map = {}\\nxvec_map = {}\\n\\ndef compute_scores(df_, eer_threshold_overall=0, agnostic_FLAG=False, emb_FLAG=True):\\n if emb_FLAG:\\n emb_mapping = emb_map\\n else:\\n emb_mapping = xvec_map\\n similarity_scores= []\\n labels = []\\n for idx, row in tqdm(enumerate(df_.iterrows())):\\n enrol = row[1]['audio_1']\\n test = row[1]['audio_2']\\n label = row[1]['label']\\n if not enrol in emb_mapping.keys():\\n print(enrol)\\n if not test in emb_mapping.keys():\\n print(test)\\n\\n sim = 1 - cosine(emb_mapping[enrol],emb_mapping[test])\\n\\n similarity_scores.append(sim)\\n labels.append(label)\\n fpr, tpr, threshold = roc_curve(labels, similarity_scores)\\n fnr = 1 - tpr\\n eer_threshold = threshold[np.nanargmin(np.absolute((fnr - fpr)))]\\n eer1 = fpr[np.nanargmin(np.absolute((fnr - fpr)))]\\n eer2 = fnr[np.nanargmin(np.absolute((fnr - fpr)))]\\n eer = np.mean((eer1,eer2))\\n\\n sim = np.array(similarity_scores)\\n labels = np.array(labels)\\n if not agnostic_FLAG:\\n fpr, fnr = compute_fpr_fnr(sim, labels, eer_threshold_overall)\\n return sim, labels, eer, fpr, fnr\\n else:\\n return sim, labels, eer, eer_threshold\\n\\ndef compute_fpr_fnr(sim,labels_e1, thresh):\\n\\n preds = np.zeros(labels_e1.shape[0])\\n preds[sim > thresh] = 1\\n tn, fp, fn, tp = confusion_matrix(labels_e1, preds).ravel()\\n fpr = fp/(fp+tn)\\n fnr = fn/(fn+tp)\\n return fpr, fnr\\n\\ndef compute_fdr(fprs, fnrs, omega=0.5):\\n A = np.absolute(fprs[0]-fprs[1])\\n B = np.absolute(fnrs[0]-fnrs[1])\\n \\n return 1 - (omega*A + (1-omega)*B)\\n\\ndef compute_auFDR(fpr_ov, tpr_ov, threshold_ov, sim_g0, sim_g1, labels_g0, labels_g1, \\n score_dir, emb_FLAG=True, omega=0.5):\\n # FDRs at various thersholds\\n fdrs = []\\n fnrs = []\\n for fpr in tqdm(fprs):\\n thresh = threshold_ov[np.nanargmin(np.absolute((fpr_ov-fpr)))]\\n fnr = 1 - tpr_ov[np.nanargmin(np.absolute((fpr_ov-fpr)))]\\n fpr_g0, fnr_g0 = compute_fpr_fnr(sim_g0, labels_g0, thresh)\\n fpr_g1, fnr_g1 = compute_fpr_fnr(sim_g1, labels_g1, thresh)\\n fdr = compute_fdr((fpr_g0, fpr_g1), (fnr_g0, fnr_g1), float(omega))\\n fdrs.append(np.round(fdr*100,2))\\n fnrs.append(np.round(fnr*100,2))\\n auFDR = auc([x*100 for x in fprs], fdrs)\\n auFDR_10 = auc([x*100 for x in fprs[0:10]], fdrs[0:10])\\n df = pd.DataFrame(zip(fprs,fdrs, fnrs), columns=['fpr','fdr', 'fnr'])\\n if emb_FLAG:\\n print(\\\"Alpha = {} auFDR auFDR_10\\\".format(omega))\\n print(\\\"Embeddings: {} {}\\\\n\\\".format(auFDR, auFDR_10))\\n df.to_csv(os.path.join(score_dir, 'fdr_at_fpr_gender_omega_{}.csv'.format(omega)), index=None)\\n else:\\n print(\\\"Alpha = {} auFDR auFDR_10\\\".format(omega))\\n print(\\\"xvectors: {} {}\\\\n\\\".format(auFDR, auFDR_10))\\n df.to_csv(os.path.join(score_dir, 'fdr_at_fpr_gender_omega_{}.csv'.format(omega)), index=None)\\n return auFDR, auFDR_10\\n\\ndef main(args):\\n xvec_FLAG = args.eval_xvector\\n\\n # Creating necessary trials for gender-specific evaluations \\n trial_dir = args.trials_root\\n trials = os.path.join(trial_dir, 'Test-Combined.csv')\\n df = pd.read_csv(trials)\\n df['label'] = pd.to_numeric(df['label'])\\n\\n df_m = df.loc[df[\\\"gender_1\\\"]=='male']\\n df_f = df.loc[df[\\\"gender_1\\\"]=='female']\\n df_m_m = df_m.loc[df_m[\\\"gender_2\\\"]=='male']\\n df_f_f = df_f.loc[df_f[\\\"gender_2\\\"]=='female']\\n \\n if not os.path.exists(os.path.join(trial_dir,'Test-male-all.csv')):\\n df_m.to_csv(os.path.join(trial_dir,'Test-male-all.csv'), index=None)\\n if not os.path.exists(os.path.join(trial_dir,'Test-female-all.csv')):\\n df_f.to_csv(os.path.join(trial_dir,'Test-female-all.csv'), index=None)\\n if not os.path.exists(os.path.join(trial_dir,'Test-male-male.csv')):\\n df_m_m.to_csv(os.path.join(trial_dir,'Test-male-male.csv'), index=None)\\n if not os.path.exists(os.path.join(trial_dir,'Test-female-female.csv')):\\n df_f_f.to_csv(os.path.join(trial_dir,'Test-female-female.csv'), index=None)\\n\\n # Create directories to save ASV scores\\n scores_dir_base = args.scores_root\\n scores_dir_xvec = os.path.join(scores_dir_base,'baseline')\\n scores_dir = os.path.join(scores_dir_base,'{}'.format(args.mode))\\n os.makedirs(scores_dir_xvec, exist_ok=True)\\n os.makedirs(scores_dir, exist_ok=True)\\n\\n # Load extracted embeddings and xvectors\\n test_utts = np.load(os.path.join(args.data_root,'test_utts.npy'))\\n \\n pred_dir = args.pred_root\\n e1 = np.load(os.path.join(pred_dir,'emb1.npy'))\\n for idx, utt in enumerate(test_utts):\\n emb_map[utt] = e1[idx,:]\\n if xvec_FLAG:\\n xvec = np.load(os.path.join(args.data_root,'test_data.npy'))\\n for idx, utt in enumerate(test_utts):\\n xvec_map[utt] = xvec[idx,:]\\n\\n\\n # Gender-agnostic scoring\\n print(\\\"Computing Gender-agnostic scores\\\")\\n if os.path.exists(os.path.join(scores_dir_xvec, 'sim_xvec_overall.npy')) and os.path.exists(os.path.join(scores_dir, 'sim_e1_overall.npy')) and os.path.exists(os.path.join(scores_dir_xvec, 'labels_overall.npy')):\\n sim_e1_ov = np.load(os.path.join(scores_dir, 'sim_e1_overall.npy'))\\n labels_ov = np.load(os.path.join(scores_dir_xvec, 'labels_overall.npy'))\\n fpr, tpr, threshold = roc_curve(labels_ov, sim_e1_ov)\\n fnr = 1 - tpr\\n eer_threshold_e1_ov = threshold[np.nanargmin(np.absolute((fnr - fpr)))]\\n eer_e1_ov = fpr[np.nanargmin(np.absolute((fnr - fpr))) ]\\n\\n if xvec_FLAG:\\n sim_xvec_ov = np.load(os.path.join(scores_dir_xvec, 'sim_xvec_overall.npy'))\\n fpr, tpr, threshold = roc_curve(labels_ov, sim_xvec_ov)\\n fnr = 1 - tpr\\n eer_threshold_xvec_ov = threshold[np.nanargmin(np.absolute((fnr - fpr)))]\\n eer_xvec_ov = fpr[np.nanargmin(np.absolute((fnr - fpr)))]\\n print(\\\"Done scoring Gender-agnostic trials\\\")\\n else:\\n sim_e1_ov, labels_ov, eer_e1_ov, eer_threshold_e1_ov = compute_scores(df, agnostic_FLAG=True)\\n np.save(os.path.join(scores_dir, 'sim_e1_overall'), sim_e1_ov)\\n np.save(os.path.join(scores_dir_xvec, 'labels_overall'), labels_ov)\\n if xvec_FLAG:\\n sim_xvec_ov, labels_xvec_ov, eer_xvec_ov, eer_threshold_xvec_ov = compute_scores(df, agnostic_FLAG=True, emb_FLAG=False)\\n np.save(os.path.join(scores_dir_xvec, 'sim_xvec_overall'), sim_xvec_ov)\\n print(\\\"Done scoring Gender-agnostic trials\\\")\\n\\n #Gender-specific scoring\\n print(\\\"Computing Gender-specific scores\\\")\\n if (not os.path.exists(os.path.join(scores_dir, 'sim_e1_male_male.npy'))) or (not os.path.exists(os.path.join(scores_dir, 'sim_e1_female_female.npy'))):\\n sim_e1_m, labels_e1_m, eer_e1_m, fpr_e1_m, fnr_e1_m = compute_scores(df_m_m, eer_threshold_e1_ov)\\n sim_e1_f, labels_e1_f, eer_e1_f, fpr_e1_f, fnr_e1_f = compute_scores(df_f_f, eer_threshold_e1_ov)\\n np.save(os.path.join(scores_dir, 'sim_e1_male_male'), sim_e1_m)\\n np.save(os.path.join(scores_dir, 'sim_e1_female_female'), sim_e1_f)\\n np.save(os.path.join(scores_dir_xvec, 'labels_male_male'), labels_e1_m)\\n np.save(os.path.join(scores_dir_xvec, 'labels_female_female'), labels_e1_f)\\n \\n print(\\\"EER_all EER_Male EER_Female\\\")\\n print(\\\"Embeddings: {} {} {}\\\\n\\\".format(np.round(eer_e1_ov*100,2), np.round(eer_e1_m*100,2), np.round(eer_e1_f*100,2)))\\n \\n sim_e1_g0 = sim_e1_m\\n sim_e1_g1 = sim_e1_f\\n labels_g0 = labels_e1_m\\n labels_g1 = labels_e1_f\\n print(\\\"Done scoring Gender-specific trials\\\")\\n else:\\n sim_e1 = []\\n labels = []\\n for group in groups:\\n sim_e1.append(np.load(os.path.join(scores_dir, 'sim_e1_{}.npy'.format(group))))\\n labels.append(np.load(os.path.join(scores_dir_xvec, 'labels_{}.npy'.format(group))))\\n sim_e1_g0 = sim_e1[0]\\n sim_e1_g1 = sim_e1[1]\\n labels_g0 = labels[0]\\n labels_g1 = labels[1]\\n print(\\\"Done scoring Gender-specific trials\\\")\\n if xvec_FLAG:\\n if (not os.path.exists(os.path.join(scores_dir_xvec, 'sim_xvec_male_male.npy'))) or (not os.path.exists(os.path.join(scores_dir_xvec, 'sim_xvec_female_female.npy'))):\\n print(\\\"Computing Gender-specific scores for x-vectors\\\")\\n sim_xvec_m, labels_xvec_m, eer_xvec_m, fpr_xvec_m, fnr_xvec_m = compute_scores(df_m_m, eer_threshold_xvec_ov, emb_FLAG=False)\\n sim_xvec_f, labels_xvec_f, eer_xvec_f, fpr_xvec_f, fnr_xvec_f = compute_scores(df_f_f, eer_threshold_xvec_ov, emb_FLAG=False)\\n np.save(os.path.join(scores_dir_xvec, 'sim_xvec_male_male'), sim_xvec_m)\\n np.save(os.path.join(scores_dir_xvec, 'sim_xvec_female_female'), sim_xvec_f)\\n sim_xvec_g0 = sim_xvec_m\\n sim_xvec_g1 = sim_xvec_f\\n print(\\\"x-vector: {} {} {}\\\\n\\\".format(np.round(eer_xvec_ov*100,2), np.round(eer_xvec_m*100,2),np.round(eer_xvec_f*100,2)))\\n print(\\\"Done scoring Gender-specific trials for x-vectors\\\")\\n else:\\n sim_xvec = []\\n for group in groups:\\n sim_xvec.append(np.load(os.path.join(scores_dir_xvec, 'sim_xvec_{}.npy'.format(group))))\\n sim_xvec_g0 = sim_xvec[0]\\n sim_xvec_g1 = sim_xvec[1]\\n print(\\\"Done scoring Gender-specific trials for x-vectors\\\")\\n\\n # Compute area under FDR-FPR curve\\n fpr_ov, tpr_ov, threshold_ov = roc_curve(labels_ov, sim_e1_ov)\\n aus, au10s = [], []\\n for omega in omegas:\\n au, au10 = compute_auFDR(fpr_ov, tpr_ov, threshold_ov, sim_e1_g0, sim_e1_g1, labels_g0, labels_g1, scores_dir, emb_FLAG=True, omega=omega)\\n aus.append(au)\\n au10s.append(au10)\\n df = pd.DataFrame(zip(omegas,aus, au10s), columns=['omega','au', 'au10'])\\n df.to_csv(os.path.join(scores_dir, 'au_fdrs.csv'), index=None)\\n\\n if xvec_FLAG:\\n fpr_ov, tpr_ov, threshold_ov = roc_curve(labels_ov, sim_xvec_ov)\\n aus, aus10 = [],[]\\n for omega in omegas:\\n compute_auFDR(fpr_ov, tpr_ov, threshold_ov, sim_xvec_g0, sim_xvec_g1, labels_g0, labels_g1, scores_dir_xvec, emb_FLAG=False, omega=omega)\\n aus.append(au)\\n au10s.append(au10)\\n df = pd.DataFrame(zip(omegas,aus, au10s), columns=['omega','au', 'au10'])\\n df.to_csv(os.path.join(scores_dir_xvec, 'aufdrs.csv'), index=None)\\n pdb.set_trace()\\nif __name__=='__main__':\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--mode', type=str, required=True)\\n parser.add_argument('--trials_root', type=str, required=True,\\n help=\\\"Directory containing Test-Combined.csv\\\")\\n\\n parser.add_argument('--data_root', type=str, required=True,\\n help=\\\"Directory containing test_utts.npy\\\")\\n\\n parser.add_argument('--pred_root', type=str, required=True,\\n help=\\\"Directory containing Extracted embeddings\\\")\\n\\n parser.add_argument('--scores_root', type=str, required=True,\\n help=\\\"Directory to save ASV scores\\\")\\n parser.add_argument('--eval_xvector', default=False, action='store_true')\\n args = parser.parse_args()\\n main(args)\\n\\n\"\n]","isConversational":false},"apis":{"kind":"list like","value":[["pandas.to_numeric","numpy.absolute","pandas.read_csv","scipy.spatial.distance.cosine","sklearn.metrics.confusion_matrix","sklearn.metrics.roc_curve","numpy.round","numpy.mean","sklearn.metrics.auc","numpy.array","numpy.zeros"]],"string":"[\n [\n \"pandas.to_numeric\",\n \"numpy.absolute\",\n \"pandas.read_csv\",\n \"scipy.spatial.distance.cosine\",\n \"sklearn.metrics.confusion_matrix\",\n \"sklearn.metrics.roc_curve\",\n \"numpy.round\",\n \"numpy.mean\",\n \"sklearn.metrics.auc\",\n \"numpy.array\",\n \"numpy.zeros\"\n ]\n]","isConversational":false},"possible_versions":{"kind":"list like","value":[{"matplotlib":[],"numpy":[],"pandas":["2.0","1.4","1.3","1.1","1.5","1.2"],"scipy":["0.13","1.6","0.14","1.10","0.15","1.4","0.16","1.9","0.19","1.5","0.18","1.2","1.7","0.12","1.0","0.17","1.3","1.8"],"tensorflow":[]}],"string":"[\n {\n \"matplotlib\": [],\n \"numpy\": [],\n \"pandas\": [\n \"2.0\",\n \"1.4\",\n \"1.3\",\n \"1.1\",\n \"1.5\",\n \"1.2\"\n ],\n \"scipy\": [\n \"0.13\",\n \"1.6\",\n \"0.14\",\n \"1.10\",\n \"0.15\",\n \"1.4\",\n \"0.16\",\n \"1.9\",\n \"0.19\",\n \"1.5\",\n \"0.18\",\n \"1.2\",\n \"1.7\",\n \"0.12\",\n \"1.0\",\n \"0.17\",\n \"1.3\",\n \"1.8\"\n ],\n \"tensorflow\": []\n }\n]","isConversational":false}}},{"rowIdx":2599,"cells":{"repo_name":{"kind":"string","value":"creare-com/podpac"},"hexsha":{"kind":"list like","value":["7feb5c957513c146ce73ba1c36c630284f513a6e","7feb5c957513c146ce73ba1c36c630284f513a6e","7feb5c957513c146ce73ba1c36c630284f513a6e","7feb5c957513c146ce73ba1c36c630284f513a6e","7feb5c957513c146ce73ba1c36c630284f513a6e"],"string":"[\n \"7feb5c957513c146ce73ba1c36c630284f513a6e\",\n \"7feb5c957513c146ce73ba1c36c630284f513a6e\",\n \"7feb5c957513c146ce73ba1c36c630284f513a6e\",\n \"7feb5c957513c146ce73ba1c36c630284f513a6e\",\n \"7feb5c957513c146ce73ba1c36c630284f513a6e\"\n]","isConversational":false},"file_path":{"kind":"list like","value":["podpac/core/coordinates/test/test_uniform_coordinates1d.py","podpac/core/test/test_node.py","podpac/core/interpolation/test/test_interpolation.py","podpac/core/algorithm/generic.py","podpac/core/algorithm/test/test_stats.py"],"string":"[\n \"podpac/core/coordinates/test/test_uniform_coordinates1d.py\",\n \"podpac/core/test/test_node.py\",\n \"podpac/core/interpolation/test/test_interpolation.py\",\n \"podpac/core/algorithm/generic.py\",\n \"podpac/core/algorithm/test/test_stats.py\"\n]","isConversational":false},"code":{"kind":"list like","value":["from datetime import datetime\nimport json\n\nimport pytest\nimport traitlets as tl\nimport numpy as np\nfrom numpy.testing import assert_equal\n\nimport podpac\nfrom podpac.core.coordinates.utils import make_coord_array\nfrom podpac.core.coordinates.coordinates1d import Coordinates1d\nfrom podpac.core.coordinates.array_coordinates1d import ArrayCoordinates1d\nfrom podpac.core.coordinates.uniform_coordinates1d import UniformCoordinates1d\nfrom podpac.core.coordinates.coordinates import Coordinates\n\n\nclass TestUniformCoordinatesCreation(object):\n def test_numerical(self):\n # ascending\n c = UniformCoordinates1d(0, 50, 10)\n a = np.array([0, 10, 20, 30, 40, 50], dtype=float)\n assert c.start == 0\n assert c.stop == 50\n assert c.step == 10\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, [0, 50])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == 6\n assert c.dtype == float\n assert c.is_monotonic == True\n assert c.is_descending == False\n assert c.is_uniform == True\n\n # descending\n c = UniformCoordinates1d(50, 0, -10)\n a = np.array([50, 40, 30, 20, 10, 0], dtype=float)\n assert c.start == 50\n assert c.stop == 0\n assert c.step == -10\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, [0, 50])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == 6\n assert c.dtype == float\n assert c.is_monotonic == True\n assert c.is_descending == True\n assert c.is_uniform == True\n\n def test_numerical_inexact(self):\n # ascending\n c = UniformCoordinates1d(0, 49, 10)\n a = np.array([0, 10, 20, 30, 40], dtype=float)\n assert c.start == 0\n assert c.stop == 49\n assert c.step == 10\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, [0, 40])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == 5\n assert c.dtype == float\n assert c.is_monotonic == True\n assert c.is_descending == False\n assert c.is_uniform == True\n\n # descending\n c = UniformCoordinates1d(50, 1, -10)\n a = np.array([50, 40, 30, 20, 10], dtype=float)\n assert c.start == 50\n assert c.stop == 1\n assert c.step == -10\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, [10, 50])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.dtype == float\n assert c.size == a.size\n assert c.is_monotonic == True\n assert c.is_descending == True\n assert c.is_uniform == True\n\n def test_datetime(self):\n # ascending\n c = UniformCoordinates1d(\"2018-01-01\", \"2018-01-04\", \"1,D\")\n a = np.array([\"2018-01-01\", \"2018-01-02\", \"2018-01-03\", \"2018-01-04\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2018-01-01\")\n assert c.stop == np.datetime64(\"2018-01-04\")\n assert c.step == np.timedelta64(1, \"D\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[0, -1]])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == False\n assert c.is_uniform == True\n\n # descending\n c = UniformCoordinates1d(\"2018-01-04\", \"2018-01-01\", \"-1,D\")\n a = np.array([\"2018-01-04\", \"2018-01-03\", \"2018-01-02\", \"2018-01-01\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2018-01-04\")\n assert c.stop == np.datetime64(\"2018-01-01\")\n assert c.step == np.timedelta64(-1, \"D\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[-1, 0]])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == True\n assert c.is_uniform == True\n\n def test_datetime_inexact(self):\n # ascending\n c = UniformCoordinates1d(\"2018-01-01\", \"2018-01-06\", \"2,D\")\n a = np.array([\"2018-01-01\", \"2018-01-03\", \"2018-01-05\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2018-01-01\")\n assert c.stop == np.datetime64(\"2018-01-06\")\n assert c.step == np.timedelta64(2, \"D\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[0, -1]])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == False\n assert c.is_uniform == True\n\n # descending\n c = UniformCoordinates1d(\"2018-01-06\", \"2018-01-01\", \"-2,D\")\n a = np.array([\"2018-01-06\", \"2018-01-04\", \"2018-01-02\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2018-01-06\")\n assert c.stop == np.datetime64(\"2018-01-01\")\n assert c.step == np.timedelta64(-2, \"D\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[-1, 0]])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == True\n assert c.is_uniform == True\n\n def test_datetime_month_step(self):\n # ascending\n c = UniformCoordinates1d(\"2018-01-01\", \"2018-04-01\", \"1,M\")\n a = np.array([\"2018-01-01\", \"2018-02-01\", \"2018-03-01\", \"2018-04-01\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2018-01-01\")\n assert c.stop == np.datetime64(\"2018-04-01\")\n assert c.step == np.timedelta64(1, \"M\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[0, -1]])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == False\n assert c.is_uniform == True\n\n # descending\n c = UniformCoordinates1d(\"2018-04-01\", \"2018-01-01\", \"-1,M\")\n a = np.array([\"2018-04-01\", \"2018-03-01\", \"2018-02-01\", \"2018-01-01\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2018-04-01\")\n assert c.stop == np.datetime64(\"2018-01-01\")\n assert c.step == np.timedelta64(-1, \"M\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[-1, 0]])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == True\n assert c.is_uniform == True\n\n def test_datetime_year_step(self):\n # ascending, exact\n c = UniformCoordinates1d(\"2018-01-01\", \"2021-01-01\", \"1,Y\")\n a = np.array([\"2018-01-01\", \"2019-01-01\", \"2020-01-01\", \"2021-01-01\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2018-01-01\")\n assert c.stop == np.datetime64(\"2021-01-01\")\n assert c.step == np.timedelta64(1, \"Y\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[0, -1]])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == False\n assert c.is_uniform == True\n\n # descending, exact\n c = UniformCoordinates1d(\"2021-01-01\", \"2018-01-01\", \"-1,Y\")\n a = np.array([\"2021-01-01\", \"2020-01-01\", \"2019-01-01\", \"2018-01-01\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2021-01-01\")\n assert c.stop == np.datetime64(\"2018-01-01\")\n assert c.step == np.timedelta64(-1, \"Y\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[-1, 0]])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == True\n assert c.is_uniform == True\n\n # ascending, inexact (two cases)\n c = UniformCoordinates1d(\"2018-01-01\", \"2021-04-01\", \"1,Y\")\n a = np.array([\"2018-01-01\", \"2019-01-01\", \"2020-01-01\", \"2021-01-01\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2018-01-01\")\n assert c.stop == np.datetime64(\"2021-04-01\")\n assert c.step == np.timedelta64(1, \"Y\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[0, -1]])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == False\n assert c.is_uniform == True\n\n c = UniformCoordinates1d(\"2018-04-01\", \"2021-01-01\", \"1,Y\")\n a = np.array([\"2018-04-01\", \"2019-04-01\", \"2020-04-01\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2018-04-01\")\n assert c.stop == np.datetime64(\"2021-01-01\")\n assert c.step == np.timedelta64(1, \"Y\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[0, -1]])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == False\n assert c.is_uniform == True\n\n # descending, inexact (two cases)\n c = UniformCoordinates1d(\"2021-01-01\", \"2018-04-01\", \"-1,Y\")\n a = np.array([\"2021-01-01\", \"2020-01-01\", \"2019-01-01\", \"2018-01-01\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2021-01-01\")\n assert c.stop == np.datetime64(\"2018-04-01\")\n assert c.step == np.timedelta64(-1, \"Y\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[-1, 0]])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == True\n assert c.is_uniform == True\n\n c = UniformCoordinates1d(\"2021-04-01\", \"2018-01-01\", \"-1,Y\")\n a = np.array([\"2021-04-01\", \"2020-04-01\", \"2019-04-01\", \"2018-04-01\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2021-04-01\")\n assert c.stop == np.datetime64(\"2018-01-01\")\n assert c.step == np.timedelta64(-1, \"Y\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[-1, 0]])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == True\n assert c.is_uniform == True\n\n def test_numerical_size(self):\n # ascending\n c = UniformCoordinates1d(0, 10, size=20)\n assert c.start == 0\n assert c.stop == 10\n assert c.step == 10 / 19.0\n assert_equal(c.coordinates, np.linspace(0, 10, 20))\n assert_equal(c.bounds, [0, 10])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == 20\n assert c.dtype == float\n assert c.is_monotonic == True\n assert c.is_descending == False\n assert c.is_uniform == True\n\n # descending\n c = UniformCoordinates1d(10, 0, size=20)\n assert c.start == 10\n assert c.stop == 0\n assert c.step == -10 / 19.0\n assert_equal(c.coordinates, np.linspace(10, 0, 20))\n assert_equal(c.bounds, [0, 10])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == 20\n assert c.dtype == float\n assert c.is_monotonic == True\n assert c.is_descending == True\n assert c.is_uniform == True\n\n def test_datetime_size(self):\n # ascending\n c = UniformCoordinates1d(\"2018-01-01\", \"2018-01-10\", size=10)\n assert c.start == np.datetime64(\"2018-01-01\")\n assert c.stop == np.datetime64(\"2018-01-10\")\n assert_equal(c.bounds, [np.datetime64(\"2018-01-01\"), np.datetime64(\"2018-01-10\")])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == 10\n assert c.dtype == np.datetime64\n assert c.is_descending == False\n\n # descending\n c = UniformCoordinates1d(\"2018-01-10\", \"2018-01-01\", size=10)\n assert c.start == np.datetime64(\"2018-01-10\")\n assert c.stop == np.datetime64(\"2018-01-01\")\n assert_equal(c.bounds, [np.datetime64(\"2018-01-01\"), np.datetime64(\"2018-01-10\")])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == 10\n assert c.dtype == np.datetime64\n assert c.is_descending == True\n\n # increase resolution\n c = UniformCoordinates1d(\"2018-01-01\", \"2018-01-10\", size=21)\n assert c.start == np.datetime64(\"2018-01-01\")\n assert c.stop == np.datetime64(\"2018-01-10\")\n assert_equal(c.bounds, [np.datetime64(\"2018-01-01\"), np.datetime64(\"2018-01-10\")])\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\n assert c.size == 21\n assert c.dtype == np.datetime64\n assert c.is_descending == False\n\n def test_datetime_size_invalid(self):\n with pytest.raises(ValueError, match=\"Cannot divide timedelta\"):\n c = UniformCoordinates1d(\"2018-01-01\", \"2018-01-10\", size=20)\n\n def test_numerical_size_floating_point_error(self):\n c = UniformCoordinates1d(50.619, 50.62795, size=30)\n assert c.size == 30\n\n def test_numerical_singleton(self):\n # positive step\n c = UniformCoordinates1d(1, 1, 10)\n a = np.array([1], dtype=float)\n assert c.start == 1\n assert c.stop == 1\n assert c.step == 10\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, [1, 1])\n assert c.size == 1\n assert c.dtype == float\n assert c.is_monotonic == True\n assert c.is_descending == None\n assert c.is_uniform == True\n\n # negative step\n c = UniformCoordinates1d(1, 1, -10)\n a = np.array([1], dtype=float)\n assert c.start == 1\n assert c.stop == 1\n assert c.step == -10\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, [1, 1])\n assert c.size == 1\n assert c.dtype == float\n assert c.is_monotonic == True\n assert c.is_descending == None\n assert c.is_uniform == True\n\n def test_datetime_singleton(self):\n # positive step\n c = UniformCoordinates1d(\"2018-01-01\", \"2018-01-01\", \"1,D\")\n a = np.array([\"2018-01-01\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2018-01-01\")\n assert c.stop == np.datetime64(\"2018-01-01\")\n assert c.step == np.timedelta64(1, \"D\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[0, -1]])\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == None\n assert c.is_uniform == True\n\n # negative step\n c = UniformCoordinates1d(\"2018-01-01\", \"2018-01-01\", \"-1,D\")\n a = np.array([\"2018-01-01\"]).astype(np.datetime64)\n assert c.start == np.datetime64(\"2018-01-01\")\n assert c.stop == np.datetime64(\"2018-01-01\")\n assert c.step == np.timedelta64(-1, \"D\")\n assert_equal(c.coordinates, a)\n assert_equal(c.bounds, a[[-1, 0]])\n assert c.size == a.size\n assert c.dtype == np.datetime64\n assert c.is_monotonic == True\n assert c.is_descending == None\n assert c.is_uniform == True\n\n def test_from_tuple(self):\n # numerical, step\n c = UniformCoordinates1d.from_tuple((0, 10, 0.5))\n assert c.start == 0.0\n assert c.stop == 10.0\n assert c.step == 0.5\n\n # numerical, size\n c = UniformCoordinates1d.from_tuple((0, 10, 20))\n assert c.start == 0.0\n assert c.stop == 10.0\n assert c.size == 20\n\n # datetime, step\n c = UniformCoordinates1d.from_tuple((\"2018-01-01\", \"2018-01-04\", \"1,D\"))\n assert c.start == np.datetime64(\"2018-01-01\")\n assert c.stop == np.datetime64(\"2018-01-04\")\n assert c.step == np.timedelta64(1, \"D\")\n\n # invalid\n with pytest.raises(ValueError, match=\"UniformCoordinates1d.from_tuple expects a tuple\"):\n UniformCoordinates1d.from_tuple((0, 10))\n\n with pytest.raises(ValueError, match=\"UniformCoordinates1d.from_tuple expects a tuple\"):\n UniformCoordinates1d.from_tuple(np.array([0, 10, 0.5]))\n\n def test_copy(self):\n c = UniformCoordinates1d(0, 10, 50, name=\"lat\")\n c2 = c.copy()\n assert c is not c2\n assert c == c2\n\n def test_invalid_init(self):\n with pytest.raises(ValueError):\n UniformCoordinates1d(0, 0, 0)\n\n with pytest.raises(ValueError):\n UniformCoordinates1d(0, 50, 0)\n\n with pytest.raises(ValueError):\n UniformCoordinates1d(0, 50, -10)\n\n with pytest.raises(ValueError):\n UniformCoordinates1d(50, 0, 10)\n\n with pytest.raises(TypeError):\n UniformCoordinates1d(0, \"2018-01-01\", 10)\n\n with pytest.raises(TypeError):\n UniformCoordinates1d(\"2018-01-01\", 50, 10)\n\n with pytest.raises(TypeError):\n UniformCoordinates1d(\"2018-01-01\", \"2018-01-02\", 10)\n\n with pytest.raises(TypeError):\n UniformCoordinates1d(0.0, \"2018-01-01\", \"1,D\")\n\n with pytest.raises(TypeError):\n UniformCoordinates1d(\"2018-01-01\", 50, \"1,D\")\n\n with pytest.raises(TypeError):\n UniformCoordinates1d(0, 50, \"1,D\")\n\n with pytest.raises(ValueError):\n UniformCoordinates1d(\"a\", 50, 10)\n\n with pytest.raises(ValueError):\n UniformCoordinates1d(0, \"b\", 10)\n\n with pytest.raises(ValueError):\n UniformCoordinates1d(0, 50, \"a\")\n\n with pytest.raises(TypeError):\n UniformCoordinates1d()\n\n with pytest.raises(TypeError):\n UniformCoordinates1d(0)\n\n with pytest.raises(TypeError):\n UniformCoordinates1d(0, 50)\n\n with pytest.raises(TypeError):\n UniformCoordinates1d(0, 50, 10, size=6)\n\n with pytest.raises(TypeError):\n UniformCoordinates1d(0, 10, size=20.0)\n\n with pytest.raises(TypeError):\n UniformCoordinates1d(0, 10, size=\"string\")\n\n with pytest.raises(TypeError):\n UniformCoordinates1d(\"2018-01-10\", \"2018-01-01\", size=\"1,D\")\n\n\nclass TestUniformCoordinatesEq(object):\n def test_equal(self):\n c1 = UniformCoordinates1d(0, 50, 10)\n c2 = UniformCoordinates1d(0, 50, 10)\n c3 = UniformCoordinates1d(0, 50, 10)\n c4 = UniformCoordinates1d(5, 50, 10)\n c5 = UniformCoordinates1d(0, 60, 10)\n c6 = UniformCoordinates1d(0, 50, 5)\n c7 = UniformCoordinates1d(50, 0, -10)\n\n assert c1 == c2\n assert c1 == c3\n assert c1 != c4\n assert c1 != c5\n assert c1 != c6\n assert c1 != c7\n\n def test_equal_array_coordinates(self):\n c1 = UniformCoordinates1d(0, 50, 10)\n c2 = ArrayCoordinates1d([0, 10, 20, 30, 40, 50])\n c3 = ArrayCoordinates1d([10, 20, 30, 40, 50, 60])\n\n assert c1 == c2\n assert c1 != c3\n\n\nclass TestUniformCoordinatesSerialization(object):\n def test_definition(self):\n # numerical\n c = UniformCoordinates1d(0, 50, 10, name=\"lat\")\n d = c.definition\n assert isinstance(d, dict)\n assert set(d.keys()) == set([\"start\", \"stop\", \"step\", \"name\"])\n json.dumps(d, cls=podpac.core.utils.JSONEncoder) # test serializable\n c2 = UniformCoordinates1d.from_definition(d) # test from_definition\n assert c2 == c\n\n # datetimes\n c = UniformCoordinates1d(\"2018-01-01\", \"2018-01-03\", \"1,D\")\n d = c.definition\n assert isinstance(d, dict)\n assert set(d.keys()) == set([\"start\", \"stop\", \"step\"])\n json.dumps(d, cls=podpac.core.utils.JSONEncoder) # test serializable\n c2 = UniformCoordinates1d.from_definition(d) # test from_definition\n assert c2 == c\n\n def test_invalid_definition(self):\n # incorrect definition\n d = {\"stop\": 50}\n with pytest.raises(ValueError, match='UniformCoordinates1d definition requires \"start\"'):\n UniformCoordinates1d.from_definition(d)\n\n d = {\"start\": 0}\n with pytest.raises(ValueError, match='UniformCoordinates1d definition requires \"stop\"'):\n UniformCoordinates1d.from_definition(d)\n\n def test_from_definition_size(self):\n # numerical\n d = {\"start\": 0, \"stop\": 50, \"size\": 6}\n c = UniformCoordinates1d.from_definition(d)\n assert_equal(c.coordinates, [0, 10, 20, 30, 40, 50])\n\n # datetime, size\n d = {\"start\": \"2018-01-01\", \"stop\": \"2018-01-03\", \"size\": 3}\n c = UniformCoordinates1d.from_definition(d)\n assert_equal(c.coordinates, np.array([\"2018-01-01\", \"2018-01-02\", \"2018-01-03\"]).astype(np.datetime64))\n\n\nclass TestUniformCoordinatesIndexing(object):\n def test_len(self):\n c = UniformCoordinates1d(0, 50, 10)\n assert len(c) == 6\n\n def test_index(self):\n c = UniformCoordinates1d(0, 50, 10, name=\"lat\")\n\n # int\n c2 = c[2]\n assert isinstance(c2, Coordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [20])\n\n c2 = c[-2]\n assert isinstance(c2, Coordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [40])\n\n # slice\n c2 = c[:2]\n assert isinstance(c2, UniformCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert c2.start == 0\n assert c2.stop == 10\n assert c2.step == 10\n\n c2 = c[2:]\n assert isinstance(c2, UniformCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert c2.start == 20\n assert c2.stop == 50\n assert c2.step == 10\n\n c2 = c[::2]\n assert isinstance(c2, UniformCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert c2.start == 0\n assert c2.stop == 50\n assert c2.step == 20\n\n c2 = c[1:-1]\n assert isinstance(c2, UniformCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert c2.start == 10\n assert c2.stop == 40\n assert c2.step == 10\n\n c2 = c[-3:5]\n assert isinstance(c2, UniformCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert c2.start == 30\n assert c2.stop == 40\n assert c2.step == 10\n\n c2 = c[::-1]\n assert isinstance(c2, UniformCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert c2.start == 50\n assert c2.stop == 0\n assert c2.step == -10\n\n # index array\n c2 = c[[0, 1, 3]]\n assert isinstance(c2, ArrayCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [0, 10, 30])\n\n c2 = c[[3, 1, 0]]\n assert isinstance(c2, ArrayCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [30, 10, 0])\n\n c2 = c[[0, 3, 1]]\n assert isinstance(c2, ArrayCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [0, 30, 10])\n\n c2 = c[[]]\n assert isinstance(c2, ArrayCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [])\n\n c2 = c[0:0]\n assert isinstance(c2, ArrayCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [])\n\n c2 = c[[]]\n assert isinstance(c2, ArrayCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [])\n\n # boolean array\n c2 = c[[True, True, True, False, True, False]]\n assert isinstance(c2, ArrayCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [0, 10, 20, 40])\n\n # invalid\n with pytest.raises(IndexError):\n c[0.3]\n\n with pytest.raises(IndexError):\n c[10]\n\n def test_index_descending(self):\n c = UniformCoordinates1d(50, 0, -10, name=\"lat\")\n\n # int\n c2 = c[2]\n assert isinstance(c2, Coordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [30])\n\n c2 = c[-2]\n assert isinstance(c2, Coordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [10])\n\n # slice\n c2 = c[:2]\n assert isinstance(c2, UniformCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert c2.start == 50\n assert c2.stop == 40\n assert c2.step == -10\n\n c2 = c[2:]\n assert isinstance(c2, UniformCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert c2.start == 30\n assert c2.stop == 0\n assert c2.step == -10\n\n c2 = c[::2]\n assert isinstance(c2, UniformCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert c2.start == 50\n assert c2.stop == 0\n assert c2.step == -20\n\n c2 = c[1:-1]\n assert isinstance(c2, UniformCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert c2.start == 40\n assert c2.stop == 10\n assert c2.step == -10\n\n c2 = c[-3:5]\n assert isinstance(c2, UniformCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert c2.start == 20\n assert c2.stop == 10\n assert c2.step == -10\n\n c2 = c[::-1]\n assert isinstance(c2, UniformCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert c2.start == 0\n assert c2.stop == 50\n assert c2.step == 10\n\n # index array\n c2 = c[[0, 1, 3]]\n assert isinstance(c2, ArrayCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [50, 40, 20])\n\n c2 = c[[3, 1, 0]]\n assert isinstance(c2, ArrayCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [20, 40, 50])\n\n c2 = c[[0, 3, 1]]\n assert isinstance(c2, ArrayCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [50, 20, 40])\n\n # boolean array\n c2 = c[[True, True, True, False, True, False]]\n assert isinstance(c2, ArrayCoordinates1d)\n assert c2.name == c.name\n assert c2.properties == c.properties\n assert_equal(c2.coordinates, [50, 40, 30, 10])\n\n def test_in(self):\n c = UniformCoordinates1d(0, 50, 10, name=\"lat\")\n assert 0 in c\n assert 10 in c\n assert 50 in c\n assert -10 not in c\n assert 60 not in c\n assert 5 not in c\n assert np.datetime64(\"2018\") not in c\n assert \"a\" not in c\n\n c = UniformCoordinates1d(50, 0, -10, name=\"lat\")\n assert 0 in c\n assert 10 in c\n assert 50 in c\n assert -10 not in c\n assert 60 not in c\n assert 5 not in c\n assert np.datetime64(\"2018\") not in c\n assert \"a\" not in c\n\n c = UniformCoordinates1d(\"2020-01-01\", \"2020-01-09\", \"2,D\", name=\"time\")\n assert np.datetime64(\"2020-01-01\") in c\n assert np.datetime64(\"2020-01-03\") in c\n assert np.datetime64(\"2020-01-09\") in c\n assert np.datetime64(\"2020-01-11\") not in c\n assert np.datetime64(\"2020-01-02\") not in c\n assert 10 not in c\n assert \"a\" not in c\n\n\nclass TestArrayCoordinatesAreaBounds(object):\n def test_get_area_bounds_numerical(self):\n c = UniformCoordinates1d(0, 50, 10)\n\n # point\n area_bounds = c.get_area_bounds(None)\n assert_equal(area_bounds, [0.0, 50.0])\n\n # uniform\n area_bounds = c.get_area_bounds(0.5)\n assert_equal(area_bounds, [-0.5, 50.5])\n\n # segment\n area_bounds = c.get_area_bounds([-0.2, 0.7])\n assert_equal(area_bounds, [-0.2, 50.7])\n\n # polygon (i.e. there would be corresponding offets for another dimension)\n area_bounds = c.get_area_bounds([-0.2, -0.5, 0.7, 0.5])\n assert_equal(area_bounds, [-0.5, 50.7])\n\n def test_get_area_bounds_datetime(self):\n c = UniformCoordinates1d(\"2018-01-01\", \"2018-01-04\", \"1,D\")\n\n # point\n area_bounds = c.get_area_bounds(None)\n assert_equal(area_bounds, make_coord_array([\"2018-01-01\", \"2018-01-04\"]))\n\n # uniform\n area_bounds = c.get_area_bounds(\"1,D\")\n assert_equal(area_bounds, make_coord_array([\"2017-12-31\", \"2018-01-05\"]))\n\n area_bounds = c.get_area_bounds(\"1,M\")\n assert_equal(area_bounds, make_coord_array([\"2017-12-01\", \"2018-02-04\"]))\n\n area_bounds = c.get_area_bounds(\"1,Y\")\n assert_equal(area_bounds, make_coord_array([\"2017-01-01\", \"2019-01-04\"]))\n\n # segment\n area_bounds = c.get_area_bounds([\"0,h\", \"12,h\"])\n assert_equal(area_bounds, make_coord_array([\"2018-01-01 00:00\", \"2018-01-04 12:00\"]))\n\n\nclass TestUniformCoordinatesSelection(object):\n def test_select_all_shortcut(self):\n c = UniformCoordinates1d(20.0, 70.0, 10.0)\n\n s = c.select([0, 100])\n assert s.start == 20.0\n assert s.stop == 70.0\n assert s.step == 10.0\n\n s, I = c.select([0, 100], return_index=True)\n assert s.start == 20.0\n assert s.stop == 70.0\n assert s.step == 10.0\n assert_equal(c[I], s)\n\n def test_select_none_shortcut(self):\n c = UniformCoordinates1d(20.0, 70.0, 10.0)\n\n # above\n s = c.select([100, 200])\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n\n s, I = c.select([100, 200], return_index=True)\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n assert c[I] == s\n\n # below\n s = c.select([0, 5])\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n\n s, I = c.select([0, 5], return_index=True)\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n assert c[I] == s\n\n def test_select_ascending(self):\n c = UniformCoordinates1d(20.0, 70.0, 10.0)\n\n # inner\n s = c.select([35.0, 55.0])\n assert s.start == 40.0\n assert s.stop == 50.0\n assert s.step == 10.0\n\n s, I = c.select([35.0, 55.0], return_index=True)\n assert s.start == 40.0\n assert s.stop == 50.0\n assert s.step == 10.0\n assert c[I] == s\n\n # inner with aligned bounds\n s = c.select([30.0, 60.0])\n assert s.start == 30.0\n assert s.stop == 60.0\n assert s.step == 10.0\n\n s, I = c.select([30.0, 60.0], return_index=True)\n assert s.start == 30.0\n assert s.stop == 60.0\n assert s.step == 10.0\n assert c[I] == s\n\n # above\n s = c.select([45, 100])\n assert s.start == 50.0\n assert s.stop == 70.0\n assert s.step == 10.0\n\n s, I = c.select([45, 100], return_index=True)\n assert s.start == 50.0\n assert s.stop == 70.0\n assert s.step == 10.0\n assert c[I] == s\n\n # below\n s = c.select([5, 55])\n assert s.start == 20.0\n assert s.stop == 50.0\n assert s.step == 10.0\n\n s, I = c.select([5, 55], return_index=True)\n assert s.start == 20.0\n assert s.stop == 50.0\n assert s.step == 10.0\n assert c[I] == s\n\n # between coordinates\n s = c.select([52, 55])\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n\n s, I = c.select([52, 55], return_index=True)\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n assert_equal(c.coordinates[I], [])\n\n # backwards bounds\n s = c.select([70, 30])\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n\n s, I = c.select([70, 30], return_index=True)\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n assert_equal(c.coordinates[I], [])\n\n def test_select_descending(self):\n c = UniformCoordinates1d(70.0, 20.0, -10.0)\n\n # inner\n s = c.select([35.0, 55.0])\n assert s.start == 50.0\n assert s.stop == 40.0\n assert s.step == -10.0\n\n s, I = c.select([35.0, 55.0], return_index=True)\n assert s.start == 50.0\n assert s.stop == 40.0\n assert s.step == -10.0\n assert c[I] == s\n\n # inner with aligned bounds\n s = c.select([30.0, 60.0])\n assert s.start == 60.0\n assert s.stop == 30.0\n assert s.step == -10.0\n\n s, I = c.select([30.0, 60.0], return_index=True)\n assert s.start == 60.0\n assert s.stop == 30.0\n assert s.step == -10.0\n assert c[I] == s\n\n # above\n s = c.select([45, 100])\n assert s.start == 70.0\n assert s.stop == 50.0\n assert s.step == -10.0\n\n s, I = c.select([45, 100], return_index=True)\n assert s.start == 70.0\n assert s.stop == 50.0\n assert s.step == -10.0\n assert c[I] == s\n\n # below\n s = c.select([5, 55])\n assert s.start == 50.0\n assert s.stop == 20.0\n assert s.step == -10.0\n\n s, I = c.select([5, 55], return_index=True)\n assert s.start == 50.0\n assert s.stop == 20.0\n assert s.step == -10.0\n assert c[I] == s\n\n # between coordinates\n s = c.select([52, 55])\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n\n s, I = c.select([52, 55], return_index=True)\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n assert_equal(c.coordinates[I], [])\n\n # backwards bounds\n s = c.select([70, 30])\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n\n s, I = c.select([70, 30], return_index=True)\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n assert_equal(c.coordinates[I], [])\n\n def test_select_outer(self):\n c = UniformCoordinates1d(20.0, 70.0, 10.0)\n\n # inner\n s = c.select([35.0, 55.0], outer=True)\n assert s.start == 30.0\n assert s.stop == 60.0\n assert s.step == 10.0\n\n s, I = c.select([35.0, 55.0], outer=True, return_index=True)\n assert s.start == 30.0\n assert s.stop == 60.0\n assert s.step == 10.0\n assert c[I] == s\n\n # inner with aligned bounds\n s = c.select([30.0, 60.0], outer=True)\n assert s.start == 30.0\n assert s.stop == 60.0\n assert s.step == 10.0\n\n s, I = c.select([30.0, 60.0], outer=True, return_index=True)\n assert s.start == 30.0\n assert s.stop == 60.0\n assert s.step == 10.0\n assert c[I] == s\n\n # above\n s = c.select([45, 100], outer=True)\n assert s.start == 40.0\n assert s.stop == 70.0\n assert s.step == 10.0\n\n s, I = c.select([45, 100], outer=True, return_index=True)\n assert s.start == 40.0\n assert s.stop == 70.0\n assert s.step == 10.0\n assert c[I] == s\n\n # below\n s = c.select([5, 55], outer=True)\n assert s.start == 20.0\n assert s.stop == 60.0\n assert s.step == 10.0\n\n s, I = c.select([5, 55], outer=True, return_index=True)\n assert s.start == 20.0\n assert s.stop == 60.0\n assert s.step == 10.0\n assert c[I] == s\n\n # between coordinates\n s = c.select([52, 55], outer=True)\n assert s.start == 50.0\n assert s.stop == 60.0\n assert s.step == 10.0\n\n s, I = c.select([52, 55], outer=True, return_index=True)\n assert s.start == 50.0\n assert s.stop == 60.0\n assert s.step == 10.0\n assert c[I] == s\n\n # backwards bounds\n s = c.select([70, 30], outer=True)\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n\n s, I = c.select([70, 30], outer=True, return_index=True)\n assert isinstance(s, ArrayCoordinates1d)\n assert_equal(s.coordinates, [])\n assert_equal(c.coordinates[I], [])\n\n def test_select_time_variable_precision(self):\n c = UniformCoordinates1d(\"2012-05-19\", \"2012-05-20\", \"1,D\", name=\"time\")\n c2 = UniformCoordinates1d(\"2012-05-20T12:00:00\", \"2012-05-21T12:00:00\", \"1,D\", name=\"time\")\n s = c.select(c2.bounds, outer=True)\n s1 = c.select(c2.bounds, outer=False)\n s2 = c2.select(c.bounds)\n assert s.size == 1\n assert s1.size == 0\n assert s2.size == 1\n\n\nclass TestUniformCoordinatesMethods(object):\n def test_unique(self):\n c = UniformCoordinates1d(1, 5, step=1)\n c2 = c.unique()\n assert c2 == c and c2 is not c\n\n c2, I = c.unique(return_index=True)\n assert c2 == c and c2 is not c\n assert c2 == c[I]\n\n def test_simplify(self):\n c = UniformCoordinates1d(1, 5, step=1)\n c2 = c.simplify()\n assert c2 == c and c2 is not c\n\n # reversed, step -2\n c = UniformCoordinates1d(4, 0, step=-2)\n c2 = c.simplify()\n assert c2 == c and c2 is not c\n\n # time, convert to UniformCoordinates\n c = UniformCoordinates1d(\"2020-01-01\", \"2020-01-05\", step=\"1,D\")\n c2 = c.simplify()\n assert c2 == c and c2 is not c\n\n # time, reverse -2,h\n c = UniformCoordinates1d(\"2020-01-01T12:00\", \"2020-01-01T08:00\", step=\"-3,h\")\n c2 = c.simplify()\n assert c2 == c and c2 is not c\n\n def test_flatten(self):\n c = UniformCoordinates1d(1, 5, step=1)\n c2 = c.flatten()\n assert c2 == c and c2 is not c\n\n def test_reshape(self):\n c = UniformCoordinates1d(1, 6, step=1, name=\"lat\")\n c2 = c.reshape((2, 3))\n assert c2 == ArrayCoordinates1d(c.coordinates.reshape((2, 3)), name=\"lat\")\n\n def test_issubset(self):\n c1 = UniformCoordinates1d(2, 1, step=-1)\n c2 = UniformCoordinates1d(1, 3, step=1)\n c3 = UniformCoordinates1d(0, 2, step=1)\n c4 = UniformCoordinates1d(1, 4, step=0.5)\n c5 = UniformCoordinates1d(1.5, 2.5, step=0.5)\n c6 = UniformCoordinates1d(1.4, 2.4, step=0.5)\n c7 = UniformCoordinates1d(1.4, 2.4, step=10)\n\n # self\n assert c1.issubset(c1)\n\n # subsets\n assert c1.issubset(c2)\n assert c1.issubset(c3)\n assert c1.issubset(c4)\n assert c5.issubset(c4)\n assert c7.issubset(c6)\n\n # not subsets\n assert not c2.issubset(c1)\n assert not c2.issubset(c3)\n assert not c3.issubset(c1)\n assert not c3.issubset(c2)\n assert not c4.issubset(c1)\n assert not c6.issubset(c4)\n\n def test_issubset_datetime(self):\n c1 = UniformCoordinates1d(\"2020-01-01\", \"2020-01-03\", \"1,D\")\n c2 = UniformCoordinates1d(\"2020-01-01\", \"2020-01-03\", \"2,D\")\n c3 = UniformCoordinates1d(\"2020-01-01\", \"2020-01-05\", \"1,D\")\n c4 = UniformCoordinates1d(\"2020-01-05\", \"2020-01-01\", \"-2,D\")\n\n # self\n assert c1.issubset(c1)\n\n # same resolution\n assert c1.issubset(c3)\n assert c2.issubset(c1)\n assert c2.issubset(c4)\n assert not c1.issubset(c2)\n assert not c1.issubset(c4)\n assert not c3.issubset(c1)\n\n # different resolution\n c5 = UniformCoordinates1d(\"2020-01-01T00:00\", \"2020-01-03T00:00\", \"1,D\")\n c6 = UniformCoordinates1d(\"2020-01-01T00:00\", \"2020-01-03T00:00\", \"6,h\")\n assert c1.issubset(c5)\n assert c5.issubset(c1)\n assert c1.issubset(c6)\n assert not c6.issubset(c1)\n\n def test_issubset_dtype(self):\n c1 = UniformCoordinates1d(0, 10, step=1)\n c2 = UniformCoordinates1d(\"2018\", \"2020\", step=\"1,Y\")\n assert not c1.issubset(c2)\n assert not c2.issubset(c1)\n\n def test_issubset_array_coordinates(self):\n u = UniformCoordinates1d(start=1, stop=3, step=1)\n a1 = ArrayCoordinates1d([1, 3, 2])\n a2 = ArrayCoordinates1d([1, 2, 3])\n a3 = ArrayCoordinates1d([1, 3, 4])\n e = ArrayCoordinates1d([])\n\n # self\n assert u.issubset(a1)\n assert u.issubset(a2)\n assert not u.issubset(a3)\n assert not u.issubset(e)\n\n def test_issubset_coordinates(self):\n u = UniformCoordinates1d(1, 3, 1, name=\"lat\")\n c1 = Coordinates([[1, 2, 3], [10, 20, 30]], dims=[\"lat\", \"lon\"])\n c2 = Coordinates([[1, 2, 4], [10, 20, 30]], dims=[\"lat\", \"lon\"])\n c3 = Coordinates([[10, 20, 30]], dims=[\"alt\"])\n\n assert u.issubset(c1)\n assert not u.issubset(c2)\n assert not u.issubset(c3)\n","from __future__ import division, unicode_literals, print_function, absolute_import\n\nimport os\nimport json\nimport warnings\nimport tempfile\nfrom collections import OrderedDict\nfrom copy import deepcopy\n\ntry:\n import urllib.parse as urllib\nexcept: # Python 2.7\n import urlparse as urllib\n\nimport six\nimport pytest\nimport numpy as np\nimport xarray as xr\nfrom pint.errors import DimensionalityError, UndefinedUnitError\nfrom pint import UnitRegistry\n\nureg = UnitRegistry()\nimport traitlets as tl\n\nimport podpac\nfrom podpac.core import common_test_utils as ctu\nfrom podpac.core.utils import ArrayTrait, NodeTrait\nfrom podpac.core.units import UnitsDataArray\nfrom podpac.core.style import Style\nfrom podpac.core.cache import CacheCtrl, RamCacheStore, DiskCacheStore\nfrom podpac.core.node import Node, NodeException, NodeDefinitionError\nfrom podpac.core.node import NoCacheMixin, DiskCacheMixin\n\n\nclass TestNode(object):\n def test_style(self):\n node = Node()\n assert isinstance(node.style, Style)\n\n def test_units(self):\n node = Node(units=\"meters\")\n\n with pytest.raises(UndefinedUnitError):\n Node(units=\"abc\")\n\n def test_outputs(self):\n node = Node()\n assert node.outputs is None\n\n node = Node(outputs=[\"a\", \"b\"])\n assert node.outputs == [\"a\", \"b\"]\n\n def test_output(self):\n node = Node()\n assert node.output is None\n\n node = Node(outputs=[\"a\", \"b\"])\n assert node.output is None\n\n node = Node(outputs=[\"a\", \"b\"], output=\"b\")\n assert node.output == \"b\"\n\n # must be one of the outputs\n with pytest.raises(ValueError, match=\"Invalid output\"):\n node = Node(outputs=[\"a\", \"b\"], output=\"other\")\n\n # only valid for multiple-output nodes\n with pytest.raises(TypeError, match=\"Invalid output\"):\n node = Node(output=\"other\")\n\n def test_cache_output(self):\n with podpac.settings:\n podpac.settings[\"CACHE_NODE_OUTPUT_DEFAULT\"] = False\n node = Node()\n assert not node.cache_output\n\n podpac.settings[\"CACHE_NODE_OUTPUT_DEFAULT\"] = True\n node = Node()\n assert node.cache_output\n\n def test_cache_ctrl(self):\n # settings\n with podpac.settings:\n podpac.settings[\"DEFAULT_CACHE\"] = [\"ram\"]\n node = Node()\n assert node.cache_ctrl is not None\n assert len(node.cache_ctrl._cache_stores) == 1\n assert isinstance(node.cache_ctrl._cache_stores[0], RamCacheStore)\n\n podpac.settings[\"DEFAULT_CACHE\"] = [\"ram\", \"disk\"]\n node = Node()\n assert node.cache_ctrl is not None\n assert len(node.cache_ctrl._cache_stores) == 2\n assert isinstance(node.cache_ctrl._cache_stores[0], RamCacheStore)\n assert isinstance(node.cache_ctrl._cache_stores[1], DiskCacheStore)\n\n # specify\n node = Node(cache_ctrl=[\"ram\"])\n assert node.cache_ctrl is not None\n assert len(node.cache_ctrl._cache_stores) == 1\n assert isinstance(node.cache_ctrl._cache_stores[0], RamCacheStore)\n\n node = Node(cache_ctrl=[\"ram\", \"disk\"])\n assert node.cache_ctrl is not None\n assert len(node.cache_ctrl._cache_stores) == 2\n assert isinstance(node.cache_ctrl._cache_stores[0], RamCacheStore)\n assert isinstance(node.cache_ctrl._cache_stores[1], DiskCacheStore)\n\n def test_tagged_attr_readonly(self):\n class MyNode(Node):\n my_attr = tl.Any().tag(attr=True)\n\n with podpac.settings:\n podpac.settings[\"DEBUG\"] = False\n node = MyNode()\n assert node.traits()[\"my_attr\"].read_only\n\n podpac.settings[\"DEBUG\"] = True\n node = MyNode()\n assert not node.traits()[\"my_attr\"].read_only\n\n def test_trait_is_defined(self):\n node = Node()\n if tl.version_info[0] >= 5:\n assert not node.trait_is_defined(\"units\")\n else:\n assert node.trait_is_defined(\"units\")\n\n def test_init(self):\n class MyNode(Node):\n init_run = False\n\n def init(self):\n super(MyNode, self).init()\n self.init_run = True\n\n node = MyNode()\n assert node.init_run\n\n def test_attrs(self):\n class MyNode(Node):\n my_attr = tl.Any().tag(attr=True)\n my_trait = tl.Any()\n\n n = MyNode()\n assert \"my_attr\" in n.attrs\n assert \"my_trait\" not in n.attrs\n\n def test_repr(self):\n n = Node()\n repr(n)\n\n n = Node(outputs=[\"a\", \"b\"])\n repr(n)\n assert \"outputs=\" in repr(n)\n assert \"output=\" not in repr(n)\n\n n = Node(outputs=[\"a\", \"b\"], output=\"a\")\n repr(n)\n assert \"outputs=\" not in repr(n)\n assert \"output=\" in repr(n)\n\n def test_str(self):\n n = Node()\n str(n)\n\n n = Node(outputs=[\"a\", \"b\"])\n str(n)\n assert \"outputs=\" in str(n)\n assert \"output=\" not in str(n)\n\n n = Node(outputs=[\"a\", \"b\"], output=\"a\")\n str(n)\n assert \"outputs=\" not in str(n)\n assert \"output=\" in str(n)\n\n def test_eval_group(self):\n class MyNode(Node):\n def eval(self, coordinates, output=None, selector=None):\n return self.create_output_array(coordinates)\n\n c1 = podpac.Coordinates([[0, 1], [0, 1]], dims=[\"lat\", \"lon\"])\n c2 = podpac.Coordinates([[10, 11], [10, 11, 12]], dims=[\"lat\", \"lon\"])\n g = podpac.coordinates.GroupCoordinates([c1, c2])\n\n node = MyNode()\n outputs = node.eval_group(g)\n assert isinstance(outputs, list)\n assert len(outputs) == 2\n assert isinstance(outputs[0], UnitsDataArray)\n assert isinstance(outputs[1], UnitsDataArray)\n assert outputs[0].shape == (2, 2)\n assert outputs[1].shape == (2, 3)\n\n # invalid\n with pytest.raises(Exception):\n node.eval_group(c1)\n\n with pytest.raises(Exception):\n node.eval(g)\n\n def test_eval_not_implemented(self):\n node = Node()\n with pytest.raises(NotImplementedError):\n node.eval(podpac.Coordinates([]))\n\n with pytest.raises(NotImplementedError):\n node.eval(podpac.Coordinates([]), output=None)\n\n def test_find_coordinates_not_implemented(self):\n node = Node()\n with pytest.raises(NotImplementedError):\n node.find_coordinates()\n\n def test_get_bounds(self):\n class MyNode(Node):\n def find_coordinates(self):\n return [\n podpac.Coordinates([[0, 1, 2], [0, 10, 20]], dims=[\"lat\", \"lon\"], crs=\"EPSG:2193\"),\n podpac.Coordinates([[3, 4], [30, 40]], dims=[\"lat\", \"lon\"], crs=\"EPSG:2193\"),\n ]\n\n node = MyNode()\n\n with podpac.settings:\n podpac.settings[\"DEFAULT_CRS\"] = \"EPSG:4326\"\n\n # specify crs\n bounds, crs = node.get_bounds(crs=\"EPSG:2193\")\n assert bounds == {\"lat\": (0, 4), \"lon\": (0, 40)}\n assert crs == \"EPSG:2193\"\n\n # default crs\n bounds, crs = node.get_bounds()\n assert bounds == {\n \"lat\": (-75.81397534013118, -75.81362774074242),\n \"lon\": (82.92787904584206, 82.9280189659297),\n }\n assert crs == \"EPSG:4326\"\n\n\nclass TestCreateOutputArray(object):\n def test_create_output_array_default(self):\n c = podpac.Coordinates([podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=[\"lat_lon\", \"time\"])\n node = Node()\n\n output = node.create_output_array(c)\n assert isinstance(output, UnitsDataArray)\n assert output.shape == c.shape\n assert output.dtype == node.dtype\n assert output.crs == c.crs\n assert np.all(np.isnan(output))\n\n def test_create_output_array_data(self):\n c = podpac.Coordinates([podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=[\"lat_lon\", \"time\"])\n node = Node()\n\n output = node.create_output_array(c, data=0)\n assert isinstance(output, UnitsDataArray)\n assert output.shape == c.shape\n assert output.dtype == node.dtype\n assert output.crs == c.crs\n assert np.all(output == 0.0)\n\n @pytest.mark.xfail(reason=\"not yet supported.\")\n def test_create_output_array_dtype(self):\n c = podpac.Coordinates([podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=[\"lat_lon\", \"time\"])\n node = Node(dtype=bool)\n\n output = node.create_output_array(c, data=0)\n assert isinstance(output, UnitsDataArray)\n assert output.shape == c.shape\n assert output.dtype == node.dtype\n assert output.crs == c.crs\n assert np.all(~output)\n\n def test_create_output_array_units(self):\n c = podpac.Coordinates([podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=[\"lat_lon\", \"time\"])\n node = Node(units=\"meters\")\n\n output = node.create_output_array(c)\n assert isinstance(output, UnitsDataArray)\n\n from podpac.core.units import ureg as _ureg\n\n assert output.units == _ureg.meters\n\n def test_create_output_array_crs(self):\n crs = \"+proj=merc +lat_ts=56.5 +ellps=GRS80\"\n c = podpac.Coordinates([podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=[\"lat_lon\", \"time\"], crs=crs)\n node = Node()\n\n output = node.create_output_array(c)\n assert output.crs == crs\n\n\nclass TestNodeEval(object):\n def test_extract_output(self):\n coords = podpac.Coordinates([[0, 1, 2, 3], [0, 1]], dims=[\"lat\", \"lon\"])\n\n class MyNode1(Node):\n outputs = [\"a\", \"b\", \"c\"]\n\n def _eval(self, coordinates, output=None, selector=None):\n return self.create_output_array(coordinates)\n\n # don't extract when no output field is requested\n node = MyNode1()\n out = node.eval(coords)\n assert out.shape == (4, 2, 3)\n\n # do extract when an output field is requested\n node = MyNode1(output=\"b\")\n out = node.eval(coords)\n assert out.shape == (4, 2)\n\n # should still work if the node has already extracted it\n class MyNode2(Node):\n outputs = [\"a\", \"b\", \"c\"]\n\n def _eval(self, coordinates, output=None, selector=None):\n out = self.create_output_array(coordinates)\n return out.sel(output=self.output)\n\n node = MyNode2(output=\"b\")\n out = node.eval(coords)\n assert out.shape == (4, 2)\n\n def test_evaluate_transpose(self):\n class MyNode(Node):\n def _eval(self, coordinates, output=None, selector=None):\n coords = coordinates.transpose(\"lat\", \"lon\")\n data = np.arange(coords.size).reshape(coords.shape)\n a = self.create_output_array(coords, data=data)\n if output is None:\n output = a\n else:\n output[:] = a.transpose(*output.dims)\n return output\n\n coords = podpac.Coordinates([[0, 1, 2, 3], [0, 1]], dims=[\"lat\", \"lon\"])\n\n node = MyNode()\n o1 = node.eval(coords)\n o2 = node.eval(coords.transpose(\"lon\", \"lat\"))\n\n # returned output should match the requested coordinates and data should be transposed\n assert o1.dims == (\"lat\", \"lon\")\n assert o2.dims == (\"lon\", \"lat\")\n np.testing.assert_array_equal(o2.transpose(\"lat\", \"lon\").data, o1.data)\n\n # with transposed output\n o3 = node.create_output_array(coords.transpose(\"lon\", \"lat\"))\n o4 = node.eval(coords, output=o3)\n\n assert o3.dims == (\"lon\", \"lat\") # stay the same\n assert o4.dims == (\"lat\", \"lon\") # match requested coordinates\n np.testing.assert_equal(o3.transpose(\"lat\", \"lon\").data, o4.data)\n\n def test_eval_get_cache(self):\n podpac.settings[\"RAM_CACHE_ENABLED\"] = True\n\n class MyNode(Node):\n def _eval(self, coordinates, output=None, selector=None):\n coords = coordinates.transpose(\"lat\", \"lon\")\n data = np.arange(coords.size).reshape(coords.shape)\n a = self.create_output_array(coords, data=data)\n if output is None:\n output = a\n else:\n output[:] = a.transpose(*output.dims)\n return output\n\n coords = podpac.Coordinates([[0, 1, 2, 3], [0, 1]], dims=[\"lat\", \"lon\"])\n\n node = MyNode(cache_output=True, cache_ctrl=CacheCtrl([RamCacheStore()]))\n\n # first eval\n o1 = node.eval(coords)\n assert node._from_cache == False\n\n # get from cache\n o2 = node.eval(coords)\n assert node._from_cache == True\n np.testing.assert_array_equal(o2, o1)\n\n # get from cache with output\n o3 = node.eval(coords, output=o1)\n assert node._from_cache == True\n np.testing.assert_array_equal(o3, o1)\n\n # get from cache with output transposed\n o4 = node.eval(coords, output=o1.transpose(\"lon\", \"lat\"))\n assert node._from_cache == True\n np.testing.assert_array_equal(o4, o1)\n\n # get from cache with coords transposed\n o5 = node.eval(coords.transpose(\"lon\", \"lat\"))\n assert node._from_cache == True\n np.testing.assert_array_equal(o5, o1.transpose(\"lon\", \"lat\"))\n\n def test_eval_output_crs(self):\n coords = podpac.Coordinates([[0, 1, 2, 3], [0, 1]], dims=[\"lat\", \"lon\"])\n\n node = Node()\n with pytest.raises(ValueError, match=\"Output coordinate reference system .* does not match\"):\n node.eval(coords, output=node.create_output_array(coords.transform(\"EPSG:2193\")))\n\n\nclass TestCaching(object):\n @classmethod\n def setup_class(cls):\n cls._ram_cache_enabled = podpac.settings[\"RAM_CACHE_ENABLED\"]\n\n podpac.settings[\"RAM_CACHE_ENABLED\"] = True\n\n class MyNode(Node):\n pass\n\n cls.node = MyNode(cache_ctrl=CacheCtrl([RamCacheStore()]))\n cls.node.rem_cache(key=\"*\", coordinates=\"*\")\n\n cls.coords = podpac.Coordinates([0, 0], dims=[\"lat\", \"lon\"])\n cls.coords2 = podpac.Coordinates([1, 1], dims=[\"lat\", \"lon\"])\n\n @classmethod\n def teardown_class(cls):\n cls.node.rem_cache(key=\"*\", coordinates=\"*\")\n\n podpac.settings[\"RAM_CACHE_ENABLED\"] = cls._ram_cache_enabled\n\n def setup_method(self, method):\n self.node.rem_cache(key=\"*\", coordinates=\"*\")\n\n def teardown_method(self, method):\n self.node.rem_cache(key=\"*\", coordinates=\"*\")\n\n def test_has_cache(self):\n assert not self.node.has_cache(\"test\")\n\n self.node.put_cache(0, \"test\")\n assert self.node.has_cache(\"test\")\n assert not self.node.has_cache(\"test\", coordinates=self.coords)\n\n def test_has_coordinates(self):\n assert not self.node.has_cache(\"test\", coordinates=self.coords)\n\n self.node.put_cache(0, \"test\", coordinates=self.coords)\n\n assert not self.node.has_cache(\"test\")\n assert self.node.has_cache(\"test\", coordinates=self.coords)\n assert not self.node.has_cache(\"test\", coordinates=self.coords2)\n\n def test_get_put_cache(self):\n with pytest.raises(NodeException):\n self.node.get_cache(\"test\")\n\n self.node.put_cache(0, \"test\")\n assert self.node.get_cache(\"test\") == 0\n\n def test_get_put_coordinates(self):\n with pytest.raises(NodeException):\n self.node.get_cache(\"test\")\n with pytest.raises(NodeException):\n self.node.get_cache(\"test\", coordinates=self.coords)\n with pytest.raises(NodeException):\n self.node.get_cache(\"test\", coordinates=self.coords2)\n\n self.node.put_cache(0, \"test\")\n self.node.put_cache(1, \"test\", coordinates=self.coords)\n self.node.put_cache(2, \"test\", coordinates=self.coords2)\n\n assert self.node.get_cache(\"test\") == 0\n assert self.node.get_cache(\"test\", coordinates=self.coords) == 1\n assert self.node.get_cache(\"test\", coordinates=self.coords2) == 2\n\n def test_put_overwrite(self):\n self.node.put_cache(0, \"test\")\n assert self.node.get_cache(\"test\") == 0\n\n with pytest.raises(NodeException):\n self.node.put_cache(1, \"test\", overwrite=False)\n assert self.node.get_cache(\"test\") == 0\n\n self.node.put_cache(1, \"test\")\n assert self.node.get_cache(\"test\") == 1\n\n def test_rem_all(self):\n self.node.put_cache(0, \"a\")\n self.node.put_cache(0, \"b\")\n self.node.put_cache(0, \"a\", coordinates=self.coords)\n self.node.put_cache(0, \"c\", coordinates=self.coords)\n self.node.put_cache(0, \"c\", coordinates=self.coords2)\n self.node.put_cache(0, \"d\", coordinates=self.coords)\n\n self.node.rem_cache(key=\"*\", coordinates=\"*\")\n assert not self.node.has_cache(\"a\")\n assert not self.node.has_cache(\"b\")\n assert not self.node.has_cache(\"a\", coordinates=self.coords)\n assert not self.node.has_cache(\"c\", coordinates=self.coords)\n assert not self.node.has_cache(\"c\", coordinates=self.coords2)\n assert not self.node.has_cache(\"d\", coordinates=self.coords)\n\n def test_rem_key(self):\n self.node.put_cache(0, \"a\")\n self.node.put_cache(0, \"b\")\n self.node.put_cache(0, \"a\", coordinates=self.coords)\n self.node.put_cache(0, \"c\", coordinates=self.coords)\n self.node.put_cache(0, \"c\", coordinates=self.coords2)\n self.node.put_cache(0, \"d\", coordinates=self.coords)\n\n self.node.rem_cache(key=\"a\", coordinates=\"*\")\n\n assert not self.node.has_cache(\"a\")\n assert not self.node.has_cache(\"a\", coordinates=self.coords)\n assert self.node.has_cache(\"b\")\n assert self.node.has_cache(\"c\", coordinates=self.coords)\n assert self.node.has_cache(\"c\", coordinates=self.coords2)\n assert self.node.has_cache(\"d\", coordinates=self.coords)\n\n def test_rem_coordinates(self):\n self.node.put_cache(0, \"a\")\n self.node.put_cache(0, \"b\")\n self.node.put_cache(0, \"a\", coordinates=self.coords)\n self.node.put_cache(0, \"c\", coordinates=self.coords)\n self.node.put_cache(0, \"c\", coordinates=self.coords2)\n self.node.put_cache(0, \"d\", coordinates=self.coords)\n\n self.node.rem_cache(key=\"*\", coordinates=self.coords)\n\n assert self.node.has_cache(\"a\")\n assert not self.node.has_cache(\"a\", coordinates=self.coords)\n assert self.node.has_cache(\"b\")\n assert not self.node.has_cache(\"c\", coordinates=self.coords)\n assert self.node.has_cache(\"c\", coordinates=self.coords2)\n assert not self.node.has_cache(\"d\", coordinates=self.coords)\n\n def test_rem_key_coordinates(self):\n self.node.put_cache(0, \"a\")\n self.node.put_cache(0, \"b\")\n self.node.put_cache(0, \"a\", coordinates=self.coords)\n self.node.put_cache(0, \"c\", coordinates=self.coords)\n self.node.put_cache(0, \"c\", coordinates=self.coords2)\n self.node.put_cache(0, \"d\", coordinates=self.coords)\n\n self.node.rem_cache(key=\"a\", coordinates=self.coords)\n\n assert self.node.has_cache(\"a\")\n assert not self.node.has_cache(\"a\", coordinates=self.coords)\n assert self.node.has_cache(\"b\")\n assert self.node.has_cache(\"c\", coordinates=self.coords)\n assert self.node.has_cache(\"c\", coordinates=self.coords2)\n assert self.node.has_cache(\"d\", coordinates=self.coords)\n\n def test_put_has_expires(self):\n self.node.put_cache(10, \"key1\", expires=\"1,D\")\n self.node.put_cache(10, \"key2\", expires=\"-1,D\")\n assert self.node.has_cache(\"key1\")\n assert not self.node.has_cache(\"key2\")\n\n def test_put_get_expires(self):\n self.node.put_cache(10, \"key1\", expires=\"1,D\")\n self.node.put_cache(10, \"key2\", expires=\"-1,D\")\n assert self.node.get_cache(\"key1\") == 10\n with pytest.raises(NodeException, match=\"cached data not found\"):\n self.node.get_cache(\"key2\")\n\n # node definition errors\n # this demonstrates both classes of error in the has_cache case, but only one for put/get/rem\n # we could test both classes for put/get/rem as well, but that is not really necessary\n def test_has_cache_unavailable_circular(self):\n class MyNode(Node):\n a = tl.Any().tag(attr=True)\n\n @tl.default(\"a\")\n def _default_a(self):\n return self.b\n\n @property\n def b(self):\n self.has_cache(\"b\")\n return 10\n\n node = MyNode(cache_ctrl=[\"ram\"])\n with pytest.raises(NodeException, match=\"Cache unavailable, node definition has a circular dependency\"):\n assert node.b == 10\n\n def test_has_cache_unavailable_uninitialized(self):\n class MyNode(Node):\n a = tl.Any().tag(attr=True)\n\n @tl.validate(\"a\")\n def _validate_a(self, d):\n self.b\n return d[\"value\"]\n\n @property\n def b(self):\n self.has_cache(\"key\")\n return 10\n\n with pytest.raises(NodeException, match=\"Cache unavailable, node is not yet fully initialized\"):\n node = MyNode(a=3, cache_ctrl=[\"ram\"])\n\n def test_put_cache_unavailable_uninitialized(self):\n class MyNode(Node):\n a = tl.Any().tag(attr=True)\n\n @tl.validate(\"a\")\n def _validate_a(self, d):\n self.b\n return d[\"value\"]\n\n @property\n def b(self):\n self.put_cache(10, \"key\")\n return 10\n\n with pytest.raises(NodeException, match=\"Cache unavailable\"):\n node = MyNode(a=3, cache_ctrl=[\"ram\"])\n\n def test_get_cache_unavailable_uninitialized(self):\n class MyNode(Node):\n a = tl.Any().tag(attr=True)\n\n @tl.validate(\"a\")\n def _validate_a(self, d):\n self.b\n return d[\"value\"]\n\n @property\n def b(self):\n self.get_cache(\"key\")\n return 10\n\n with pytest.raises(NodeException, match=\"Cache unavailable\"):\n node = MyNode(a=3, cache_ctrl=[\"ram\"])\n\n def test_rem_cache_unavailable_uninitialized(self):\n class MyNode(Node):\n a = tl.Any().tag(attr=True)\n\n @tl.validate(\"a\")\n def _validate_a(self, d):\n self.b\n return d[\"value\"]\n\n @property\n def b(self):\n self.rem_cache(\"key\")\n return 10\n\n with pytest.raises(NodeException, match=\"Cache unavailable\"):\n node = MyNode(a=3, cache_ctrl=[\"ram\"])\n\n\nclass TestSerialization(object):\n @classmethod\n def setup_class(cls):\n a = podpac.algorithm.Arange()\n b = podpac.data.Array(source=[10, 20, 30], coordinates=podpac.Coordinates([[0, 1, 2]], dims=[\"lat\"]))\n c = podpac.compositor.OrderedCompositor(sources=[a, b])\n\n with warnings.catch_warnings():\n warnings.filterwarnings(\"ignore\", \"Insecure evaluation.*\")\n cls.node = podpac.algorithm.Arithmetic(A=a, B=b, C=c, eqn=\"A + B + C\")\n\n def test_base_ref(self):\n node = Node()\n assert isinstance(node.base_ref, six.string_types)\n\n def test_base_definition(self):\n node = Node()\n d = node._base_definition\n assert \"node\" in d\n assert isinstance(d[\"node\"], six.string_types)\n\n def test_base_definition_attrs(self):\n class MyNode(Node):\n my_attr = tl.Int().tag(attr=True)\n\n node = MyNode(my_attr=7)\n\n d = node._base_definition\n assert d[\"attrs\"][\"my_attr\"] == 7\n\n def test_base_definition_inputs(self):\n class MyNode(Node):\n my_attr = NodeTrait().tag(attr=True)\n\n a = Node()\n node = MyNode(my_attr=a)\n\n d = node._base_definition\n assert d[\"inputs\"][\"my_attr\"] == a\n\n def test_base_definition_inputs_array(self):\n class MyNode(Node):\n my_attr = ArrayTrait().tag(attr=True)\n\n a = Node()\n b = Node()\n node = MyNode(my_attr=[a, b])\n\n d = node._base_definition\n assert d[\"inputs\"][\"my_attr\"][0] == a\n assert d[\"inputs\"][\"my_attr\"][1] == b\n\n def test_base_definition_inputs_dict(self):\n class MyNode(Node):\n my_attr = tl.Dict().tag(attr=True)\n\n a = Node()\n b = Node()\n node = MyNode(my_attr={\"a\": a, \"b\": b})\n\n d = node._base_definition\n assert d[\"inputs\"][\"my_attr\"][\"a\"] == a\n assert d[\"inputs\"][\"my_attr\"][\"b\"] == b\n\n def test_base_definition_style(self):\n node = Node(style=Style(name=\"test\"))\n d = node._base_definition\n assert \"style\" in node._base_definition\n\n def test_base_definition_remove_unnecessary_attrs(self):\n node = Node(outputs=[\"a\", \"b\"], output=\"a\", units=\"m\")\n d = node._base_definition\n assert \"outputs\" in d[\"attrs\"]\n assert \"output\" in d[\"attrs\"]\n assert \"units\" in d[\"attrs\"]\n\n node = Node()\n d = node._base_definition\n if \"attrs\" in d:\n assert \"outputs\" not in d[\"attrs\"]\n assert \"output\" not in d[\"attrs\"]\n assert \"units\" not in d[\"attrs\"]\n\n def test_definition(self):\n # definition\n d = self.node.definition\n assert isinstance(d, OrderedDict)\n assert len(d) == 5\n\n # from_definition\n with warnings.catch_warnings():\n warnings.filterwarnings(\"ignore\", \"Insecure evaluation.*\")\n node = Node.from_definition(d)\n\n assert node is not self.node\n assert node == self.node\n assert isinstance(node, podpac.algorithm.Arithmetic)\n assert isinstance(node.inputs[\"A\"], podpac.algorithm.Arange)\n assert isinstance(node.inputs[\"B\"], podpac.data.Array)\n assert isinstance(node.inputs[\"C\"], podpac.compositor.OrderedCompositor)\n\n def test_definition_duplicate_base_ref(self):\n n1 = Node(units=\"m\")\n n2 = Node(units=\"ft\")\n n3 = Node(units=\"in\")\n node = podpac.compositor.OrderedCompositor(sources=[n1, n2, n3])\n d = node.definition\n assert n1.base_ref == n2.base_ref == n3.base_ref\n assert len(d) == 5\n\n def test_definition_inputs_array(self):\n global MyNodeWithArrayInput\n\n class MyNodeWithArrayInput(Node):\n my_array = ArrayTrait().tag(attr=True)\n\n node1 = MyNodeWithArrayInput(my_array=[podpac.algorithm.Arange()])\n node2 = Node.from_definition(node1.definition)\n assert node2 is not node1 and node2 == node1\n\n def test_definition_inputs_dict(self):\n global MyNodeWithDictInput\n\n class MyNodeWithDictInput(Node):\n my_dict = tl.Dict().tag(attr=True)\n\n node1 = MyNodeWithDictInput(my_dict={\"a\": podpac.algorithm.Arange()})\n node2 = Node.from_definition(node1.definition)\n assert node2 is not node1 and node2 == node1\n\n def test_definition_version(self):\n d = self.node.definition\n assert \"podpac_version\" in d\n assert d[\"podpac_version\"] == podpac.__version__\n\n def test_json(self):\n # json\n s = self.node.json\n assert isinstance(s, six.string_types)\n assert json.loads(s)\n\n # test from_json\n with warnings.catch_warnings():\n warnings.filterwarnings(\"ignore\", \"Insecure evaluation.*\")\n node = Node.from_json(s)\n assert node is not self.node\n assert node == self.node\n assert isinstance(node, podpac.algorithm.Arithmetic)\n assert isinstance(node.inputs[\"A\"], podpac.algorithm.Arange)\n assert isinstance(node.inputs[\"B\"], podpac.data.Array)\n assert isinstance(node.inputs[\"C\"], podpac.compositor.OrderedCompositor)\n\n def test_file(self):\n path = tempfile.mkdtemp(prefix=\"podpac-test-\")\n filename = os.path.join(path, \"node.json\")\n\n # save\n self.node.save(filename)\n assert os.path.exists(filename)\n\n with warnings.catch_warnings():\n warnings.filterwarnings(\"ignore\", \"Insecure evaluation.*\")\n node = Node.load(filename)\n\n assert node is not self.node\n assert node == self.node\n assert isinstance(node, podpac.algorithm.Arithmetic)\n assert isinstance(node.inputs[\"A\"], podpac.algorithm.Arange)\n assert isinstance(node.inputs[\"B\"], podpac.data.Array)\n assert isinstance(node.inputs[\"C\"], podpac.compositor.OrderedCompositor)\n\n def test_json_pretty(self):\n node = Node()\n s = node.json_pretty\n assert isinstance(s, six.string_types)\n json.loads(s)\n\n def test_hash(self):\n class N(Node):\n my_attr = tl.Int().tag(attr=True)\n\n class M(Node):\n my_attr = tl.Int().tag(attr=True)\n\n n1 = N(my_attr=1)\n n2 = N(my_attr=1)\n n3 = N(my_attr=2)\n m1 = M(my_attr=1)\n\n assert n1.hash == n2.hash\n assert n1.hash != n3.hash\n assert n1.hash != m1.hash\n\n def test_hash_preserves_definition(self):\n n = Node()\n d_before = deepcopy(n.definition)\n h = n.hash\n d_after = deepcopy(n.definition)\n\n assert d_before == d_after\n\n def test_hash_omit_style(self):\n class N(Node):\n my_attr = tl.Int().tag(attr=True)\n\n n1 = N(my_attr=1, style=Style(name=\"a\"))\n n2 = N(my_attr=1, style=Style(name=\"b\"))\n\n # json has style in it\n assert n1.json != n2.json\n\n # but hash does not\n assert n1.hash == n2.hash\n\n def test_hash_omit_version(self):\n version = podpac.__version__\n\n try:\n # actual version\n n1 = Node()\n s1 = n1.json\n h1 = n1.hash\n\n # spoof different version\n podpac.__version__ = \"other\"\n n2 = Node()\n s2 = n2.json\n h2 = n2.hash\n\n # JSON should be different, but hash should be the same\n assert s1 != s2\n assert h1 == h2\n\n finally:\n # reset version\n podpac.__version__ = version\n\n def test_eq(self):\n class N(Node):\n my_attr = tl.Int().tag(attr=True)\n\n class M(Node):\n my_attr = tl.Int().tag(attr=True)\n\n n1 = N(my_attr=1)\n n2 = N(my_attr=1)\n n3 = N(my_attr=2)\n m1 = M(my_attr=1)\n\n # eq\n assert n1 == n2\n assert not n1 == n3\n assert not n1 == m1\n assert not n1 == \"other\"\n\n # ne\n assert not n1 != n2\n assert n1 != n3\n assert n1 != m1\n assert n1 != \"other\"\n\n def test_eq_ignore_style(self):\n class N(Node):\n my_attr = tl.Int().tag(attr=True)\n\n n1 = N(my_attr=1, style=Style(name=\"a\"))\n n2 = N(my_attr=1, style=Style(name=\"b\"))\n\n # json has style in it\n assert n1.json != n2.json\n\n # but == and != don't care\n assert n1 == n2\n assert not n1 != n2\n\n def test_from_url(self):\n url = (\n r\"http://testwms/?map=map&&service={service}&request=GetMap&{layername}={layer}&styles=&format=image%2Fpng\"\n r\"&transparent=true&version=1.1.1&transparency=true&width=256&height=256&srs=EPSG%3A4326\"\n r\"&bbox=40,-71,41,70&time=2018-05-19&PARAMS={params}\"\n )\n\n params = [\"{}\", '{\"a\":{\"node\":\"algorithm.Arange\"}}', \"{}\", \"{}\"]\n\n for service, layername in zip([\"WMS\", \"WCS\"], [\"LAYERS\", \"COVERAGE\"]):\n for layer, param in zip(\n [\n \"algorithm.SinCoords\",\n \"%PARAMS%\",\n # urllib.urlencode({'a':'https://raw.githubusercontent.com/creare-com/podpac/develop/podpac/core/pipeline/test/test.json'})[2:],\n # urllib.urlencode({'a':'s3://podpac-s3/test/test.json'})[2:] # Tested locally, works fine. Hard to test with CI\n ],\n params,\n ):\n pipe = Node.from_url(url.format(service=service, layername=layername, layer=layer, params=param))\n\n def test_from_url_with_plugin_style_params(self):\n url0 = (\n r\"https://mobility-devel.crearecomputing.com/geowatch?&SERVICE=WMS&REQUEST=GetMap&VERSION=1.3.0&\"\n r\"LAYERS=Arange&STYLES=&FORMAT=image%2Fpng&TRANSPARENT=true&HEIGHT=256&WIDTH=256\"\n r\"&CRS=EPSG%3A3857&BBOX=-20037508.342789244,10018754.171394618,-10018754.171394622,20037508.34278071&\"\n r'PARAMS={\"plugin\": \"podpac.algorithm\"}'\n )\n url1 = (\n r\"https://mobility-devel.crearecomputing.com/geowatch?&SERVICE=WMS&REQUEST=GetMap&VERSION=1.3.0&\"\n r\"LAYERS=datalib.terraintiles.TerrainTiles&STYLES=&FORMAT=image%2Fpng&TRANSPARENT=true&HEIGHT=256&WIDTH=256&\"\n r\"TIME=2021-03-01T12%3A00%3A00.000Z&CRS=EPSG%3A3857&BBOX=-10018754.171394622,5009377.08569731,-9392582.035682458,5635549.221409475\"\n r'&PARAMS={\"style\": {\"name\": \"Aspect (Composited 30-90 m)\",\"units\": \"radians\",\"colormap\": \"hsv\",\"clim\": [0,6.283185307179586]}}'\n )\n node = Node.from_url(url0)\n node = Node.from_url(url1)\n\n def test_from_name_params(self):\n # Normal\n name = \"algorithm.Arange\"\n node = Node.from_name_params(name)\n\n # Normal with params\n name = \"algorithm.CoordData\"\n params = {\"coord_name\": \"alt\"}\n node = Node.from_name_params(name, params)\n assert node.coord_name == \"alt\"\n\n # Plugin style\n name = \"CoordData\"\n params = {\"plugin\": \"podpac.algorithm\", \"attrs\": {\"coord_name\": \"alt\"}}\n node = Node.from_name_params(name, params)\n assert node.coord_name == \"alt\"\n\n def test_style(self):\n node = podpac.data.Array(\n source=[10, 20, 30],\n coordinates=podpac.Coordinates([[0, 1, 2]], dims=[\"lat\"]),\n style=Style(name=\"test\", units=\"m\"),\n )\n\n d = node.definition\n assert \"style\" in d[node.base_ref]\n\n node2 = Node.from_definition(d)\n assert node2 is not node\n assert isinstance(node2, podpac.data.Array)\n assert node2.style is not node.style\n assert node2.style == node.style\n assert node2.style.name == \"test\"\n assert node2.style.units == \"m\"\n\n # default style\n node = podpac.data.Array(source=[10, 20, 30], coordinates=podpac.Coordinates([[0, 1, 2]], dims=[\"lat\"]))\n d = node.definition\n assert \"style\" not in d[node.base_ref]\n\n def test_circular_definition(self):\n # this is admittedly a contrived example in order to demonstrate the most direct case\n class MyNode(Node):\n a = tl.Any().tag(attr=True)\n\n @tl.default(\"a\")\n def _default_a(self):\n self.definition\n return 10\n\n node = MyNode()\n with pytest.raises(NodeDefinitionError, match=\"node definition has a circular dependency\"):\n node.a\n\n\nclass TestUserDefinition(object):\n def test_empty(self):\n s = \"{ }\"\n with pytest.raises(ValueError, match=\"definition cannot be empty\"):\n Node.from_json(s)\n\n def test_no_node(self):\n s = '{\"test\": { } }'\n with pytest.raises(ValueError, match=\"'node' property required\"):\n Node.from_json(s)\n\n def test_invalid_node(self):\n # module does not exist\n s = '{\"a\": {\"node\": \"nonexistent.Arbitrary\"} }'\n with pytest.raises(ValueError, match=\"no module found\"):\n Node.from_json(s)\n\n # node does not exist in module\n s = '{\"a\": {\"node\": \"core.Nonexistent\"} }'\n with pytest.raises(ValueError, match=\"class 'Nonexistent' not found in module\"):\n Node.from_json(s)\n\n def test_inputs(self):\n # invalid type\n s = \"\"\"\n {\n \"a\": {\n \"node\": \"algorithm.Min\",\n \"inputs\": { \"source\": 10 }\n }\n }\n \"\"\"\n\n with pytest.raises(ValueError, match=\"Invalid definition for node\"):\n Node.from_json(s)\n\n # nonexistent node\n s = \"\"\"\n {\n \"a\": {\n \"node\": \"algorithm.Min\",\n \"inputs\": { \"source\": \"nonexistent\" }\n }\n }\n \"\"\"\n\n with pytest.raises(ValueError, match=\"Invalid definition for node\"):\n Node.from_json(s)\n\n def test_lookup_attrs(self):\n s = \"\"\"\n {\n \"a\": {\n \"node\": \"algorithm.CoordData\",\n \"attrs\": { \"coord_name\": \"lat\" }\n },\n \"b\": {\n \"node\": \"algorithm.CoordData\",\n \"lookup_attrs\": { \"coord_name\": \"a.coord_name\" }\n }\n }\n \"\"\"\n\n node = Node.from_json(s)\n assert isinstance(node, podpac.algorithm.CoordData)\n assert node.coord_name == \"lat\"\n\n # invalid type\n s = \"\"\"\n {\n \"a\": {\n \"node\": \"algorithm.CoordData\",\n \"attrs\": { \"coord_name\": \"lat\" }\n },\n \"b\": {\n \"node\": \"algorithm.CoordData\",\n \"lookup_attrs\": { \"coord_name\": 10 }\n }\n }\n \"\"\"\n\n with pytest.raises(ValueError, match=\"Invalid definition for node\"):\n Node.from_json(s)\n\n # nonexistent node\n s = \"\"\"\n {\n \"a\": {\n \"node\": \"algorithm.CoordData\",\n \"attrs\": { \"coord_name\": \"lat\" }\n },\n \"b\": {\n \"node\": \"algorithm.CoordData\",\n \"lookup_attrs\": { \"coord_name\": \"nonexistent.coord_name\" }\n }\n }\n \"\"\"\n\n with pytest.raises(ValueError, match=\"Invalid definition for node\"):\n Node.from_json(s)\n\n # nonexistent subattr\n s = \"\"\"\n {\n \"a\": {\n \"node\": \"algorithm.CoordData\",\n \"attrs\": { \"coord_name\": \"lat\" }\n },\n \"b\": {\n \"node\": \"algorithm.CoordData\",\n \"lookup_attrs\": { \"coord_name\": \"a.nonexistent\" }\n }\n }\n \"\"\"\n\n with pytest.raises(ValueError, match=\"Invalid definition for node\"):\n Node.from_json(s)\n\n def test_invalid_property(self):\n s = \"\"\"\n {\n \"a\": {\n \"node\": \"algorithm.Arange\",\n \"invalid_property\": \"value\"\n }\n }\n \"\"\"\n\n with pytest.raises(ValueError, match=\"unexpected property\"):\n Node.from_json(s)\n\n def test_plugin(self):\n global MyPluginNode\n\n class MyPluginNode(Node):\n pass\n\n s = \"\"\"\n {\n \"mynode\": {\n \"plugin\": \"test_node\",\n \"node\": \"MyPluginNode\"\n }\n }\n \"\"\"\n\n node = Node.from_json(s)\n assert isinstance(node, MyPluginNode)\n\n # missing plugin\n s = \"\"\"\n {\n \"mynode\": {\n \"plugin\": \"missing\",\n \"node\": \"MyPluginNode\"\n }\n }\n \"\"\"\n\n with pytest.raises(ValueError, match=\"no module found\"):\n Node.from_json(s)\n\n def test_debuggable(self):\n s = \"\"\"\n {\n \"a\": {\n \"node\": \"algorithm.Arange\"\n },\n \"mean\": {\n \"node\": \"algorithm.Convolution\",\n \"lookup_attrs\": {\"source\": \"a\"},\n \"attrs\": {\"kernel_type\": \"mean,3\", \"kernel_dims\": [\"lat\", \"lon\"]}\n },\n \"c\": {\n \"node\": \"algorithm.Arithmetic\",\n \"lookup_attrs\": {\"A\": \"a\", \"B\": \"mean\"},\n \"attrs\": {\"eqn\": \"a-b\"}\n }\n }\n \"\"\"\n\n with warnings.catch_warnings(), podpac.settings:\n warnings.filterwarnings(\"ignore\", \"Insecure evaluation.*\")\n\n # normally node objects can and should be re-used\n podpac.settings[\"DEBUG\"] = False\n node = Node.from_json(s)\n assert node.inputs[\"A\"] is node.inputs[\"B\"].source\n\n # when debugging is on, node objects should be unique\n podpac.settings[\"DEBUG\"] = True\n node = Node.from_json(s)\n assert node.inputs[\"A\"] is not node.inputs[\"B\"].source\n\n def test_from_definition_version_warning(self):\n s = \"\"\"\n {\n \"a\": {\n \"node\": \"algorithm.Arange\"\n },\n \"podpac_version\": \"other\"\n }\n \"\"\"\n\n with pytest.warns(UserWarning, match=\"node definition version mismatch\"):\n node = Node.from_json(s)\n\n\nclass TestNoCacheMixin(object):\n class NoCacheNode(NoCacheMixin, Node):\n pass\n\n def test_default_no_cache(self):\n with podpac.settings:\n podpac.settings[\"DEFAULT_CACHE\"] = [\"ram\"]\n node = self.NoCacheNode()\n assert len(node.cache_ctrl._cache_stores) == 0\n\n def test_customizable(self):\n podpac.settings[\"DEFAULT_CACHE\"] = [\"ram\"]\n node = self.NoCacheNode(cache_ctrl=[\"ram\"])\n assert len(node.cache_ctrl._cache_stores) == 1\n\n\nclass TestDiskCacheMixin(object):\n class DiskCacheNode(DiskCacheMixin, Node):\n pass\n\n def test_default_disk_cache(self):\n with podpac.settings:\n # add disk cache\n podpac.settings[\"DEFAULT_CACHE\"] = [\"ram\"]\n node = self.DiskCacheNode()\n assert len(node.cache_ctrl._cache_stores) == 2\n\n # don't add if it is already there\n podpac.settings[\"DEFAULT_CACHE\"] = [\"ram\", \"disk\"]\n node = self.DiskCacheNode()\n assert len(node.cache_ctrl._cache_stores) == 2\n\n def test_customizable(self):\n node = self.DiskCacheNode(cache_ctrl=[\"ram\"])\n assert len(node.cache_ctrl._cache_stores) == 1\n\n\n# TODO: remove this - this is currently a placeholder test until we actually have integration tests (pytest will exit with code 5 if no tests found)\n@pytest.mark.integration\ndef tests_node_integration():\n assert True\n","\"\"\"\nTest interpolation methods\n\n\n\"\"\"\n# pylint: disable=C0111,W0212,R0903\n\n\nimport warnings\n\nimport pytest\nimport traitlets as tl\nimport numpy as np\nfrom numpy.testing import assert_array_equal\n\nimport podpac\nfrom podpac.core.units import UnitsDataArray\nfrom podpac.core.node import Node\nfrom podpac.core.coordinates import Coordinates\nfrom podpac.core.interpolation.interpolation_manager import InterpolationException\nfrom podpac.core.interpolation.interpolation import Interpolate, InterpolationMixin\nfrom podpac.core.data.array_source import Array, ArrayRaw\nfrom podpac.core.compositor.tile_compositor import TileCompositorRaw\nfrom podpac.core.interpolation.scipy_interpolator import ScipyGrid\n\n\nclass TestInterpolationMixin(object):\n def test_interpolation_mixin(self):\n class InterpArray(InterpolationMixin, ArrayRaw):\n pass\n\n data = np.random.rand(4, 5)\n native_coords = Coordinates([np.linspace(0, 3, 4), np.linspace(0, 4, 5)], [\"lat\", \"lon\"])\n coords = Coordinates([np.linspace(0, 3, 7), np.linspace(0, 4, 9)], [\"lat\", \"lon\"])\n\n iarr_src = InterpArray(source=data, coordinates=native_coords, interpolation=\"bilinear\")\n arr_src = Array(source=data, coordinates=native_coords, interpolation=\"bilinear\")\n arrb_src = ArrayRaw(source=data, coordinates=native_coords)\n\n iaso = iarr_src.eval(coords)\n aso = arr_src.eval(coords)\n abso = arrb_src.eval(coords)\n\n np.testing.assert_array_equal(iaso.data, aso.data)\n np.testing.assert_array_equal(abso.data, data)\n\n\nclass TestInterpolation(object):\n s1 = ArrayRaw(\n source=np.random.rand(9, 15),\n coordinates=Coordinates([np.linspace(0, 8, 9), np.linspace(0, 14, 15)], [\"lat\", \"lon\"]),\n )\n s2 = ArrayRaw(\n source=np.random.rand(9, 15),\n coordinates=Coordinates([np.linspace(9, 17, 9), np.linspace(0, 14, 15)], [\"lat\", \"lon\"]),\n )\n interp = Interpolate(source=s1, interpolation=\"nearest\")\n coords = Coordinates([np.linspace(0, 8, 17), np.linspace(0, 14, 29)], [\"lat\", \"lon\"])\n coords2 = Coordinates([np.linspace(0, 17, 18), np.linspace(0, 14, 15)], [\"lat\", \"lon\"])\n coords2c = Coordinates([np.linspace(0.1, 16.8, 5), np.linspace(0.1, 13.8, 3)], [\"lat\", \"lon\"])\n\n def test_basic_interpolation(self):\n # This JUST tests the interface, tests for the actual value of the interpolation is left\n # to the test_interpolation_manager.py file\n\n o = self.interp.eval(self.coords)\n\n assert o.shape == (17, 29)\n\n def test_interpolation_definition(self):\n node = Node.from_json(self.interp.json)\n o1 = node.eval(self.coords)\n o2 = self.interp.eval(self.coords)\n np.testing.assert_array_equal(o1.data, o2.data)\n assert node.json == self.interp.json\n\n def test_compositor_chain(self):\n dc = TileCompositorRaw(sources=[self.s2, self.s1])\n node = Interpolate(source=dc, interpolation=\"nearest\")\n o = node.eval(self.coords2)\n\n np.testing.assert_array_equal(o.data, np.concatenate([self.s1.source, self.s2.source], axis=0))\n\n def test_get_bounds(self):\n assert self.interp.get_bounds() == self.s1.get_bounds()\n\n\nclass TestInterpolationBehavior(object):\n def test_linear_1D_issue411and413(self):\n data = [0, 1, 2]\n raw_coords = data.copy()\n raw_e_coords = [0, 0.5, 1, 1.5, 2]\n\n for dim in [\"lat\", \"lon\", \"alt\", \"time\"]:\n ec = Coordinates([raw_e_coords], [dim])\n\n arrb = ArrayRaw(source=data, coordinates=Coordinates([raw_coords], [dim]))\n node = Interpolate(source=arrb, interpolation=\"linear\")\n o = node.eval(ec)\n\n np.testing.assert_array_equal(o.data, raw_e_coords, err_msg=\"dim {} failed to interpolate\".format(dim))\n\n # Do time interpolation explicitly\n raw_coords = [\"2020-11-01\", \"2020-11-03\", \"2020-11-05\"]\n raw_et_coords = [\"2020-11-01\", \"2020-11-02\", \"2020-11-03\", \"2020-11-04\", \"2020-11-05\"]\n ec = Coordinates([raw_et_coords], [\"time\"])\n\n arrb = ArrayRaw(source=data, coordinates=Coordinates([raw_coords], [\"time\"]))\n node = Interpolate(source=arrb, interpolation=\"linear\")\n o = node.eval(ec)\n\n np.testing.assert_array_equal(\n o.data, raw_e_coords, err_msg=\"dim time failed to interpolate with datetime64 coords\"\n )\n\n def test_stacked_coords_with_partial_dims_issue123(self):\n node = Array(\n source=[0, 1, 2],\n coordinates=Coordinates(\n [[[0, 2, 1], [10, 12, 11], [\"2018-01-01\", \"2018-01-02\", \"2018-01-03\"]]], dims=[\"lat_lon_time\"]\n ),\n interpolation=\"nearest\",\n )\n\n # unstacked or and stacked requests without time\n o1 = node.eval(Coordinates([[0.5, 1.5], [10.5, 11.5]], dims=[\"lat\", \"lon\"]))\n o2 = node.eval(Coordinates([[[0.5, 1.5], [10.5, 11.5]]], dims=[\"lat_lon\"]))\n\n assert_array_equal(o1.data, [[0, 2], [2, 1]])\n assert_array_equal(o2.data, [0, 1])\n\n # request without lat or lon\n o3 = node.eval(Coordinates([\"2018-01-01\"], dims=[\"time\"]))\n assert o3.data[0] == 0\n\n def test_ignored_interpolation_params_issue340(self, caplog):\n node = Array(\n source=[0, 1, 2],\n coordinates=Coordinates([[0, 2, 1]], dims=[\"time\"]),\n interpolation={\"method\": \"nearest\", \"params\": {\"fake_param\": 1.1, \"spatial_tolerance\": 1}},\n )\n\n with warnings.catch_warnings():\n warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n node.eval(Coordinates([[0.5, 1.5]], [\"time\"]))\n assert \"interpolation parameter 'fake_param' was ignored\" in caplog.text\n assert \"interpolation parameter 'spatial_tolerance' was ignored\" not in caplog.text\n\n def test_silent_nearest_neighbor_interp_bug_issue412(self):\n node = podpac.data.Array(\n source=[0, 1, 2],\n coordinates=podpac.Coordinates([[1, 5, 9]], dims=[\"lat\"]),\n interpolation=[{\"method\": \"bilinear\", \"dims\": [\"lat\"], \"interpolators\": [ScipyGrid]}],\n )\n with pytest.raises(InterpolationException, match=\"can't be handled\"):\n o = node.eval(podpac.Coordinates([podpac.crange(1, 9, 1)], dims=[\"lat\"]))\n\n node = podpac.data.Array(\n source=[0, 1, 2],\n coordinates=podpac.Coordinates([[1, 5, 9]], dims=[\"lat\"]),\n interpolation=[{\"method\": \"bilinear\", \"dims\": [\"lat\"]}],\n )\n o = node.eval(podpac.Coordinates([podpac.crange(1, 9, 1)], dims=[\"lat\"]))\n assert_array_equal(o.data, np.linspace(0, 2, 9))\n\n def test_selection_crs(self):\n base = podpac.core.data.array_source.ArrayRaw(\n source=[0, 1, 2],\n coordinates=podpac.Coordinates(\n [[1, 5, 9]], dims=[\"time\"], crs=\"+proj=longlat +datum=WGS84 +no_defs +vunits=m\"\n ),\n )\n node = podpac.interpolators.Interpolate(source=base, interpolation=\"linear\")\n tocrds = podpac.Coordinates([podpac.crange(1, 9, 1, \"time\")], crs=\"EPSG:4326\")\n o = node.eval(tocrds)\n assert o.crs == tocrds.crs\n assert_array_equal(o.data, np.linspace(0, 2, 9))\n","\"\"\"\nGeneral-purpose Algorithm Nodes.\n\"\"\"\n\nfrom __future__ import division, unicode_literals, print_function, absolute_import\n\nimport sys\nimport warnings\n\nimport numpy as np\nimport xarray as xr\nimport traitlets as tl\n\n# Optional dependencies\nfrom lazy_import import lazy_module\n\nne = lazy_module(\"numexpr\")\n\nfrom podpac import settings\nfrom podpac import Coordinates\nfrom podpac.core.node import Node\nfrom podpac.core.utils import NodeTrait\nfrom podpac.core.algorithm.algorithm import Algorithm\n\nif sys.version_info.major == 2:\n\n class PermissionError(OSError):\n pass\n\n\nclass GenericInputs(Algorithm):\n \"\"\"Base class for Algorithms that accept generic named inputs.\"\"\"\n\n inputs = tl.Dict(read_only=True)\n\n _repr_keys = [\"inputs\"]\n\n def _first_init(self, **kwargs):\n trait_names = self.trait_names()\n for key in kwargs:\n if key in trait_names and isinstance(kwargs[key], Node):\n raise RuntimeError(\"Trait '%s' is reserved and cannot be used as an Generic Algorithm input\" % key)\n input_keys = [key for key in kwargs if key not in trait_names and isinstance(kwargs[key], Node)]\n inputs = {key: kwargs.pop(key) for key in input_keys}\n self.set_trait(\"inputs\", inputs)\n return super(GenericInputs, self)._first_init(**kwargs)\n\n @property\n def _base_definition(self):\n d = super(GenericInputs, self)._base_definition\n d[\"inputs\"] = self.inputs\n return d\n\n\nclass Arithmetic(GenericInputs):\n \"\"\"Create a simple point-by-point computation using named input nodes.\n\n Examples\n ----------\n a = SinCoords()\n b = Arange()\n arith = Arithmetic(A=a, B=b, eqn = 'A * B + {offset}', params={'offset': 1})\n \"\"\"\n\n eqn = tl.Unicode().tag(attr=True)\n params = tl.Dict().tag(attr=True)\n\n _repr_keys = [\"eqn\"]\n\n def init(self):\n if not settings.allow_unsafe_eval:\n warnings.warn(\n \"Insecure evaluation of Python code using Arithmetic node has not been allowed. If \"\n \"this is an error, use: `podpac.settings.set_unsafe_eval(True)`. \"\n \"NOTE: Allowing unsafe evaluation enables arbitrary execution of Python code through PODPAC \"\n \"Node definitions.\"\n )\n\n if self.eqn == \"\":\n raise ValueError(\"Arithmetic eqn cannot be empty\")\n\n super(Arithmetic, self).init()\n\n def algorithm(self, inputs, coordinates):\n \"\"\"Compute the algorithms equation\n\n Attributes\n ----------\n inputs : dict\n Evaluated outputs of the input nodes. The keys are the attribute names.\n coordinates : podpac.Coordinates\n Requested coordinates.\n Note that the ``inputs`` may contain with different coordinates.\n\n Returns\n -------\n result : UnitsDataArray\n Algorithm result.\n \"\"\"\n\n if not settings.allow_unsafe_eval:\n raise PermissionError(\n \"Insecure evaluation of Python code using Arithmetic node has not been allowed. If \"\n \"this is an error, use: `podpac.settings.set_unsafe_eval(True)`. \"\n \"NOTE: Allowing unsafe evaluation enables arbitrary execution of Python code through PODPAC \"\n \"Node definitions.\"\n )\n\n eqn = self.eqn.format(**self.params)\n\n fields = self.inputs.keys()\n res = xr.broadcast(*[inputs[f] for f in fields])\n f_locals = dict(zip(fields, res))\n\n try:\n from numexpr import evaluate # Needed for some systems to get around lazy_module issues\n\n result = ne.evaluate(eqn, f_locals)\n except (NotImplementedError, ImportError):\n result = eval(eqn, f_locals)\n res = res[0].copy() # Make an xarray object with correct dimensions\n res[:] = result\n return res\n\n\nclass Generic(GenericInputs):\n \"\"\"\n Generic Algorithm Node that allows arbitrary Python code to be executed.\n\n Attributes\n ----------\n code : str\n The multi-line code that will be evaluated. This code should assign \"output\" to the desired result, and \"output\"\n needs to be a \"numpy array\" or \"xarray DataArray\"\n inputs : dict(str: podpac.Node)\n A dictionary of PODPAC nodes that will serve as the input data for the Python script\n\n Examples\n ----------\n a = SinCoords()\n b = Arange()\n code = '''import numpy as np\n output = np.minimum(a, b)\n '''\n generic = Generic(code=code, a=a, b=b)\n \"\"\"\n\n code = tl.Unicode().tag(attr=True, readonly=True)\n\n def init(self):\n if not settings.allow_unsafe_eval:\n warnings.warn(\n \"Insecure evaluation of Python code using Generic node has not been allowed. If this \"\n \"this is an error, use: `podpac.settings.set_unsafe_eval(True)`. \"\n \"NOTE: Allowing unsafe evaluation enables arbitrary execution of Python code through PODPAC \"\n \"Node definitions.\"\n )\n super(Generic, self).init()\n\n def algorithm(self, inputs, coordinates):\n \"\"\"\n Run the generic code.\n\n Attributes\n ----------\n inputs : dict\n Evaluated outputs of the input nodes. The keys are the attribute names.\n coordinates : podpac.Coordinates\n Requested coordinates.\n Note that the ``inputs`` may contain with different coordinates.\n\n Returns\n -------\n result : UnitsDataArray\n Algorithm result.\n \"\"\"\n\n if not settings.allow_unsafe_eval:\n raise PermissionError(\n \"Insecure evaluation of Python code using Generic node has not been allowed. If this \"\n \"this is an error, use: `podpac.settings.set_unsafe_eval(True)`. \"\n \"NOTE: Allowing unsafe evaluation enables arbitrary execution of Python code through PODPAC \"\n \"Node definitions.\"\n )\n exec(self.code, inputs)\n return inputs[\"output\"]\n\n\nclass Mask(Algorithm):\n \"\"\"\n Masks the `source` based on a boolean expression involving the `mask`\n (i.e. source[mask <bool_op> <bool_val> ] = <masked_val>).\n For a normal boolean mask input, default values for `bool_op`, `bool_val` and `masked_val` can be used.\n\n Attributes\n ----------\n source : podpac.Node\n The source that will be masked\n mask : podpac.Node\n The data that will be used to compute the mask\n masked_val : float, optional\n Default value is np.nan. The value that will replace the masked items.\n bool_val : float, optional\n Default value is 1. The value used to compare the mask when creating the boolean expression\n bool_op : enum, optional\n Default value is '=='. One of ['==', '<', '<=', '>', '>=']\n in_place : bool, optional\n Default is False. If True, the source array will be changed in-place, which could affect the value of the source\n in other parts of the pipeline.\n\n Examples\n ----------\n # Mask data from a boolean data node using the default behavior.\n # Create a boolean masked Node (as an example)\n b = Arithmetic(A=SinCoords(), eqn='A>0)\n # Create the source node\n a = Arange()\n masked = Mask(source=a, mask=b)\n\n # Create a node that make the following substitution \"a[b > 0] = np.nan\"\n a = Arange()\n b = SinCoords()\n masked = Mask(source=a, mask=b,\n masked_val=np.nan,\n bool_val=0, bool_op='>'\n in_place=True)\n\n \"\"\"\n\n source = NodeTrait().tag(attr=True)\n mask = NodeTrait().tag(attr=True)\n masked_val = tl.Float(allow_none=True, default_value=None).tag(attr=True)\n bool_val = tl.Float(1).tag(attr=True)\n bool_op = tl.Enum([\"==\", \"<\", \"<=\", \">\", \">=\"], default_value=\"==\").tag(attr=True)\n in_place = tl.Bool(False).tag(attr=True)\n\n _repr_keys = [\"source\", \"mask\"]\n\n def algorithm(self, inputs, coordinates):\n \"\"\"\n Sets the values in inputs['source'] to self.masked_val using (inputs['mask'] <self.bool_op> <self.bool_val>)\n\n Attributes\n ----------\n inputs : dict\n Evaluated outputs of the input nodes. The keys are the attribute names.\n coordinates : podpac.Coordinates\n Requested coordinates.\n Note that the ``inputs`` may contain with different coordinates.\n\n Returns\n -------\n result : UnitsDataArray\n Algorithm result.\n \"\"\"\n\n # shorter names\n mask = inputs[\"mask\"]\n source = inputs[\"source\"]\n op = self.bool_op\n bv = self.bool_val\n\n # Make a copy if we don't want to change the source in-place\n if not self.in_place:\n source = source.copy()\n\n # Make the mask boolean\n if op == \"==\":\n mask = mask == bv\n elif op == \"<\":\n mask = mask < bv\n elif op == \"<=\":\n mask = mask <= bv\n elif op == \">\":\n mask = mask > bv\n elif op == \">=\":\n mask = mask >= bv\n\n # Mask the values and return\n if self.masked_val is None:\n source.set(np.nan, mask)\n else:\n source.set(self.masked_val, mask)\n\n return source\n\n\nclass Combine(GenericInputs):\n \"\"\"Combine multiple nodes into a single node with multiple outputs.\n\n If not output names are specified, the keyword argument names will be used.\n \"\"\"\n\n @tl.default(\"outputs\")\n def _default_outputs(self):\n input_keys = list(self.inputs.keys())\n return input_keys\n\n def algorithm(self, inputs, coordinates):\n cs = [Coordinates.from_xarray(x) for x in inputs.values()]\n if any(c != cs[0] for c in cs):\n raise NodeException(\"Cannot combine inputs with different coordinates\")\n\n data = np.stack([inputs[key] for key in self.inputs], axis=-1)\n return self.create_output_array(cs[0], data=data)\n","from __future__ import division, unicode_literals, print_function, absolute_import\n\nimport pytest\nimport numpy as np\nimport xarray as xr\nimport scipy.stats\nimport traitlets as tl\n\nimport podpac\nfrom podpac.core.algorithm.utility import Arange\nfrom podpac.core.data.array_source import Array\nfrom podpac.core.algorithm.stats import Reduce\nfrom podpac.core.algorithm.stats import Min, Max, Sum, Count, Mean, Variance, Skew, Kurtosis, StandardDeviation\nfrom podpac.core.algorithm.generic import Arithmetic\nfrom podpac.core.algorithm.stats import Median, Percentile\nfrom podpac.core.algorithm.stats import GroupReduce, DayOfYear, DayOfYearWindow\n\n\ndef setup_module():\n global coords, source, data, multisource, bdata\n coords = podpac.Coordinates(\n [podpac.clinspace(0, 1, 10), podpac.clinspace(0, 1, 10), podpac.crange(\"2018-01-01\", \"2018-01-10\", \"1,D\")],\n dims=[\"lat\", \"lon\", \"time\"],\n )\n\n a = np.random.random(coords.shape)\n a[3, 0, 0] = np.nan\n a[0, 3, 0] = np.nan\n a[0, 0, 3] = np.nan\n source = Array(source=a, coordinates=coords)\n data = source.eval(coords)\n\n ab = np.stack([a, 2 * a], -1)\n multisource = Array(source=ab, coordinates=coords, outputs=[\"a\", \"b\"])\n bdata = 2 * data\n\n\nclass TestReduce(object):\n \"\"\" Tests the Reduce class \"\"\"\n\n def test_auto_chunk(self):\n # any reduce node would do here\n node = Min(source=source)\n\n with podpac.settings:\n podpac.settings[\"CACHE_NODE_OUTPUT_DEFAULT\"] = False\n podpac.settings[\"CHUNK_SIZE\"] = \"auto\"\n node.eval(coords)\n\n def test_chunked_fallback(self):\n with podpac.settings:\n podpac.settings[\"CACHE_NODE_OUTPUT_DEFAULT\"] = False\n\n class First(Reduce):\n def reduce(self, x):\n return x.isel(**{dim: 0 for dim in self.dims})\n\n node = First(source=source, dims=\"time\")\n\n # use reduce function\n podpac.settings[\"CHUNK_SIZE\"] = None\n output = node.eval(coords)\n\n # fall back on reduce function with warning\n with pytest.warns(UserWarning):\n podpac.settings[\"CHUNK_SIZE\"] = 500\n output_chunked = node.eval(coords)\n\n # should be the same\n xr.testing.assert_allclose(output, output_chunked)\n\n\nclass BaseTests(object):\n \"\"\" Common tests for Reduce subclasses \"\"\"\n\n def test_full(self):\n with podpac.settings:\n podpac.settings[\"CACHE_NODE_OUTPUT_DEFAULT\"] = False\n podpac.settings[\"CHUNK_SIZE\"] = None\n\n node = self.NodeClass(source=source)\n output = node.eval(coords)\n # xr.testing.assert_allclose(output, self.expected_full)\n np.testing.assert_allclose(output.data, self.expected_full.data)\n\n node = self.NodeClass(source=source, dims=coords.dims)\n output = node.eval(coords)\n # xr.testing.assert_allclose(output, self.expected_full)\n np.testing.assert_allclose(output.data, self.expected_full.data)\n\n def test_full_chunked(self):\n with podpac.settings:\n node = self.NodeClass(source=source, dims=coords.dims)\n podpac.settings[\"CACHE_NODE_OUTPUT_DEFAULT\"] = False\n podpac.settings[\"CHUNK_SIZE\"] = 500\n output = node.eval(coords)\n # xr.testing.assert_allclose(output, self.expected_full)\n np.testing.assert_allclose(output.data, self.expected_full.data)\n\n def test_lat_lon(self):\n with podpac.settings:\n podpac.settings[\"CACHE_NODE_OUTPUT_DEFAULT\"] = False\n podpac.settings[\"CHUNK_SIZE\"] = None\n node = self.NodeClass(source=source, dims=[\"lat\", \"lon\"])\n output = node.eval(coords)\n # xr.testing.assert_allclose(output, self.expected_latlon)\n np.testing.assert_allclose(output.data, self.expected_latlon.data)\n\n def test_lat_lon_chunked(self):\n with podpac.settings:\n podpac.settings[\"CACHE_NODE_OUTPUT_DEFAULT\"] = False\n podpac.settings[\"CHUNK_SIZE\"] = 500\n node = self.NodeClass(source=source, dims=[\"lat\", \"lon\"])\n output = node.eval(coords)\n # xr.testing.assert_allclose(output, self.expected_latlon)\n np.testing.assert_allclose(output.data, self.expected_latlon.data)\n\n def test_time(self):\n with podpac.settings:\n podpac.settings[\"CACHE_NODE_OUTPUT_DEFAULT\"] = False\n podpac.settings[\"CHUNK_SIZE\"] = None\n node = self.NodeClass(source=source, dims=\"time\")\n output = node.eval(coords)\n # xr.testing.assert_allclose(output, self.expected_time)\n np.testing.assert_allclose(output.data, self.expected_time.data)\n\n def test_time_chunked(self):\n with podpac.settings:\n podpac.settings[\"CACHE_NODE_OUTPUT_DEFAULT\"] = False\n podpac.settings[\"CHUNK_SIZE\"] = 500\n node = self.NodeClass(source=source, dims=\"time\")\n output = node.eval(coords)\n # xr.testing.assert_allclose(output, self.expected_time)\n np.testing.assert_allclose(output.data, self.expected_time.data)\n\n def test_multiple_outputs(self):\n with podpac.settings:\n podpac.settings[\"CACHE_NODE_OUTPUT_DEFAULT\"] = False\n podpac.settings[\"CHUNK_SIZE\"] = None\n node = self.NodeClass(source=multisource, dims=[\"lat\", \"lon\"])\n output = node.eval(coords)\n assert output.dims == (\"time\", \"output\")\n np.testing.assert_array_equal(output[\"output\"], [\"a\", \"b\"])\n np.testing.assert_allclose(output.sel(output=\"a\"), self.expected_latlon)\n np.testing.assert_allclose(output.sel(output=\"b\"), self.expected_latlon_b)\n\n\nclass TestMin(BaseTests):\n @classmethod\n def setup_class(cls):\n cls.NodeClass = Min\n cls.expected_full = data.min()\n cls.expected_latlon = data.min(dim=[\"lat\", \"lon\"])\n cls.expected_latlon_b = bdata.min(dim=[\"lat\", \"lon\"])\n cls.expected_time = data.min(dim=\"time\")\n\n\nclass TestMax(BaseTests):\n @classmethod\n def setup_class(cls):\n cls.NodeClass = Max\n cls.expected_full = data.max()\n cls.expected_latlon = data.max(dim=[\"lat\", \"lon\"])\n cls.expected_latlon_b = bdata.max(dim=[\"lat\", \"lon\"])\n cls.expected_time = data.max(dim=\"time\")\n\n\nclass TestSum(BaseTests):\n @classmethod\n def setup_class(cls):\n cls.NodeClass = Sum\n cls.expected_full = data.sum()\n cls.expected_latlon = data.sum(dim=[\"lat\", \"lon\"])\n cls.expected_latlon_b = bdata.sum(dim=[\"lat\", \"lon\"])\n cls.expected_time = data.sum(dim=\"time\")\n\n\nclass TestCount(BaseTests):\n @classmethod\n def setup_class(cls):\n cls.NodeClass = Count\n cls.expected_full = np.isfinite(data).sum()\n cls.expected_latlon = np.isfinite(data).sum(dim=[\"lat\", \"lon\"])\n cls.expected_latlon_b = np.isfinite(bdata).sum(dim=[\"lat\", \"lon\"])\n cls.expected_time = np.isfinite(data).sum(dim=\"time\")\n\n\nclass TestMean(BaseTests):\n @classmethod\n def setup_class(cls):\n cls.NodeClass = Mean\n cls.expected_full = data.mean()\n cls.expected_latlon = data.mean(dim=[\"lat\", \"lon\"])\n cls.expected_latlon_b = bdata.mean(dim=[\"lat\", \"lon\"])\n cls.expected_time = data.mean(dim=\"time\")\n\n def test_chunk_sizes(self):\n for n in [20, 21, 1000, 1001]:\n podpac.settings[\"CHUNK_SIZE\"] = n\n node = self.NodeClass(source=source, dims=coords.dims)\n output = node.eval(coords)\n # xr.testing.assert_allclose(output, self.expected_full)\n np.testing.assert_allclose(output.data, self.expected_full.data)\n\n\nclass TestVariance(BaseTests):\n @classmethod\n def setup_class(cls):\n cls.NodeClass = Variance\n cls.expected_full = data.var()\n cls.expected_latlon = data.var(dim=[\"lat\", \"lon\"])\n cls.expected_latlon_b = bdata.var(dim=[\"lat\", \"lon\"])\n cls.expected_time = data.var(dim=\"time\")\n\n\nclass TestStandardDeviation(BaseTests):\n @classmethod\n def setup_class(cls):\n cls.NodeClass = StandardDeviation\n cls.expected_full = data.std()\n cls.expected_latlon = data.std(dim=[\"lat\", \"lon\"])\n cls.expected_latlon_b = bdata.std(dim=[\"lat\", \"lon\"])\n cls.expected_time = data.std(dim=\"time\")\n cls.expected_latlon_b = 2 * cls.expected_latlon\n\n\nclass TestSkew(BaseTests):\n @classmethod\n def setup_class(cls):\n cls.NodeClass = Skew\n n, m, l = data.shape\n cls.expected_full = xr.DataArray(scipy.stats.skew(data.data.reshape(n * m * l), nan_policy=\"omit\"))\n cls.expected_latlon = scipy.stats.skew(data.data.reshape((n * m, l)), axis=0, nan_policy=\"omit\")\n cls.expected_latlon_b = scipy.stats.skew(bdata.data.reshape((n * m, l)), axis=0, nan_policy=\"omit\")\n cls.expected_time = scipy.stats.skew(data, axis=2, nan_policy=\"omit\")\n\n\nclass TestKurtosis(BaseTests):\n @classmethod\n def setup_class(cls):\n cls.NodeClass = Kurtosis\n n, m, l = data.shape\n cls.expected_full = xr.DataArray(scipy.stats.kurtosis(data.data.reshape(n * m * l), nan_policy=\"omit\"))\n cls.expected_latlon = scipy.stats.kurtosis(data.data.reshape((n * m, l)), axis=0, nan_policy=\"omit\")\n cls.expected_latlon_b = scipy.stats.kurtosis(bdata.data.reshape((n * m, l)), axis=0, nan_policy=\"omit\")\n cls.expected_time = scipy.stats.kurtosis(data, axis=2, nan_policy=\"omit\")\n\n\nclass TestMedian(BaseTests):\n @classmethod\n def setup_class(cls):\n cls.NodeClass = Median\n cls.expected_full = data.median()\n cls.expected_latlon = data.median(dim=[\"lat\", \"lon\"])\n cls.expected_latlon_b = bdata.median(dim=[\"lat\", \"lon\"])\n cls.expected_time = data.median(dim=\"time\")\n\n\n@pytest.mark.skip(\"TODO\")\nclass TestPercentile(BaseTests):\n @classmethod\n def setup_class(cls):\n cls.node = Percentile(source=source)\n # TODO can we replace dims_axes with reshape (or vice versa)\n\n\nclass TestGroupReduce(object):\n pass\n\n\nclass TestResampleReduce(object):\n pass\n\n\nclass TestDayOfYear(object):\n pass\n\n\nclass F(DayOfYearWindow):\n cache_output = tl.Bool(False)\n force_eval = tl.Bool(True)\n\n def function(self, data, output):\n return len(data)\n\n\nclass FM(DayOfYearWindow):\n cache_output = tl.Bool(False)\n force_eval = tl.Bool(True)\n\n def function(self, data, output):\n return np.mean(data)\n\n\nclass TestDayOfYearWindow(object):\n def test_doy_window1(self):\n coords = podpac.coordinates.concat(\n [\n podpac.Coordinates([podpac.crange(\"1999-12-29\", \"2000-01-02\", \"1,D\", \"time\")]),\n podpac.Coordinates([podpac.crange(\"2001-12-30\", \"2002-01-03\", \"1,D\", \"time\")]),\n ]\n )\n\n node = Arange()\n nodedoywindow = F(source=node, window=1, cache_output=False, force_eval=True)\n o = nodedoywindow.eval(coords)\n\n np.testing.assert_array_equal(o, [2, 2, 1, 1, 2, 2])\n\n def test_doy_window2(self):\n coords = podpac.coordinates.concat(\n [\n podpac.Coordinates([podpac.crange(\"1999-12-29\", \"2000-01-03\", \"1,D\", \"time\")]),\n podpac.Coordinates([podpac.crange(\"2001-12-30\", \"2002-01-02\", \"1,D\", \"time\")]),\n ]\n )\n\n node = Arange()\n nodedoywindow = F(source=node, window=2, cache_output=False, force_eval=True)\n o = nodedoywindow.eval(coords)\n\n np.testing.assert_array_equal(o, [6, 5, 3, 3, 5, 6])\n\n def test_doy_window2_mean_rescale_float(self):\n coords = podpac.coordinates.concat(\n [\n podpac.Coordinates([podpac.crange(\"1999-12-29\", \"2000-01-03\", \"1,D\", \"time\")]),\n podpac.Coordinates([podpac.crange(\"2001-12-30\", \"2002-01-02\", \"1,D\", \"time\")]),\n ]\n )\n\n node = Arange()\n nodedoywindow = FM(source=node, window=2, cache_output=False, force_eval=True)\n o = nodedoywindow.eval(coords)\n\n nodedoywindow_s = FM(\n source=node, window=2, cache_output=False, force_eval=True, scale_float=[0, coords.size], rescale=True\n )\n o_s = nodedoywindow_s.eval(coords)\n\n np.testing.assert_array_almost_equal(o, o_s)\n\n def test_doy_window2_mean_rescale_max_min(self):\n with podpac.settings:\n podpac.settings.set_unsafe_eval(True)\n\n coords = podpac.coordinates.concat(\n [\n podpac.Coordinates([podpac.crange(\"1999-12-29\", \"2000-01-03\", \"1,D\", \"time\")]),\n podpac.Coordinates([podpac.crange(\"2001-12-30\", \"2002-01-02\", \"1,D\", \"time\")]),\n ]\n )\n\n node = Arange()\n node_max = Arithmetic(source=node, eqn=\"(source < 5) + source\")\n node_min = Arithmetic(source=node, eqn=\"-1*(source < 5) + source\")\n\n nodedoywindow_s = FM(\n source=node,\n window=2,\n cache_output=False,\n force_eval=True,\n scale_max=node_max,\n scale_min=node_min,\n rescale=False,\n )\n o_s = nodedoywindow_s.eval(coords)\n\n np.testing.assert_array_almost_equal([0.5] * o_s.size, o_s)\n"],"string":"[\n \"from datetime import datetime\\nimport json\\n\\nimport pytest\\nimport traitlets as tl\\nimport numpy as np\\nfrom numpy.testing import assert_equal\\n\\nimport podpac\\nfrom podpac.core.coordinates.utils import make_coord_array\\nfrom podpac.core.coordinates.coordinates1d import Coordinates1d\\nfrom podpac.core.coordinates.array_coordinates1d import ArrayCoordinates1d\\nfrom podpac.core.coordinates.uniform_coordinates1d import UniformCoordinates1d\\nfrom podpac.core.coordinates.coordinates import Coordinates\\n\\n\\nclass TestUniformCoordinatesCreation(object):\\n def test_numerical(self):\\n # ascending\\n c = UniformCoordinates1d(0, 50, 10)\\n a = np.array([0, 10, 20, 30, 40, 50], dtype=float)\\n assert c.start == 0\\n assert c.stop == 50\\n assert c.step == 10\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, [0, 50])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == 6\\n assert c.dtype == float\\n assert c.is_monotonic == True\\n assert c.is_descending == False\\n assert c.is_uniform == True\\n\\n # descending\\n c = UniformCoordinates1d(50, 0, -10)\\n a = np.array([50, 40, 30, 20, 10, 0], dtype=float)\\n assert c.start == 50\\n assert c.stop == 0\\n assert c.step == -10\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, [0, 50])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == 6\\n assert c.dtype == float\\n assert c.is_monotonic == True\\n assert c.is_descending == True\\n assert c.is_uniform == True\\n\\n def test_numerical_inexact(self):\\n # ascending\\n c = UniformCoordinates1d(0, 49, 10)\\n a = np.array([0, 10, 20, 30, 40], dtype=float)\\n assert c.start == 0\\n assert c.stop == 49\\n assert c.step == 10\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, [0, 40])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == 5\\n assert c.dtype == float\\n assert c.is_monotonic == True\\n assert c.is_descending == False\\n assert c.is_uniform == True\\n\\n # descending\\n c = UniformCoordinates1d(50, 1, -10)\\n a = np.array([50, 40, 30, 20, 10], dtype=float)\\n assert c.start == 50\\n assert c.stop == 1\\n assert c.step == -10\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, [10, 50])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.dtype == float\\n assert c.size == a.size\\n assert c.is_monotonic == True\\n assert c.is_descending == True\\n assert c.is_uniform == True\\n\\n def test_datetime(self):\\n # ascending\\n c = UniformCoordinates1d(\\\"2018-01-01\\\", \\\"2018-01-04\\\", \\\"1,D\\\")\\n a = np.array([\\\"2018-01-01\\\", \\\"2018-01-02\\\", \\\"2018-01-03\\\", \\\"2018-01-04\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2018-01-01\\\")\\n assert c.stop == np.datetime64(\\\"2018-01-04\\\")\\n assert c.step == np.timedelta64(1, \\\"D\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[0, -1]])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == False\\n assert c.is_uniform == True\\n\\n # descending\\n c = UniformCoordinates1d(\\\"2018-01-04\\\", \\\"2018-01-01\\\", \\\"-1,D\\\")\\n a = np.array([\\\"2018-01-04\\\", \\\"2018-01-03\\\", \\\"2018-01-02\\\", \\\"2018-01-01\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2018-01-04\\\")\\n assert c.stop == np.datetime64(\\\"2018-01-01\\\")\\n assert c.step == np.timedelta64(-1, \\\"D\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[-1, 0]])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == True\\n assert c.is_uniform == True\\n\\n def test_datetime_inexact(self):\\n # ascending\\n c = UniformCoordinates1d(\\\"2018-01-01\\\", \\\"2018-01-06\\\", \\\"2,D\\\")\\n a = np.array([\\\"2018-01-01\\\", \\\"2018-01-03\\\", \\\"2018-01-05\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2018-01-01\\\")\\n assert c.stop == np.datetime64(\\\"2018-01-06\\\")\\n assert c.step == np.timedelta64(2, \\\"D\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[0, -1]])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == False\\n assert c.is_uniform == True\\n\\n # descending\\n c = UniformCoordinates1d(\\\"2018-01-06\\\", \\\"2018-01-01\\\", \\\"-2,D\\\")\\n a = np.array([\\\"2018-01-06\\\", \\\"2018-01-04\\\", \\\"2018-01-02\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2018-01-06\\\")\\n assert c.stop == np.datetime64(\\\"2018-01-01\\\")\\n assert c.step == np.timedelta64(-2, \\\"D\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[-1, 0]])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == True\\n assert c.is_uniform == True\\n\\n def test_datetime_month_step(self):\\n # ascending\\n c = UniformCoordinates1d(\\\"2018-01-01\\\", \\\"2018-04-01\\\", \\\"1,M\\\")\\n a = np.array([\\\"2018-01-01\\\", \\\"2018-02-01\\\", \\\"2018-03-01\\\", \\\"2018-04-01\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2018-01-01\\\")\\n assert c.stop == np.datetime64(\\\"2018-04-01\\\")\\n assert c.step == np.timedelta64(1, \\\"M\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[0, -1]])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == False\\n assert c.is_uniform == True\\n\\n # descending\\n c = UniformCoordinates1d(\\\"2018-04-01\\\", \\\"2018-01-01\\\", \\\"-1,M\\\")\\n a = np.array([\\\"2018-04-01\\\", \\\"2018-03-01\\\", \\\"2018-02-01\\\", \\\"2018-01-01\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2018-04-01\\\")\\n assert c.stop == np.datetime64(\\\"2018-01-01\\\")\\n assert c.step == np.timedelta64(-1, \\\"M\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[-1, 0]])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == True\\n assert c.is_uniform == True\\n\\n def test_datetime_year_step(self):\\n # ascending, exact\\n c = UniformCoordinates1d(\\\"2018-01-01\\\", \\\"2021-01-01\\\", \\\"1,Y\\\")\\n a = np.array([\\\"2018-01-01\\\", \\\"2019-01-01\\\", \\\"2020-01-01\\\", \\\"2021-01-01\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2018-01-01\\\")\\n assert c.stop == np.datetime64(\\\"2021-01-01\\\")\\n assert c.step == np.timedelta64(1, \\\"Y\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[0, -1]])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == False\\n assert c.is_uniform == True\\n\\n # descending, exact\\n c = UniformCoordinates1d(\\\"2021-01-01\\\", \\\"2018-01-01\\\", \\\"-1,Y\\\")\\n a = np.array([\\\"2021-01-01\\\", \\\"2020-01-01\\\", \\\"2019-01-01\\\", \\\"2018-01-01\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2021-01-01\\\")\\n assert c.stop == np.datetime64(\\\"2018-01-01\\\")\\n assert c.step == np.timedelta64(-1, \\\"Y\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[-1, 0]])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == True\\n assert c.is_uniform == True\\n\\n # ascending, inexact (two cases)\\n c = UniformCoordinates1d(\\\"2018-01-01\\\", \\\"2021-04-01\\\", \\\"1,Y\\\")\\n a = np.array([\\\"2018-01-01\\\", \\\"2019-01-01\\\", \\\"2020-01-01\\\", \\\"2021-01-01\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2018-01-01\\\")\\n assert c.stop == np.datetime64(\\\"2021-04-01\\\")\\n assert c.step == np.timedelta64(1, \\\"Y\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[0, -1]])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == False\\n assert c.is_uniform == True\\n\\n c = UniformCoordinates1d(\\\"2018-04-01\\\", \\\"2021-01-01\\\", \\\"1,Y\\\")\\n a = np.array([\\\"2018-04-01\\\", \\\"2019-04-01\\\", \\\"2020-04-01\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2018-04-01\\\")\\n assert c.stop == np.datetime64(\\\"2021-01-01\\\")\\n assert c.step == np.timedelta64(1, \\\"Y\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[0, -1]])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == False\\n assert c.is_uniform == True\\n\\n # descending, inexact (two cases)\\n c = UniformCoordinates1d(\\\"2021-01-01\\\", \\\"2018-04-01\\\", \\\"-1,Y\\\")\\n a = np.array([\\\"2021-01-01\\\", \\\"2020-01-01\\\", \\\"2019-01-01\\\", \\\"2018-01-01\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2021-01-01\\\")\\n assert c.stop == np.datetime64(\\\"2018-04-01\\\")\\n assert c.step == np.timedelta64(-1, \\\"Y\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[-1, 0]])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == True\\n assert c.is_uniform == True\\n\\n c = UniformCoordinates1d(\\\"2021-04-01\\\", \\\"2018-01-01\\\", \\\"-1,Y\\\")\\n a = np.array([\\\"2021-04-01\\\", \\\"2020-04-01\\\", \\\"2019-04-01\\\", \\\"2018-04-01\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2021-04-01\\\")\\n assert c.stop == np.datetime64(\\\"2018-01-01\\\")\\n assert c.step == np.timedelta64(-1, \\\"Y\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[-1, 0]])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == True\\n assert c.is_uniform == True\\n\\n def test_numerical_size(self):\\n # ascending\\n c = UniformCoordinates1d(0, 10, size=20)\\n assert c.start == 0\\n assert c.stop == 10\\n assert c.step == 10 / 19.0\\n assert_equal(c.coordinates, np.linspace(0, 10, 20))\\n assert_equal(c.bounds, [0, 10])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == 20\\n assert c.dtype == float\\n assert c.is_monotonic == True\\n assert c.is_descending == False\\n assert c.is_uniform == True\\n\\n # descending\\n c = UniformCoordinates1d(10, 0, size=20)\\n assert c.start == 10\\n assert c.stop == 0\\n assert c.step == -10 / 19.0\\n assert_equal(c.coordinates, np.linspace(10, 0, 20))\\n assert_equal(c.bounds, [0, 10])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == 20\\n assert c.dtype == float\\n assert c.is_monotonic == True\\n assert c.is_descending == True\\n assert c.is_uniform == True\\n\\n def test_datetime_size(self):\\n # ascending\\n c = UniformCoordinates1d(\\\"2018-01-01\\\", \\\"2018-01-10\\\", size=10)\\n assert c.start == np.datetime64(\\\"2018-01-01\\\")\\n assert c.stop == np.datetime64(\\\"2018-01-10\\\")\\n assert_equal(c.bounds, [np.datetime64(\\\"2018-01-01\\\"), np.datetime64(\\\"2018-01-10\\\")])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == 10\\n assert c.dtype == np.datetime64\\n assert c.is_descending == False\\n\\n # descending\\n c = UniformCoordinates1d(\\\"2018-01-10\\\", \\\"2018-01-01\\\", size=10)\\n assert c.start == np.datetime64(\\\"2018-01-10\\\")\\n assert c.stop == np.datetime64(\\\"2018-01-01\\\")\\n assert_equal(c.bounds, [np.datetime64(\\\"2018-01-01\\\"), np.datetime64(\\\"2018-01-10\\\")])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == 10\\n assert c.dtype == np.datetime64\\n assert c.is_descending == True\\n\\n # increase resolution\\n c = UniformCoordinates1d(\\\"2018-01-01\\\", \\\"2018-01-10\\\", size=21)\\n assert c.start == np.datetime64(\\\"2018-01-01\\\")\\n assert c.stop == np.datetime64(\\\"2018-01-10\\\")\\n assert_equal(c.bounds, [np.datetime64(\\\"2018-01-01\\\"), np.datetime64(\\\"2018-01-10\\\")])\\n assert c.coordinates[c.argbounds[0]] == c.bounds[0]\\n assert c.coordinates[c.argbounds[1]] == c.bounds[1]\\n assert c.size == 21\\n assert c.dtype == np.datetime64\\n assert c.is_descending == False\\n\\n def test_datetime_size_invalid(self):\\n with pytest.raises(ValueError, match=\\\"Cannot divide timedelta\\\"):\\n c = UniformCoordinates1d(\\\"2018-01-01\\\", \\\"2018-01-10\\\", size=20)\\n\\n def test_numerical_size_floating_point_error(self):\\n c = UniformCoordinates1d(50.619, 50.62795, size=30)\\n assert c.size == 30\\n\\n def test_numerical_singleton(self):\\n # positive step\\n c = UniformCoordinates1d(1, 1, 10)\\n a = np.array([1], dtype=float)\\n assert c.start == 1\\n assert c.stop == 1\\n assert c.step == 10\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, [1, 1])\\n assert c.size == 1\\n assert c.dtype == float\\n assert c.is_monotonic == True\\n assert c.is_descending == None\\n assert c.is_uniform == True\\n\\n # negative step\\n c = UniformCoordinates1d(1, 1, -10)\\n a = np.array([1], dtype=float)\\n assert c.start == 1\\n assert c.stop == 1\\n assert c.step == -10\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, [1, 1])\\n assert c.size == 1\\n assert c.dtype == float\\n assert c.is_monotonic == True\\n assert c.is_descending == None\\n assert c.is_uniform == True\\n\\n def test_datetime_singleton(self):\\n # positive step\\n c = UniformCoordinates1d(\\\"2018-01-01\\\", \\\"2018-01-01\\\", \\\"1,D\\\")\\n a = np.array([\\\"2018-01-01\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2018-01-01\\\")\\n assert c.stop == np.datetime64(\\\"2018-01-01\\\")\\n assert c.step == np.timedelta64(1, \\\"D\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[0, -1]])\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == None\\n assert c.is_uniform == True\\n\\n # negative step\\n c = UniformCoordinates1d(\\\"2018-01-01\\\", \\\"2018-01-01\\\", \\\"-1,D\\\")\\n a = np.array([\\\"2018-01-01\\\"]).astype(np.datetime64)\\n assert c.start == np.datetime64(\\\"2018-01-01\\\")\\n assert c.stop == np.datetime64(\\\"2018-01-01\\\")\\n assert c.step == np.timedelta64(-1, \\\"D\\\")\\n assert_equal(c.coordinates, a)\\n assert_equal(c.bounds, a[[-1, 0]])\\n assert c.size == a.size\\n assert c.dtype == np.datetime64\\n assert c.is_monotonic == True\\n assert c.is_descending == None\\n assert c.is_uniform == True\\n\\n def test_from_tuple(self):\\n # numerical, step\\n c = UniformCoordinates1d.from_tuple((0, 10, 0.5))\\n assert c.start == 0.0\\n assert c.stop == 10.0\\n assert c.step == 0.5\\n\\n # numerical, size\\n c = UniformCoordinates1d.from_tuple((0, 10, 20))\\n assert c.start == 0.0\\n assert c.stop == 10.0\\n assert c.size == 20\\n\\n # datetime, step\\n c = UniformCoordinates1d.from_tuple((\\\"2018-01-01\\\", \\\"2018-01-04\\\", \\\"1,D\\\"))\\n assert c.start == np.datetime64(\\\"2018-01-01\\\")\\n assert c.stop == np.datetime64(\\\"2018-01-04\\\")\\n assert c.step == np.timedelta64(1, \\\"D\\\")\\n\\n # invalid\\n with pytest.raises(ValueError, match=\\\"UniformCoordinates1d.from_tuple expects a tuple\\\"):\\n UniformCoordinates1d.from_tuple((0, 10))\\n\\n with pytest.raises(ValueError, match=\\\"UniformCoordinates1d.from_tuple expects a tuple\\\"):\\n UniformCoordinates1d.from_tuple(np.array([0, 10, 0.5]))\\n\\n def test_copy(self):\\n c = UniformCoordinates1d(0, 10, 50, name=\\\"lat\\\")\\n c2 = c.copy()\\n assert c is not c2\\n assert c == c2\\n\\n def test_invalid_init(self):\\n with pytest.raises(ValueError):\\n UniformCoordinates1d(0, 0, 0)\\n\\n with pytest.raises(ValueError):\\n UniformCoordinates1d(0, 50, 0)\\n\\n with pytest.raises(ValueError):\\n UniformCoordinates1d(0, 50, -10)\\n\\n with pytest.raises(ValueError):\\n UniformCoordinates1d(50, 0, 10)\\n\\n with pytest.raises(TypeError):\\n UniformCoordinates1d(0, \\\"2018-01-01\\\", 10)\\n\\n with pytest.raises(TypeError):\\n UniformCoordinates1d(\\\"2018-01-01\\\", 50, 10)\\n\\n with pytest.raises(TypeError):\\n UniformCoordinates1d(\\\"2018-01-01\\\", \\\"2018-01-02\\\", 10)\\n\\n with pytest.raises(TypeError):\\n UniformCoordinates1d(0.0, \\\"2018-01-01\\\", \\\"1,D\\\")\\n\\n with pytest.raises(TypeError):\\n UniformCoordinates1d(\\\"2018-01-01\\\", 50, \\\"1,D\\\")\\n\\n with pytest.raises(TypeError):\\n UniformCoordinates1d(0, 50, \\\"1,D\\\")\\n\\n with pytest.raises(ValueError):\\n UniformCoordinates1d(\\\"a\\\", 50, 10)\\n\\n with pytest.raises(ValueError):\\n UniformCoordinates1d(0, \\\"b\\\", 10)\\n\\n with pytest.raises(ValueError):\\n UniformCoordinates1d(0, 50, \\\"a\\\")\\n\\n with pytest.raises(TypeError):\\n UniformCoordinates1d()\\n\\n with pytest.raises(TypeError):\\n UniformCoordinates1d(0)\\n\\n with pytest.raises(TypeError):\\n UniformCoordinates1d(0, 50)\\n\\n with pytest.raises(TypeError):\\n UniformCoordinates1d(0, 50, 10, size=6)\\n\\n with pytest.raises(TypeError):\\n UniformCoordinates1d(0, 10, size=20.0)\\n\\n with pytest.raises(TypeError):\\n UniformCoordinates1d(0, 10, size=\\\"string\\\")\\n\\n with pytest.raises(TypeError):\\n UniformCoordinates1d(\\\"2018-01-10\\\", \\\"2018-01-01\\\", size=\\\"1,D\\\")\\n\\n\\nclass TestUniformCoordinatesEq(object):\\n def test_equal(self):\\n c1 = UniformCoordinates1d(0, 50, 10)\\n c2 = UniformCoordinates1d(0, 50, 10)\\n c3 = UniformCoordinates1d(0, 50, 10)\\n c4 = UniformCoordinates1d(5, 50, 10)\\n c5 = UniformCoordinates1d(0, 60, 10)\\n c6 = UniformCoordinates1d(0, 50, 5)\\n c7 = UniformCoordinates1d(50, 0, -10)\\n\\n assert c1 == c2\\n assert c1 == c3\\n assert c1 != c4\\n assert c1 != c5\\n assert c1 != c6\\n assert c1 != c7\\n\\n def test_equal_array_coordinates(self):\\n c1 = UniformCoordinates1d(0, 50, 10)\\n c2 = ArrayCoordinates1d([0, 10, 20, 30, 40, 50])\\n c3 = ArrayCoordinates1d([10, 20, 30, 40, 50, 60])\\n\\n assert c1 == c2\\n assert c1 != c3\\n\\n\\nclass TestUniformCoordinatesSerialization(object):\\n def test_definition(self):\\n # numerical\\n c = UniformCoordinates1d(0, 50, 10, name=\\\"lat\\\")\\n d = c.definition\\n assert isinstance(d, dict)\\n assert set(d.keys()) == set([\\\"start\\\", \\\"stop\\\", \\\"step\\\", \\\"name\\\"])\\n json.dumps(d, cls=podpac.core.utils.JSONEncoder) # test serializable\\n c2 = UniformCoordinates1d.from_definition(d) # test from_definition\\n assert c2 == c\\n\\n # datetimes\\n c = UniformCoordinates1d(\\\"2018-01-01\\\", \\\"2018-01-03\\\", \\\"1,D\\\")\\n d = c.definition\\n assert isinstance(d, dict)\\n assert set(d.keys()) == set([\\\"start\\\", \\\"stop\\\", \\\"step\\\"])\\n json.dumps(d, cls=podpac.core.utils.JSONEncoder) # test serializable\\n c2 = UniformCoordinates1d.from_definition(d) # test from_definition\\n assert c2 == c\\n\\n def test_invalid_definition(self):\\n # incorrect definition\\n d = {\\\"stop\\\": 50}\\n with pytest.raises(ValueError, match='UniformCoordinates1d definition requires \\\"start\\\"'):\\n UniformCoordinates1d.from_definition(d)\\n\\n d = {\\\"start\\\": 0}\\n with pytest.raises(ValueError, match='UniformCoordinates1d definition requires \\\"stop\\\"'):\\n UniformCoordinates1d.from_definition(d)\\n\\n def test_from_definition_size(self):\\n # numerical\\n d = {\\\"start\\\": 0, \\\"stop\\\": 50, \\\"size\\\": 6}\\n c = UniformCoordinates1d.from_definition(d)\\n assert_equal(c.coordinates, [0, 10, 20, 30, 40, 50])\\n\\n # datetime, size\\n d = {\\\"start\\\": \\\"2018-01-01\\\", \\\"stop\\\": \\\"2018-01-03\\\", \\\"size\\\": 3}\\n c = UniformCoordinates1d.from_definition(d)\\n assert_equal(c.coordinates, np.array([\\\"2018-01-01\\\", \\\"2018-01-02\\\", \\\"2018-01-03\\\"]).astype(np.datetime64))\\n\\n\\nclass TestUniformCoordinatesIndexing(object):\\n def test_len(self):\\n c = UniformCoordinates1d(0, 50, 10)\\n assert len(c) == 6\\n\\n def test_index(self):\\n c = UniformCoordinates1d(0, 50, 10, name=\\\"lat\\\")\\n\\n # int\\n c2 = c[2]\\n assert isinstance(c2, Coordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [20])\\n\\n c2 = c[-2]\\n assert isinstance(c2, Coordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [40])\\n\\n # slice\\n c2 = c[:2]\\n assert isinstance(c2, UniformCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert c2.start == 0\\n assert c2.stop == 10\\n assert c2.step == 10\\n\\n c2 = c[2:]\\n assert isinstance(c2, UniformCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert c2.start == 20\\n assert c2.stop == 50\\n assert c2.step == 10\\n\\n c2 = c[::2]\\n assert isinstance(c2, UniformCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert c2.start == 0\\n assert c2.stop == 50\\n assert c2.step == 20\\n\\n c2 = c[1:-1]\\n assert isinstance(c2, UniformCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert c2.start == 10\\n assert c2.stop == 40\\n assert c2.step == 10\\n\\n c2 = c[-3:5]\\n assert isinstance(c2, UniformCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert c2.start == 30\\n assert c2.stop == 40\\n assert c2.step == 10\\n\\n c2 = c[::-1]\\n assert isinstance(c2, UniformCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert c2.start == 50\\n assert c2.stop == 0\\n assert c2.step == -10\\n\\n # index array\\n c2 = c[[0, 1, 3]]\\n assert isinstance(c2, ArrayCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [0, 10, 30])\\n\\n c2 = c[[3, 1, 0]]\\n assert isinstance(c2, ArrayCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [30, 10, 0])\\n\\n c2 = c[[0, 3, 1]]\\n assert isinstance(c2, ArrayCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [0, 30, 10])\\n\\n c2 = c[[]]\\n assert isinstance(c2, ArrayCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [])\\n\\n c2 = c[0:0]\\n assert isinstance(c2, ArrayCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [])\\n\\n c2 = c[[]]\\n assert isinstance(c2, ArrayCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [])\\n\\n # boolean array\\n c2 = c[[True, True, True, False, True, False]]\\n assert isinstance(c2, ArrayCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [0, 10, 20, 40])\\n\\n # invalid\\n with pytest.raises(IndexError):\\n c[0.3]\\n\\n with pytest.raises(IndexError):\\n c[10]\\n\\n def test_index_descending(self):\\n c = UniformCoordinates1d(50, 0, -10, name=\\\"lat\\\")\\n\\n # int\\n c2 = c[2]\\n assert isinstance(c2, Coordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [30])\\n\\n c2 = c[-2]\\n assert isinstance(c2, Coordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [10])\\n\\n # slice\\n c2 = c[:2]\\n assert isinstance(c2, UniformCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert c2.start == 50\\n assert c2.stop == 40\\n assert c2.step == -10\\n\\n c2 = c[2:]\\n assert isinstance(c2, UniformCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert c2.start == 30\\n assert c2.stop == 0\\n assert c2.step == -10\\n\\n c2 = c[::2]\\n assert isinstance(c2, UniformCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert c2.start == 50\\n assert c2.stop == 0\\n assert c2.step == -20\\n\\n c2 = c[1:-1]\\n assert isinstance(c2, UniformCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert c2.start == 40\\n assert c2.stop == 10\\n assert c2.step == -10\\n\\n c2 = c[-3:5]\\n assert isinstance(c2, UniformCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert c2.start == 20\\n assert c2.stop == 10\\n assert c2.step == -10\\n\\n c2 = c[::-1]\\n assert isinstance(c2, UniformCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert c2.start == 0\\n assert c2.stop == 50\\n assert c2.step == 10\\n\\n # index array\\n c2 = c[[0, 1, 3]]\\n assert isinstance(c2, ArrayCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [50, 40, 20])\\n\\n c2 = c[[3, 1, 0]]\\n assert isinstance(c2, ArrayCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [20, 40, 50])\\n\\n c2 = c[[0, 3, 1]]\\n assert isinstance(c2, ArrayCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [50, 20, 40])\\n\\n # boolean array\\n c2 = c[[True, True, True, False, True, False]]\\n assert isinstance(c2, ArrayCoordinates1d)\\n assert c2.name == c.name\\n assert c2.properties == c.properties\\n assert_equal(c2.coordinates, [50, 40, 30, 10])\\n\\n def test_in(self):\\n c = UniformCoordinates1d(0, 50, 10, name=\\\"lat\\\")\\n assert 0 in c\\n assert 10 in c\\n assert 50 in c\\n assert -10 not in c\\n assert 60 not in c\\n assert 5 not in c\\n assert np.datetime64(\\\"2018\\\") not in c\\n assert \\\"a\\\" not in c\\n\\n c = UniformCoordinates1d(50, 0, -10, name=\\\"lat\\\")\\n assert 0 in c\\n assert 10 in c\\n assert 50 in c\\n assert -10 not in c\\n assert 60 not in c\\n assert 5 not in c\\n assert np.datetime64(\\\"2018\\\") not in c\\n assert \\\"a\\\" not in c\\n\\n c = UniformCoordinates1d(\\\"2020-01-01\\\", \\\"2020-01-09\\\", \\\"2,D\\\", name=\\\"time\\\")\\n assert np.datetime64(\\\"2020-01-01\\\") in c\\n assert np.datetime64(\\\"2020-01-03\\\") in c\\n assert np.datetime64(\\\"2020-01-09\\\") in c\\n assert np.datetime64(\\\"2020-01-11\\\") not in c\\n assert np.datetime64(\\\"2020-01-02\\\") not in c\\n assert 10 not in c\\n assert \\\"a\\\" not in c\\n\\n\\nclass TestArrayCoordinatesAreaBounds(object):\\n def test_get_area_bounds_numerical(self):\\n c = UniformCoordinates1d(0, 50, 10)\\n\\n # point\\n area_bounds = c.get_area_bounds(None)\\n assert_equal(area_bounds, [0.0, 50.0])\\n\\n # uniform\\n area_bounds = c.get_area_bounds(0.5)\\n assert_equal(area_bounds, [-0.5, 50.5])\\n\\n # segment\\n area_bounds = c.get_area_bounds([-0.2, 0.7])\\n assert_equal(area_bounds, [-0.2, 50.7])\\n\\n # polygon (i.e. there would be corresponding offets for another dimension)\\n area_bounds = c.get_area_bounds([-0.2, -0.5, 0.7, 0.5])\\n assert_equal(area_bounds, [-0.5, 50.7])\\n\\n def test_get_area_bounds_datetime(self):\\n c = UniformCoordinates1d(\\\"2018-01-01\\\", \\\"2018-01-04\\\", \\\"1,D\\\")\\n\\n # point\\n area_bounds = c.get_area_bounds(None)\\n assert_equal(area_bounds, make_coord_array([\\\"2018-01-01\\\", \\\"2018-01-04\\\"]))\\n\\n # uniform\\n area_bounds = c.get_area_bounds(\\\"1,D\\\")\\n assert_equal(area_bounds, make_coord_array([\\\"2017-12-31\\\", \\\"2018-01-05\\\"]))\\n\\n area_bounds = c.get_area_bounds(\\\"1,M\\\")\\n assert_equal(area_bounds, make_coord_array([\\\"2017-12-01\\\", \\\"2018-02-04\\\"]))\\n\\n area_bounds = c.get_area_bounds(\\\"1,Y\\\")\\n assert_equal(area_bounds, make_coord_array([\\\"2017-01-01\\\", \\\"2019-01-04\\\"]))\\n\\n # segment\\n area_bounds = c.get_area_bounds([\\\"0,h\\\", \\\"12,h\\\"])\\n assert_equal(area_bounds, make_coord_array([\\\"2018-01-01 00:00\\\", \\\"2018-01-04 12:00\\\"]))\\n\\n\\nclass TestUniformCoordinatesSelection(object):\\n def test_select_all_shortcut(self):\\n c = UniformCoordinates1d(20.0, 70.0, 10.0)\\n\\n s = c.select([0, 100])\\n assert s.start == 20.0\\n assert s.stop == 70.0\\n assert s.step == 10.0\\n\\n s, I = c.select([0, 100], return_index=True)\\n assert s.start == 20.0\\n assert s.stop == 70.0\\n assert s.step == 10.0\\n assert_equal(c[I], s)\\n\\n def test_select_none_shortcut(self):\\n c = UniformCoordinates1d(20.0, 70.0, 10.0)\\n\\n # above\\n s = c.select([100, 200])\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n\\n s, I = c.select([100, 200], return_index=True)\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n assert c[I] == s\\n\\n # below\\n s = c.select([0, 5])\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n\\n s, I = c.select([0, 5], return_index=True)\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n assert c[I] == s\\n\\n def test_select_ascending(self):\\n c = UniformCoordinates1d(20.0, 70.0, 10.0)\\n\\n # inner\\n s = c.select([35.0, 55.0])\\n assert s.start == 40.0\\n assert s.stop == 50.0\\n assert s.step == 10.0\\n\\n s, I = c.select([35.0, 55.0], return_index=True)\\n assert s.start == 40.0\\n assert s.stop == 50.0\\n assert s.step == 10.0\\n assert c[I] == s\\n\\n # inner with aligned bounds\\n s = c.select([30.0, 60.0])\\n assert s.start == 30.0\\n assert s.stop == 60.0\\n assert s.step == 10.0\\n\\n s, I = c.select([30.0, 60.0], return_index=True)\\n assert s.start == 30.0\\n assert s.stop == 60.0\\n assert s.step == 10.0\\n assert c[I] == s\\n\\n # above\\n s = c.select([45, 100])\\n assert s.start == 50.0\\n assert s.stop == 70.0\\n assert s.step == 10.0\\n\\n s, I = c.select([45, 100], return_index=True)\\n assert s.start == 50.0\\n assert s.stop == 70.0\\n assert s.step == 10.0\\n assert c[I] == s\\n\\n # below\\n s = c.select([5, 55])\\n assert s.start == 20.0\\n assert s.stop == 50.0\\n assert s.step == 10.0\\n\\n s, I = c.select([5, 55], return_index=True)\\n assert s.start == 20.0\\n assert s.stop == 50.0\\n assert s.step == 10.0\\n assert c[I] == s\\n\\n # between coordinates\\n s = c.select([52, 55])\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n\\n s, I = c.select([52, 55], return_index=True)\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n assert_equal(c.coordinates[I], [])\\n\\n # backwards bounds\\n s = c.select([70, 30])\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n\\n s, I = c.select([70, 30], return_index=True)\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n assert_equal(c.coordinates[I], [])\\n\\n def test_select_descending(self):\\n c = UniformCoordinates1d(70.0, 20.0, -10.0)\\n\\n # inner\\n s = c.select([35.0, 55.0])\\n assert s.start == 50.0\\n assert s.stop == 40.0\\n assert s.step == -10.0\\n\\n s, I = c.select([35.0, 55.0], return_index=True)\\n assert s.start == 50.0\\n assert s.stop == 40.0\\n assert s.step == -10.0\\n assert c[I] == s\\n\\n # inner with aligned bounds\\n s = c.select([30.0, 60.0])\\n assert s.start == 60.0\\n assert s.stop == 30.0\\n assert s.step == -10.0\\n\\n s, I = c.select([30.0, 60.0], return_index=True)\\n assert s.start == 60.0\\n assert s.stop == 30.0\\n assert s.step == -10.0\\n assert c[I] == s\\n\\n # above\\n s = c.select([45, 100])\\n assert s.start == 70.0\\n assert s.stop == 50.0\\n assert s.step == -10.0\\n\\n s, I = c.select([45, 100], return_index=True)\\n assert s.start == 70.0\\n assert s.stop == 50.0\\n assert s.step == -10.0\\n assert c[I] == s\\n\\n # below\\n s = c.select([5, 55])\\n assert s.start == 50.0\\n assert s.stop == 20.0\\n assert s.step == -10.0\\n\\n s, I = c.select([5, 55], return_index=True)\\n assert s.start == 50.0\\n assert s.stop == 20.0\\n assert s.step == -10.0\\n assert c[I] == s\\n\\n # between coordinates\\n s = c.select([52, 55])\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n\\n s, I = c.select([52, 55], return_index=True)\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n assert_equal(c.coordinates[I], [])\\n\\n # backwards bounds\\n s = c.select([70, 30])\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n\\n s, I = c.select([70, 30], return_index=True)\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n assert_equal(c.coordinates[I], [])\\n\\n def test_select_outer(self):\\n c = UniformCoordinates1d(20.0, 70.0, 10.0)\\n\\n # inner\\n s = c.select([35.0, 55.0], outer=True)\\n assert s.start == 30.0\\n assert s.stop == 60.0\\n assert s.step == 10.0\\n\\n s, I = c.select([35.0, 55.0], outer=True, return_index=True)\\n assert s.start == 30.0\\n assert s.stop == 60.0\\n assert s.step == 10.0\\n assert c[I] == s\\n\\n # inner with aligned bounds\\n s = c.select([30.0, 60.0], outer=True)\\n assert s.start == 30.0\\n assert s.stop == 60.0\\n assert s.step == 10.0\\n\\n s, I = c.select([30.0, 60.0], outer=True, return_index=True)\\n assert s.start == 30.0\\n assert s.stop == 60.0\\n assert s.step == 10.0\\n assert c[I] == s\\n\\n # above\\n s = c.select([45, 100], outer=True)\\n assert s.start == 40.0\\n assert s.stop == 70.0\\n assert s.step == 10.0\\n\\n s, I = c.select([45, 100], outer=True, return_index=True)\\n assert s.start == 40.0\\n assert s.stop == 70.0\\n assert s.step == 10.0\\n assert c[I] == s\\n\\n # below\\n s = c.select([5, 55], outer=True)\\n assert s.start == 20.0\\n assert s.stop == 60.0\\n assert s.step == 10.0\\n\\n s, I = c.select([5, 55], outer=True, return_index=True)\\n assert s.start == 20.0\\n assert s.stop == 60.0\\n assert s.step == 10.0\\n assert c[I] == s\\n\\n # between coordinates\\n s = c.select([52, 55], outer=True)\\n assert s.start == 50.0\\n assert s.stop == 60.0\\n assert s.step == 10.0\\n\\n s, I = c.select([52, 55], outer=True, return_index=True)\\n assert s.start == 50.0\\n assert s.stop == 60.0\\n assert s.step == 10.0\\n assert c[I] == s\\n\\n # backwards bounds\\n s = c.select([70, 30], outer=True)\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n\\n s, I = c.select([70, 30], outer=True, return_index=True)\\n assert isinstance(s, ArrayCoordinates1d)\\n assert_equal(s.coordinates, [])\\n assert_equal(c.coordinates[I], [])\\n\\n def test_select_time_variable_precision(self):\\n c = UniformCoordinates1d(\\\"2012-05-19\\\", \\\"2012-05-20\\\", \\\"1,D\\\", name=\\\"time\\\")\\n c2 = UniformCoordinates1d(\\\"2012-05-20T12:00:00\\\", \\\"2012-05-21T12:00:00\\\", \\\"1,D\\\", name=\\\"time\\\")\\n s = c.select(c2.bounds, outer=True)\\n s1 = c.select(c2.bounds, outer=False)\\n s2 = c2.select(c.bounds)\\n assert s.size == 1\\n assert s1.size == 0\\n assert s2.size == 1\\n\\n\\nclass TestUniformCoordinatesMethods(object):\\n def test_unique(self):\\n c = UniformCoordinates1d(1, 5, step=1)\\n c2 = c.unique()\\n assert c2 == c and c2 is not c\\n\\n c2, I = c.unique(return_index=True)\\n assert c2 == c and c2 is not c\\n assert c2 == c[I]\\n\\n def test_simplify(self):\\n c = UniformCoordinates1d(1, 5, step=1)\\n c2 = c.simplify()\\n assert c2 == c and c2 is not c\\n\\n # reversed, step -2\\n c = UniformCoordinates1d(4, 0, step=-2)\\n c2 = c.simplify()\\n assert c2 == c and c2 is not c\\n\\n # time, convert to UniformCoordinates\\n c = UniformCoordinates1d(\\\"2020-01-01\\\", \\\"2020-01-05\\\", step=\\\"1,D\\\")\\n c2 = c.simplify()\\n assert c2 == c and c2 is not c\\n\\n # time, reverse -2,h\\n c = UniformCoordinates1d(\\\"2020-01-01T12:00\\\", \\\"2020-01-01T08:00\\\", step=\\\"-3,h\\\")\\n c2 = c.simplify()\\n assert c2 == c and c2 is not c\\n\\n def test_flatten(self):\\n c = UniformCoordinates1d(1, 5, step=1)\\n c2 = c.flatten()\\n assert c2 == c and c2 is not c\\n\\n def test_reshape(self):\\n c = UniformCoordinates1d(1, 6, step=1, name=\\\"lat\\\")\\n c2 = c.reshape((2, 3))\\n assert c2 == ArrayCoordinates1d(c.coordinates.reshape((2, 3)), name=\\\"lat\\\")\\n\\n def test_issubset(self):\\n c1 = UniformCoordinates1d(2, 1, step=-1)\\n c2 = UniformCoordinates1d(1, 3, step=1)\\n c3 = UniformCoordinates1d(0, 2, step=1)\\n c4 = UniformCoordinates1d(1, 4, step=0.5)\\n c5 = UniformCoordinates1d(1.5, 2.5, step=0.5)\\n c6 = UniformCoordinates1d(1.4, 2.4, step=0.5)\\n c7 = UniformCoordinates1d(1.4, 2.4, step=10)\\n\\n # self\\n assert c1.issubset(c1)\\n\\n # subsets\\n assert c1.issubset(c2)\\n assert c1.issubset(c3)\\n assert c1.issubset(c4)\\n assert c5.issubset(c4)\\n assert c7.issubset(c6)\\n\\n # not subsets\\n assert not c2.issubset(c1)\\n assert not c2.issubset(c3)\\n assert not c3.issubset(c1)\\n assert not c3.issubset(c2)\\n assert not c4.issubset(c1)\\n assert not c6.issubset(c4)\\n\\n def test_issubset_datetime(self):\\n c1 = UniformCoordinates1d(\\\"2020-01-01\\\", \\\"2020-01-03\\\", \\\"1,D\\\")\\n c2 = UniformCoordinates1d(\\\"2020-01-01\\\", \\\"2020-01-03\\\", \\\"2,D\\\")\\n c3 = UniformCoordinates1d(\\\"2020-01-01\\\", \\\"2020-01-05\\\", \\\"1,D\\\")\\n c4 = UniformCoordinates1d(\\\"2020-01-05\\\", \\\"2020-01-01\\\", \\\"-2,D\\\")\\n\\n # self\\n assert c1.issubset(c1)\\n\\n # same resolution\\n assert c1.issubset(c3)\\n assert c2.issubset(c1)\\n assert c2.issubset(c4)\\n assert not c1.issubset(c2)\\n assert not c1.issubset(c4)\\n assert not c3.issubset(c1)\\n\\n # different resolution\\n c5 = UniformCoordinates1d(\\\"2020-01-01T00:00\\\", \\\"2020-01-03T00:00\\\", \\\"1,D\\\")\\n c6 = UniformCoordinates1d(\\\"2020-01-01T00:00\\\", \\\"2020-01-03T00:00\\\", \\\"6,h\\\")\\n assert c1.issubset(c5)\\n assert c5.issubset(c1)\\n assert c1.issubset(c6)\\n assert not c6.issubset(c1)\\n\\n def test_issubset_dtype(self):\\n c1 = UniformCoordinates1d(0, 10, step=1)\\n c2 = UniformCoordinates1d(\\\"2018\\\", \\\"2020\\\", step=\\\"1,Y\\\")\\n assert not c1.issubset(c2)\\n assert not c2.issubset(c1)\\n\\n def test_issubset_array_coordinates(self):\\n u = UniformCoordinates1d(start=1, stop=3, step=1)\\n a1 = ArrayCoordinates1d([1, 3, 2])\\n a2 = ArrayCoordinates1d([1, 2, 3])\\n a3 = ArrayCoordinates1d([1, 3, 4])\\n e = ArrayCoordinates1d([])\\n\\n # self\\n assert u.issubset(a1)\\n assert u.issubset(a2)\\n assert not u.issubset(a3)\\n assert not u.issubset(e)\\n\\n def test_issubset_coordinates(self):\\n u = UniformCoordinates1d(1, 3, 1, name=\\\"lat\\\")\\n c1 = Coordinates([[1, 2, 3], [10, 20, 30]], dims=[\\\"lat\\\", \\\"lon\\\"])\\n c2 = Coordinates([[1, 2, 4], [10, 20, 30]], dims=[\\\"lat\\\", \\\"lon\\\"])\\n c3 = Coordinates([[10, 20, 30]], dims=[\\\"alt\\\"])\\n\\n assert u.issubset(c1)\\n assert not u.issubset(c2)\\n assert not u.issubset(c3)\\n\",\n \"from __future__ import division, unicode_literals, print_function, absolute_import\\n\\nimport os\\nimport json\\nimport warnings\\nimport tempfile\\nfrom collections import OrderedDict\\nfrom copy import deepcopy\\n\\ntry:\\n import urllib.parse as urllib\\nexcept: # Python 2.7\\n import urlparse as urllib\\n\\nimport six\\nimport pytest\\nimport numpy as np\\nimport xarray as xr\\nfrom pint.errors import DimensionalityError, UndefinedUnitError\\nfrom pint import UnitRegistry\\n\\nureg = UnitRegistry()\\nimport traitlets as tl\\n\\nimport podpac\\nfrom podpac.core import common_test_utils as ctu\\nfrom podpac.core.utils import ArrayTrait, NodeTrait\\nfrom podpac.core.units import UnitsDataArray\\nfrom podpac.core.style import Style\\nfrom podpac.core.cache import CacheCtrl, RamCacheStore, DiskCacheStore\\nfrom podpac.core.node import Node, NodeException, NodeDefinitionError\\nfrom podpac.core.node import NoCacheMixin, DiskCacheMixin\\n\\n\\nclass TestNode(object):\\n def test_style(self):\\n node = Node()\\n assert isinstance(node.style, Style)\\n\\n def test_units(self):\\n node = Node(units=\\\"meters\\\")\\n\\n with pytest.raises(UndefinedUnitError):\\n Node(units=\\\"abc\\\")\\n\\n def test_outputs(self):\\n node = Node()\\n assert node.outputs is None\\n\\n node = Node(outputs=[\\\"a\\\", \\\"b\\\"])\\n assert node.outputs == [\\\"a\\\", \\\"b\\\"]\\n\\n def test_output(self):\\n node = Node()\\n assert node.output is None\\n\\n node = Node(outputs=[\\\"a\\\", \\\"b\\\"])\\n assert node.output is None\\n\\n node = Node(outputs=[\\\"a\\\", \\\"b\\\"], output=\\\"b\\\")\\n assert node.output == \\\"b\\\"\\n\\n # must be one of the outputs\\n with pytest.raises(ValueError, match=\\\"Invalid output\\\"):\\n node = Node(outputs=[\\\"a\\\", \\\"b\\\"], output=\\\"other\\\")\\n\\n # only valid for multiple-output nodes\\n with pytest.raises(TypeError, match=\\\"Invalid output\\\"):\\n node = Node(output=\\\"other\\\")\\n\\n def test_cache_output(self):\\n with podpac.settings:\\n podpac.settings[\\\"CACHE_NODE_OUTPUT_DEFAULT\\\"] = False\\n node = Node()\\n assert not node.cache_output\\n\\n podpac.settings[\\\"CACHE_NODE_OUTPUT_DEFAULT\\\"] = True\\n node = Node()\\n assert node.cache_output\\n\\n def test_cache_ctrl(self):\\n # settings\\n with podpac.settings:\\n podpac.settings[\\\"DEFAULT_CACHE\\\"] = [\\\"ram\\\"]\\n node = Node()\\n assert node.cache_ctrl is not None\\n assert len(node.cache_ctrl._cache_stores) == 1\\n assert isinstance(node.cache_ctrl._cache_stores[0], RamCacheStore)\\n\\n podpac.settings[\\\"DEFAULT_CACHE\\\"] = [\\\"ram\\\", \\\"disk\\\"]\\n node = Node()\\n assert node.cache_ctrl is not None\\n assert len(node.cache_ctrl._cache_stores) == 2\\n assert isinstance(node.cache_ctrl._cache_stores[0], RamCacheStore)\\n assert isinstance(node.cache_ctrl._cache_stores[1], DiskCacheStore)\\n\\n # specify\\n node = Node(cache_ctrl=[\\\"ram\\\"])\\n assert node.cache_ctrl is not None\\n assert len(node.cache_ctrl._cache_stores) == 1\\n assert isinstance(node.cache_ctrl._cache_stores[0], RamCacheStore)\\n\\n node = Node(cache_ctrl=[\\\"ram\\\", \\\"disk\\\"])\\n assert node.cache_ctrl is not None\\n assert len(node.cache_ctrl._cache_stores) == 2\\n assert isinstance(node.cache_ctrl._cache_stores[0], RamCacheStore)\\n assert isinstance(node.cache_ctrl._cache_stores[1], DiskCacheStore)\\n\\n def test_tagged_attr_readonly(self):\\n class MyNode(Node):\\n my_attr = tl.Any().tag(attr=True)\\n\\n with podpac.settings:\\n podpac.settings[\\\"DEBUG\\\"] = False\\n node = MyNode()\\n assert node.traits()[\\\"my_attr\\\"].read_only\\n\\n podpac.settings[\\\"DEBUG\\\"] = True\\n node = MyNode()\\n assert not node.traits()[\\\"my_attr\\\"].read_only\\n\\n def test_trait_is_defined(self):\\n node = Node()\\n if tl.version_info[0] >= 5:\\n assert not node.trait_is_defined(\\\"units\\\")\\n else:\\n assert node.trait_is_defined(\\\"units\\\")\\n\\n def test_init(self):\\n class MyNode(Node):\\n init_run = False\\n\\n def init(self):\\n super(MyNode, self).init()\\n self.init_run = True\\n\\n node = MyNode()\\n assert node.init_run\\n\\n def test_attrs(self):\\n class MyNode(Node):\\n my_attr = tl.Any().tag(attr=True)\\n my_trait = tl.Any()\\n\\n n = MyNode()\\n assert \\\"my_attr\\\" in n.attrs\\n assert \\\"my_trait\\\" not in n.attrs\\n\\n def test_repr(self):\\n n = Node()\\n repr(n)\\n\\n n = Node(outputs=[\\\"a\\\", \\\"b\\\"])\\n repr(n)\\n assert \\\"outputs=\\\" in repr(n)\\n assert \\\"output=\\\" not in repr(n)\\n\\n n = Node(outputs=[\\\"a\\\", \\\"b\\\"], output=\\\"a\\\")\\n repr(n)\\n assert \\\"outputs=\\\" not in repr(n)\\n assert \\\"output=\\\" in repr(n)\\n\\n def test_str(self):\\n n = Node()\\n str(n)\\n\\n n = Node(outputs=[\\\"a\\\", \\\"b\\\"])\\n str(n)\\n assert \\\"outputs=\\\" in str(n)\\n assert \\\"output=\\\" not in str(n)\\n\\n n = Node(outputs=[\\\"a\\\", \\\"b\\\"], output=\\\"a\\\")\\n str(n)\\n assert \\\"outputs=\\\" not in str(n)\\n assert \\\"output=\\\" in str(n)\\n\\n def test_eval_group(self):\\n class MyNode(Node):\\n def eval(self, coordinates, output=None, selector=None):\\n return self.create_output_array(coordinates)\\n\\n c1 = podpac.Coordinates([[0, 1], [0, 1]], dims=[\\\"lat\\\", \\\"lon\\\"])\\n c2 = podpac.Coordinates([[10, 11], [10, 11, 12]], dims=[\\\"lat\\\", \\\"lon\\\"])\\n g = podpac.coordinates.GroupCoordinates([c1, c2])\\n\\n node = MyNode()\\n outputs = node.eval_group(g)\\n assert isinstance(outputs, list)\\n assert len(outputs) == 2\\n assert isinstance(outputs[0], UnitsDataArray)\\n assert isinstance(outputs[1], UnitsDataArray)\\n assert outputs[0].shape == (2, 2)\\n assert outputs[1].shape == (2, 3)\\n\\n # invalid\\n with pytest.raises(Exception):\\n node.eval_group(c1)\\n\\n with pytest.raises(Exception):\\n node.eval(g)\\n\\n def test_eval_not_implemented(self):\\n node = Node()\\n with pytest.raises(NotImplementedError):\\n node.eval(podpac.Coordinates([]))\\n\\n with pytest.raises(NotImplementedError):\\n node.eval(podpac.Coordinates([]), output=None)\\n\\n def test_find_coordinates_not_implemented(self):\\n node = Node()\\n with pytest.raises(NotImplementedError):\\n node.find_coordinates()\\n\\n def test_get_bounds(self):\\n class MyNode(Node):\\n def find_coordinates(self):\\n return [\\n podpac.Coordinates([[0, 1, 2], [0, 10, 20]], dims=[\\\"lat\\\", \\\"lon\\\"], crs=\\\"EPSG:2193\\\"),\\n podpac.Coordinates([[3, 4], [30, 40]], dims=[\\\"lat\\\", \\\"lon\\\"], crs=\\\"EPSG:2193\\\"),\\n ]\\n\\n node = MyNode()\\n\\n with podpac.settings:\\n podpac.settings[\\\"DEFAULT_CRS\\\"] = \\\"EPSG:4326\\\"\\n\\n # specify crs\\n bounds, crs = node.get_bounds(crs=\\\"EPSG:2193\\\")\\n assert bounds == {\\\"lat\\\": (0, 4), \\\"lon\\\": (0, 40)}\\n assert crs == \\\"EPSG:2193\\\"\\n\\n # default crs\\n bounds, crs = node.get_bounds()\\n assert bounds == {\\n \\\"lat\\\": (-75.81397534013118, -75.81362774074242),\\n \\\"lon\\\": (82.92787904584206, 82.9280189659297),\\n }\\n assert crs == \\\"EPSG:4326\\\"\\n\\n\\nclass TestCreateOutputArray(object):\\n def test_create_output_array_default(self):\\n c = podpac.Coordinates([podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=[\\\"lat_lon\\\", \\\"time\\\"])\\n node = Node()\\n\\n output = node.create_output_array(c)\\n assert isinstance(output, UnitsDataArray)\\n assert output.shape == c.shape\\n assert output.dtype == node.dtype\\n assert output.crs == c.crs\\n assert np.all(np.isnan(output))\\n\\n def test_create_output_array_data(self):\\n c = podpac.Coordinates([podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=[\\\"lat_lon\\\", \\\"time\\\"])\\n node = Node()\\n\\n output = node.create_output_array(c, data=0)\\n assert isinstance(output, UnitsDataArray)\\n assert output.shape == c.shape\\n assert output.dtype == node.dtype\\n assert output.crs == c.crs\\n assert np.all(output == 0.0)\\n\\n @pytest.mark.xfail(reason=\\\"not yet supported.\\\")\\n def test_create_output_array_dtype(self):\\n c = podpac.Coordinates([podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=[\\\"lat_lon\\\", \\\"time\\\"])\\n node = Node(dtype=bool)\\n\\n output = node.create_output_array(c, data=0)\\n assert isinstance(output, UnitsDataArray)\\n assert output.shape == c.shape\\n assert output.dtype == node.dtype\\n assert output.crs == c.crs\\n assert np.all(~output)\\n\\n def test_create_output_array_units(self):\\n c = podpac.Coordinates([podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=[\\\"lat_lon\\\", \\\"time\\\"])\\n node = Node(units=\\\"meters\\\")\\n\\n output = node.create_output_array(c)\\n assert isinstance(output, UnitsDataArray)\\n\\n from podpac.core.units import ureg as _ureg\\n\\n assert output.units == _ureg.meters\\n\\n def test_create_output_array_crs(self):\\n crs = \\\"+proj=merc +lat_ts=56.5 +ellps=GRS80\\\"\\n c = podpac.Coordinates([podpac.clinspace((0, 0), (1, 1), 10), [0, 1, 2]], dims=[\\\"lat_lon\\\", \\\"time\\\"], crs=crs)\\n node = Node()\\n\\n output = node.create_output_array(c)\\n assert output.crs == crs\\n\\n\\nclass TestNodeEval(object):\\n def test_extract_output(self):\\n coords = podpac.Coordinates([[0, 1, 2, 3], [0, 1]], dims=[\\\"lat\\\", \\\"lon\\\"])\\n\\n class MyNode1(Node):\\n outputs = [\\\"a\\\", \\\"b\\\", \\\"c\\\"]\\n\\n def _eval(self, coordinates, output=None, selector=None):\\n return self.create_output_array(coordinates)\\n\\n # don't extract when no output field is requested\\n node = MyNode1()\\n out = node.eval(coords)\\n assert out.shape == (4, 2, 3)\\n\\n # do extract when an output field is requested\\n node = MyNode1(output=\\\"b\\\")\\n out = node.eval(coords)\\n assert out.shape == (4, 2)\\n\\n # should still work if the node has already extracted it\\n class MyNode2(Node):\\n outputs = [\\\"a\\\", \\\"b\\\", \\\"c\\\"]\\n\\n def _eval(self, coordinates, output=None, selector=None):\\n out = self.create_output_array(coordinates)\\n return out.sel(output=self.output)\\n\\n node = MyNode2(output=\\\"b\\\")\\n out = node.eval(coords)\\n assert out.shape == (4, 2)\\n\\n def test_evaluate_transpose(self):\\n class MyNode(Node):\\n def _eval(self, coordinates, output=None, selector=None):\\n coords = coordinates.transpose(\\\"lat\\\", \\\"lon\\\")\\n data = np.arange(coords.size).reshape(coords.shape)\\n a = self.create_output_array(coords, data=data)\\n if output is None:\\n output = a\\n else:\\n output[:] = a.transpose(*output.dims)\\n return output\\n\\n coords = podpac.Coordinates([[0, 1, 2, 3], [0, 1]], dims=[\\\"lat\\\", \\\"lon\\\"])\\n\\n node = MyNode()\\n o1 = node.eval(coords)\\n o2 = node.eval(coords.transpose(\\\"lon\\\", \\\"lat\\\"))\\n\\n # returned output should match the requested coordinates and data should be transposed\\n assert o1.dims == (\\\"lat\\\", \\\"lon\\\")\\n assert o2.dims == (\\\"lon\\\", \\\"lat\\\")\\n np.testing.assert_array_equal(o2.transpose(\\\"lat\\\", \\\"lon\\\").data, o1.data)\\n\\n # with transposed output\\n o3 = node.create_output_array(coords.transpose(\\\"lon\\\", \\\"lat\\\"))\\n o4 = node.eval(coords, output=o3)\\n\\n assert o3.dims == (\\\"lon\\\", \\\"lat\\\") # stay the same\\n assert o4.dims == (\\\"lat\\\", \\\"lon\\\") # match requested coordinates\\n np.testing.assert_equal(o3.transpose(\\\"lat\\\", \\\"lon\\\").data, o4.data)\\n\\n def test_eval_get_cache(self):\\n podpac.settings[\\\"RAM_CACHE_ENABLED\\\"] = True\\n\\n class MyNode(Node):\\n def _eval(self, coordinates, output=None, selector=None):\\n coords = coordinates.transpose(\\\"lat\\\", \\\"lon\\\")\\n data = np.arange(coords.size).reshape(coords.shape)\\n a = self.create_output_array(coords, data=data)\\n if output is None:\\n output = a\\n else:\\n output[:] = a.transpose(*output.dims)\\n return output\\n\\n coords = podpac.Coordinates([[0, 1, 2, 3], [0, 1]], dims=[\\\"lat\\\", \\\"lon\\\"])\\n\\n node = MyNode(cache_output=True, cache_ctrl=CacheCtrl([RamCacheStore()]))\\n\\n # first eval\\n o1 = node.eval(coords)\\n assert node._from_cache == False\\n\\n # get from cache\\n o2 = node.eval(coords)\\n assert node._from_cache == True\\n np.testing.assert_array_equal(o2, o1)\\n\\n # get from cache with output\\n o3 = node.eval(coords, output=o1)\\n assert node._from_cache == True\\n np.testing.assert_array_equal(o3, o1)\\n\\n # get from cache with output transposed\\n o4 = node.eval(coords, output=o1.transpose(\\\"lon\\\", \\\"lat\\\"))\\n assert node._from_cache == True\\n np.testing.assert_array_equal(o4, o1)\\n\\n # get from cache with coords transposed\\n o5 = node.eval(coords.transpose(\\\"lon\\\", \\\"lat\\\"))\\n assert node._from_cache == True\\n np.testing.assert_array_equal(o5, o1.transpose(\\\"lon\\\", \\\"lat\\\"))\\n\\n def test_eval_output_crs(self):\\n coords = podpac.Coordinates([[0, 1, 2, 3], [0, 1]], dims=[\\\"lat\\\", \\\"lon\\\"])\\n\\n node = Node()\\n with pytest.raises(ValueError, match=\\\"Output coordinate reference system .* does not match\\\"):\\n node.eval(coords, output=node.create_output_array(coords.transform(\\\"EPSG:2193\\\")))\\n\\n\\nclass TestCaching(object):\\n @classmethod\\n def setup_class(cls):\\n cls._ram_cache_enabled = podpac.settings[\\\"RAM_CACHE_ENABLED\\\"]\\n\\n podpac.settings[\\\"RAM_CACHE_ENABLED\\\"] = True\\n\\n class MyNode(Node):\\n pass\\n\\n cls.node = MyNode(cache_ctrl=CacheCtrl([RamCacheStore()]))\\n cls.node.rem_cache(key=\\\"*\\\", coordinates=\\\"*\\\")\\n\\n cls.coords = podpac.Coordinates([0, 0], dims=[\\\"lat\\\", \\\"lon\\\"])\\n cls.coords2 = podpac.Coordinates([1, 1], dims=[\\\"lat\\\", \\\"lon\\\"])\\n\\n @classmethod\\n def teardown_class(cls):\\n cls.node.rem_cache(key=\\\"*\\\", coordinates=\\\"*\\\")\\n\\n podpac.settings[\\\"RAM_CACHE_ENABLED\\\"] = cls._ram_cache_enabled\\n\\n def setup_method(self, method):\\n self.node.rem_cache(key=\\\"*\\\", coordinates=\\\"*\\\")\\n\\n def teardown_method(self, method):\\n self.node.rem_cache(key=\\\"*\\\", coordinates=\\\"*\\\")\\n\\n def test_has_cache(self):\\n assert not self.node.has_cache(\\\"test\\\")\\n\\n self.node.put_cache(0, \\\"test\\\")\\n assert self.node.has_cache(\\\"test\\\")\\n assert not self.node.has_cache(\\\"test\\\", coordinates=self.coords)\\n\\n def test_has_coordinates(self):\\n assert not self.node.has_cache(\\\"test\\\", coordinates=self.coords)\\n\\n self.node.put_cache(0, \\\"test\\\", coordinates=self.coords)\\n\\n assert not self.node.has_cache(\\\"test\\\")\\n assert self.node.has_cache(\\\"test\\\", coordinates=self.coords)\\n assert not self.node.has_cache(\\\"test\\\", coordinates=self.coords2)\\n\\n def test_get_put_cache(self):\\n with pytest.raises(NodeException):\\n self.node.get_cache(\\\"test\\\")\\n\\n self.node.put_cache(0, \\\"test\\\")\\n assert self.node.get_cache(\\\"test\\\") == 0\\n\\n def test_get_put_coordinates(self):\\n with pytest.raises(NodeException):\\n self.node.get_cache(\\\"test\\\")\\n with pytest.raises(NodeException):\\n self.node.get_cache(\\\"test\\\", coordinates=self.coords)\\n with pytest.raises(NodeException):\\n self.node.get_cache(\\\"test\\\", coordinates=self.coords2)\\n\\n self.node.put_cache(0, \\\"test\\\")\\n self.node.put_cache(1, \\\"test\\\", coordinates=self.coords)\\n self.node.put_cache(2, \\\"test\\\", coordinates=self.coords2)\\n\\n assert self.node.get_cache(\\\"test\\\") == 0\\n assert self.node.get_cache(\\\"test\\\", coordinates=self.coords) == 1\\n assert self.node.get_cache(\\\"test\\\", coordinates=self.coords2) == 2\\n\\n def test_put_overwrite(self):\\n self.node.put_cache(0, \\\"test\\\")\\n assert self.node.get_cache(\\\"test\\\") == 0\\n\\n with pytest.raises(NodeException):\\n self.node.put_cache(1, \\\"test\\\", overwrite=False)\\n assert self.node.get_cache(\\\"test\\\") == 0\\n\\n self.node.put_cache(1, \\\"test\\\")\\n assert self.node.get_cache(\\\"test\\\") == 1\\n\\n def test_rem_all(self):\\n self.node.put_cache(0, \\\"a\\\")\\n self.node.put_cache(0, \\\"b\\\")\\n self.node.put_cache(0, \\\"a\\\", coordinates=self.coords)\\n self.node.put_cache(0, \\\"c\\\", coordinates=self.coords)\\n self.node.put_cache(0, \\\"c\\\", coordinates=self.coords2)\\n self.node.put_cache(0, \\\"d\\\", coordinates=self.coords)\\n\\n self.node.rem_cache(key=\\\"*\\\", coordinates=\\\"*\\\")\\n assert not self.node.has_cache(\\\"a\\\")\\n assert not self.node.has_cache(\\\"b\\\")\\n assert not self.node.has_cache(\\\"a\\\", coordinates=self.coords)\\n assert not self.node.has_cache(\\\"c\\\", coordinates=self.coords)\\n assert not self.node.has_cache(\\\"c\\\", coordinates=self.coords2)\\n assert not self.node.has_cache(\\\"d\\\", coordinates=self.coords)\\n\\n def test_rem_key(self):\\n self.node.put_cache(0, \\\"a\\\")\\n self.node.put_cache(0, \\\"b\\\")\\n self.node.put_cache(0, \\\"a\\\", coordinates=self.coords)\\n self.node.put_cache(0, \\\"c\\\", coordinates=self.coords)\\n self.node.put_cache(0, \\\"c\\\", coordinates=self.coords2)\\n self.node.put_cache(0, \\\"d\\\", coordinates=self.coords)\\n\\n self.node.rem_cache(key=\\\"a\\\", coordinates=\\\"*\\\")\\n\\n assert not self.node.has_cache(\\\"a\\\")\\n assert not self.node.has_cache(\\\"a\\\", coordinates=self.coords)\\n assert self.node.has_cache(\\\"b\\\")\\n assert self.node.has_cache(\\\"c\\\", coordinates=self.coords)\\n assert self.node.has_cache(\\\"c\\\", coordinates=self.coords2)\\n assert self.node.has_cache(\\\"d\\\", coordinates=self.coords)\\n\\n def test_rem_coordinates(self):\\n self.node.put_cache(0, \\\"a\\\")\\n self.node.put_cache(0, \\\"b\\\")\\n self.node.put_cache(0, \\\"a\\\", coordinates=self.coords)\\n self.node.put_cache(0, \\\"c\\\", coordinates=self.coords)\\n self.node.put_cache(0, \\\"c\\\", coordinates=self.coords2)\\n self.node.put_cache(0, \\\"d\\\", coordinates=self.coords)\\n\\n self.node.rem_cache(key=\\\"*\\\", coordinates=self.coords)\\n\\n assert self.node.has_cache(\\\"a\\\")\\n assert not self.node.has_cache(\\\"a\\\", coordinates=self.coords)\\n assert self.node.has_cache(\\\"b\\\")\\n assert not self.node.has_cache(\\\"c\\\", coordinates=self.coords)\\n assert self.node.has_cache(\\\"c\\\", coordinates=self.coords2)\\n assert not self.node.has_cache(\\\"d\\\", coordinates=self.coords)\\n\\n def test_rem_key_coordinates(self):\\n self.node.put_cache(0, \\\"a\\\")\\n self.node.put_cache(0, \\\"b\\\")\\n self.node.put_cache(0, \\\"a\\\", coordinates=self.coords)\\n self.node.put_cache(0, \\\"c\\\", coordinates=self.coords)\\n self.node.put_cache(0, \\\"c\\\", coordinates=self.coords2)\\n self.node.put_cache(0, \\\"d\\\", coordinates=self.coords)\\n\\n self.node.rem_cache(key=\\\"a\\\", coordinates=self.coords)\\n\\n assert self.node.has_cache(\\\"a\\\")\\n assert not self.node.has_cache(\\\"a\\\", coordinates=self.coords)\\n assert self.node.has_cache(\\\"b\\\")\\n assert self.node.has_cache(\\\"c\\\", coordinates=self.coords)\\n assert self.node.has_cache(\\\"c\\\", coordinates=self.coords2)\\n assert self.node.has_cache(\\\"d\\\", coordinates=self.coords)\\n\\n def test_put_has_expires(self):\\n self.node.put_cache(10, \\\"key1\\\", expires=\\\"1,D\\\")\\n self.node.put_cache(10, \\\"key2\\\", expires=\\\"-1,D\\\")\\n assert self.node.has_cache(\\\"key1\\\")\\n assert not self.node.has_cache(\\\"key2\\\")\\n\\n def test_put_get_expires(self):\\n self.node.put_cache(10, \\\"key1\\\", expires=\\\"1,D\\\")\\n self.node.put_cache(10, \\\"key2\\\", expires=\\\"-1,D\\\")\\n assert self.node.get_cache(\\\"key1\\\") == 10\\n with pytest.raises(NodeException, match=\\\"cached data not found\\\"):\\n self.node.get_cache(\\\"key2\\\")\\n\\n # node definition errors\\n # this demonstrates both classes of error in the has_cache case, but only one for put/get/rem\\n # we could test both classes for put/get/rem as well, but that is not really necessary\\n def test_has_cache_unavailable_circular(self):\\n class MyNode(Node):\\n a = tl.Any().tag(attr=True)\\n\\n @tl.default(\\\"a\\\")\\n def _default_a(self):\\n return self.b\\n\\n @property\\n def b(self):\\n self.has_cache(\\\"b\\\")\\n return 10\\n\\n node = MyNode(cache_ctrl=[\\\"ram\\\"])\\n with pytest.raises(NodeException, match=\\\"Cache unavailable, node definition has a circular dependency\\\"):\\n assert node.b == 10\\n\\n def test_has_cache_unavailable_uninitialized(self):\\n class MyNode(Node):\\n a = tl.Any().tag(attr=True)\\n\\n @tl.validate(\\\"a\\\")\\n def _validate_a(self, d):\\n self.b\\n return d[\\\"value\\\"]\\n\\n @property\\n def b(self):\\n self.has_cache(\\\"key\\\")\\n return 10\\n\\n with pytest.raises(NodeException, match=\\\"Cache unavailable, node is not yet fully initialized\\\"):\\n node = MyNode(a=3, cache_ctrl=[\\\"ram\\\"])\\n\\n def test_put_cache_unavailable_uninitialized(self):\\n class MyNode(Node):\\n a = tl.Any().tag(attr=True)\\n\\n @tl.validate(\\\"a\\\")\\n def _validate_a(self, d):\\n self.b\\n return d[\\\"value\\\"]\\n\\n @property\\n def b(self):\\n self.put_cache(10, \\\"key\\\")\\n return 10\\n\\n with pytest.raises(NodeException, match=\\\"Cache unavailable\\\"):\\n node = MyNode(a=3, cache_ctrl=[\\\"ram\\\"])\\n\\n def test_get_cache_unavailable_uninitialized(self):\\n class MyNode(Node):\\n a = tl.Any().tag(attr=True)\\n\\n @tl.validate(\\\"a\\\")\\n def _validate_a(self, d):\\n self.b\\n return d[\\\"value\\\"]\\n\\n @property\\n def b(self):\\n self.get_cache(\\\"key\\\")\\n return 10\\n\\n with pytest.raises(NodeException, match=\\\"Cache unavailable\\\"):\\n node = MyNode(a=3, cache_ctrl=[\\\"ram\\\"])\\n\\n def test_rem_cache_unavailable_uninitialized(self):\\n class MyNode(Node):\\n a = tl.Any().tag(attr=True)\\n\\n @tl.validate(\\\"a\\\")\\n def _validate_a(self, d):\\n self.b\\n return d[\\\"value\\\"]\\n\\n @property\\n def b(self):\\n self.rem_cache(\\\"key\\\")\\n return 10\\n\\n with pytest.raises(NodeException, match=\\\"Cache unavailable\\\"):\\n node = MyNode(a=3, cache_ctrl=[\\\"ram\\\"])\\n\\n\\nclass TestSerialization(object):\\n @classmethod\\n def setup_class(cls):\\n a = podpac.algorithm.Arange()\\n b = podpac.data.Array(source=[10, 20, 30], coordinates=podpac.Coordinates([[0, 1, 2]], dims=[\\\"lat\\\"]))\\n c = podpac.compositor.OrderedCompositor(sources=[a, b])\\n\\n with warnings.catch_warnings():\\n warnings.filterwarnings(\\\"ignore\\\", \\\"Insecure evaluation.*\\\")\\n cls.node = podpac.algorithm.Arithmetic(A=a, B=b, C=c, eqn=\\\"A + B + C\\\")\\n\\n def test_base_ref(self):\\n node = Node()\\n assert isinstance(node.base_ref, six.string_types)\\n\\n def test_base_definition(self):\\n node = Node()\\n d = node._base_definition\\n assert \\\"node\\\" in d\\n assert isinstance(d[\\\"node\\\"], six.string_types)\\n\\n def test_base_definition_attrs(self):\\n class MyNode(Node):\\n my_attr = tl.Int().tag(attr=True)\\n\\n node = MyNode(my_attr=7)\\n\\n d = node._base_definition\\n assert d[\\\"attrs\\\"][\\\"my_attr\\\"] == 7\\n\\n def test_base_definition_inputs(self):\\n class MyNode(Node):\\n my_attr = NodeTrait().tag(attr=True)\\n\\n a = Node()\\n node = MyNode(my_attr=a)\\n\\n d = node._base_definition\\n assert d[\\\"inputs\\\"][\\\"my_attr\\\"] == a\\n\\n def test_base_definition_inputs_array(self):\\n class MyNode(Node):\\n my_attr = ArrayTrait().tag(attr=True)\\n\\n a = Node()\\n b = Node()\\n node = MyNode(my_attr=[a, b])\\n\\n d = node._base_definition\\n assert d[\\\"inputs\\\"][\\\"my_attr\\\"][0] == a\\n assert d[\\\"inputs\\\"][\\\"my_attr\\\"][1] == b\\n\\n def test_base_definition_inputs_dict(self):\\n class MyNode(Node):\\n my_attr = tl.Dict().tag(attr=True)\\n\\n a = Node()\\n b = Node()\\n node = MyNode(my_attr={\\\"a\\\": a, \\\"b\\\": b})\\n\\n d = node._base_definition\\n assert d[\\\"inputs\\\"][\\\"my_attr\\\"][\\\"a\\\"] == a\\n assert d[\\\"inputs\\\"][\\\"my_attr\\\"][\\\"b\\\"] == b\\n\\n def test_base_definition_style(self):\\n node = Node(style=Style(name=\\\"test\\\"))\\n d = node._base_definition\\n assert \\\"style\\\" in node._base_definition\\n\\n def test_base_definition_remove_unnecessary_attrs(self):\\n node = Node(outputs=[\\\"a\\\", \\\"b\\\"], output=\\\"a\\\", units=\\\"m\\\")\\n d = node._base_definition\\n assert \\\"outputs\\\" in d[\\\"attrs\\\"]\\n assert \\\"output\\\" in d[\\\"attrs\\\"]\\n assert \\\"units\\\" in d[\\\"attrs\\\"]\\n\\n node = Node()\\n d = node._base_definition\\n if \\\"attrs\\\" in d:\\n assert \\\"outputs\\\" not in d[\\\"attrs\\\"]\\n assert \\\"output\\\" not in d[\\\"attrs\\\"]\\n assert \\\"units\\\" not in d[\\\"attrs\\\"]\\n\\n def test_definition(self):\\n # definition\\n d = self.node.definition\\n assert isinstance(d, OrderedDict)\\n assert len(d) == 5\\n\\n # from_definition\\n with warnings.catch_warnings():\\n warnings.filterwarnings(\\\"ignore\\\", \\\"Insecure evaluation.*\\\")\\n node = Node.from_definition(d)\\n\\n assert node is not self.node\\n assert node == self.node\\n assert isinstance(node, podpac.algorithm.Arithmetic)\\n assert isinstance(node.inputs[\\\"A\\\"], podpac.algorithm.Arange)\\n assert isinstance(node.inputs[\\\"B\\\"], podpac.data.Array)\\n assert isinstance(node.inputs[\\\"C\\\"], podpac.compositor.OrderedCompositor)\\n\\n def test_definition_duplicate_base_ref(self):\\n n1 = Node(units=\\\"m\\\")\\n n2 = Node(units=\\\"ft\\\")\\n n3 = Node(units=\\\"in\\\")\\n node = podpac.compositor.OrderedCompositor(sources=[n1, n2, n3])\\n d = node.definition\\n assert n1.base_ref == n2.base_ref == n3.base_ref\\n assert len(d) == 5\\n\\n def test_definition_inputs_array(self):\\n global MyNodeWithArrayInput\\n\\n class MyNodeWithArrayInput(Node):\\n my_array = ArrayTrait().tag(attr=True)\\n\\n node1 = MyNodeWithArrayInput(my_array=[podpac.algorithm.Arange()])\\n node2 = Node.from_definition(node1.definition)\\n assert node2 is not node1 and node2 == node1\\n\\n def test_definition_inputs_dict(self):\\n global MyNodeWithDictInput\\n\\n class MyNodeWithDictInput(Node):\\n my_dict = tl.Dict().tag(attr=True)\\n\\n node1 = MyNodeWithDictInput(my_dict={\\\"a\\\": podpac.algorithm.Arange()})\\n node2 = Node.from_definition(node1.definition)\\n assert node2 is not node1 and node2 == node1\\n\\n def test_definition_version(self):\\n d = self.node.definition\\n assert \\\"podpac_version\\\" in d\\n assert d[\\\"podpac_version\\\"] == podpac.__version__\\n\\n def test_json(self):\\n # json\\n s = self.node.json\\n assert isinstance(s, six.string_types)\\n assert json.loads(s)\\n\\n # test from_json\\n with warnings.catch_warnings():\\n warnings.filterwarnings(\\\"ignore\\\", \\\"Insecure evaluation.*\\\")\\n node = Node.from_json(s)\\n assert node is not self.node\\n assert node == self.node\\n assert isinstance(node, podpac.algorithm.Arithmetic)\\n assert isinstance(node.inputs[\\\"A\\\"], podpac.algorithm.Arange)\\n assert isinstance(node.inputs[\\\"B\\\"], podpac.data.Array)\\n assert isinstance(node.inputs[\\\"C\\\"], podpac.compositor.OrderedCompositor)\\n\\n def test_file(self):\\n path = tempfile.mkdtemp(prefix=\\\"podpac-test-\\\")\\n filename = os.path.join(path, \\\"node.json\\\")\\n\\n # save\\n self.node.save(filename)\\n assert os.path.exists(filename)\\n\\n with warnings.catch_warnings():\\n warnings.filterwarnings(\\\"ignore\\\", \\\"Insecure evaluation.*\\\")\\n node = Node.load(filename)\\n\\n assert node is not self.node\\n assert node == self.node\\n assert isinstance(node, podpac.algorithm.Arithmetic)\\n assert isinstance(node.inputs[\\\"A\\\"], podpac.algorithm.Arange)\\n assert isinstance(node.inputs[\\\"B\\\"], podpac.data.Array)\\n assert isinstance(node.inputs[\\\"C\\\"], podpac.compositor.OrderedCompositor)\\n\\n def test_json_pretty(self):\\n node = Node()\\n s = node.json_pretty\\n assert isinstance(s, six.string_types)\\n json.loads(s)\\n\\n def test_hash(self):\\n class N(Node):\\n my_attr = tl.Int().tag(attr=True)\\n\\n class M(Node):\\n my_attr = tl.Int().tag(attr=True)\\n\\n n1 = N(my_attr=1)\\n n2 = N(my_attr=1)\\n n3 = N(my_attr=2)\\n m1 = M(my_attr=1)\\n\\n assert n1.hash == n2.hash\\n assert n1.hash != n3.hash\\n assert n1.hash != m1.hash\\n\\n def test_hash_preserves_definition(self):\\n n = Node()\\n d_before = deepcopy(n.definition)\\n h = n.hash\\n d_after = deepcopy(n.definition)\\n\\n assert d_before == d_after\\n\\n def test_hash_omit_style(self):\\n class N(Node):\\n my_attr = tl.Int().tag(attr=True)\\n\\n n1 = N(my_attr=1, style=Style(name=\\\"a\\\"))\\n n2 = N(my_attr=1, style=Style(name=\\\"b\\\"))\\n\\n # json has style in it\\n assert n1.json != n2.json\\n\\n # but hash does not\\n assert n1.hash == n2.hash\\n\\n def test_hash_omit_version(self):\\n version = podpac.__version__\\n\\n try:\\n # actual version\\n n1 = Node()\\n s1 = n1.json\\n h1 = n1.hash\\n\\n # spoof different version\\n podpac.__version__ = \\\"other\\\"\\n n2 = Node()\\n s2 = n2.json\\n h2 = n2.hash\\n\\n # JSON should be different, but hash should be the same\\n assert s1 != s2\\n assert h1 == h2\\n\\n finally:\\n # reset version\\n podpac.__version__ = version\\n\\n def test_eq(self):\\n class N(Node):\\n my_attr = tl.Int().tag(attr=True)\\n\\n class M(Node):\\n my_attr = tl.Int().tag(attr=True)\\n\\n n1 = N(my_attr=1)\\n n2 = N(my_attr=1)\\n n3 = N(my_attr=2)\\n m1 = M(my_attr=1)\\n\\n # eq\\n assert n1 == n2\\n assert not n1 == n3\\n assert not n1 == m1\\n assert not n1 == \\\"other\\\"\\n\\n # ne\\n assert not n1 != n2\\n assert n1 != n3\\n assert n1 != m1\\n assert n1 != \\\"other\\\"\\n\\n def test_eq_ignore_style(self):\\n class N(Node):\\n my_attr = tl.Int().tag(attr=True)\\n\\n n1 = N(my_attr=1, style=Style(name=\\\"a\\\"))\\n n2 = N(my_attr=1, style=Style(name=\\\"b\\\"))\\n\\n # json has style in it\\n assert n1.json != n2.json\\n\\n # but == and != don't care\\n assert n1 == n2\\n assert not n1 != n2\\n\\n def test_from_url(self):\\n url = (\\n r\\\"http://testwms/?map=map&&service={service}&request=GetMap&{layername}={layer}&styles=&format=image%2Fpng\\\"\\n r\\\"&transparent=true&version=1.1.1&transparency=true&width=256&height=256&srs=EPSG%3A4326\\\"\\n r\\\"&bbox=40,-71,41,70&time=2018-05-19&PARAMS={params}\\\"\\n )\\n\\n params = [\\\"{}\\\", '{\\\"a\\\":{\\\"node\\\":\\\"algorithm.Arange\\\"}}', \\\"{}\\\", \\\"{}\\\"]\\n\\n for service, layername in zip([\\\"WMS\\\", \\\"WCS\\\"], [\\\"LAYERS\\\", \\\"COVERAGE\\\"]):\\n for layer, param in zip(\\n [\\n \\\"algorithm.SinCoords\\\",\\n \\\"%PARAMS%\\\",\\n # urllib.urlencode({'a':'https://raw.githubusercontent.com/creare-com/podpac/develop/podpac/core/pipeline/test/test.json'})[2:],\\n # urllib.urlencode({'a':'s3://podpac-s3/test/test.json'})[2:] # Tested locally, works fine. Hard to test with CI\\n ],\\n params,\\n ):\\n pipe = Node.from_url(url.format(service=service, layername=layername, layer=layer, params=param))\\n\\n def test_from_url_with_plugin_style_params(self):\\n url0 = (\\n r\\\"https://mobility-devel.crearecomputing.com/geowatch?&SERVICE=WMS&REQUEST=GetMap&VERSION=1.3.0&\\\"\\n r\\\"LAYERS=Arange&STYLES=&FORMAT=image%2Fpng&TRANSPARENT=true&HEIGHT=256&WIDTH=256\\\"\\n r\\\"&CRS=EPSG%3A3857&BBOX=-20037508.342789244,10018754.171394618,-10018754.171394622,20037508.34278071&\\\"\\n r'PARAMS={\\\"plugin\\\": \\\"podpac.algorithm\\\"}'\\n )\\n url1 = (\\n r\\\"https://mobility-devel.crearecomputing.com/geowatch?&SERVICE=WMS&REQUEST=GetMap&VERSION=1.3.0&\\\"\\n r\\\"LAYERS=datalib.terraintiles.TerrainTiles&STYLES=&FORMAT=image%2Fpng&TRANSPARENT=true&HEIGHT=256&WIDTH=256&\\\"\\n r\\\"TIME=2021-03-01T12%3A00%3A00.000Z&CRS=EPSG%3A3857&BBOX=-10018754.171394622,5009377.08569731,-9392582.035682458,5635549.221409475\\\"\\n r'&PARAMS={\\\"style\\\": {\\\"name\\\": \\\"Aspect (Composited 30-90 m)\\\",\\\"units\\\": \\\"radians\\\",\\\"colormap\\\": \\\"hsv\\\",\\\"clim\\\": [0,6.283185307179586]}}'\\n )\\n node = Node.from_url(url0)\\n node = Node.from_url(url1)\\n\\n def test_from_name_params(self):\\n # Normal\\n name = \\\"algorithm.Arange\\\"\\n node = Node.from_name_params(name)\\n\\n # Normal with params\\n name = \\\"algorithm.CoordData\\\"\\n params = {\\\"coord_name\\\": \\\"alt\\\"}\\n node = Node.from_name_params(name, params)\\n assert node.coord_name == \\\"alt\\\"\\n\\n # Plugin style\\n name = \\\"CoordData\\\"\\n params = {\\\"plugin\\\": \\\"podpac.algorithm\\\", \\\"attrs\\\": {\\\"coord_name\\\": \\\"alt\\\"}}\\n node = Node.from_name_params(name, params)\\n assert node.coord_name == \\\"alt\\\"\\n\\n def test_style(self):\\n node = podpac.data.Array(\\n source=[10, 20, 30],\\n coordinates=podpac.Coordinates([[0, 1, 2]], dims=[\\\"lat\\\"]),\\n style=Style(name=\\\"test\\\", units=\\\"m\\\"),\\n )\\n\\n d = node.definition\\n assert \\\"style\\\" in d[node.base_ref]\\n\\n node2 = Node.from_definition(d)\\n assert node2 is not node\\n assert isinstance(node2, podpac.data.Array)\\n assert node2.style is not node.style\\n assert node2.style == node.style\\n assert node2.style.name == \\\"test\\\"\\n assert node2.style.units == \\\"m\\\"\\n\\n # default style\\n node = podpac.data.Array(source=[10, 20, 30], coordinates=podpac.Coordinates([[0, 1, 2]], dims=[\\\"lat\\\"]))\\n d = node.definition\\n assert \\\"style\\\" not in d[node.base_ref]\\n\\n def test_circular_definition(self):\\n # this is admittedly a contrived example in order to demonstrate the most direct case\\n class MyNode(Node):\\n a = tl.Any().tag(attr=True)\\n\\n @tl.default(\\\"a\\\")\\n def _default_a(self):\\n self.definition\\n return 10\\n\\n node = MyNode()\\n with pytest.raises(NodeDefinitionError, match=\\\"node definition has a circular dependency\\\"):\\n node.a\\n\\n\\nclass TestUserDefinition(object):\\n def test_empty(self):\\n s = \\\"{ }\\\"\\n with pytest.raises(ValueError, match=\\\"definition cannot be empty\\\"):\\n Node.from_json(s)\\n\\n def test_no_node(self):\\n s = '{\\\"test\\\": { } }'\\n with pytest.raises(ValueError, match=\\\"'node' property required\\\"):\\n Node.from_json(s)\\n\\n def test_invalid_node(self):\\n # module does not exist\\n s = '{\\\"a\\\": {\\\"node\\\": \\\"nonexistent.Arbitrary\\\"} }'\\n with pytest.raises(ValueError, match=\\\"no module found\\\"):\\n Node.from_json(s)\\n\\n # node does not exist in module\\n s = '{\\\"a\\\": {\\\"node\\\": \\\"core.Nonexistent\\\"} }'\\n with pytest.raises(ValueError, match=\\\"class 'Nonexistent' not found in module\\\"):\\n Node.from_json(s)\\n\\n def test_inputs(self):\\n # invalid type\\n s = \\\"\\\"\\\"\\n {\\n \\\"a\\\": {\\n \\\"node\\\": \\\"algorithm.Min\\\",\\n \\\"inputs\\\": { \\\"source\\\": 10 }\\n }\\n }\\n \\\"\\\"\\\"\\n\\n with pytest.raises(ValueError, match=\\\"Invalid definition for node\\\"):\\n Node.from_json(s)\\n\\n # nonexistent node\\n s = \\\"\\\"\\\"\\n {\\n \\\"a\\\": {\\n \\\"node\\\": \\\"algorithm.Min\\\",\\n \\\"inputs\\\": { \\\"source\\\": \\\"nonexistent\\\" }\\n }\\n }\\n \\\"\\\"\\\"\\n\\n with pytest.raises(ValueError, match=\\\"Invalid definition for node\\\"):\\n Node.from_json(s)\\n\\n def test_lookup_attrs(self):\\n s = \\\"\\\"\\\"\\n {\\n \\\"a\\\": {\\n \\\"node\\\": \\\"algorithm.CoordData\\\",\\n \\\"attrs\\\": { \\\"coord_name\\\": \\\"lat\\\" }\\n },\\n \\\"b\\\": {\\n \\\"node\\\": \\\"algorithm.CoordData\\\",\\n \\\"lookup_attrs\\\": { \\\"coord_name\\\": \\\"a.coord_name\\\" }\\n }\\n }\\n \\\"\\\"\\\"\\n\\n node = Node.from_json(s)\\n assert isinstance(node, podpac.algorithm.CoordData)\\n assert node.coord_name == \\\"lat\\\"\\n\\n # invalid type\\n s = \\\"\\\"\\\"\\n {\\n \\\"a\\\": {\\n \\\"node\\\": \\\"algorithm.CoordData\\\",\\n \\\"attrs\\\": { \\\"coord_name\\\": \\\"lat\\\" }\\n },\\n \\\"b\\\": {\\n \\\"node\\\": \\\"algorithm.CoordData\\\",\\n \\\"lookup_attrs\\\": { \\\"coord_name\\\": 10 }\\n }\\n }\\n \\\"\\\"\\\"\\n\\n with pytest.raises(ValueError, match=\\\"Invalid definition for node\\\"):\\n Node.from_json(s)\\n\\n # nonexistent node\\n s = \\\"\\\"\\\"\\n {\\n \\\"a\\\": {\\n \\\"node\\\": \\\"algorithm.CoordData\\\",\\n \\\"attrs\\\": { \\\"coord_name\\\": \\\"lat\\\" }\\n },\\n \\\"b\\\": {\\n \\\"node\\\": \\\"algorithm.CoordData\\\",\\n \\\"lookup_attrs\\\": { \\\"coord_name\\\": \\\"nonexistent.coord_name\\\" }\\n }\\n }\\n \\\"\\\"\\\"\\n\\n with pytest.raises(ValueError, match=\\\"Invalid definition for node\\\"):\\n Node.from_json(s)\\n\\n # nonexistent subattr\\n s = \\\"\\\"\\\"\\n {\\n \\\"a\\\": {\\n \\\"node\\\": \\\"algorithm.CoordData\\\",\\n \\\"attrs\\\": { \\\"coord_name\\\": \\\"lat\\\" }\\n },\\n \\\"b\\\": {\\n \\\"node\\\": \\\"algorithm.CoordData\\\",\\n \\\"lookup_attrs\\\": { \\\"coord_name\\\": \\\"a.nonexistent\\\" }\\n }\\n }\\n \\\"\\\"\\\"\\n\\n with pytest.raises(ValueError, match=\\\"Invalid definition for node\\\"):\\n Node.from_json(s)\\n\\n def test_invalid_property(self):\\n s = \\\"\\\"\\\"\\n {\\n \\\"a\\\": {\\n \\\"node\\\": \\\"algorithm.Arange\\\",\\n \\\"invalid_property\\\": \\\"value\\\"\\n }\\n }\\n \\\"\\\"\\\"\\n\\n with pytest.raises(ValueError, match=\\\"unexpected property\\\"):\\n Node.from_json(s)\\n\\n def test_plugin(self):\\n global MyPluginNode\\n\\n class MyPluginNode(Node):\\n pass\\n\\n s = \\\"\\\"\\\"\\n {\\n \\\"mynode\\\": {\\n \\\"plugin\\\": \\\"test_node\\\",\\n \\\"node\\\": \\\"MyPluginNode\\\"\\n }\\n }\\n \\\"\\\"\\\"\\n\\n node = Node.from_json(s)\\n assert isinstance(node, MyPluginNode)\\n\\n # missing plugin\\n s = \\\"\\\"\\\"\\n {\\n \\\"mynode\\\": {\\n \\\"plugin\\\": \\\"missing\\\",\\n \\\"node\\\": \\\"MyPluginNode\\\"\\n }\\n }\\n \\\"\\\"\\\"\\n\\n with pytest.raises(ValueError, match=\\\"no module found\\\"):\\n Node.from_json(s)\\n\\n def test_debuggable(self):\\n s = \\\"\\\"\\\"\\n {\\n \\\"a\\\": {\\n \\\"node\\\": \\\"algorithm.Arange\\\"\\n },\\n \\\"mean\\\": {\\n \\\"node\\\": \\\"algorithm.Convolution\\\",\\n \\\"lookup_attrs\\\": {\\\"source\\\": \\\"a\\\"},\\n \\\"attrs\\\": {\\\"kernel_type\\\": \\\"mean,3\\\", \\\"kernel_dims\\\": [\\\"lat\\\", \\\"lon\\\"]}\\n },\\n \\\"c\\\": {\\n \\\"node\\\": \\\"algorithm.Arithmetic\\\",\\n \\\"lookup_attrs\\\": {\\\"A\\\": \\\"a\\\", \\\"B\\\": \\\"mean\\\"},\\n \\\"attrs\\\": {\\\"eqn\\\": \\\"a-b\\\"}\\n }\\n }\\n \\\"\\\"\\\"\\n\\n with warnings.catch_warnings(), podpac.settings:\\n warnings.filterwarnings(\\\"ignore\\\", \\\"Insecure evaluation.*\\\")\\n\\n # normally node objects can and should be re-used\\n podpac.settings[\\\"DEBUG\\\"] = False\\n node = Node.from_json(s)\\n assert node.inputs[\\\"A\\\"] is node.inputs[\\\"B\\\"].source\\n\\n # when debugging is on, node objects should be unique\\n podpac.settings[\\\"DEBUG\\\"] = True\\n node = Node.from_json(s)\\n assert node.inputs[\\\"A\\\"] is not node.inputs[\\\"B\\\"].source\\n\\n def test_from_definition_version_warning(self):\\n s = \\\"\\\"\\\"\\n {\\n \\\"a\\\": {\\n \\\"node\\\": \\\"algorithm.Arange\\\"\\n },\\n \\\"podpac_version\\\": \\\"other\\\"\\n }\\n \\\"\\\"\\\"\\n\\n with pytest.warns(UserWarning, match=\\\"node definition version mismatch\\\"):\\n node = Node.from_json(s)\\n\\n\\nclass TestNoCacheMixin(object):\\n class NoCacheNode(NoCacheMixin, Node):\\n pass\\n\\n def test_default_no_cache(self):\\n with podpac.settings:\\n podpac.settings[\\\"DEFAULT_CACHE\\\"] = [\\\"ram\\\"]\\n node = self.NoCacheNode()\\n assert len(node.cache_ctrl._cache_stores) == 0\\n\\n def test_customizable(self):\\n podpac.settings[\\\"DEFAULT_CACHE\\\"] = [\\\"ram\\\"]\\n node = self.NoCacheNode(cache_ctrl=[\\\"ram\\\"])\\n assert len(node.cache_ctrl._cache_stores) == 1\\n\\n\\nclass TestDiskCacheMixin(object):\\n class DiskCacheNode(DiskCacheMixin, Node):\\n pass\\n\\n def test_default_disk_cache(self):\\n with podpac.settings:\\n # add disk cache\\n podpac.settings[\\\"DEFAULT_CACHE\\\"] = [\\\"ram\\\"]\\n node = self.DiskCacheNode()\\n assert len(node.cache_ctrl._cache_stores) == 2\\n\\n # don't add if it is already there\\n podpac.settings[\\\"DEFAULT_CACHE\\\"] = [\\\"ram\\\", \\\"disk\\\"]\\n node = self.DiskCacheNode()\\n assert len(node.cache_ctrl._cache_stores) == 2\\n\\n def test_customizable(self):\\n node = self.DiskCacheNode(cache_ctrl=[\\\"ram\\\"])\\n assert len(node.cache_ctrl._cache_stores) == 1\\n\\n\\n# TODO: remove this - this is currently a placeholder test until we actually have integration tests (pytest will exit with code 5 if no tests found)\\n@pytest.mark.integration\\ndef tests_node_integration():\\n assert True\\n\",\n \"\\\"\\\"\\\"\\nTest interpolation methods\\n\\n\\n\\\"\\\"\\\"\\n# pylint: disable=C0111,W0212,R0903\\n\\n\\nimport warnings\\n\\nimport pytest\\nimport traitlets as tl\\nimport numpy as np\\nfrom numpy.testing import assert_array_equal\\n\\nimport podpac\\nfrom podpac.core.units import UnitsDataArray\\nfrom podpac.core.node import Node\\nfrom podpac.core.coordinates import Coordinates\\nfrom podpac.core.interpolation.interpolation_manager import InterpolationException\\nfrom podpac.core.interpolation.interpolation import Interpolate, InterpolationMixin\\nfrom podpac.core.data.array_source import Array, ArrayRaw\\nfrom podpac.core.compositor.tile_compositor import TileCompositorRaw\\nfrom podpac.core.interpolation.scipy_interpolator import ScipyGrid\\n\\n\\nclass TestInterpolationMixin(object):\\n def test_interpolation_mixin(self):\\n class InterpArray(InterpolationMixin, ArrayRaw):\\n pass\\n\\n data = np.random.rand(4, 5)\\n native_coords = Coordinates([np.linspace(0, 3, 4), np.linspace(0, 4, 5)], [\\\"lat\\\", \\\"lon\\\"])\\n coords = Coordinates([np.linspace(0, 3, 7), np.linspace(0, 4, 9)], [\\\"lat\\\", \\\"lon\\\"])\\n\\n iarr_src = InterpArray(source=data, coordinates=native_coords, interpolation=\\\"bilinear\\\")\\n arr_src = Array(source=data, coordinates=native_coords, interpolation=\\\"bilinear\\\")\\n arrb_src = ArrayRaw(source=data, coordinates=native_coords)\\n\\n iaso = iarr_src.eval(coords)\\n aso = arr_src.eval(coords)\\n abso = arrb_src.eval(coords)\\n\\n np.testing.assert_array_equal(iaso.data, aso.data)\\n np.testing.assert_array_equal(abso.data, data)\\n\\n\\nclass TestInterpolation(object):\\n s1 = ArrayRaw(\\n source=np.random.rand(9, 15),\\n coordinates=Coordinates([np.linspace(0, 8, 9), np.linspace(0, 14, 15)], [\\\"lat\\\", \\\"lon\\\"]),\\n )\\n s2 = ArrayRaw(\\n source=np.random.rand(9, 15),\\n coordinates=Coordinates([np.linspace(9, 17, 9), np.linspace(0, 14, 15)], [\\\"lat\\\", \\\"lon\\\"]),\\n )\\n interp = Interpolate(source=s1, interpolation=\\\"nearest\\\")\\n coords = Coordinates([np.linspace(0, 8, 17), np.linspace(0, 14, 29)], [\\\"lat\\\", \\\"lon\\\"])\\n coords2 = Coordinates([np.linspace(0, 17, 18), np.linspace(0, 14, 15)], [\\\"lat\\\", \\\"lon\\\"])\\n coords2c = Coordinates([np.linspace(0.1, 16.8, 5), np.linspace(0.1, 13.8, 3)], [\\\"lat\\\", \\\"lon\\\"])\\n\\n def test_basic_interpolation(self):\\n # This JUST tests the interface, tests for the actual value of the interpolation is left\\n # to the test_interpolation_manager.py file\\n\\n o = self.interp.eval(self.coords)\\n\\n assert o.shape == (17, 29)\\n\\n def test_interpolation_definition(self):\\n node = Node.from_json(self.interp.json)\\n o1 = node.eval(self.coords)\\n o2 = self.interp.eval(self.coords)\\n np.testing.assert_array_equal(o1.data, o2.data)\\n assert node.json == self.interp.json\\n\\n def test_compositor_chain(self):\\n dc = TileCompositorRaw(sources=[self.s2, self.s1])\\n node = Interpolate(source=dc, interpolation=\\\"nearest\\\")\\n o = node.eval(self.coords2)\\n\\n np.testing.assert_array_equal(o.data, np.concatenate([self.s1.source, self.s2.source], axis=0))\\n\\n def test_get_bounds(self):\\n assert self.interp.get_bounds() == self.s1.get_bounds()\\n\\n\\nclass TestInterpolationBehavior(object):\\n def test_linear_1D_issue411and413(self):\\n data = [0, 1, 2]\\n raw_coords = data.copy()\\n raw_e_coords = [0, 0.5, 1, 1.5, 2]\\n\\n for dim in [\\\"lat\\\", \\\"lon\\\", \\\"alt\\\", \\\"time\\\"]:\\n ec = Coordinates([raw_e_coords], [dim])\\n\\n arrb = ArrayRaw(source=data, coordinates=Coordinates([raw_coords], [dim]))\\n node = Interpolate(source=arrb, interpolation=\\\"linear\\\")\\n o = node.eval(ec)\\n\\n np.testing.assert_array_equal(o.data, raw_e_coords, err_msg=\\\"dim {} failed to interpolate\\\".format(dim))\\n\\n # Do time interpolation explicitly\\n raw_coords = [\\\"2020-11-01\\\", \\\"2020-11-03\\\", \\\"2020-11-05\\\"]\\n raw_et_coords = [\\\"2020-11-01\\\", \\\"2020-11-02\\\", \\\"2020-11-03\\\", \\\"2020-11-04\\\", \\\"2020-11-05\\\"]\\n ec = Coordinates([raw_et_coords], [\\\"time\\\"])\\n\\n arrb = ArrayRaw(source=data, coordinates=Coordinates([raw_coords], [\\\"time\\\"]))\\n node = Interpolate(source=arrb, interpolation=\\\"linear\\\")\\n o = node.eval(ec)\\n\\n np.testing.assert_array_equal(\\n o.data, raw_e_coords, err_msg=\\\"dim time failed to interpolate with datetime64 coords\\\"\\n )\\n\\n def test_stacked_coords_with_partial_dims_issue123(self):\\n node = Array(\\n source=[0, 1, 2],\\n coordinates=Coordinates(\\n [[[0, 2, 1], [10, 12, 11], [\\\"2018-01-01\\\", \\\"2018-01-02\\\", \\\"2018-01-03\\\"]]], dims=[\\\"lat_lon_time\\\"]\\n ),\\n interpolation=\\\"nearest\\\",\\n )\\n\\n # unstacked or and stacked requests without time\\n o1 = node.eval(Coordinates([[0.5, 1.5], [10.5, 11.5]], dims=[\\\"lat\\\", \\\"lon\\\"]))\\n o2 = node.eval(Coordinates([[[0.5, 1.5], [10.5, 11.5]]], dims=[\\\"lat_lon\\\"]))\\n\\n assert_array_equal(o1.data, [[0, 2], [2, 1]])\\n assert_array_equal(o2.data, [0, 1])\\n\\n # request without lat or lon\\n o3 = node.eval(Coordinates([\\\"2018-01-01\\\"], dims=[\\\"time\\\"]))\\n assert o3.data[0] == 0\\n\\n def test_ignored_interpolation_params_issue340(self, caplog):\\n node = Array(\\n source=[0, 1, 2],\\n coordinates=Coordinates([[0, 2, 1]], dims=[\\\"time\\\"]),\\n interpolation={\\\"method\\\": \\\"nearest\\\", \\\"params\\\": {\\\"fake_param\\\": 1.1, \\\"spatial_tolerance\\\": 1}},\\n )\\n\\n with warnings.catch_warnings():\\n warnings.filterwarnings(\\\"ignore\\\", category=DeprecationWarning)\\n node.eval(Coordinates([[0.5, 1.5]], [\\\"time\\\"]))\\n assert \\\"interpolation parameter 'fake_param' was ignored\\\" in caplog.text\\n assert \\\"interpolation parameter 'spatial_tolerance' was ignored\\\" not in caplog.text\\n\\n def test_silent_nearest_neighbor_interp_bug_issue412(self):\\n node = podpac.data.Array(\\n source=[0, 1, 2],\\n coordinates=podpac.Coordinates([[1, 5, 9]], dims=[\\\"lat\\\"]),\\n interpolation=[{\\\"method\\\": \\\"bilinear\\\", \\\"dims\\\": [\\\"lat\\\"], \\\"interpolators\\\": [ScipyGrid]}],\\n )\\n with pytest.raises(InterpolationException, match=\\\"can't be handled\\\"):\\n o = node.eval(podpac.Coordinates([podpac.crange(1, 9, 1)], dims=[\\\"lat\\\"]))\\n\\n node = podpac.data.Array(\\n source=[0, 1, 2],\\n coordinates=podpac.Coordinates([[1, 5, 9]], dims=[\\\"lat\\\"]),\\n interpolation=[{\\\"method\\\": \\\"bilinear\\\", \\\"dims\\\": [\\\"lat\\\"]}],\\n )\\n o = node.eval(podpac.Coordinates([podpac.crange(1, 9, 1)], dims=[\\\"lat\\\"]))\\n assert_array_equal(o.data, np.linspace(0, 2, 9))\\n\\n def test_selection_crs(self):\\n base = podpac.core.data.array_source.ArrayRaw(\\n source=[0, 1, 2],\\n coordinates=podpac.Coordinates(\\n [[1, 5, 9]], dims=[\\\"time\\\"], crs=\\\"+proj=longlat +datum=WGS84 +no_defs +vunits=m\\\"\\n ),\\n )\\n node = podpac.interpolators.Interpolate(source=base, interpolation=\\\"linear\\\")\\n tocrds = podpac.Coordinates([podpac.crange(1, 9, 1, \\\"time\\\")], crs=\\\"EPSG:4326\\\")\\n o = node.eval(tocrds)\\n assert o.crs == tocrds.crs\\n assert_array_equal(o.data, np.linspace(0, 2, 9))\\n\",\n \"\\\"\\\"\\\"\\nGeneral-purpose Algorithm Nodes.\\n\\\"\\\"\\\"\\n\\nfrom __future__ import division, unicode_literals, print_function, absolute_import\\n\\nimport sys\\nimport warnings\\n\\nimport numpy as np\\nimport xarray as xr\\nimport traitlets as tl\\n\\n# Optional dependencies\\nfrom lazy_import import lazy_module\\n\\nne = lazy_module(\\\"numexpr\\\")\\n\\nfrom podpac import settings\\nfrom podpac import Coordinates\\nfrom podpac.core.node import Node\\nfrom podpac.core.utils import NodeTrait\\nfrom podpac.core.algorithm.algorithm import Algorithm\\n\\nif sys.version_info.major == 2:\\n\\n class PermissionError(OSError):\\n pass\\n\\n\\nclass GenericInputs(Algorithm):\\n \\\"\\\"\\\"Base class for Algorithms that accept generic named inputs.\\\"\\\"\\\"\\n\\n inputs = tl.Dict(read_only=True)\\n\\n _repr_keys = [\\\"inputs\\\"]\\n\\n def _first_init(self, **kwargs):\\n trait_names = self.trait_names()\\n for key in kwargs:\\n if key in trait_names and isinstance(kwargs[key], Node):\\n raise RuntimeError(\\\"Trait '%s' is reserved and cannot be used as an Generic Algorithm input\\\" % key)\\n input_keys = [key for key in kwargs if key not in trait_names and isinstance(kwargs[key], Node)]\\n inputs = {key: kwargs.pop(key) for key in input_keys}\\n self.set_trait(\\\"inputs\\\", inputs)\\n return super(GenericInputs, self)._first_init(**kwargs)\\n\\n @property\\n def _base_definition(self):\\n d = super(GenericInputs, self)._base_definition\\n d[\\\"inputs\\\"] = self.inputs\\n return d\\n\\n\\nclass Arithmetic(GenericInputs):\\n \\\"\\\"\\\"Create a simple point-by-point computation using named input nodes.\\n\\n Examples\\n ----------\\n a = SinCoords()\\n b = Arange()\\n arith = Arithmetic(A=a, B=b, eqn = 'A * B + {offset}', params={'offset': 1})\\n \\\"\\\"\\\"\\n\\n eqn = tl.Unicode().tag(attr=True)\\n params = tl.Dict().tag(attr=True)\\n\\n _repr_keys = [\\\"eqn\\\"]\\n\\n def init(self):\\n if not settings.allow_unsafe_eval:\\n warnings.warn(\\n \\\"Insecure evaluation of Python code using Arithmetic node has not been allowed. If \\\"\\n \\\"this is an error, use: `podpac.settings.set_unsafe_eval(True)`. \\\"\\n \\\"NOTE: Allowing unsafe evaluation enables arbitrary execution of Python code through PODPAC \\\"\\n \\\"Node definitions.\\\"\\n )\\n\\n if self.eqn == \\\"\\\":\\n raise ValueError(\\\"Arithmetic eqn cannot be empty\\\")\\n\\n super(Arithmetic, self).init()\\n\\n def algorithm(self, inputs, coordinates):\\n \\\"\\\"\\\"Compute the algorithms equation\\n\\n Attributes\\n ----------\\n inputs : dict\\n Evaluated outputs of the input nodes. The keys are the attribute names.\\n coordinates : podpac.Coordinates\\n Requested coordinates.\\n Note that the ``inputs`` may contain with different coordinates.\\n\\n Returns\\n -------\\n result : UnitsDataArray\\n Algorithm result.\\n \\\"\\\"\\\"\\n\\n if not settings.allow_unsafe_eval:\\n raise PermissionError(\\n \\\"Insecure evaluation of Python code using Arithmetic node has not been allowed. If \\\"\\n \\\"this is an error, use: `podpac.settings.set_unsafe_eval(True)`. \\\"\\n \\\"NOTE: Allowing unsafe evaluation enables arbitrary execution of Python code through PODPAC \\\"\\n \\\"Node definitions.\\\"\\n )\\n\\n eqn = self.eqn.format(**self.params)\\n\\n fields = self.inputs.keys()\\n res = xr.broadcast(*[inputs[f] for f in fields])\\n f_locals = dict(zip(fields, res))\\n\\n try:\\n from numexpr import evaluate # Needed for some systems to get around lazy_module issues\\n\\n result = ne.evaluate(eqn, f_locals)\\n except (NotImplementedError, ImportError):\\n result = eval(eqn, f_locals)\\n res = res[0].copy() # Make an xarray object with correct dimensions\\n res[:] = result\\n return res\\n\\n\\nclass Generic(GenericInputs):\\n \\\"\\\"\\\"\\n Generic Algorithm Node that allows arbitrary Python code to be executed.\\n\\n Attributes\\n ----------\\n code : str\\n The multi-line code that will be evaluated. This code should assign \\\"output\\\" to the desired result, and \\\"output\\\"\\n needs to be a \\\"numpy array\\\" or \\\"xarray DataArray\\\"\\n inputs : dict(str: podpac.Node)\\n A dictionary of PODPAC nodes that will serve as the input data for the Python script\\n\\n Examples\\n ----------\\n a = SinCoords()\\n b = Arange()\\n code = '''import numpy as np\\n output = np.minimum(a, b)\\n '''\\n generic = Generic(code=code, a=a, b=b)\\n \\\"\\\"\\\"\\n\\n code = tl.Unicode().tag(attr=True, readonly=True)\\n\\n def init(self):\\n if not settings.allow_unsafe_eval:\\n warnings.warn(\\n \\\"Insecure evaluation of Python code using Generic node has not been allowed. If this \\\"\\n \\\"this is an error, use: `podpac.settings.set_unsafe_eval(True)`. \\\"\\n \\\"NOTE: Allowing unsafe evaluation enables arbitrary execution of Python code through PODPAC \\\"\\n \\\"Node definitions.\\\"\\n )\\n super(Generic, self).init()\\n\\n def algorithm(self, inputs, coordinates):\\n \\\"\\\"\\\"\\n Run the generic code.\\n\\n Attributes\\n ----------\\n inputs : dict\\n Evaluated outputs of the input nodes. The keys are the attribute names.\\n coordinates : podpac.Coordinates\\n Requested coordinates.\\n Note that the ``inputs`` may contain with different coordinates.\\n\\n Returns\\n -------\\n result : UnitsDataArray\\n Algorithm result.\\n \\\"\\\"\\\"\\n\\n if not settings.allow_unsafe_eval:\\n raise PermissionError(\\n \\\"Insecure evaluation of Python code using Generic node has not been allowed. If this \\\"\\n \\\"this is an error, use: `podpac.settings.set_unsafe_eval(True)`. \\\"\\n \\\"NOTE: Allowing unsafe evaluation enables arbitrary execution of Python code through PODPAC \\\"\\n \\\"Node definitions.\\\"\\n )\\n exec(self.code, inputs)\\n return inputs[\\\"output\\\"]\\n\\n\\nclass Mask(Algorithm):\\n \\\"\\\"\\\"\\n Masks the `source` based on a boolean expression involving the `mask`\\n (i.e. source[mask <bool_op> <bool_val> ] = <masked_val>).\\n For a normal boolean mask input, default values for `bool_op`, `bool_val` and `masked_val` can be used.\\n\\n Attributes\\n ----------\\n source : podpac.Node\\n The source that will be masked\\n mask : podpac.Node\\n The data that will be used to compute the mask\\n masked_val : float, optional\\n Default value is np.nan. The value that will replace the masked items.\\n bool_val : float, optional\\n Default value is 1. The value used to compare the mask when creating the boolean expression\\n bool_op : enum, optional\\n Default value is '=='. One of ['==', '<', '<=', '>', '>=']\\n in_place : bool, optional\\n Default is False. If True, the source array will be changed in-place, which could affect the value of the source\\n in other parts of the pipeline.\\n\\n Examples\\n ----------\\n # Mask data from a boolean data node using the default behavior.\\n # Create a boolean masked Node (as an example)\\n b = Arithmetic(A=SinCoords(), eqn='A>0)\\n # Create the source node\\n a = Arange()\\n masked = Mask(source=a, mask=b)\\n\\n # Create a node that make the following substitution \\\"a[b > 0] = np.nan\\\"\\n a = Arange()\\n b = SinCoords()\\n masked = Mask(source=a, mask=b,\\n masked_val=np.nan,\\n bool_val=0, bool_op='>'\\n in_place=True)\\n\\n \\\"\\\"\\\"\\n\\n source = NodeTrait().tag(attr=True)\\n mask = NodeTrait().tag(attr=True)\\n masked_val = tl.Float(allow_none=True, default_value=None).tag(attr=True)\\n bool_val = tl.Float(1).tag(attr=True)\\n bool_op = tl.Enum([\\\"==\\\", \\\"<\\\", \\\"<=\\\", \\\">\\\", \\\">=\\\"], default_value=\\\"==\\\").tag(attr=True)\\n in_place = tl.Bool(False).tag(attr=True)\\n\\n _repr_keys = [\\\"source\\\", \\\"mask\\\"]\\n\\n def algorithm(self, inputs, coordinates):\\n \\\"\\\"\\\"\\n Sets the values in inputs['source'] to self.masked_val using (inputs['mask'] <self.bool_op> <self.bool_val>)\\n\\n Attributes\\n ----------\\n inputs : dict\\n Evaluated outputs of the input nodes. The keys are the attribute names.\\n coordinates : podpac.Coordinates\\n Requested coordinates.\\n Note that the ``inputs`` may contain with different coordinates.\\n\\n Returns\\n -------\\n result : UnitsDataArray\\n Algorithm result.\\n \\\"\\\"\\\"\\n\\n # shorter names\\n mask = inputs[\\\"mask\\\"]\\n source = inputs[\\\"source\\\"]\\n op = self.bool_op\\n bv = self.bool_val\\n\\n # Make a copy if we don't want to change the source in-place\\n if not self.in_place:\\n source = source.copy()\\n\\n # Make the mask boolean\\n if op == \\\"==\\\":\\n mask = mask == bv\\n elif op == \\\"<\\\":\\n mask = mask < bv\\n elif op == \\\"<=\\\":\\n mask = mask <= bv\\n elif op == \\\">\\\":\\n mask = mask > bv\\n elif op == \\\">=\\\":\\n mask = mask >= bv\\n\\n # Mask the values and return\\n if self.masked_val is None:\\n source.set(np.nan, mask)\\n else:\\n source.set(self.masked_val, mask)\\n\\n return source\\n\\n\\nclass Combine(GenericInputs):\\n \\\"\\\"\\\"Combine multiple nodes into a single node with multiple outputs.\\n\\n If not output names are specified, the keyword argument names will be used.\\n \\\"\\\"\\\"\\n\\n @tl.default(\\\"outputs\\\")\\n def _default_outputs(self):\\n input_keys = list(self.inputs.keys())\\n return input_keys\\n\\n def algorithm(self, inputs, coordinates):\\n cs = [Coordinates.from_xarray(x) for x in inputs.values()]\\n if any(c != cs[0] for c in cs):\\n raise NodeException(\\\"Cannot combine inputs with different coordinates\\\")\\n\\n data = np.stack([inputs[key] for key in self.inputs], axis=-1)\\n return self.create_output_array(cs[0], data=data)\\n\",\n \"from __future__ import division, unicode_literals, print_function, absolute_import\\n\\nimport pytest\\nimport numpy as np\\nimport xarray as xr\\nimport scipy.stats\\nimport traitlets as tl\\n\\nimport podpac\\nfrom podpac.core.algorithm.utility import Arange\\nfrom podpac.core.data.array_source import Array\\nfrom podpac.core.algorithm.stats import Reduce\\nfrom podpac.core.algorithm.stats import Min, Max, Sum, Count, Mean, Variance, Skew, Kurtosis, StandardDeviation\\nfrom podpac.core.algorithm.generic import Arithmetic\\nfrom podpac.core.algorithm.stats import Median, Percentile\\nfrom podpac.core.algorithm.stats import GroupReduce, DayOfYear, DayOfYearWindow\\n\\n\\ndef setup_module():\\n global coords, source, data, multisource, bdata\\n coords = podpac.Coordinates(\\n [podpac.clinspace(0, 1, 10), podpac.clinspace(0, 1, 10), podpac.crange(\\\"2018-01-01\\\", \\\"2018-01-10\\\", \\\"1,D\\\")],\\n dims=[\\\"lat\\\", \\\"lon\\\", \\\"time\\\"],\\n )\\n\\n a = np.random.random(coords.shape)\\n a[3, 0, 0] = np.nan\\n a[0, 3, 0] = np.nan\\n a[0, 0, 3] = np.nan\\n source = Array(source=a, coordinates=coords)\\n data = source.eval(coords)\\n\\n ab = np.stack([a, 2 * a], -1)\\n multisource = Array(source=ab, coordinates=coords, outputs=[\\\"a\\\", \\\"b\\\"])\\n bdata = 2 * data\\n\\n\\nclass TestReduce(object):\\n \\\"\\\"\\\" Tests the Reduce class \\\"\\\"\\\"\\n\\n def test_auto_chunk(self):\\n # any reduce node would do here\\n node = Min(source=source)\\n\\n with podpac.settings:\\n podpac.settings[\\\"CACHE_NODE_OUTPUT_DEFAULT\\\"] = False\\n podpac.settings[\\\"CHUNK_SIZE\\\"] = \\\"auto\\\"\\n node.eval(coords)\\n\\n def test_chunked_fallback(self):\\n with podpac.settings:\\n podpac.settings[\\\"CACHE_NODE_OUTPUT_DEFAULT\\\"] = False\\n\\n class First(Reduce):\\n def reduce(self, x):\\n return x.isel(**{dim: 0 for dim in self.dims})\\n\\n node = First(source=source, dims=\\\"time\\\")\\n\\n # use reduce function\\n podpac.settings[\\\"CHUNK_SIZE\\\"] = None\\n output = node.eval(coords)\\n\\n # fall back on reduce function with warning\\n with pytest.warns(UserWarning):\\n podpac.settings[\\\"CHUNK_SIZE\\\"] = 500\\n output_chunked = node.eval(coords)\\n\\n # should be the same\\n xr.testing.assert_allclose(output, output_chunked)\\n\\n\\nclass BaseTests(object):\\n \\\"\\\"\\\" Common tests for Reduce subclasses \\\"\\\"\\\"\\n\\n def test_full(self):\\n with podpac.settings:\\n podpac.settings[\\\"CACHE_NODE_OUTPUT_DEFAULT\\\"] = False\\n podpac.settings[\\\"CHUNK_SIZE\\\"] = None\\n\\n node = self.NodeClass(source=source)\\n output = node.eval(coords)\\n # xr.testing.assert_allclose(output, self.expected_full)\\n np.testing.assert_allclose(output.data, self.expected_full.data)\\n\\n node = self.NodeClass(source=source, dims=coords.dims)\\n output = node.eval(coords)\\n # xr.testing.assert_allclose(output, self.expected_full)\\n np.testing.assert_allclose(output.data, self.expected_full.data)\\n\\n def test_full_chunked(self):\\n with podpac.settings:\\n node = self.NodeClass(source=source, dims=coords.dims)\\n podpac.settings[\\\"CACHE_NODE_OUTPUT_DEFAULT\\\"] = False\\n podpac.settings[\\\"CHUNK_SIZE\\\"] = 500\\n output = node.eval(coords)\\n # xr.testing.assert_allclose(output, self.expected_full)\\n np.testing.assert_allclose(output.data, self.expected_full.data)\\n\\n def test_lat_lon(self):\\n with podpac.settings:\\n podpac.settings[\\\"CACHE_NODE_OUTPUT_DEFAULT\\\"] = False\\n podpac.settings[\\\"CHUNK_SIZE\\\"] = None\\n node = self.NodeClass(source=source, dims=[\\\"lat\\\", \\\"lon\\\"])\\n output = node.eval(coords)\\n # xr.testing.assert_allclose(output, self.expected_latlon)\\n np.testing.assert_allclose(output.data, self.expected_latlon.data)\\n\\n def test_lat_lon_chunked(self):\\n with podpac.settings:\\n podpac.settings[\\\"CACHE_NODE_OUTPUT_DEFAULT\\\"] = False\\n podpac.settings[\\\"CHUNK_SIZE\\\"] = 500\\n node = self.NodeClass(source=source, dims=[\\\"lat\\\", \\\"lon\\\"])\\n output = node.eval(coords)\\n # xr.testing.assert_allclose(output, self.expected_latlon)\\n np.testing.assert_allclose(output.data, self.expected_latlon.data)\\n\\n def test_time(self):\\n with podpac.settings:\\n podpac.settings[\\\"CACHE_NODE_OUTPUT_DEFAULT\\\"] = False\\n podpac.settings[\\\"CHUNK_SIZE\\\"] = None\\n node = self.NodeClass(source=source, dims=\\\"time\\\")\\n output = node.eval(coords)\\n # xr.testing.assert_allclose(output, self.expected_time)\\n np.testing.assert_allclose(output.data, self.expected_time.data)\\n\\n def test_time_chunked(self):\\n with podpac.settings:\\n podpac.settings[\\\"CACHE_NODE_OUTPUT_DEFAULT\\\"] = False\\n podpac.settings[\\\"CHUNK_SIZE\\\"] = 500\\n node = self.NodeClass(source=source, dims=\\\"time\\\")\\n output = node.eval(coords)\\n # xr.testing.assert_allclose(output, self.expected_time)\\n np.testing.assert_allclose(output.data, self.expected_time.data)\\n\\n def test_multiple_outputs(self):\\n with podpac.settings:\\n podpac.settings[\\\"CACHE_NODE_OUTPUT_DEFAULT\\\"] = False\\n podpac.settings[\\\"CHUNK_SIZE\\\"] = None\\n node = self.NodeClass(source=multisource, dims=[\\\"lat\\\", \\\"lon\\\"])\\n output = node.eval(coords)\\n assert output.dims == (\\\"time\\\", \\\"output\\\")\\n np.testing.assert_array_equal(output[\\\"output\\\"], [\\\"a\\\", \\\"b\\\"])\\n np.testing.assert_allclose(output.sel(output=\\\"a\\\"), self.expected_latlon)\\n np.testing.assert_allclose(output.sel(output=\\\"b\\\"), self.expected_latlon_b)\\n\\n\\nclass TestMin(BaseTests):\\n @classmethod\\n def setup_class(cls):\\n cls.NodeClass = Min\\n cls.expected_full = data.min()\\n cls.expected_latlon = data.min(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_latlon_b = bdata.min(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_time = data.min(dim=\\\"time\\\")\\n\\n\\nclass TestMax(BaseTests):\\n @classmethod\\n def setup_class(cls):\\n cls.NodeClass = Max\\n cls.expected_full = data.max()\\n cls.expected_latlon = data.max(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_latlon_b = bdata.max(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_time = data.max(dim=\\\"time\\\")\\n\\n\\nclass TestSum(BaseTests):\\n @classmethod\\n def setup_class(cls):\\n cls.NodeClass = Sum\\n cls.expected_full = data.sum()\\n cls.expected_latlon = data.sum(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_latlon_b = bdata.sum(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_time = data.sum(dim=\\\"time\\\")\\n\\n\\nclass TestCount(BaseTests):\\n @classmethod\\n def setup_class(cls):\\n cls.NodeClass = Count\\n cls.expected_full = np.isfinite(data).sum()\\n cls.expected_latlon = np.isfinite(data).sum(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_latlon_b = np.isfinite(bdata).sum(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_time = np.isfinite(data).sum(dim=\\\"time\\\")\\n\\n\\nclass TestMean(BaseTests):\\n @classmethod\\n def setup_class(cls):\\n cls.NodeClass = Mean\\n cls.expected_full = data.mean()\\n cls.expected_latlon = data.mean(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_latlon_b = bdata.mean(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_time = data.mean(dim=\\\"time\\\")\\n\\n def test_chunk_sizes(self):\\n for n in [20, 21, 1000, 1001]:\\n podpac.settings[\\\"CHUNK_SIZE\\\"] = n\\n node = self.NodeClass(source=source, dims=coords.dims)\\n output = node.eval(coords)\\n # xr.testing.assert_allclose(output, self.expected_full)\\n np.testing.assert_allclose(output.data, self.expected_full.data)\\n\\n\\nclass TestVariance(BaseTests):\\n @classmethod\\n def setup_class(cls):\\n cls.NodeClass = Variance\\n cls.expected_full = data.var()\\n cls.expected_latlon = data.var(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_latlon_b = bdata.var(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_time = data.var(dim=\\\"time\\\")\\n\\n\\nclass TestStandardDeviation(BaseTests):\\n @classmethod\\n def setup_class(cls):\\n cls.NodeClass = StandardDeviation\\n cls.expected_full = data.std()\\n cls.expected_latlon = data.std(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_latlon_b = bdata.std(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_time = data.std(dim=\\\"time\\\")\\n cls.expected_latlon_b = 2 * cls.expected_latlon\\n\\n\\nclass TestSkew(BaseTests):\\n @classmethod\\n def setup_class(cls):\\n cls.NodeClass = Skew\\n n, m, l = data.shape\\n cls.expected_full = xr.DataArray(scipy.stats.skew(data.data.reshape(n * m * l), nan_policy=\\\"omit\\\"))\\n cls.expected_latlon = scipy.stats.skew(data.data.reshape((n * m, l)), axis=0, nan_policy=\\\"omit\\\")\\n cls.expected_latlon_b = scipy.stats.skew(bdata.data.reshape((n * m, l)), axis=0, nan_policy=\\\"omit\\\")\\n cls.expected_time = scipy.stats.skew(data, axis=2, nan_policy=\\\"omit\\\")\\n\\n\\nclass TestKurtosis(BaseTests):\\n @classmethod\\n def setup_class(cls):\\n cls.NodeClass = Kurtosis\\n n, m, l = data.shape\\n cls.expected_full = xr.DataArray(scipy.stats.kurtosis(data.data.reshape(n * m * l), nan_policy=\\\"omit\\\"))\\n cls.expected_latlon = scipy.stats.kurtosis(data.data.reshape((n * m, l)), axis=0, nan_policy=\\\"omit\\\")\\n cls.expected_latlon_b = scipy.stats.kurtosis(bdata.data.reshape((n * m, l)), axis=0, nan_policy=\\\"omit\\\")\\n cls.expected_time = scipy.stats.kurtosis(data, axis=2, nan_policy=\\\"omit\\\")\\n\\n\\nclass TestMedian(BaseTests):\\n @classmethod\\n def setup_class(cls):\\n cls.NodeClass = Median\\n cls.expected_full = data.median()\\n cls.expected_latlon = data.median(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_latlon_b = bdata.median(dim=[\\\"lat\\\", \\\"lon\\\"])\\n cls.expected_time = data.median(dim=\\\"time\\\")\\n\\n\\n@pytest.mark.skip(\\\"TODO\\\")\\nclass TestPercentile(BaseTests):\\n @classmethod\\n def setup_class(cls):\\n cls.node = Percentile(source=source)\\n # TODO can we replace dims_axes with reshape (or vice versa)\\n\\n\\nclass TestGroupReduce(object):\\n pass\\n\\n\\nclass TestResampleReduce(object):\\n pass\\n\\n\\nclass TestDayOfYear(object):\\n pass\\n\\n\\nclass F(DayOfYearWindow):\\n cache_output = tl.Bool(False)\\n force_eval = tl.Bool(True)\\n\\n def function(self, data, output):\\n return len(data)\\n\\n\\nclass FM(DayOfYearWindow):\\n cache_output = tl.Bool(False)\\n force_eval = tl.Bool(True)\\n\\n def function(self, data, output):\\n return np.mean(data)\\n\\n\\nclass TestDayOfYearWindow(object):\\n def test_doy_window1(self):\\n coords = podpac.coordinates.concat(\\n [\\n podpac.Coordinates([podpac.crange(\\\"1999-12-29\\\", \\\"2000-01-02\\\", \\\"1,D\\\", \\\"time\\\")]),\\n podpac.Coordinates([podpac.crange(\\\"2001-12-30\\\", \\\"2002-01-03\\\", \\\"1,D\\\", \\\"time\\\")]),\\n ]\\n )\\n\\n node = Arange()\\n nodedoywindow = F(source=node, window=1, cache_output=False, force_eval=True)\\n o = nodedoywindow.eval(coords)\\n\\n np.testing.assert_array_equal(o, [2, 2, 1, 1, 2, 2])\\n\\n def test_doy_window2(self):\\n coords = podpac.coordinates.concat(\\n [\\n podpac.Coordinates([podpac.crange(\\\"1999-12-29\\\", \\\"2000-01-03\\\", \\\"1,D\\\", \\\"time\\\")]),\\n podpac.Coordinates([podpac.crange(\\\"2001-12-30\\\", \\\"2002-01-02\\\", \\\"1,D\\\", \\\"time\\\")]),\\n ]\\n )\\n\\n node = Arange()\\n nodedoywindow = F(source=node, window=2, cache_output=False, force_eval=True)\\n o = nodedoywindow.eval(coords)\\n\\n np.testing.assert_array_equal(o, [6, 5, 3, 3, 5, 6])\\n\\n def test_doy_window2_mean_rescale_float(self):\\n coords = podpac.coordinates.concat(\\n [\\n podpac.Coordinates([podpac.crange(\\\"1999-12-29\\\", \\\"2000-01-03\\\", \\\"1,D\\\", \\\"time\\\")]),\\n podpac.Coordinates([podpac.crange(\\\"2001-12-30\\\", \\\"2002-01-02\\\", \\\"1,D\\\", \\\"time\\\")]),\\n ]\\n )\\n\\n node = Arange()\\n nodedoywindow = FM(source=node, window=2, cache_output=False, force_eval=True)\\n o = nodedoywindow.eval(coords)\\n\\n nodedoywindow_s = FM(\\n source=node, window=2, cache_output=False, force_eval=True, scale_float=[0, coords.size], rescale=True\\n )\\n o_s = nodedoywindow_s.eval(coords)\\n\\n np.testing.assert_array_almost_equal(o, o_s)\\n\\n def test_doy_window2_mean_rescale_max_min(self):\\n with podpac.settings:\\n podpac.settings.set_unsafe_eval(True)\\n\\n coords = podpac.coordinates.concat(\\n [\\n podpac.Coordinates([podpac.crange(\\\"1999-12-29\\\", \\\"2000-01-03\\\", \\\"1,D\\\", \\\"time\\\")]),\\n podpac.Coordinates([podpac.crange(\\\"2001-12-30\\\", \\\"2002-01-02\\\", \\\"1,D\\\", \\\"time\\\")]),\\n ]\\n )\\n\\n node = Arange()\\n node_max = Arithmetic(source=node, eqn=\\\"(source < 5) + source\\\")\\n node_min = Arithmetic(source=node, eqn=\\\"-1*(source < 5) + source\\\")\\n\\n nodedoywindow_s = FM(\\n source=node,\\n window=2,\\n cache_output=False,\\n force_eval=True,\\n scale_max=node_max,\\n scale_min=node_min,\\n rescale=False,\\n )\\n o_s = nodedoywindow_s.eval(coords)\\n\\n np.testing.assert_array_almost_equal([0.5] * o_s.size, o_s)\\n\"\n]","isConversational":false},"apis":{"kind":"list like","value":[["numpy.testing.assert_equal","numpy.linspace","numpy.datetime64","numpy.timedelta64","numpy.array"],["numpy.all","numpy.arange","numpy.isnan","numpy.testing.assert_array_equal"],["numpy.testing.assert_array_equal","numpy.concatenate","numpy.random.rand","numpy.linspace"],["numpy.stack"],["numpy.random.random","numpy.isfinite","numpy.stack","numpy.testing.assert_array_equal","numpy.mean","numpy.testing.assert_allclose","numpy.testing.assert_array_almost_equal"]],"string":"[\n [\n \"numpy.testing.assert_equal\",\n \"numpy.linspace\",\n \"numpy.datetime64\",\n \"numpy.timedelta64\",\n \"numpy.array\"\n ],\n [\n \"numpy.all\",\n \"numpy.arange\",\n \"numpy.isnan\",\n \"numpy.testing.assert_array_equal\"\n ],\n [\n \"numpy.testing.assert_array_equal\",\n \"numpy.concatenate\",\n \"numpy.random.rand\",\n \"numpy.linspace\"\n ],\n [\n \"numpy.stack\"\n ],\n [\n \"numpy.random.random\",\n \"numpy.isfinite\",\n \"numpy.stack\",\n \"numpy.testing.assert_array_equal\",\n \"numpy.mean\",\n \"numpy.testing.assert_allclose\",\n \"numpy.testing.assert_array_almost_equal\"\n ]\n]","isConversational":false},"possible_versions":{"kind":"list like","value":[{"matplotlib":[],"numpy":[],"pandas":[],"scipy":[],"tensorflow":[]},{"matplotlib":[],"numpy":[],"pandas":[],"scipy":[],"tensorflow":[]},{"matplotlib":[],"numpy":[],"pandas":[],"scipy":[],"tensorflow":[]},{"matplotlib":[],"numpy":[],"pandas":[],"scipy":[],"tensorflow":[]},{"matplotlib":[],"numpy":[],"pandas":[],"scipy":[],"tensorflow":[]}],"string":"[\n {\n \"matplotlib\": [],\n \"numpy\": [],\n \"pandas\": [],\n \"scipy\": [],\n \"tensorflow\": []\n },\n {\n \"matplotlib\": [],\n \"numpy\": [],\n \"pandas\": [],\n \"scipy\": [],\n \"tensorflow\": []\n },\n {\n \"matplotlib\": [],\n \"numpy\": [],\n \"pandas\": [],\n \"scipy\": [],\n \"tensorflow\": []\n },\n {\n \"matplotlib\": [],\n \"numpy\": [],\n \"pandas\": [],\n \"scipy\": [],\n \"tensorflow\": []\n },\n {\n \"matplotlib\": [],\n \"numpy\": [],\n \"pandas\": [],\n \"scipy\": [],\n \"tensorflow\": []\n }\n]","isConversational":false}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":25,"numItemsPerPage":100,"numTotalItems":73810,"offset":2500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NDM3MTEzMSwic3ViIjoiL2RhdGFzZXRzL3ZlcnNpb24tY29udHJvbC90aGUtc3RhY2stZHMtbGliLTEwMGstdHJhY2UtdmVyc2lvbiIsImV4cCI6MTc3NDM3NDczMSwiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.sVZ2xJJPHYEnY5HKT1QD4Mm0omSIToWm6CUKu_FEiTzhwxswHy-eK6COAXPuQDn1QQgLW0JTE3Owg3anp7EfCQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":73810,"numBytesParquet":432865008}]},"discussionsStats":{"closed":0,"open":0,"total":0},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
repo_name stringlengths 6 130 | hexsha list | file_path list | code list | apis list | possible_versions list |
|---|---|---|---|---|---|
nextBillyonair/DPM | [
"840ffaafe15c208b200b74094ffa8fe493b4c975",
"840ffaafe15c208b200b74094ffa8fe493b4c975",
"840ffaafe15c208b200b74094ffa8fe493b4c975"
] | [
"tests/test_moments.py",
"dpm/transforms/power.py",
"dpm/distributions/arcsine.py"
] | [
"import pytest\nfrom dpm.distributions import *\nimport dpm.utils as utils\nimport torch\n\n\ndef test_arcsine():\n model = Arcsine()\n assert model.expectation == 0.5\n assert model.median == 0.5\n assert model.variance == 0.125\n assert model.skewness == 0.\n assert model.kurtosis == -1.5\n\n ... | [
[
"torch.tensor"
],
[
"torch.nn.Parameter",
"torch.tensor"
],
[
"torch.nn.Parameter",
"torch.max",
"torch.min",
"torch.tensor",
"torch.rand",
"torch.cos"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
skyquant2/gs-quant | [
"b7e648fa7912b13ad1fd503b643389e34587aa1e",
"b7e648fa7912b13ad1fd503b643389e34587aa1e"
] | [
"gs_quant/test/timeseries/test_datetime.py",
"gs_quant/test/timeseries/test_statistics.py"
] | [
"\"\"\"\nCopyright 2018 Goldman Sachs.\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in wr... | [
[
"pandas.testing.assert_series_equal"
],
[
"pandas.testing.assert_series_equal",
"scipy.integrate.odeint"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"p... |
Fa-Li/E3SM | [
"a91995093ec6fc0dd6e50114f3c70b5fb64de0f0",
"a91995093ec6fc0dd6e50114f3c70b5fb64de0f0",
"a91995093ec6fc0dd6e50114f3c70b5fb64de0f0"
] | [
"components/mpas-seaice/testing_and_setup/forcing/create_ocean_forcing.py",
"components/mpas-seaice/testing_and_setup/testcases/square/operators_strain_stress_divergence/strain_stress_divergence_map.py",
"components/mpas-seaice/testing_and_setup/testcases/spherical_operators/strain/average_variational_strains.p... | [
"from __future__ import print_function\nfrom netCDF4 import Dataset\nimport netCDF4\nimport numpy as np\nimport os\nimport sys\nimport ConfigParser\nimport math\nfrom scipy.interpolate import griddata\nfrom create_forcing import create_scrip_grid_file, get_mpas_grid_info, create_scrip_file_MPAS, write_scrip_in_file... | [
[
"numpy.array",
"numpy.zeros",
"scipy.interpolate.griddata",
"numpy.ones"
],
[
"numpy.amax",
"matplotlib.collections.PatchCollection",
"matplotlib.patches.Polygon",
"numpy.amin",
"matplotlib.pyplot.cla",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.savefig",
... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"1.7",
"1.0",
"0.10",
"1.2",
"0.14",
"0.19",
"1.5",
"0.12",
"0.17",
"0.13",
"1.6",
"1.4",
"1.9",
"1.3",
"1.10",
"0.15",
"0.18",
"0.16"... |
minkowski0125/multilayer-gcn-simulation | [
"15a4cd29d819246549148e3a32c99f3b8589f3b4"
] | [
"main.py"
] | [
"import json\nfrom utils import *\nfrom config import args\nfrom train import train\nfrom torch.utils.tensorboard import SummaryWriter\n\nif __name__ == '__main__':\n set_seed(args.seed)\n\n series = []\n if args.dataset == 'pubmed':\n graphs, features, adjs, labels = load_pubmed_data({\n ... | [
[
"torch.utils.tensorboard.SummaryWriter"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
SatyaSiddharthDash/headlinegen | [
"ec11cb4b4dd4e6dce553c787cf31670a83f1c650"
] | [
"data_preprocessing_scripts/preprocess.py"
] | [
"import pandas as pd\nfrom sklearn.model_selection import train_test_split\n\n\nrandom_state = 100\n\ndata = pd.read_csv(\"~/headlinegen/data/nytime_front_page.csv\")\ndata['title'] = data['title'].apply(lambda x: ' '.join(x.split(' ')[:-5]))\n\nlens = data[\"content\"].apply(lambda x: len(x.split(\" \"))).nlargest... | [
[
"pandas.read_csv"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
duypham2108/stLearn | [
"91b6bae91b29aba8b4f055bf92da13f1558ddbe8",
"91b6bae91b29aba8b4f055bf92da13f1558ddbe8"
] | [
"stlearn/tools/microenv/cci/base_grouping.py",
"stlearn/tools/microenv/cci/perm_utils.py"
] | [
"\"\"\" Performs LR analysis by grouping LR pairs which having hotspots across\n similar tissues.\n\"\"\"\n\nfrom stlearn.pl import het_plot\nfrom sklearn.cluster import DBSCAN, AgglomerativeClustering\nfrom anndata import AnnData\nfrom tqdm import tqdm\nimport numpy as np\nimport pandas as pd\nimport matplotlib... | [
[
"numpy.array",
"numpy.unique",
"numpy.quantile",
"matplotlib.pyplot.subplots",
"pandas.DataFrame",
"sklearn.cluster.DBSCAN",
"numpy.apply_along_axis",
"numpy.mean",
"numpy.argmax",
"numpy.argsort",
"sklearn.cluster.AgglomerativeClustering",
"matplotlib.pyplot.show",... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"nump... |
MarkDaoust/agents | [
"00ddf75a8a35a26a03a9323b78d95c06211b5b3f"
] | [
"tf_agents/bandits/agents/utils_test.py"
] | [
"# coding=utf-8\n# Copyright 2018 The TF-Agents 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 b... | [
[
"tensorflow.compat.v1.enable_v2_behavior",
"tensorflow.norm",
"tensorflow.constant",
"tensorflow.reduce_sum",
"tensorflow.test.main",
"tensorflow.ones",
"numpy.array",
"numpy.zeros",
"numpy.sum"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"2.7",
"1.12",
"2.6",
"2.2",
"1.13",
"2.3",
"2.4",
"1.4",
"2.9",
"1.5",
"1.7",
"2.5",
"0.12",
"1.0",
"2.8",
"1... |
abhinavralhan/dask | [
"e840ba38eadfa93c3b9959347f0a43c1279a94ab",
"e840ba38eadfa93c3b9959347f0a43c1279a94ab",
"e840ba38eadfa93c3b9959347f0a43c1279a94ab"
] | [
"dask/dataframe/tests/test_hashing.py",
"dask/dataframe/rolling.py",
"dask/dataframe/categorical.py"
] | [
"import numpy as np\nimport pandas as pd\nimport pandas.util.testing as tm\n\nimport pytest\n\nfrom dask.dataframe.hashing import hash_pandas_object\nfrom dask.dataframe.utils import assert_eq\n\n\n@pytest.mark.parametrize('obj', [\n pd.Series([1, 2, 3]),\n pd.Series([1.0, 1.5, 3.2]),\n pd.Series([1.0, 1.5... | [
[
"pandas.util.testing.makeTimeDataFrame",
"numpy.testing.assert_equal",
"pandas.util.testing.makeMissingDataframe",
"pandas.Series",
"pandas.util.testing.makeTimeSeries",
"pandas.util.testing.makeMixedDataFrame",
"pandas.Index",
"pandas.util.testing.assert_series_equal",
"pandas... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"1.4",
"1.3",
"0.19",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"... |
alechfho/dog_breed | [
"2e2f7083c859fdb250f5ba920246b9d2f8168b4d"
] | [
"dataset_processing.py"
] | [
"import numpy as np\nimport pandas as pd\n\n\ndef partition_images(df_labels, identifier_label=None, label_postfix='postfix', target_dir='./', filter_identity=[],\n dev_portion=0.20, encoding_strategy='vgg19_4096'):\n if np.size(filter_identity) == 0:\n filter_identity = df_labels[iden... | [
[
"numpy.ceil",
"numpy.size",
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
ebothmann/heppyplot | [
"dab969879391f70a91c34f71482a9691b9c80141"
] | [
"heppyplot/plot_helpers.py"
] | [
"import math\n\nimport matplotlib.pyplot as plt\nimport matplotlib.gridspec as gridspec\nimport matplotlib.transforms as mtransforms\nfrom mpl_toolkits.axes_grid.anchored_artists import AnchoredText\n\ndef setup_axes(diff=False):\n fig = plt.figure()\n axes = []\n if diff:\n gs = gridspec.GridSpec(2... | [
[
"matplotlib.pyplot.subplot",
"matplotlib.gridspec.GridSpec",
"matplotlib.pyplot.rcParams.update",
"matplotlib.transforms.interval_contains",
"matplotlib.pyplot.figure"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
SeanNaren/transformers | [
"8d43c71a1ca3ad322cc45008eb66a5611f1e017e",
"8d43c71a1ca3ad322cc45008eb66a5611f1e017e"
] | [
"examples/tensorflow/text-classification/run_text_classification.py",
"src/transformers/models/speech_to_text/modeling_speech_to_text.py"
] | [
"#!/usr/bin/env python\n# coding=utf-8\n# Copyright 2021 The HuggingFace Inc. team. 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.... | [
[
"tensorflow.keras.losses.SparseCategoricalCrossentropy",
"tensorflow.keras.losses.MeanSquaredError",
"numpy.arange",
"numpy.squeeze",
"tensorflow.ragged.constant",
"tensorflow.keras.optimizers.Adam",
"numpy.random.permutation",
"numpy.argmax",
"numpy.array"
],
[
"torch.... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"2.7",
"2.2",
"2.3",
"2.4",
"2.5",
"2.6"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
ParticularMiner/dask | [
"f40ef97ac802efb6d8bef03b03c6357cf871bc0a"
] | [
"dask/dataframe/io/parquet/fastparquet.py"
] | [
"import copy\nimport pickle\nimport threading\nimport warnings\nfrom collections import OrderedDict, defaultdict\nfrom contextlib import ExitStack\n\nimport numpy as np\nimport pandas as pd\nimport tlz as toolz\nfrom packaging.version import parse as parse_version\n\nfrom dask.core import flatten\n\ntry:\n impor... | [
[
"pandas.Timestamp",
"pandas.CategoricalDtype",
"pandas.Series"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"0.24",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
facebookresearch/pythia | [
"079740bee4b357a7b1b866d35e2f1fad6edba8a4"
] | [
"mmf/modules/encoders.py"
] | [
"# Copyright (c) Facebook, Inc. and its affiliates.\nimport importlib\nimport logging\nimport os\nimport pickle\nimport re\nfrom collections import OrderedDict\nfrom copy import deepcopy\nfrom dataclasses import asdict, dataclass\nfrom enum import Enum\nfrom typing import Any\n\nimport torch\nimport torchvision\nfr... | [
[
"torch.nn.Sequential",
"torch.load",
"torch.cat",
"torch.nn.Conv2d",
"torch.from_numpy",
"torch.nn.Embedding",
"torch.nn.Linear",
"torch.nn.Identity",
"torch.nn.functional.relu",
"torch.prod",
"torch.flatten",
"torch.hub.load",
"torch.hub.load_state_dict_from_ur... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
ZPAVelocity/DataStructureExercise | [
"39b1cce859e5c46599b3a6e69ac80ade5920aa34"
] | [
"DynamicProgramming/matrixChainMultiplication.py"
] | [
"import sys\nimport numpy as np\n\n\ndef main():\n p = [30, 35, 15, 5, 10, 20, 25]\n m, s = matrixChainOrder(p)\n \n print('m')\n for i in m:\n print(i)\n print('s')\n for i in s:\n print(i)\n\n\ndef matrixMultiply(A, B):\n if A.shape[1] != B.shape[0]:\n print('incompati... | [
[
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
IngrojShrestha/language | [
"674a3d016b1e17658e301e8d9bdfa63e3d3f5d15"
] | [
"language/bert_extraction/steal_bert_qa/data_generation/preprocess_thief_dev_squad.py"
] | [
"# coding=utf-8\n# Copyright 2018 The Google AI Language Team 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# Unl... | [
[
"numpy.random.seed"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
tangzhiyi11/Paddle | [
"790cadd1f06fabeadc4b9aeca5622ea50985b990",
"790cadd1f06fabeadc4b9aeca5622ea50985b990"
] | [
"python/paddle/fluid/tests/unittests/test_egr_python_api.py",
"python/paddle/fluid/tests/unittests/dygraph_to_static/test_declarative.py"
] | [
"# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.\n# \n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n# \n# http://www.apache.org/licenses/LICENSE-2.0\n# \n# Unless... | [
[
"numpy.random.random",
"numpy.array_equal",
"numpy.ones",
"numpy.random.rand",
"numpy.zeros",
"numpy.random.randint"
],
[
"numpy.ones"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Efreeto/face-alignment | [
"d496866ac3d66c8353ba3e0305f16ac8a2ccc017"
] | [
"face_alignment/FaceLandmarksDataset.py"
] | [
"import torch\nfrom torch.utils.data import Dataset\nfrom skimage import io, color, transform\nimport torchvision\nimport os, glob\nimport numpy as np\nimport random\nfrom scipy import ndimage\nfrom PIL import Image\nimport torch.nn.functional as F\n\nfrom . import utils\n\n#########################################... | [
[
"numpy.dot",
"torch.Tensor",
"numpy.fliplr",
"torch.from_numpy",
"scipy.ndimage.rotate",
"numpy.ones",
"numpy.zeros",
"numpy.loadtxt",
"numpy.random.randint"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"1.7",
"1.0",
"0.10",
"1.2",
"0.14",
"0.19",
"1.5",
"0.12",
"0.17",
"0.13",
"1.6",
"1.4",
"1.9",
"1.3",
"1.10",
"0.15",
"0.18",
"0.16"... |
PNNL-Comp-Mass-Spec/CRNT4SBML | [
"20406f452863f35f766b504fe2b3f3ab034b62fe",
"20406f452863f35f766b504fe2b3f3ab034b62fe"
] | [
"crnt4sbml/safety_wrap.py",
"tests/nuts_script.py"
] | [
"import os\nimport pickle\nimport numpy\nimport antimony\nimport roadrunner\nimport rrplugins\nimport sys\n\nroadrunner.Logger.setLevel(roadrunner.Logger.LOG_ERROR)\nroadrunner.Logger.disableLogging()\nroadrunner.Logger.disableConsoleLogging()\nroadrunner.Logger.disableFileLogging()\nrrplugins.setLogLevel('error')\... | [
[
"numpy.zeros",
"numpy.save"
],
[
"pandas.concat",
"numpy.linspace",
"numpy.vstack",
"numpy.save",
"scipy.integrate.odeint",
"pandas.DataFrame",
"numpy.array",
"numpy.flip",
"matplotlib.rc"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.3",
"0.19",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"... |
TimeTraveller-San/FairGAN | [
"526c2937714fc322714db54dc6a3f392f2c88e18"
] | [
"we.py"
] | [
"from __future__ import print_function, division\nimport re\nimport sys\nimport numpy as np\nimport scipy.sparse\nimport codecs\nfrom sklearn.decomposition import PCA\nif sys.version_info[0] < 3:\n import io\n open = io.open\nelse:\n unicode = str\n\"\"\"\nTools for debiasing word embeddings\n\nMan is to C... | [
[
"numpy.median",
"numpy.linalg.norm",
"numpy.mean",
"numpy.load",
"numpy.array",
"sklearn.decomposition.PCA"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
seanlam97/PDK_Generator | [
"15c1f4f56575f8e21ea874443d06ef740ccb5aa5",
"15c1f4f56575f8e21ea874443d06ef740ccb5aa5",
"15c1f4f56575f8e21ea874443d06ef740ccb5aa5",
"15c1f4f56575f8e21ea874443d06ef740ccb5aa5"
] | [
"PDK_Generator/inverse_design_y_branch/lumopt/geometries/parameterized_geometry.py",
"PDK_Generator/inverse_design_y_branch/lumopt/geometries/geometry.py",
"PDK_Generator/inverse_design_y_branch/lumopt/optimizers/generic_optimizers.py",
"PDK_Generator/design_automation/polarization_splitter_rotator/psr_bitape... | [
"import numpy as np\nimport inspect\n\nfrom lumopt.geometries.geometry import Geometry\n\nclass ParameterizedGeometry(Geometry):\n \"\"\" \n Defines a parametrized geometry using any of the built-in geometric structures available in the FDTD CAD.\n Users must provide a Python function with the sign... | [
[
"numpy.array"
],
[
"numpy.concatenate",
"numpy.array"
],
[
"scipy.optimize.minimize"
],
[
"matplotlib.pyplot.legend",
"matplotlib.pyplot.title",
"numpy.linspace",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.show",
"matplotlib.pyp... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.13",
"1.6",
"... |
szhaofelicia/sgan | [
"ead42d4bb3b1278c4c9ffcae8fa9c2dc036a52ff",
"ead42d4bb3b1278c4c9ffcae8fa9c2dc036a52ff"
] | [
"vis/visualize_court.py",
"sgan/data/trajectories_basketball_0427.py"
] | [
"import numpy as np\n# import plotly\nimport plotly.graph_objects as go\n\n\n\ndef draw_plotly_half_court(fig, fig_width=600, margins=10):\n # From: https://community.plot.ly/t/arc-shape-with-path/7205/5\n def ellipse_arc(x_center=0.0, y_center=0.0, a=10.5, b=10.5, start_angle=0.0, end_angle=2 * np.pi, N=200,... | [
[
"numpy.cos",
"numpy.linspace",
"numpy.sin"
],
[
"torch.LongTensor",
"numpy.polyfit",
"numpy.linspace",
"torch.cat",
"numpy.asarray",
"numpy.unique",
"numpy.around",
"numpy.cumsum",
"torch.from_numpy",
"numpy.concatenate",
"numpy.transpose",
"numpy.ze... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
ChristophReich1996/Mode_Collapse | [
"937ee8bf96510fbf4070fc7e14b78276ab036b8c"
] | [
"utils.py"
] | [
"from typing import Optional\n\nimport torch\nimport torch.nn as nn\nfrom torch.nn.utils import spectral_norm\nimport numpy as np\n\n\ndef get_generator(latent_size: int, use_spectral_norm: bool) -> nn.Module:\n \"\"\"\n Returns the generator network.\n :param latent_size: (int) Size of the latent input ve... | [
[
"torch.normal",
"torch.ones",
"torch.empty",
"torch.sin",
"torch.randperm",
"torch.nn.Tanh",
"torch.nn.Linear",
"torch.nn.LeakyReLU",
"torch.cos"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
galad-loth/LearnDescriptor | [
"30552a699597415a13793eb85d21b5e33a296a99"
] | [
"symbols/symbol_ssdh.py"
] | [
"# -*- coding: utf-8 -*-\r\n\"\"\"\r\nCreated on Tue Mar 07 21:00:11 2017\r\n\r\n@author: galad-loth\r\n\"\"\"\r\nimport numpy as npy\r\nimport mxnet as mx\r\n\r\nclass HashLossLayer(mx.operator.NumpyOp):\r\n def __init__(self, w_bin,w_balance):\r\n super(HashLossLayer, self).__init__(False)\r\n se... | [
[
"numpy.mean"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
stevenvandenberghe/pandas | [
"8cbee356da1161c56c64f6f89cb5548bcadc3e44"
] | [
"pandas/tests/reshape/test_tile.py"
] | [
"import os\nimport pytest\n\nimport numpy as np\nfrom pandas.compat import zip\n\nfrom pandas import (Series, isna, to_datetime, DatetimeIndex,\n Timestamp, Interval, IntervalIndex, Categorical,\n cut, qcut, date_range)\nimport pandas.util.testing as tm\nfrom pandas.api.types i... | [
[
"pandas.to_datetime",
"pandas.Series",
"numpy.linspace",
"numpy.asarray",
"pandas.util.testing.assert_index_equal",
"numpy.random.randn",
"pandas.isna",
"pandas.util.testing.assert_numpy_array_equal",
"numpy.allclose",
"pandas.util.testing.assert_categorical_equal",
"nu... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
Jokeren/RzLinear | [
"d318d95254cd5c3dcf814774d22dc71179450aa0"
] | [
"python/rz_linear/impl/RzLinearBackward.py"
] | [
"from typing import Tuple\nimport torch\nimport triton\nimport triton.language as tl\n\n\ndef rz_linear_backward_tl(input: torch.tensor, hashed_weight: torch.tensor, output_grad: torch.tensor,\n M: int, K: int, N: int, H: int,\n R3: int, R2: int, R1: int, R0: int,\n... | [
[
"torch.empty",
"torch.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
cdgreenidge/gpytorch | [
"d4cc610963bd812052e43e3aed84fb8b2ec94aa6",
"d4cc610963bd812052e43e3aed84fb8b2ec94aa6",
"d4cc610963bd812052e43e3aed84fb8b2ec94aa6"
] | [
"test/lazy/test_added_diag_lazy_tensor.py",
"test/lazy/test_toeplitz_lazy_tensor.py",
"gpytorch/lazy/lazy_tensor.py"
] | [
"#!/usr/bin/env python3\n\nimport torch\nimport unittest\nfrom gpytorch.lazy import NonLazyTensor, DiagLazyTensor, AddedDiagLazyTensor\nfrom test.lazy._lazy_tensor_test_case import LazyTensorTestCase\n\n\nclass TestAddedDiagLazyTensor(LazyTensorTestCase, unittest.TestCase):\n seed = 0\n should_test_sample = T... | [
[
"torch.randn",
"torch.tensor"
],
[
"torch.tensor"
],
[
"torch.autograd.enable_grad",
"torch.Size",
"torch.cat",
"torch.eye",
"torch.is_tensor",
"torch.tensor",
"torch.arange",
"torch.autograd.grad"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
UKPLab/emnlp2019-dualgraph | [
"0c58fb7f3ad3b9da3b92b2d2841558807fc79fd0"
] | [
"onmt/models/model_saver.py"
] | [
"import os\nimport torch\nimport torch.nn as nn\n\nfrom collections import deque\nfrom onmt.utils.logging import logger\n\nfrom copy import deepcopy\n\n\ndef build_model_saver(model_opt, opt, model, fields, optim):\n model_saver = ModelSaver(opt.save_model,\n model,\n ... | [
[
"torch.save"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
hsk9767/mesh_rcnn_copy | [
"6dd4d9ea8af33c03a084e34c7d16eeaddfe924ae"
] | [
"meshrcnn/modeling/roi_heads/roi_heads.py"
] | [
"# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\nfrom typing import Dict\nimport torch\nfrom detectron2.layers import ShapeSpec, cat\nfrom detectron2.modeling import ROI_HEADS_REGISTRY\nfrom detectron2.modeling.poolers import ROIPooler\nfrom detectron2.modeling.roi_heads.fast_rcnn import Fas... | [
[
"torch.no_grad"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
J-Massey/postproc | [
"4552b0ad79072f5d217cf62632c08617ea3d2d82",
"4552b0ad79072f5d217cf62632c08617ea3d2d82"
] | [
"circular_cylinder/figures/plot.py",
"flat_plate/res_test.py"
] | [
"import matplotlib.pyplot as plt\nimport seaborn as sns\nimport numpy as np\nfrom itertools import product\nimport os\nfrom mpl_toolkits.axes_grid1 import make_axes_locatable\nfrom matplotlib import ticker, cm\nfrom mpl_toolkits.axes_grid1 import make_axes_locatable\nfrom matplotlib.ticker import FormatStrFormatter... | [
[
"numpy.sqrt",
"numpy.meshgrid",
"numpy.arange",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.savefig",
"numpy.cos",
"numpy.sin",
"matplotlib.pyplot.colorbar",
"numpy.mean",
"matplotlib.pyplot.close",
"matplotlib.colors.LinearSegmentedColormap.from_list",
"numpy.... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
zhengzx-nlp/REDER | [
"7035e089e4d30b8090a2c3caa937b1e0ba27cedc"
] | [
"fairseq/modules/fairseq_dropout.py"
] | [
"# Copyright (c) Facebook, Inc. and its affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\nimport logging\nfrom typing import List, Optional\n\nimport torch.nn as nn\nimport torch.nn.functional as F\n\n\nlogger = logging.ge... | [
[
"torch.nn.functional.dropout"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
EricPedley/FCRN-DepthPrediction | [
"93aaed329e9e071c6d5c5a59e77a73a09684b156"
] | [
"tensorflow/network.py"
] | [
"import numpy as np\nimport tensorflow.compat.v1 as tf\ntf.disable_v2_behavior()\n\n# ----------------------------------------------------------------------------------\n# Commonly used layers and operations based on ethereon's implementation \n# https://github.com/ethereon/caffe-tensorflow\n# Slight modifications ... | [
[
"tensorflow.compat.v1.nn.dropout",
"tensorflow.compat.v1.concat",
"tensorflow.compat.v1.add_n",
"tensorflow.compat.v1.reshape",
"tensorflow.compat.v1.nn.avg_pool",
"tensorflow.compat.v1.constant_initializer",
"numpy.load",
"tensorflow.compat.v1.nn.local_response_normalization",
... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
arjunchandra/continuous-rl | [
"8f3c655c6a4b2e9d15a6b052e5466c0a75191a08"
] | [
"code/nn.py"
] | [
"\"\"\"Some nn utilities.\"\"\"\nimport torch\nfrom abstract import ParametricFunction\n\ndef copy_buffer(net: ParametricFunction, target_net: ParametricFunction):\n \"\"\"Copy all buffers from net to target_net.\"\"\"\n with torch.no_grad():\n for target_buf, buf in zip(target_net.buffers(), net.buffe... | [
[
"torch.no_grad"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
sotudian/Natural-Language-Processing | [
"61ba2ac78e440683519d2121ca2b29a17277e46b"
] | [
"LSTM for language modeling/Question2_Part_1_To_2.py"
] | [
"#!/usr/bin/env python3\n# -*- coding: utf-8 -*-\n\"\"\"\nTrain the language model on texts from the file pride And Prejudice. Before using it to train the language model,\nyou need to first sentence segment, then tokenize, then lower case each line of the file using Spacy. Append \nstart-of-sentence token ’<s>’ an... | [
[
"torch.nn.CrossEntropyLoss",
"torch.nn.Dropout",
"torch.nn.functional.softmax",
"torch.load",
"torch.nn.LSTM",
"torch.from_numpy",
"torch.nn.Embedding",
"torch.nn.Linear",
"torch.no_grad",
"torch.cuda.is_available",
"numpy.array",
"torch.save"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
ChenRocks/Distill-BERT-Textgen | [
"a3b0b22ce16febc4d3ffdbd8791ea3374110a892"
] | [
"dump_teacher_hiddens.py"
] | [
"\"\"\"\nCopyright (c) Microsoft Corporation.\nLicensed under the MIT license.\n\nprecompute hidden states of CMLM teacher to speedup KD training\n\"\"\"\nimport argparse\nimport io\nimport os\nimport shelve\n\nimport numpy as np\nimport torch\nfrom torch.utils.data import Dataset, DataLoader\nfrom tqdm import tqdm... | [
[
"torch.ones",
"torch.load",
"torch.zeros",
"torch.utils.data.DataLoader",
"torch.eye",
"torch.nn.Linear",
"torch.no_grad",
"torch.stack",
"torch.save"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
mikimaus78/ml_monorepo | [
"b2c2627ff0e86e27f6829170d0dac168d8e5783b",
"b2c2627ff0e86e27f6829170d0dac168d8e5783b",
"b2c2627ff0e86e27f6829170d0dac168d8e5783b",
"b2c2627ff0e86e27f6829170d0dac168d8e5783b",
"b2c2627ff0e86e27f6829170d0dac168d8e5783b"
] | [
"trading-with-python/util/trendy.py",
"BiBloSA/exp_SQuAD_sim/src/nn_utils/baselines/block_attention.py",
"ufcnn-keras/models/a3c/game_ac_network_v2.py",
"pymf/pymf/svd.py",
"pymf/pymf/cmde.py"
] | [
"import numpy as np\nfrom filter import movingaverage\n\ndef gentrends(x, window=1/3.0, charts=True):\n \"\"\"\n Returns a Pandas dataframe with support and resistance lines.\n\n :param x: One-dimensional data set\n :param window: How long the trendlines should be. If window < 1, then it\n ... | [
[
"numpy.isnan",
"numpy.ones",
"matplotlib.pyplot.plot",
"numpy.append",
"numpy.insert",
"matplotlib.pyplot.grid",
"numpy.array",
"numpy.zeros",
"numpy.where",
"matplotlib.pyplot.show",
"matplotlib.pyplot.figure"
],
[
"tensorflow.concat",
"tensorflow.zeros",
... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"1.12",
"1.4",
"1.13",
"1.5",
"1.7",
"0.12",
"1.0",
"1... |
jbushago/GamestonkTerminal | [
"73a2b419664bf62bbdc59aa8402c8cd6a913a518",
"ab4de1dd70fba866930150e440a03e461a6ca6a8",
"73a2b419664bf62bbdc59aa8402c8cd6a913a518",
"ab4de1dd70fba866930150e440a03e461a6ca6a8"
] | [
"gamestonk_terminal/stocks/insider/openinsider_view.py",
"gamestonk_terminal/stocks/insider/finviz_view.py",
"gamestonk_terminal/stocks/due_diligence/finnhub_model.py",
"gamestonk_terminal/common/quantitative_analysis/qa_model.py"
] | [
"import itertools\nimport logging\nimport os\nimport textwrap\nfrom typing import List\n\nimport numpy as np\nimport pandas as pd\nimport requests\nfrom bs4 import BeautifulSoup\n\nfrom gamestonk_terminal.decorators import log_start_end\nfrom gamestonk_terminal.helper_funcs import (\n export_data,\n patch_pan... | [
[
"pandas.set_option",
"pandas.DataFrame",
"numpy.unique"
],
[
"pandas.DataFrame.from_dict"
],
[
"pandas.DataFrame"
],
[
"scipy.stats.kstest",
"scipy.stats.norm.ppf",
"numpy.log",
"numpy.sqrt",
"scipy.stats.norm.pdf",
"scipy.stats.skewtest",
"pandas.DataFr... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"nump... |
drkostas/COSC525-Project2 | [
"a33c786621e6047b0a586c7c3a3b5b85cb51fd6d",
"a33c786621e6047b0a586c7c3a3b5b85cb51fd6d"
] | [
"main.py",
"main_project1.py"
] | [
"import traceback\nimport argparse\nimport numpy as np\nfrom src import NeuralNetwork, generateExample, getTensorExample\nfrom typing import *\n\n\ndef get_args() -> argparse.Namespace:\n \"\"\"Set-up the argument parser\n\n Returns:\n argparse.Namespace:\n \"\"\"\n parser = argparse.ArgumentPars... | [
[
"numpy.concatenate",
"numpy.array"
],
[
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
suo/pytext | [
"400c80b4c040de12028970a85ce0af864931e0f4"
] | [
"pytext/trainers/trainer.py"
] | [
"#!/usr/bin/env python3\n# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved\n\nimport itertools\nimport time\nfrom contextlib import ExitStack as contextlib_ExitStack\nfrom typing import Any, Iterable, List, Optional, Tuple\n\nimport torch\nfrom pytext.common.constants import BatchContext, Stage... | [
[
"torch.no_grad",
"torch.cuda.current_device"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
a1600012888/fairseq | [
"dbd2cd08fc396f919d2e737513095fcb966896c0"
] | [
"fairseq/criterions/masked_adlm.py"
] | [
"# Copyright (c) Facebook, Inc. and its affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\nimport math\n\nimport torch\nimport torch.nn.functional as F\n\nfrom fairseq import metrics, utils\nfrom fairseq.criterions import F... | [
[
"torch.nn.functional.embedding",
"torch.mean",
"torch.exp",
"torch.no_grad",
"torch.ones_like"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
terra-submersa/opensfm-camera-coverage | [
"a9ad2bff799a5d0d07d7900fc7d1bf10bc489632"
] | [
"src/odm_report_shot_coverage/models/reconstruction.py"
] | [
"import json\nimport logging\n\nimport geojson\nimport numpy as np\nfrom tqdm import tqdm\nfrom scipy import stats\n\nfrom odm_report_shot_coverage.models.camera import Camera, json_parse_camera\nfrom odm_report_shot_coverage.models.shot import Shot, shot_boundaries_from_points, Boundaries\nfrom odm_report_shot_cov... | [
[
"scipy.stats.linregress",
"numpy.abs"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.13",
"1.6",
"0.14",
"1.10",
"0.15",
"1.4",
"0.16",
"1.9",
"0.19",
"1.5",
"0.18",
"1.2",
"1.7",
"0.12",
"1.0",
"0.17",
"1.3",
"1.8"
... |
SeongSuKim95/ReID-Baseline-swin | [
"f30db86eb2690c20c4fbb0189eb52b57358705df"
] | [
"demo.py"
] | [
"import argparse\nimport scipy.io\nimport torch\nimport numpy as np\nimport os\nfrom torchvision import datasets\nimport matplotlib\nmatplotlib.use('agg')\nimport matplotlib.pyplot as plt\n#######################################################################\n# Evaluate\nparser = argparse.ArgumentParser(descripti... | [
[
"matplotlib.pyplot.imshow",
"torch.mm",
"matplotlib.pyplot.title",
"matplotlib.use",
"matplotlib.pyplot.imread",
"numpy.in1d",
"numpy.argwhere",
"numpy.intersect1d",
"numpy.append",
"matplotlib.pyplot.subplot",
"torch.FloatTensor",
"numpy.argsort",
"matplotlib.p... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
erinaldi/MetaRL | [
"6dfb8d2e63a1802ca7ef9c28f6ab1a758d07f871"
] | [
"rlkit/envs/point_robot.py"
] | [
"import numpy as np\nfrom gym import spaces\nfrom gym import Env\n\nfrom . import register_env\n\n\n@register_env('point-robot')\nclass PointEnv(Env):\n \"\"\"\n point robot on a 2-D plane with position control\n tasks (aka goals) are positions on the plane\n\n - tasks sampled from unit square\n - ... | [
[
"numpy.random.seed",
"numpy.linspace",
"numpy.cos",
"numpy.stack",
"numpy.random.shuffle",
"numpy.sin",
"numpy.copy",
"numpy.random.uniform",
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
sejongjoa/openpilot_083 | [
"301500dff6bd53e64257898cac939b24f56befac"
] | [
"selfdrive/locationd/locationd.py"
] | [
"#!/usr/bin/env python3\nimport json\nimport numpy as np\nimport sympy as sp\nimport cereal.messaging as messaging\nfrom cereal import log\nfrom common.params import Params\nimport common.transformations.coordinates as coord\nfrom common.transformations.orientation import ecef_euler_from_ned, \\\n ... | [
[
"numpy.diag",
"numpy.radians",
"numpy.sqrt",
"numpy.eye",
"numpy.linalg.norm",
"numpy.ones",
"numpy.concatenate",
"numpy.mean",
"numpy.mod",
"numpy.array",
"numpy.zeros",
"numpy.diagonal"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
redhat6/cornac | [
"856cf0f546a0dc6b46f407128d89ef2534994c60",
"856cf0f546a0dc6b46f407128d89ef2534994c60"
] | [
"cornac/models/hft/recom_hft.py",
"cornac/models/ncf/recom_gmf.py"
] | [
"# Copyright 2018 The Cornac 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... | [
[
"numpy.arange"
],
[
"tensorflow.Graph",
"tensorflow.nn.sigmoid",
"numpy.random.seed",
"numpy.arange",
"tensorflow.placeholder",
"tensorflow.compat.v1.logging.set_verbosity",
"tensorflow.ConfigProto",
"tensorflow.global_variables_initializer",
"tensorflow.initializers.le... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"1.12",
"1.4",
"1.13",
"1.5",
"1.7",
"0.12",
"1.0",
"1... |
ryanloney/openvino-1 | [
"4e0a740eb3ee31062ba0df88fcf438564f67edb7",
"4e0a740eb3ee31062ba0df88fcf438564f67edb7",
"4e0a740eb3ee31062ba0df88fcf438564f67edb7",
"4e0a740eb3ee31062ba0df88fcf438564f67edb7",
"4e0a740eb3ee31062ba0df88fcf438564f67edb7",
"4e0a740eb3ee31062ba0df88fcf438564f67edb7",
"4e0a740eb3ee31062ba0df88fcf438564f67edb... | [
"tools/mo/unit_tests/mo/load/loader_test.py",
"tools/mo/unit_tests/mo/ops/dft_signal_size_canonicalization_test.py",
"tools/mo/unit_tests/mo/middle/InterpolateSequenceToInterpolate_test.py",
"tools/mo/openvino/tools/mo/ops/constant_fill.py",
"tools/mo/openvino/tools/mo/ops/prelu.py",
"tools/mo/openvino/to... | [
"# Copyright (C) 2018-2022 Intel Corporation\n# SPDX-License-Identifier: Apache-2.0\n\nimport unittest\n\nimport numpy as np\n\nfrom openvino.tools.mo.load.tf.loader import graph_or_sub_graph_has_nhwc_ops\nfrom unit_tests.utils.graph import build_graph, result, regular_op, const, connect_front\n\n\nclass TFLoaderTe... | [
[
"numpy.random.randn"
],
[
"numpy.array_equal"
],
[
"numpy.array"
],
[
"numpy.full"
],
[
"numpy.all"
],
[
"numpy.reshape"
],
[
"numpy.array"
],
[
"numpy.ones"
],
[
"numpy.uint32",
"numpy.bool",
"numpy.uint8",
"numpy.float16",
"nump... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
... |
hades208002/mdp-project | [
"c242a8d00412cc3772d298986977f6acc47002ee",
"c242a8d00412cc3772d298986977f6acc47002ee"
] | [
"client_server_test/NEWGUI.py",
"client_server_test/LocalModel.py"
] | [
"from tkinter import *\nfrom tkinter import ttk\nimport tkinter.filedialog as fd\nimport pandas as pd\nfrom LocalModelCommunication import LocalModelCommunication\nfrom APP import APP\n\nclass GUI(object):\n\tdef __init__(self):\n\t\t# overall\n\t\tself.tabControl = None\n\t\tself.tab_step1 = None\n\t\tself.tab_ste... | [
[
"pandas.read_csv"
],
[
"sklearn.ensemble.BaggingClassifier",
"pandas.concat",
"sklearn.naive_bayes.GaussianNB",
"sklearn.linear_model.LogisticRegression",
"sklearn.ensemble.RandomForestClassifier",
"sklearn.ensemble.ExtraTreesClassifier",
"sklearn.discriminant_analysis.LinearDi... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1.3"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.3",
... |
sidneyp/bidirectional | [
"d3d1dbb727e5a25b4980646f1eb500245072f079",
"d3d1dbb727e5a25b4980646f1eb500245072f079"
] | [
"cifar_cnn_three_conv.py",
"mnist_nn_four_hidden.py"
] | [
"import tensorflow as tf\nimport keras\nfrom keras.datasets import cifar10\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport matplotlib.gridspec as gridspec\nimport os\nimport sys\nimport csv\nimport utils_csv\nimport utils_tf as utils\nfrom cleverhans.utils_tf import model_train, model_eval\nfrom clever... | [
[
"tensorflow.nn.softmax_cross_entropy_with_logits",
"tensorflow.cast",
"numpy.random.random_sample",
"tensorflow.nn.conv2d_transpose",
"tensorflow.nn.sigmoid_cross_entropy_with_logits",
"tensorflow.train.AdamOptimizer",
"numpy.exp",
"tensorflow.summary.scalar",
"tensorflow.nn.co... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
}
] |
kathryn-garside/PyDMD-fork | [
"0158c4144019f0899ce34ec44286b0f700c56b38",
"0158c4144019f0899ce34ec44286b0f700c56b38",
"0158c4144019f0899ce34ec44286b0f700c56b38"
] | [
"pydmd/hankeldmd.py",
"tests/test_dmd.py",
"pydmd/dmd_modes_tuner.py"
] | [
"\"\"\"\nDerived module from dmdbase.py for hankel dmd.\n\nReference:\n- H. Arbabi, I. Mezic, Ergodic theory, dynamic mode decomposition, and\ncomputation of spectral properties of the Koopman operator. SIAM Journal on\nApplied Dynamical Systems, 2017, 16.4: 2096-2126.\n\"\"\"\nfrom copy import copy\n\nimport numpy... | [
[
"numpy.split",
"numpy.isnan",
"numpy.full",
"numpy.mean",
"numpy.average"
],
[
"numpy.sqrt",
"numpy.linspace",
"numpy.squeeze",
"numpy.all",
"numpy.exp",
"numpy.testing.assert_equal",
"numpy.arange",
"numpy.full",
"numpy.testing.assert_almost_equal",
... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
tkelestemur/pfrl | [
"388855fb30313185d43ae0d0f4b694be647a5c43"
] | [
"pfrl/policies/softmax_policy.py"
] | [
"import torch\nfrom torch import nn\nfrom torch.distributions import Categorical\n\n\nclass SoftmaxCategoricalHead(nn.Module):\n def forward(self, logits):\n return torch.distributions.Categorical(logits=logits)\n\n\n# class MultiSoftmaxCategoricalHead(nn.Module):\n# def forward(self, logits):\n# ... | [
[
"torch.argmax",
"torch.distributions.Categorical",
"torch.unbind"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
LaudateCorpus1/sunpy | [
"f7bdf22e5229a577c5851c1e05502f0d68b4b369",
"f7bdf22e5229a577c5851c1e05502f0d68b4b369",
"f7bdf22e5229a577c5851c1e05502f0d68b4b369"
] | [
"sunpy/coordinates/wcs_utils.py",
"sunpy/tests/helpers.py",
"sunpy/map/compositemap.py"
] | [
"import numpy as np\n\nimport astropy.units as u\nimport astropy.wcs.utils\nfrom astropy.coordinates import (\n ITRS,\n BaseCoordinateFrame,\n CartesianRepresentation,\n SkyCoord,\n SphericalRepresentation,\n)\nfrom astropy.wcs import WCS\n\nfrom sunpy import log\nfrom .frames import (\n BaseCoord... | [
[
"numpy.all",
"numpy.array",
"numpy.isfinite"
],
[
"matplotlib.__version__.replace",
"matplotlib.pyplot.gcf",
"matplotlib.ft2font.__freetype_version__.replace"
],
[
"matplotlib.pyplot.colorbar",
"matplotlib.pyplot.sci",
"matplotlib.pyplot.figure"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
icane/demographic-indicators | [
"b1c394a4497e8e4c0189bf4c0518ce38fb873d4c"
] | [
"etl/deaths.py"
] | [
"\"\"\"Deaths indicators.\"\"\"\n\nfrom etl.common import to_json_stat, write_to_file\n\nfrom etl.config_deaths import deaths_cfg as cfg\n\nfrom etlstat.extractor.extractor import xlsx\n\nimport json\n\nimport pandas as pd\n\n\ndef transform(df, periods, prefix=''):\n \"\"\"Slice dataframe. Generate time period ... | [
[
"pandas.concat",
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"1.3",
"0.19",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
codecakes/random_games | [
"1e670021ec97a196726e937e658878dc63ba9d34"
] | [
"probability_combinatorics/linear_regression.py"
] | [
"from math import sqrt\nfrom itertools import izip\nfrom numpy import mean\n\nfrom py_variance_std import t_percentile\n\ndef calc_slope(r, sdy, sdx): return r * (float(sdy)/sdx)\n\ndef line_fitting(x_arr, y_arr):\n \"\"\"\n using straight line y = mx + c;\n m(of a sample data points) = Covariance(X,Y)/Cov... | [
[
"numpy.mean"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
LeoRoweBrown/ckvpy | [
"fff27847f5577750ae5860e3fdff81877fa4455a"
] | [
"tools/photon_yield.py"
] | [
"import numpy as np\nfrom scipy.integrate import simps\nimport scipy.constants as const\n\ndef compute(theta_in, f, beta, L, n=None):\n \"\"\"compute number of photons due to Frank-Tamm and Fresen equations\n theta (ndarray/list[float]): Angles in chosen wavelength range\n f (ndarray/list[float]): Frequenc... | [
[
"numpy.min",
"numpy.cos",
"numpy.sin",
"numpy.max",
"numpy.interp"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
andrewschreiber/numpy-saliency | [
"2e788a1150f6e160f2271cbb4f20747559f243c0"
] | [
"model/network.py"
] | [
"import numpy as np\nimport pickle\nfrom model.loss import cross_entropy\nfrom model.layers import Conv2D, Maxpool2D, Dense, Flatten, ReLu, Softmax\n\n\nclass LeNet5:\n \"\"\"Implementation of LeNet 5 for MNIST\n http://yann.lecun.com/exdb/publis/pdf/lecun-98.pdf\n \"\"\"\n\n def __init__(self, weigh... | [
[
"numpy.argmax"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Seb-Good/deepecg | [
"c99fbe80718ee9969936154ae2c1a04d81c9b246"
] | [
"deepecg/training/model/disc/model.py"
] | [
"\"\"\"\nmodel.py\n--------\nThis module provides a class and methods for building and managing a model with tensorflow.\nBy: Sebastian D. Goodfellow, Ph.D., 2018\n\"\"\"\n\n# Compatibility imports\nfrom __future__ import absolute_import, division, print_function\n\n# 3rd party imports\nimport os\nimport sys\nimpor... | [
[
"tensorflow.ConfigProto"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
garibaldu/boundary-seekers | [
"441fea01e93de882bf22e0deb411f0b10602fa37"
] | [
"Testing/ND-Testing.py"
] | [
"import numpy as np\nimport tensorflow as tf\n\ndef __perms(n):\n if not n:\n return\n\n p = []\n\n for i in range(0, 2**n):\n s = bin(i)[2:]\n s = \"0\" * (n-len(s)) + s\n\n s_prime = np.array(list(map(lambda x: int(x), list(s))))\n p.append(s_prime)\n\n return p\n\nd... | [
[
"numpy.dot",
"tensorflow.multiply",
"tensorflow.concat",
"tensorflow.reduce_sum",
"tensorflow.expand_dims",
"tensorflow.placeholder",
"tensorflow.exp",
"numpy.ones",
"tensorflow.global_variables_initializer",
"numpy.concatenate",
"tensorflow.train.GradientDescentOptimiz... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
}
] |
okkhoy/rlpy | [
"af25d2011fff1d61cb7c5cc8992549808f0c6103",
"af25d2011fff1d61cb7c5cc8992549808f0c6103",
"af25d2011fff1d61cb7c5cc8992549808f0c6103",
"af25d2011fff1d61cb7c5cc8992549808f0c6103",
"af25d2011fff1d61cb7c5cc8992549808f0c6103"
] | [
"examples/pacman/independent.py",
"rlpy/Representations/BEBF.py",
"rlpy/Representations/Representation.py",
"rlpy/Domains/HIVTreatment.py",
"rlpy/Domains/FlipBoard.py"
] | [
"\"\"\"\nCart-pole balancing with independent discretization\n\"\"\"\nfrom __future__ import unicode_literals\nfrom __future__ import print_function\nfrom __future__ import division\nfrom __future__ import absolute_import\nfrom future import standard_library\nstandard_library.install_aliases()\nfrom rlpy.Domains im... | [
[
"numpy.log"
],
[
"numpy.arange",
"numpy.zeros"
],
[
"numpy.dot",
"numpy.hstack",
"numpy.multiply",
"numpy.arange",
"numpy.eye",
"numpy.cumsum",
"numpy.ones",
"numpy.atleast_1d",
"numpy.all",
"numpy.argmax",
"numpy.ma.masked_array",
"numpy.array",... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"1.7",
"1.0",
"0... |
rsampaths16/ReRes | [
"51089c806c57087eb94d9a659036ebed88e96f13"
] | [
"processing/gray-scale-processing.py"
] | [
"import numpy\nimport scipy\nimport glob\nfrom matplotlib import pyplot\nfrom scipy import misc\nfrom numpy import random\n\nrandom.seed(0)\nSIZE = 128\nORIGINAL = '../data/offline-data/black-and-white-images/original'\nHIGH = '../data/offline-data/black-and-white-images/train/high'\nLOW = '../data/offline-data/bla... | [
[
"scipy.misc.imresize",
"numpy.random.seed",
"numpy.copy",
"scipy.misc.imread",
"numpy.random.randint"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.13",
"0.14",
"0.15",
"0.10",
"0.16",
"0.19",
"0.18",
"0.12",
"1.0",
"0.17",
"1.2"
],
"tensorflow": []
}
] |
franyancr/lenstronomy | [
"3a7b33512a474bf1796d23276d9028b580580cf1",
"3a7b33512a474bf1796d23276d9028b580580cf1",
"3a7b33512a474bf1796d23276d9028b580580cf1",
"3a7b33512a474bf1796d23276d9028b580580cf1",
"3a7b33512a474bf1796d23276d9028b580580cf1",
"3a7b33512a474bf1796d23276d9028b580580cf1",
"3a7b33512a474bf1796d23276d9028b580580cf... | [
"lenstronomy/PointSource/point_source_types.py",
"lenstronomy/LensModel/Profiles/curved_arc.py",
"test/test_LensModel/test_Solver/test_solver4.py",
"lenstronomy/Util/util.py",
"test/test_ImSim/test_Numerics/test_grid.py",
"lenstronomy/GalKin/galkin.py",
"lenstronomy/LightModel/Profiles/nie.py",
"test/... | [
"import numpy as np\nfrom lenstronomy.LensModel.Solver.lens_equation_solver import LensEquationSolver\n\n\nclass Unlensed(object):\n \"\"\"\n class of a single point source in the image plane, aka star\n parameters: ra_image, dec_image, point_amp\n\n \"\"\"\n def __init__(self):\n pass\n\n ... | [
[
"numpy.abs",
"numpy.ones",
"numpy.mean",
"numpy.isscalar",
"numpy.array",
"numpy.zeros"
],
[
"numpy.arctan2",
"numpy.cos",
"numpy.sqrt",
"numpy.sin"
],
[
"numpy.sqrt",
"numpy.sort",
"numpy.testing.assert_almost_equal",
"numpy.max",
"numpy.mean",
... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
... |
dirty-cat/categorical-encoding | [
"fb0a1c4216533034e7516efc0698c7e4477b0243"
] | [
"benchmarks/supervectorizer_tuning.py"
] | [
"\"\"\"\nPerforms a GridSearch to find the best parameters for the SuperVectorizer\namong a selection.\n\"\"\"\n\nimport logging\nimport pandas as pd\n\nfrom sklearn.ensemble import RandomForestRegressor, RandomForestClassifier\nfrom sklearn.model_selection import GridSearchCV\nfrom sklearn.pipeline import Pipeline... | [
[
"sklearn.ensemble.RandomForestRegressor",
"sklearn.model_selection.GridSearchCV",
"pandas.read_csv",
"sklearn.ensemble.RandomForestClassifier",
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
viettriit2110/face_recognition | [
"0e1821af6538c573ed4a87acc361c44900f849eb"
] | [
"examples/face_recognition_svm.py"
] | [
"# Train multiple images per person\r\n# Find and recognize faces in an image using a SVC with scikit-learn\r\n\r\n\"\"\"\r\nStructure:\r\n <test_image>.jpg\r\n <train_dir>/\r\n <person_1>/\r\n <person_1_face-1>.jpg\r\n <person_1_face-2>.jpg\r\n ... | [
[
"sklearn.svm.SVC"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
oeg-upm/ttla | [
"ab1cc5a2777b3d4fb905f4452379f469153c904b",
"ab1cc5a2777b3d4fb905f4452379f469153c904b"
] | [
"commons/__init__.py",
"label/classification.py"
] | [
"import os\nimport pandas as pd\nfrom easysparql import *\n\nENDPOINT = \"https://dbpedia.org/sparql\"\nMIN_NUM_OF_ENT_PER_PROP = 30 # the minimum number of entities per property (get_properties)\nQUERY_LIMIT = \"\" # At the moment, we do not put any limit on the number of results\nMIN_NUM_NUMS = 30 # The minimu... | [
[
"pandas.isna",
"pandas.read_csv"
],
[
"numpy.array",
"numpy.set_printoptions",
"pandas.read_csv"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1... |
dyabel/wsod-mmdet | [
"60fc1993ea298f992b160b5599a6134702ac0d4f"
] | [
"mmdet/models/losses/my_cross_entropy_loss.py"
] | [
"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport numpy as np\n\nfrom ..builder import LOSSES\nfrom .utils import weight_reduce_loss\neps = 0.000001\n\n\ndef cross_entropy_without_softmax(pred,\n label,\n weight=None,\n ... | [
[
"torch.nn.functional.binary_cross_entropy_with_logits",
"torch.nn.functional.cross_entropy",
"torch.nn.functional.binary_cross_entropy",
"torch.log",
"torch.nonzero",
"torch.arange"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
ForrestPi/ObjectDetection | [
"54e0821e73f67be5360c36f01229a123c34ab3b3",
"0d6766038bd3ee37036e4255713d5c06e81a83ed",
"54e0821e73f67be5360c36f01229a123c34ab3b3",
"54e0821e73f67be5360c36f01229a123c34ab3b3",
"54e0821e73f67be5360c36f01229a123c34ab3b3",
"54e0821e73f67be5360c36f01229a123c34ab3b3"
] | [
"nms/benchmark/nms_numba_cpu.py",
"SSD/SSD_FPN_GIoU/data/utils/augmentations.py",
"YOLO/Stronger-yolo-pytorch/dataset/augment/image.py",
"YOLO/yolov3_asff_pt/models/utils_loss.py",
"AnchorFree/FCOS/models/utils.py",
"SSD/SSD_FPN_GIoU/model/head/build_head.py"
] | [
"from __future__ import absolute_import\nimport numba\nimport numpy as np\n@numba.jit(nopython=True)\ndef nms_cpu(dets, thresh):\n x1 = dets[:, 0]\n y1 = dets[:, 1]\n x2 = dets[:, 2]\n y2 = dets[:, 3]\n scores = dets[:, 4]\n areas = (x2 - x1 + 1) * (y2 - y1 + 1)\n order = scores.argsort()[::-1]... | [
[
"numpy.load",
"numpy.where",
"numpy.maximum",
"numpy.minimum"
],
[
"numpy.maximum",
"numpy.minimum",
"numpy.clip",
"numpy.random.choice",
"numpy.random.uniform",
"numpy.array",
"numpy.random.randint"
],
[
"numpy.dot",
"numpy.random.choice",
"numpy.fl... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
... |
delemottelab/demystifying | [
"e8527b52d5fbe0570cd391921ecda5aefceb797a",
"e8527b52d5fbe0570cd391921ecda5aefceb797a"
] | [
"demystifying/feature_extraction/mlp_feature_extractor.py",
"demystifying/postprocessing.py"
] | [
"from __future__ import absolute_import, division, print_function\n\nimport logging\nimport sys\n\nlogging.basicConfig(\n stream=sys.stdout,\n format='%(asctime)s %(name)s-%(levelname)s: %(message)s',\n datefmt='%Y-%m-%d %H:%M:%S')\nimport numpy as np\nfrom sklearn.neural_network import MLPClassifier, MLPR... | [
[
"sklearn.neural_network.MLPClassifier",
"numpy.min",
"numpy.max",
"numpy.zeros",
"sklearn.neural_network.MLPRegressor"
],
[
"numpy.sqrt",
"numpy.save",
"numpy.append",
"numpy.mean",
"numpy.load",
"numpy.array",
"numpy.zeros",
"numpy.where",
"numpy.empty"... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
JayWu7/Machine-Learning-Courses-Study-Record | [
"7586c3429514bc21c7cfe42f85ca8c0fcf8f072b",
"7586c3429514bc21c7cfe42f85ca8c0fcf8f072b",
"7586c3429514bc21c7cfe42f85ca8c0fcf8f072b"
] | [
"Algorithmic Methods of Data Mining/Final_project/graph_partitioning1.py",
"Artificial Intelligence/r08exercise/u1b1.py",
"Deep Learning/convolutional_nn.py"
] | [
"import numpy as np\nfrom sklearn.cluster import KMeans\nimport time\nfrom scipy.sparse.linalg import eigs\nfrom scipy.sparse import csr_matrix\n\n\nclass Graph:\n\n def __init__(self, data_name):\n self.filename = data_name\n self.n = None\n self.k = None\n self.edges = self.form_gra... | [
[
"sklearn.cluster.KMeans",
"numpy.linalg.norm",
"numpy.ndarray",
"scipy.sparse.csr_matrix",
"scipy.sparse.linalg.eigs",
"numpy.zeros"
],
[
"numpy.log",
"numpy.mean"
],
[
"torch.nn.CrossEntropyLoss",
"torch.max",
"torch.nn.Conv2d",
"torch.utils.data.DataLoader... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.13",
"1.6",
"0.14",
"1.10",
"0.15",
"1.4",
"1.3",
"1.9",
"0.19",
"1.5",
"0.18",
"1.2",
"1.7",
"0.12",
"1.0",
"0.17",
"0.16",
"1.8"
... |
webclinic017/time-series-pipeline | [
"5ac418b91e395a48cba397f95d25d221adfff9bd",
"5ac418b91e395a48cba397f95d25d221adfff9bd"
] | [
"EOD_api/test_EOD_api.py",
"EOD_api/EOD_api.py"
] | [
"import os\nimport re\nimport datetime\nimport unittest\nfrom io import StringIO\nfrom unittest.mock import patch\n\nimport pandas as pd\n\nimport EOD_api as eod\n\nTOKEN = os.environ[\"EOD_TOKEN\"]\n\n\ndef date_parser(string):\n date_pattern = re.compile(\"([0-9]{4}-[0-9]{2}-[0-9]{2})[ ]\", re.VERBOSE)\n re... | [
[
"pandas.read_csv",
"pandas.testing.assert_frame_equal"
],
[
"pandas.concat",
"pandas.read_csv",
"pandas.to_datetime",
"pandas.DateOffset",
"pandas.json_normalize",
"pandas.DataFrame",
"pandas.read_json",
"pandas.DataFrame.from_dict"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0"
],
"scipy": [],
"tensorflow": []
}
] |
Leylasaadi/MACT20.21_Digital_tools_Big_Data_part_2 | [
"94cafa0581ec36a305867ebfdcb91c787aa77a16"
] | [
"session4/e_animations_2axis.py"
] | [
"# encoding: utf-8\n\n##################################################\n# This script shows how to create animated plots using matplotlib and a basic dataset\n# Multiple tutorials inspired the current design but they mostly came from:\n# hhttps://towardsdatascience.com/how-to-create-animated-graphs-in-python-bb61... | [
[
"pandas.read_csv",
"pandas.to_datetime",
"matplotlib.pyplot.title",
"matplotlib.pyplot.ylim",
"numpy.arange",
"matplotlib.pyplot.subplots",
"numpy.timedelta64",
"matplotlib.pyplot.xlim",
"matplotlib.animation.FuncAnimation",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplo... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
genepattern/genepattern-utils | [
"950d748301b3c4d07ad8d24c9b037bbb9b4c80e2"
] | [
"genepattern/utils/clustering.py"
] | [
"\"\"\"\nCopied and modified from the dev branch of:\nhttps://github.com/genepattern/HierarchicalClustering\non 2018-01-31\n\"\"\"\nimport sys\nimport numpy as np\nfrom statistics import mode\nfrom sklearn.metrics import pairwise\nfrom sklearn import metrics\n\nfrom scipy.cluster.hierarchy import dendrogram\nimport... | [
[
"numpy.sqrt",
"numpy.cumsum",
"numpy.mean",
"sklearn.cluster.AgglomerativeClustering",
"numpy.exp",
"matplotlib.pyplot.gca",
"pandas.read_csv",
"numpy.unique",
"numpy.arange",
"numpy.finfo",
"matplotlib.pyplot.subplot",
"matplotlib.gridspec.GridSpec",
"numpy.cou... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [
"0.13",
"1.6",
"0.14",
"1.10",
"0.15",
"1.4",
"0.16",
"1.9",
"0.19",
"1.5",
"0.18",
"1.2... |
jsevo/taxumap | [
"1a02518dca822a65847994910177c74607243dae",
"1a02518dca822a65847994910177c74607243dae"
] | [
"taxumap-manuscript-notebooks/embeddings.py",
"taxumap/tools.py"
] | [
"from sklearn.manifold import TSNE \nfrom sklearn.decomposition import PCA, KernelPCA\nfrom umap import UMAP\nfrom sklearn.preprocessing import MinMaxScaler\n\nRUNEMBEDDINGS = False\nif RUNEMBEDDINGS:\n #simple PCA\n pcaembedding = PCA(n_components=2).fit_transform(XASV.fillna(0))\n \n #base embedding (... | [
[
"sklearn.decomposition.KernelPCA",
"sklearn.decomposition.PCA"
],
[
"scipy.spatial.distance.cdist",
"pandas.DataFrame",
"sklearn.preprocessing.MinMaxScaler"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"... |
catalys1/dnnutil | [
"a55a73ae59c5ac0117f58d8d8136bdd32902141f"
] | [
"dnnutil/training.py"
] | [
"import torch\nimport numpy as np\nimport dnnutil.network as network\nimport time\n\n\n__all__ = ['calculate_accuracy', 'Trainer', 'ClassifierTrainer', 'AutoencoderTrainer']\n\n\ndef calculate_accuracy(prediction, label, axis=1):\n '''calculate_accuracy(prediction, label)\n \n Computes the mean accuracy ov... | [
[
"torch.no_grad",
"numpy.mean"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
vinayphadnis/NeMo | [
"9dc7773c48e164b8a82051bb558a728c6eeb85ec",
"9dc7773c48e164b8a82051bb558a728c6eeb85ec",
"9dc7773c48e164b8a82051bb558a728c6eeb85ec",
"9dc7773c48e164b8a82051bb558a728c6eeb85ec"
] | [
"nemo/collections/asr/models/classification_models.py",
"nemo/collections/nlp/models/neural_machine_translation/neural_machine_translation_model.py",
"nemo/collections/tts/losses/uniglowloss.py",
"nemo/collections/tts/modules/squeezewave_submodules.py"
] | [
"# Copyright (c) 2020, 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 re... | [
[
"torch.stack"
],
[
"torch.stack"
],
[
"torch.norm",
"torch.nn.ModuleList",
"torch.sum",
"torch.log",
"torch.clamp",
"torch.stft"
],
[
"torch.nn.Sequential",
"torch.nn.BatchNorm1d",
"torch.mm",
"torch.transpose",
"torch.sqrt",
"torch.nn.utils.weig... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
... |
nlindqv/pytorch_RVAE | [
"d9e58134965f69aad557fb3bd2478500a51210f8",
"d9e58134965f69aad557fb3bd2478500a51210f8"
] | [
"human_eval.py",
"best_scores.py"
] | [
"import argparse\r\nimport os\r\n\r\nimport pandas as pd\r\nimport numpy as np\r\nimport torch as t\r\nfrom torch.optim import Adam\r\nimport pickle5 as pickle\r\nimport json\r\nimport random\r\n\r\nfrom sample import sample_with_input, sample_with_beam\r\nfrom utils.batch_loader import BatchLoader, clean_str\r\nfr... | [
[
"torch.device",
"pandas.read_csv",
"pandas.DataFrame"
],
[
"numpy.array",
"numpy.loadtxt"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
denis19973/Keras-RFCN | [
"5e1fdaf197b3a93c22a82d9476a3f9a1c804e398"
] | [
"Fashion_Test.py"
] | [
"\"\"\"\nKeras RFCN\nCopyright (c) 2018\nLicensed under the MIT License (see LICENSE for details)\nWritten by parap1uie-s@github.com\n\"\"\"\n\n'''\nThis is a demo to Eval a RFCN model with DeepFashion Dataset\nhttp://mmlab.ie.cuhk.edu.hk/projects/DeepFashion.html\n'''\n\nfrom KerasRFCN.Model.Model import RFCN_Mode... | [
[
"matplotlib.pyplot.imread",
"matplotlib.patches.Rectangle",
"matplotlib.pyplot.clf",
"matplotlib.pyplot.subplots"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
KuKuXia/DeepLearningMugenKnock | [
"979cf05e65e352da36453337380a418a2a2fdccb"
] | [
"Question_prepare/answers/answer_rotation.py"
] | [
"import cv2\nimport numpy as np\nfrom glob import glob\nimport matplotlib.pyplot as plt\n\nnp.random.seed(0)\n\nnum_classes = 2\nimg_height, img_width = 64, 64\n\nCLS = ['akahara', 'madara']\n\n# get train data\ndef data_load(path, hf=False, vf=False, rot=None):\n xs = []\n ts = []\n paths = []\n \n ... | [
[
"matplotlib.pyplot.imshow",
"numpy.sqrt",
"numpy.random.seed",
"matplotlib.pyplot.title",
"numpy.random.shuffle",
"numpy.ceil",
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.axis",
"numpy.array",
"numpy.zeros",
"matplotlib.pyplot.show"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
mariuslindegaard/6.867_MARL_project | [
"572b88b4d491db8a1673535868f4bf9aff58f73d"
] | [
"src/modules/agents/noisy_agents.py"
] | [
"import torch.nn as nn\nimport torch.nn.functional as F\nfrom utils.noisy_liner import NoisyLinear\nfrom torch.nn import LayerNorm\n\nclass NoisyRNNAgent(nn.Module):\n def __init__(self, input_shape, args):\n super(NoisyRNNAgent, self).__init__()\n self.args = args\n\n self.fc1 = nn.Linear(i... | [
[
"torch.nn.Linear",
"torch.nn.GRUCell",
"torch.nn.LayerNorm"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
aasensio/bayesDI | [
"4ddad57d89c3512b4c4ee5684ddc5608060ebdec"
] | [
"modules/flow.py"
] | [
"import numpy as np\nimport torch\nimport torch.nn.functional as F\nfrom nflows import transforms, distributions, flows, utils\nimport nflows.nn.nets as nn_\nimport matplotlib.pyplot as pl\nfrom modules import resnet\n\n# https://github.com/stephengreen/lfi-gw/blob/master/lfigw/nde_flows.py\n\ndef create_linear_tra... | [
[
"torch.no_grad",
"torch.from_numpy",
"torch.cat"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
zhaipro/MySceneDetect | [
"fbbe085b05e916d52253ffddd91848c3e85b2fe9"
] | [
"scenedetect/main.py"
] | [
"import sys\nimport time\n\nimport cv2\nimport numpy as np\n\n\ndef scenedetect(cap, threshold=30, min_scene_len=15):\n w = cap.get(cv2.CAP_PROP_FRAME_WIDTH)\n downscale_factor = int(w / 200)\n last_hsv = None\n first = 0\n curr = 0\n\n while True:\n ret, im = cap.read()\n if not ret... | [
[
"numpy.abs"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
lightyang/tensorflow | [
"14c58e1d380b2001ffdf7ef782d44ad1a21f763c"
] | [
"tensorflow/python/keras/layers/preprocessing/categorical.py"
] | [
"# Copyright 2019 The TensorFlow Authors. All Rights Reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless requ... | [
[
"tensorflow.python.ops.lookup_ops.index_table_from_tensor",
"tensorflow.python.framework.tensor_shape.TensorShape",
"tensorflow.python.ops.lookup_ops.index_table_from_file",
"tensorflow.python.framework.tensor_spec.TensorSpec",
"tensorflow.python.ops.sparse_ops.sparse_cross",
"tensorflow.p... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.7",
"2.6",
"2.2",
"2.3",
"2.4",
"2.9",
"2.5",
"2.8",
"2.10"
]
}
] |
stillmatic/pandas | [
"da067b2fe4cdc43eac5349e0648cfbbe4b96dbbd"
] | [
"pandas/tests/categorical/test_algos.py"
] | [
"import pytest\nimport numpy as np\n\nimport pandas as pd\nimport pandas.util.testing as tm\n\n\n@pytest.mark.parametrize('ordered', [True, False])\n@pytest.mark.parametrize('categories', [\n ['b', 'a', 'c'],\n ['a', 'b', 'c', 'd'],\n])\ndef test_factorize(categories, ordered):\n cat = pd.Categorical(['b',... | [
[
"pandas.util.testing.assert_numpy_array_equal",
"pandas.util.testing.assert_categorical_equal",
"pandas.Categorical",
"pandas.factorize",
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"1.4",
"1.3",
"0.19",
"1.1",
"1.5",
"0.24",
"0.20",
"1.0",
"0.25",
"1.2"
],
"scipy": [],
"tensorflow": []
}
] |
supersamdam/ConversationalAI | [
"bb6013c33f6332aee57abbae310577c056c6fdc1"
] | [
"Prototype.py"
] | [
"import numpy as np\nimport pandas as pd\nimport re\nimport nltk\nnltk.download('stopwords')\nfrom nltk.corpus import stopwords\nfrom nltk.stem.porter import PorterStemmer\nfrom sklearn.feature_extraction.text import CountVectorizer\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.naive_bayes imp... | [
[
"pandas.read_csv",
"sklearn.naive_bayes.GaussianNB",
"sklearn.metrics.confusion_matrix",
"sklearn.model_selection.train_test_split",
"sklearn.feature_extraction.text.CountVectorizer",
"sklearn.metrics.accuracy_score"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.1",
"1.5",
"1.2",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
XiaotingChen/tfmodisco | [
"17cbafe806942304a02e8134fe10224bdff38b0c"
] | [
"modisco/value_provider.py"
] | [
"from __future__ import division, print_function, absolute_import\nimport numpy as np\nimport scipy.stats\n\n\nclass AbstractValueProvider(object):\n\n def __call__(self, seqlet):\n raise NotImplementedError()\n\n @classmethod\n def from_hdf5(cls, grp):\n the_class = eval(grp.attrs[\"class\"]... | [
[
"numpy.abs",
"numpy.sign",
"numpy.searchsorted",
"numpy.array",
"numpy.sum"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
bgalbraith/macarico | [
"448e3e7f088dde0f4eb016fbdee857221b9523fb",
"448e3e7f088dde0f4eb016fbdee857221b9523fb"
] | [
"macarico/actors/bow.py",
"macarico/policies/linear.py"
] | [
"from __future__ import division, generators, print_function\n\nimport torch\nimport torch.nn as nn\n\nimport macarico\nimport macarico.util as util\nfrom macarico.util import Var, Varng\n\nclass BOWActor(macarico.Actor):\n def __init__(self, attention, n_actions, act_history_length=1, obs_history_length=0):\n ... | [
[
"torch.cat"
],
[
"torch.nn.SmoothL1Loss",
"torch.nn.functional.softmax",
"torch.nn.NLLLoss",
"torch.LongTensor",
"torch.zeros",
"torch.nn.Linear",
"torch.nn.MSELoss",
"torch.nn.MultiMarginLoss"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
FrancisLiang/models-1 | [
"e14d5bc1ab36d0dd11977f27cff54605bf99c945",
"e14d5bc1ab36d0dd11977f27cff54605bf99c945",
"e14d5bc1ab36d0dd11977f27cff54605bf99c945",
"e14d5bc1ab36d0dd11977f27cff54605bf99c945",
"e14d5bc1ab36d0dd11977f27cff54605bf99c945",
"e14d5bc1ab36d0dd11977f27cff54605bf99c945",
"e14d5bc1ab36d0dd11977f27cff54605bf99c94... | [
"PaddleNLP/emotion_detection/run_classifier.py",
"PaddleCV/ocr_recognition/infer.py",
"PaddleNLP/unarchived/sequence_tagging_for_ner/utils_extend.py",
"PaddleCV/deeplabv3+/reader.py",
"PaddleRec/ssr/train.py",
"PaddleCV/PaddleDetection/ppdet/data/transform/shared_queue/sharedmemory.py",
"PaddleRec/gru4r... | [
"\"\"\"\nEmotion Detection Task\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n\nimport os\nimport time\nimport argparse\nimport multiprocessing\nimport sys\nsys.path.append(\"../\")\n\nimport paddle\nimport paddle.fluid as fluid\nimport nu... | [
[
"numpy.array",
"numpy.argmax",
"numpy.sum"
],
[
"numpy.percentile",
"numpy.average",
"numpy.array",
"numpy.where",
"numpy.divide"
],
[
"numpy.concatenate",
"numpy.loadtxt"
],
[
"numpy.random.rand",
"numpy.array",
"numpy.pad",
"numpy.random.shuffl... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
... |
ice-blaze/simple-captcha-deeplearning | [
"16960249bf316bef8fe6b9d86113c902309b36c5"
] | [
"deep_learning.py"
] | [
"from generate_captchas import CHAR_POSSIBILITIES\nfrom generate_captchas import generate_captcha\nfrom generate_captchas import get_random_captcha_names_and_lines\nfrom digital_processing_image_approach import clean_image_kernel4\nimport keras\nfrom keras.models import Sequential, load_model\nfrom keras.layers imp... | [
[
"numpy.max",
"numpy.array",
"numpy.argmax",
"numpy.random.seed"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
Samteymoori/pepper | [
"734d226de47a855952e3b58145c1fcfbe221d3b4"
] | [
"pepper_variant/modules/python/models/predict_distributed_cpu.py"
] | [
"import sys\nimport os\nimport torch\nimport torch.onnx\nimport torch.distributed as dist\nimport torch.nn as nn\nimport onnxruntime\nfrom datetime import datetime\nfrom torch.utils.data import DataLoader\nimport torch.multiprocessing as mp\n\nfrom pepper_variant.modules.python.models.dataloader_predict import Sequ... | [
[
"torch.nn.Softmax",
"torch.onnx.export",
"torch.distributed.init_process_group",
"torch.multiprocessing.spawn",
"torch.zeros",
"torch.add",
"torch.utils.data.DataLoader",
"torch.from_numpy",
"torch.set_num_threads",
"torch.no_grad",
"torch.distributed.destroy_process_gr... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
thanever/SOC | [
"9f30d1a9c7610a68de9c178a1170bdf1c8ca11d4",
"9f30d1a9c7610a68de9c178a1170bdf1c8ca11d4",
"9f30d1a9c7610a68de9c178a1170bdf1c8ca11d4",
"9f30d1a9c7610a68de9c178a1170bdf1c8ca11d4",
"9f30d1a9c7610a68de9c178a1170bdf1c8ca11d4",
"9f30d1a9c7610a68de9c178a1170bdf1c8ca11d4"
] | [
"Data/scigrid-de/pypower/scigrid_2011_01_07_01.py",
"Data/scigrid-de/pypower/scigrid_2011_01_07_22.py",
"Data/scigrid-de/pypower/scigrid_2011_01_08_02.py",
"Uncertainty/data/case-ln/case_ln_101.py",
"Data/scigrid-de/pypower/scigrid_2011_01_06_19.py",
"Uncertainty/data/case-de/case_de_103.py"
] | [
"from numpy import array\ndef scigrid_2011_01_07_01():\n\tppc = {\"version\": '2'}\n\tppc[\"baseMVA\"] = 100.0\n\tppc[\"bus\"] = array([\n\t\t[586,\t\t3,\t\t0,\t\t0,\t\t0,\t\t0,\t\t0,\t\t1.0,\t\t0,\t\t220.0,\t\t0,\t\t1.1,\t\t0.9\t\t],\n\t\t[589,\t\t2,\t\t0,\t\t0,\t\t0,\t\t0,\t\t0,\t\t1.0,\t\t0,\t\t380.0,\t\t0,\t\t1... | [
[
"numpy.array"
],
[
"numpy.array"
],
[
"numpy.array"
],
[
"numpy.array"
],
[
"numpy.array"
],
[
"numpy.array"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
... |
nestauk/la_funding_analysis | [
"bc338583817174f47f2cff2105f4a20a89df4c99"
] | [
"la_funding_analysis/pipeline/cleaning.py"
] | [
"# File: pipeline/cleaning.py\n\"\"\"Functions to clean datasets.\nCalling each function returns a clean version of the associated dataset.\n\"\"\"\n\nimport numpy as np\nimport pandas as pd\n\nfrom la_funding_analysis.getters.local_authority_data import (\n get_epc,\n get_grants,\n get_imd,\n get_old_p... | [
[
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
HwangDongJun/Federated_Learning_using_Websockets | [
"87c2873ae9b6a651750d08f4cd0ad5757893ce88"
] | [
"federated_learning_without_transfer_learning/ntf_client_fit_model.py"
] | [
"# Setup library\nfrom __future__ import absolute_import, division, print_function, unicode_literals\n\nimport os\nimport numpy as np\nimport PIL.Image as Image\nfrom PIL import ImageFile\nimport tensorflow as tf\nimport tensorflow_hub as hub\nfrom tensorflow.keras import layers\nimport matplotlib.pylab as plt\nimp... | [
[
"tensorflow.keras.models.load_model",
"tensorflow.config.experimental.list_logical_devices",
"tensorflow.keras.preprocessing.image.ImageDataGenerator",
"tensorflow.config.experimental.set_memory_growth",
"tensorflow.keras.layers.Dense",
"tensorflow.config.experimental.list_physical_devices... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"2.7",
"2.2",
"2.3",
"2.4",
"2.5",
"2.6"
]
}
] |
pedersor/google-research | [
"6fa751dd261b3f6d918fd2cd35efef5d8bf3eea6",
"6fa751dd261b3f6d918fd2cd35efef5d8bf3eea6",
"6fa751dd261b3f6d918fd2cd35efef5d8bf3eea6",
"6fa751dd261b3f6d918fd2cd35efef5d8bf3eea6",
"6fa751dd261b3f6d918fd2cd35efef5d8bf3eea6",
"6fa751dd261b3f6d918fd2cd35efef5d8bf3eea6",
"6fa751dd261b3f6d918fd2cd35efef5d8bf3eea... | [
"representation_batch_rl/representation_batch_rl/cql_pixels.py",
"ml_debiaser/randomized_threshold.py",
"goemotions/analyze_data.py",
"depth_and_motion_learning/losses/loss_aggregator.py",
"mol_dqn/chemgraph/dqn/molecules_test.py",
"task_set/tasks/synthetic_sequence.py",
"supcon/losses_test.py",
"non_... | [
"# coding=utf-8\n# Copyright 2022 The Google Research 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 requ... | [
[
"tensorflow.constant",
"tensorflow.gather_nd",
"tensorflow.zeros",
"tensorflow.reduce_mean",
"tensorflow.shape",
"tensorflow.minimum",
"tensorflow.cast",
"tensorflow.exp",
"tensorflow.eye",
"tensorflow.math.log",
"tensorflow.expand_dims",
"tensorflow.keras.optimizer... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
... |
bburan/cochlear | [
"1e7ea32730a794b9f6936440a32e4a82c4bf73e7"
] | [
"cochlear/noise_exposure.py"
] | [
"from __future__ import division\n\nimport logging\nlog = logging.getLogger(__name__)\n\nimport numpy as np\nfrom scipy import signal\n\nfrom traits.api import Instance, Float, Property, Int\nfrom traitsui.api import (View, Item, ToolBar, Action, ActionGroup, VGroup,\n HSplit, MenuBar, Menu... | [
[
"scipy.signal.lfilter",
"numpy.log10",
"numpy.mean",
"scipy.signal.iirfilter"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [
"0.13",
"1.6",
"0.14",
"1.10",
"0.15",
"1.4",
"1.3",
"1.9",
"0.19",
"1.5",
"0.18",
"1.2",
"1.7",
"0.12",
"1.0",
"0.17",
"0.16",
"1.8"
... |
visinf/deblur-devil | [
"53cc4c72a4ddb9dcede5ee52dc53000c39ff5dab",
"53cc4c72a4ddb9dcede5ee52dc53000c39ff5dab"
] | [
"contrib/cmap.py",
"losses/classification_losses.py"
] | [
"# Author: Jochen Gast <jochen.gast@visinf.tu-darmstadt.de>\n\nimport numpy as np\nimport torch\nfrom matplotlib import cm\nfrom torch import nn\n\n# ----------------------------------------------------------------------------------------\n# See https://matplotlib.org/examples/color/colormaps_reference.html\n#\n# T... | [
[
"numpy.arange",
"torch.ones_like",
"matplotlib.cm.get_cmap"
],
[
"torch.nn.CrossEntropyLoss"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
alshedivat/federated | [
"fe9f44a504bc51b603a3ab9a181148da0aa9612f",
"fe9f44a504bc51b603a3ab9a181148da0aa9612f",
"fe9f44a504bc51b603a3ab9a181148da0aa9612f",
"fe9f44a504bc51b603a3ab9a181148da0aa9612f"
] | [
"optimization/main/federated_trainer.py",
"gans/experiments/emnist/preprocessing/filtered_emnist_data_utils.py",
"triehh/triehh_tf_test.py",
"fedopt_guide/stackoverflow_transformer/centralized_main.py"
] | [
"# Copyright 2020, Google LLC.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agree... | [
[
"tensorflow.squeeze"
],
[
"tensorflow.io.gfile.GFile",
"tensorflow.data.Dataset.from_generator"
],
[
"tensorflow.constant",
"tensorflow.zeros",
"tensorflow.shape",
"tensorflow.data.Dataset.from_tensor_slices",
"tensorflow.test.main",
"tensorflow.function"
],
[
"... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"1.12",
"1.4",
"1.13",
"1.5",
"1.7",
"0.12",
"1.0",
"1.2"
]
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensor... |
lighthall-lab/NiPype | [
"80d3f05d9aa006fa3055785327892e8a89530a80"
] | [
"nipype/utils/misc.py"
] | [
"# -*- coding: utf-8 -*-\n# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-\n# vi: set ft=python sts=4 ts=4 sw=4 et:\n\"\"\"Miscellaneous utility functions\n\"\"\"\nfrom __future__ import (print_function, unicode_literals, division,\n absolute_import)\nfrom builtins im... | [
[
"numpy.asarray",
"numpy.ravel",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
}
] |
drienyov/treadmill | [
"812109e31c503a6eddaee2d3f2e1faf2833b6aaf"
] | [
"lib/python/treadmill/cli/scheduler/__init__.py"
] | [
"\"\"\"Top level command for Treadmill reports.\n\"\"\"\n\nfrom __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\nfrom __future__ import unicode_literals\n\nimport json\n\nimport click\nimport pandas as pd\nimport tabulate\n\nfrom six.moves import urllib_pars... | [
[
"pandas.DataFrame"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
ruomingp/lingvo | [
"ba59e8c46471be77d5d3c48177f0f0dd8d5d44e9",
"ba59e8c46471be77d5d3c48177f0f0dd8d5d44e9",
"ba59e8c46471be77d5d3c48177f0f0dd8d5d44e9",
"ba59e8c46471be77d5d3c48177f0f0dd8d5d44e9"
] | [
"lingvo/jax/eval.py",
"lingvo/jax/base_input.py",
"lingvo/core/conformer_layer_test.py",
"lingvo/core/attention.py"
] | [
"# Lint as: python3\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... | [
[
"tensorflow.compat.v2.nest.map_structure",
"tensorflow.compat.v2.io.gfile.exists",
"tensorflow.compat.v2.io.gfile.makedirs"
],
[
"tensorflow.compat.v2.nest.map_structure",
"tensorflow.compat.v2.function",
"tensorflow.compat.v2.errors.OutOfRangeError"
],
[
"numpy.zeros",
"nu... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
... |
pakesson/scaml | [
"c69d422d6839d75a81426c81fd8d570fa421744b"
] | [
"explain.py"
] | [
"#!/usr/bin/env python\n\nimport sys\nimport math\nimport numpy as np\n\nfrom tensorflow.keras.models import load_model\n\nfrom aes import aes_sbox, aes_sbox_inv\n\nimport matplotlib\nmatplotlib.use('TkAgg')\nimport matplotlib.pyplot as plt\n\ndef get_label(plaintext, key, index):\n return aes_sbox[plaintext[ind... | [
[
"tensorflow.keras.models.load_model",
"matplotlib.pyplot.cm.plasma",
"matplotlib.pyplot.title",
"numpy.linspace",
"matplotlib.use",
"numpy.ptp",
"numpy.savez_compressed",
"numpy.argmax",
"numpy.mean",
"numpy.log10",
"numpy.load",
"numpy.array",
"numpy.zeros",
... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": [
"1.10",
"2.7",
"2.2",
"2.3",
"2.4",
"2.5",
"2.6"
]
}
] |
diegomrsantos/Python-Baseball | [
"4543df7a4d74e82106a3e8481553149c447d8ab6"
] | [
"stats/attendance.py"
] | [
"import pandas as pd\nimport matplotlib.pyplot as plt\nfrom data import games\n\ninfo_filter = games['type'] == 'info'\nattendance_filter = games['multi2'] == 'attendance'\nattendance = games.loc[info_filter & attendance_filter, ['year', 'multi3']]\n\nattendance.columns = ['year', 'attendance']\n\nattendance.loc[:,... | [
[
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.show",
"pandas.to_numeric",
"matplotlib.pyplot.ylabel"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"0.23",
"0.21",
"2.0",
"1.4",
"0.19",
"1.1",
"1.5",
"1.2",
"0.24",
"0.20",
"1.0",
"0.25",
"1.3"
],
"scipy": [],
"tensorflow": []
}
] |
rperi/trustworthy-asv-fairness | [
"15df69a8f3f8ad5262002c9e3d12aa12ea8f1c6f"
] | [
"evaluate/evaluate_FDR.py"
] | [
"import numpy as np\nimport pandas as pd\nimport os\nimport pdb\nfrom scipy.spatial.distance import cosine\nfrom sklearn.metrics import roc_curve, confusion_matrix\nimport sys\nfrom tqdm import tqdm\nfrom sklearn.metrics import auc\nimport argparse\n\nfprs = [0.01,0.02,0.03,0.04,0.05,0.06,0.07,0.08,0.09,0.1,0.2,0.3... | [
[
"pandas.to_numeric",
"numpy.absolute",
"pandas.read_csv",
"scipy.spatial.distance.cosine",
"sklearn.metrics.confusion_matrix",
"sklearn.metrics.roc_curve",
"numpy.round",
"numpy.mean",
"sklearn.metrics.auc",
"numpy.array",
"numpy.zeros"
]
] | [
{
"matplotlib": [],
"numpy": [],
"pandas": [
"2.0",
"1.4",
"1.3",
"1.1",
"1.5",
"1.2"
],
"scipy": [
"0.13",
"1.6",
"0.14",
"1.10",
"0.15",
"1.4",
"0.16",
"1.9",
"0.19",
"1.5",
"0.18",
"1.2... |
creare-com/podpac | [
"7feb5c957513c146ce73ba1c36c630284f513a6e",
"7feb5c957513c146ce73ba1c36c630284f513a6e",
"7feb5c957513c146ce73ba1c36c630284f513a6e",
"7feb5c957513c146ce73ba1c36c630284f513a6e",
"7feb5c957513c146ce73ba1c36c630284f513a6e"
] | [
"podpac/core/coordinates/test/test_uniform_coordinates1d.py",
"podpac/core/test/test_node.py",
"podpac/core/interpolation/test/test_interpolation.py",
"podpac/core/algorithm/generic.py",
"podpac/core/algorithm/test/test_stats.py"
] | [
"from datetime import datetime\nimport json\n\nimport pytest\nimport traitlets as tl\nimport numpy as np\nfrom numpy.testing import assert_equal\n\nimport podpac\nfrom podpac.core.coordinates.utils import make_coord_array\nfrom podpac.core.coordinates.coordinates1d import Coordinates1d\nfrom podpac.core.coordinates... | [
[
"numpy.testing.assert_equal",
"numpy.linspace",
"numpy.datetime64",
"numpy.timedelta64",
"numpy.array"
],
[
"numpy.all",
"numpy.arange",
"numpy.isnan",
"numpy.testing.assert_array_equal"
],
[
"numpy.testing.assert_array_equal",
"numpy.concatenate",
"numpy.ra... | [
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
"matplotlib": [],
"numpy": [],
"pandas": [],
"scipy": [],
"tensorflow": []
},
{
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.