Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use cond method in hypothesis

Best Python code snippet using hypothesis

cond_v2_test.py

Source:cond_v2_test.py

...45    if not feed_dict:46      feed_dict = {}47    with self.session(graph=ops.get_default_graph()) as sess:48      pred = array_ops.placeholder(dtypes.bool, name="pred")49      expected = control_flow_ops.cond(pred, true_fn, false_fn, name="expected")50      actual = cond_v2.cond_v2(pred, true_fn, false_fn, name="actual")51      expected_grad = gradients_impl.gradients(expected, train_vals)52      actual_grad = gradients_impl.gradients(actual, train_vals)53      sess_run_args = {pred: True}54      sess_run_args.update(feed_dict)55      expected_val, actual_val, expected_grad_val, actual_grad_val = sess.run(56          (expected, actual, expected_grad, actual_grad), sess_run_args)57      self.assertEqual(expected_val, actual_val)58      self.assertEqual(expected_grad_val, actual_grad_val)59      sess_run_args = {pred: False}60      sess_run_args.update(feed_dict)61      expected_val, actual_val, expected_grad_val, actual_grad_val = sess.run(62          (expected, actual, expected_grad, actual_grad), sess_run_args)63      self.assertEqual(expected_val, actual_val)64      self.assertEqual(expected_grad_val, actual_grad_val)65  @test_util.run_deprecated_v166  def testBasic(self):67    x = constant_op.constant(1.0, name="x")68    y = constant_op.constant(2.0, name="y")69    def true_fn():70      return x * 2.071    def false_fn():72      return y * 3.073    self._testCond(true_fn, false_fn, [x])74    self._testCond(true_fn, false_fn, [x, y])75    self._testCond(true_fn, false_fn, [y])76  def testExternalControlDependencies(self):77    with ops.Graph().as_default(), self.test_session():78      v = variables.Variable(1.0)79      v.initializer.run()80      op = v.assign_add(1.0)81      def true_branch():82        with ops.control_dependencies([op]):83          return 1.084      cond_v2.cond_v2(array_ops.placeholder_with_default(False, None),85                      true_branch,86                      lambda: 2.0).eval()87      self.assertAllEqual(self.evaluate(v), 2.0)88  @test_util.run_deprecated_v189  def testMultipleOutputs(self):90    x = constant_op.constant(1.0, name="x")91    y = constant_op.constant(3.0, name="y")92    def true_fn():93      return x * y, y94    def false_fn():95      return x, y * 3.096    self._testCond(true_fn, false_fn, [x])97    self._testCond(true_fn, false_fn, [x, y])98    self._testCond(true_fn, false_fn, [y])99  @test_util.run_deprecated_v1100  def testBasic2(self):101    x = constant_op.constant(1.0, name="x")102    y = constant_op.constant(2.0, name="y")103    def true_fn():104      return x * y * 2.0105    def false_fn():106      return 2.0107    self._testCond(true_fn, false_fn, [x])108    self._testCond(true_fn, false_fn, [x, y])109    self._testCond(true_fn, false_fn, [y])110  @test_util.run_deprecated_v1111  def testNoInputs(self):112    with self.cached_session() as sess:113      pred = array_ops.placeholder(dtypes.bool, name="pred")114      def true_fn():115        return constant_op.constant(1.0)116      def false_fn():117        return constant_op.constant(2.0)118      out = cond_v2.cond_v2(pred, true_fn, false_fn)119      self.assertEqual(sess.run(out, {pred: True}), (1.0,))120      self.assertEqual(sess.run(out, {pred: False}), (2.0,))121  def _createCond(self, name):122    """Creates a cond_v2 call and returns the output tensor and the cond op."""123    pred = constant_op.constant(True, name="pred")124    x = constant_op.constant(1.0, name="x")125    def true_fn():126      return x127    def false_fn():128      return x + 1129    output = cond_v2.cond_v2(pred, true_fn, false_fn, name=name)130    cond_op = output.op.inputs[0].op131    self.assertEqual(cond_op.type, "If")132    return output, cond_op133  def _createNestedCond(self, name):134    """Like _createCond but creates a nested cond_v2 call as well."""135    pred = constant_op.constant(True, name="pred")136    x = constant_op.constant(1.0, name="x")137    def true_fn():138      return cond_v2.cond_v2(pred, lambda: x, lambda: x + 1)139    def false_fn():140      return x + 2141    output = cond_v2.cond_v2(pred, true_fn, false_fn, name=name)142    cond_op = output.op.inputs[0].op143    self.assertEqual(cond_op.type, "If")144    return output, cond_op145  def testDefaultName(self):146    with ops.Graph().as_default():147      _, cond_op = self._createCond(None)148      self.assertEqual(cond_op.name, "cond")149      self.assertRegexpMatches(150          cond_op.get_attr("then_branch").name, r"cond_true_\d*")151      self.assertRegexpMatches(152          cond_op.get_attr("else_branch").name, r"cond_false_\d*")153    with ops.Graph().as_default():154      with ops.name_scope("foo"):155        _, cond1_op = self._createCond("")156        self.assertEqual(cond1_op.name, "foo/cond")157        self.assertRegexpMatches(158            cond1_op.get_attr("then_branch").name, r"foo_cond_true_\d*")159        self.assertRegexpMatches(160            cond1_op.get_attr("else_branch").name, r"foo_cond_false_\d*")161        _, cond2_op = self._createCond(None)162        self.assertEqual(cond2_op.name, "foo/cond_1")163        self.assertRegexpMatches(164            cond2_op.get_attr("then_branch").name, r"foo_cond_1_true_\d*")165        self.assertRegexpMatches(166            cond2_op.get_attr("else_branch").name, r"foo_cond_1_false_\d*")167  @test_util.run_v1_only("b/120545219")168  def testDefunInCond(self):169    x = constant_op.constant(1.0, name="x")170    y = constant_op.constant(2.0, name="y")171    def true_fn():172      @function.defun173      def fn():174        return x * y * 2.0175      return fn()176    def false_fn():177      return 2.0178    self._testCond(true_fn, false_fn, [x])179    self._testCond(true_fn, false_fn, [x, y])180    self._testCond(true_fn, false_fn, [y])181  @test_util.run_deprecated_v1182  def testNestedDefunInCond(self):183    x = constant_op.constant(1.0, name="x")184    y = constant_op.constant(2.0, name="y")185    def true_fn():186      return 2.0187    def false_fn():188      @function.defun189      def fn():190        @function.defun191        def nested_fn():192          return x * y * 2.0193        return nested_fn()194      return fn()195    self._testCond(true_fn, false_fn, [x])196    self._testCond(true_fn, false_fn, [x, y])197    self._testCond(true_fn, false_fn, [y])198  @test_util.run_deprecated_v1199  def testDoubleNestedDefunInCond(self):200    x = constant_op.constant(1.0, name="x")201    y = constant_op.constant(2.0, name="y")202    def true_fn():203      @function.defun204      def fn():205        @function.defun206        def nested_fn():207          @function.defun208          def nested_nested_fn():209            return x * y * 2.0210          return nested_nested_fn()211        return nested_fn()212      return fn()213    def false_fn():214      return 2.0215    self._testCond(true_fn, false_fn, [x])216    self._testCond(true_fn, false_fn, [x, y])217    self._testCond(true_fn, false_fn, [y])218  def testNestedCond(self):219    def run_test(pred_value):220      def build_graph():221        pred = array_ops.placeholder(dtypes.bool, name="pred")222        x = constant_op.constant(1.0, name="x")223        y = constant_op.constant(2.0, name="y")224        def true_fn():225          return 2.0226        def false_fn():227          def false_true_fn():228            return x * y * 2.0229          def false_false_fn():230            return x * 5.0231          return _cond(pred, false_true_fn, false_false_fn, "inside_false_fn")232        return x, y, pred, true_fn, false_fn233      with ops.Graph().as_default():234        x, y, pred, true_fn, false_fn = build_graph()235        self._testCond(true_fn, false_fn, [x, y], {pred: pred_value})236        self._testCond(true_fn, false_fn, [x], {pred: pred_value})237        self._testCond(true_fn, false_fn, [y], {pred: pred_value})238    run_test(True)239    run_test(False)240  def testNestedCondBothBranches(self):241    def run_test(pred_value):242      def build_graph():243        pred = array_ops.placeholder(dtypes.bool, name="pred")244        x = constant_op.constant(1.0, name="x")245        y = constant_op.constant(2.0, name="y")246        def true_fn():247          return _cond(pred, lambda: x + y, lambda: x * x, name=None)248        def false_fn():249          return _cond(pred, lambda: x - y, lambda: y * y, name=None)250        return x, y, pred, true_fn, false_fn251      with ops.Graph().as_default():252        x, y, pred, true_fn, false_fn = build_graph()253        self._testCond(true_fn, false_fn, [x, y], {pred: pred_value})254        self._testCond(true_fn, false_fn, [x], {pred: pred_value})255        self._testCond(true_fn, false_fn, [y], {pred: pred_value})256    run_test(True)257    run_test(False)258  def testDoubleNestedCond(self):259    def run_test(pred1_value, pred2_value):260      def build_graph():261        pred1 = array_ops.placeholder(dtypes.bool, name="pred1")262        pred2 = array_ops.placeholder(dtypes.bool, name="pred2")263        x = constant_op.constant(1.0, name="x")264        y = constant_op.constant(2.0, name="y")265        def true_fn():266          return 2.0267        def false_fn():268          def false_true_fn():269            def false_true_true_fn():270              return x * y * 2.0271            def false_true_false_fn():272              return x * 10.0273            return _cond(274                pred1,275                false_true_true_fn,276                false_true_false_fn,277                name="inside_false_true_fn")278          def false_false_fn():279            return x * 5.0280          return _cond(281              pred2, false_true_fn, false_false_fn, name="inside_false_fn")282        return x, y, pred1, pred2, true_fn, false_fn283      with ops.Graph().as_default():284        x, y, pred1, pred2, true_fn, false_fn = build_graph()285        self._testCond(true_fn, false_fn, [x, y], {286            pred1: pred1_value,287            pred2: pred2_value288        })289        x, y, pred1, pred2, true_fn, false_fn = build_graph()290        self._testCond(true_fn, false_fn, [x], {291            pred1: pred1_value,292            pred2: pred2_value293        })294        x, y, pred1, pred2, true_fn, false_fn = build_graph()295        self._testCond(true_fn, false_fn, [y], {296            pred1: pred1_value,297            pred2: pred2_value298        })299    run_test(True, True)300    run_test(True, False)301    run_test(False, False)302    run_test(False, True)303  def testGradientFromInsideDefun(self):304    def build_graph():305      pred_outer = array_ops.placeholder(dtypes.bool, name="pred_outer")306      pred_inner = array_ops.placeholder(dtypes.bool, name="pred_inner")307      x = constant_op.constant(1.0, name="x")308      y = constant_op.constant(2.0, name="y")309      def true_fn():310        return 2.0311      def false_fn():312        def inner_true_fn():313          return x * y * 2.0314        def inner_false_fn():315          return x * 5.0316        return cond_v2.cond_v2(317            pred_inner, inner_true_fn, inner_false_fn, name="inner_cond")318      cond_outer = cond_v2.cond_v2(319          pred_outer, true_fn, false_fn, name="outer_cond")320      # Compute grads inside a Defun.321      @function.defun322      def nesting_fn():323        return gradients_impl.gradients(cond_outer, [x, y])324      grads = nesting_fn()325      return grads, pred_outer, pred_inner326    with ops.Graph().as_default():327      grads, pred_outer, pred_inner = build_graph()328      with self.session(graph=ops.get_default_graph()) as sess:329        self.assertSequenceEqual(330            sess.run(grads, {331                pred_outer: True,332                pred_inner: True333            }), [0., 0.])334        self.assertSequenceEqual(335            sess.run(grads, {336                pred_outer: True,337                pred_inner: False338            }), [0., 0.])339        self.assertSequenceEqual(340            sess.run(grads, {341                pred_outer: False,342                pred_inner: True343            }), [4., 2.])344        self.assertSequenceEqual(345            sess.run(grads, {346                pred_outer: False,347                pred_inner: False348            }), [5., 0.])349  def testGradientFromInsideNestedDefun(self):350    def build_graph():351      pred_outer = array_ops.placeholder(dtypes.bool, name="pred_outer")352      pred_inner = array_ops.placeholder(dtypes.bool, name="pred_inner")353      x = constant_op.constant(1.0, name="x")354      y = constant_op.constant(2.0, name="y")355      def true_fn():356        return 2.0357      def false_fn():358        def inner_true_fn():359          return x * y * 2.0360        def inner_false_fn():361          return x * 5.0362        return cond_v2.cond_v2(363            pred_inner, inner_true_fn, inner_false_fn, name="inner_cond")364      cond_outer = cond_v2.cond_v2(365          pred_outer, true_fn, false_fn, name="outer_cond")366      # Compute grads inside a Defun.367      @function.defun368      def nesting_fn():369        @function.defun370        def inner_nesting_fn():371          return gradients_impl.gradients(cond_outer, [x, y])372        return inner_nesting_fn()373      grads = nesting_fn()374      return grads, pred_outer, pred_inner375    with ops.Graph().as_default():376      grads, pred_outer, pred_inner = build_graph()377      with self.session(graph=ops.get_default_graph()) as sess:378        self.assertSequenceEqual(379            sess.run(grads, {380                pred_outer: True,381                pred_inner: True382            }), [0., 0.])383        self.assertSequenceEqual(384            sess.run(grads, {385                pred_outer: True,386                pred_inner: False387            }), [0., 0.])388        self.assertSequenceEqual(389            sess.run(grads, {390                pred_outer: False,391                pred_inner: True392            }), [4., 2.])393        self.assertSequenceEqual(394            sess.run(grads, {395                pred_outer: False,396                pred_inner: False397            }), [5., 0.])398  def testBuildCondAndGradientInsideDefun(self):399    def build_graph():400      pred_outer = array_ops.placeholder(dtypes.bool, name="pred_outer")401      pred_inner = array_ops.placeholder(dtypes.bool, name="pred_inner")402      x = constant_op.constant(1.0, name="x")403      y = constant_op.constant(2.0, name="y")404      # Build cond and its gradient inside a Defun.405      @function.defun406      def fn():407        def true_fn():408          return 2.0409        def false_fn():410          def inner_true_fn():411            return x * y * 2.0412          def inner_false_fn():413            return x * 5.0414          return cond_v2.cond_v2(415              pred_inner, inner_true_fn, inner_false_fn, name="inner_cond")416        cond_outer = cond_v2.cond_v2(417            pred_outer, true_fn, false_fn, name="outer_cond")418        return gradients_impl.gradients(cond_outer, [x, y])419      grads = fn()420      return grads, pred_outer, pred_inner421    with ops.Graph().as_default(), self.session(422        graph=ops.get_default_graph()) as sess:423      grads, pred_outer, pred_inner = build_graph()424      self.assertSequenceEqual(425          sess.run(grads, {426              pred_outer: True,427              pred_inner: True428          }), [0., 0.])429      self.assertSequenceEqual(430          sess.run(grads, {431              pred_outer: True,432              pred_inner: False433          }), [0., 0.])434      self.assertSequenceEqual(435          sess.run(grads, {436              pred_outer: False,437              pred_inner: True438          }), [4., 2.])439      self.assertSequenceEqual(440          sess.run(grads, {441              pred_outer: False,442              pred_inner: False443          }), [5., 0.])444  @test_util.run_deprecated_v1445  def testSecondDerivative(self):446    with self.cached_session() as sess:447      pred = array_ops.placeholder(dtypes.bool, name="pred")448      x = constant_op.constant(3.0, name="x")449      def true_fn():450        return math_ops.pow(x, 3)451      def false_fn():452        return x453      cond = cond_v2.cond_v2(pred, true_fn, false_fn, name="cond")454      cond_grad = gradients_impl.gradients(cond, [x])455      cond_grad_grad = gradients_impl.gradients(cond_grad, [x])456      # d[x^3]/dx = 3x^2457      true_val = sess.run(cond_grad, {pred: True})458      self.assertEqual(true_val, [27.0])459      # d[x]/dx = 1460      false_val = sess.run(cond_grad, {pred: False})461      self.assertEqual(false_val, [1.0])462      true_val = sess.run(cond_grad_grad, {pred: True})463      # d2[x^3]/dx2 = 6x464      self.assertEqual(true_val, [18.0])465      false_val = sess.run(cond_grad_grad, {pred: False})466      # d2[x]/dx2 = 0467      self.assertEqual(false_val, [0.0])468  def testGradientOfDeserializedCond(self):469    with ops.Graph().as_default():470      pred = array_ops.placeholder(dtypes.bool, name="pred")471      x = constant_op.constant(3.0, name="x")472      ops.add_to_collection("x", x)473      def true_fn():474        return math_ops.pow(x, 3)475      def false_fn():476        return x477      ops.add_to_collection("pred", pred)478      cond = cond_v2.cond_v2(pred, true_fn, false_fn, name="cond")479      ops.add_to_collection("cond", cond)480      meta_graph = saver.export_meta_graph()481    with ops.Graph().as_default() as g:482      with self.session(graph=g) as sess:483        saver.import_meta_graph(meta_graph)484        x = ops.get_collection("x")[0]485        pred = ops.get_collection("pred")[0]486        cond = ops.get_collection("cond")487        cond_grad = gradients_impl.gradients(cond, [x], name="cond_grad")488        cond_grad_grad = gradients_impl.gradients(489            cond_grad, [x], name="cond_grad_grad")490        # d[x^3]/dx = 3x^2491        true_val = sess.run(cond_grad, {pred: True})492        self.assertEqual(true_val, [27.0])493        # d[x]/dx = 1494        false_val = sess.run(cond_grad, {pred: False})495        self.assertEqual(false_val, [1.0])496        true_val = sess.run(cond_grad_grad, {pred: True})497        # d2[x^3]/dx2 = 6x498        self.assertEqual(true_val, [18.0])499        false_val = sess.run(cond_grad_grad, {pred: False})500        # d2[x]/dx2 = 0501        self.assertEqual(false_val, [0.0])502  def testGradientTapeOfCondWithResourceVariableInFunction(self):503    with context.eager_mode():504      v = variables.Variable(2.)505      @def_function.function506      def fnWithCond():  # pylint: disable=invalid-name507        with backprop.GradientTape() as tape:508          pred = constant_op.constant(True, dtype=dtypes.bool)509          def true_fn():510            return math_ops.pow(v, 3)511          def false_fn():512            return v513          cond = cond_v2.cond_v2(pred, true_fn, false_fn, name="cond")514        return tape.gradient(cond, v)515      self.assertAllEqual(fnWithCond(), 12.0)516  def testLowering(self):517    with ops.Graph().as_default() as g:518      with self.session(graph=g) as sess:519        cond_output, _ = self._createCond("cond")520        run_options = config_pb2.RunOptions(output_partition_graphs=True)521        run_metadata = config_pb2.RunMetadata()522        sess.run(cond_output, options=run_options, run_metadata=run_metadata)523        # If lowering was enabled, there should be a `Switch` node524        switch_found = any(525            any(node.op == "Switch" for node in graph.node)526            for graph in run_metadata.partition_graphs527        )528        self.assertTrue(switch_found,529                        "A `Switch` op should exist if the graph was lowered.")530        # If lowering was enabled, there should be no `If` node531        if_found = any(532            any(node.op == "If" for node in graph.node)533            for graph in run_metadata.partition_graphs534        )535        self.assertFalse(if_found,536                         "An `If` op was found, but it should be lowered.")537  @test_util.run_deprecated_v1538  def testLoweringDisabledInXLA(self):539    with self.session(graph=ops.Graph()) as sess:540      # Build the cond_v2 in an XLA context541      xla_context = control_flow_ops.XLAControlFlowContext()542      xla_context.Enter()543      cond_output, cond_op = self._createCond("cond")544      xla_context.Exit()545      # Check lowering attr is not set.546      with self.assertRaises(ValueError):547        cond_op.get_attr("_lower_using_switch_merge")548      # Check the actual graph that is run.549      run_options = config_pb2.RunOptions(output_partition_graphs=True)550      run_metadata = config_pb2.RunMetadata()551      sess.run(cond_output, options=run_options, run_metadata=run_metadata)552      # Lowering disabled in XLA, there should be no `Switch` node553      switch_found = any(554          any(node.op == "Switch" for node in graph.node)555          for graph in run_metadata.partition_graphs556      )557      self.assertFalse(558          switch_found,559          "A `Switch` op exists, but the graph should not be lowered.")560      # Lowering disabled in XLA, there should still be an `If` node561      if_found = any(562          any(node.op == "If" for node in graph.node)563          for graph in run_metadata.partition_graphs564      )565      self.assertTrue(566          if_found,567          "An `If` op was not found, but the graph should not be lowered.")568  @test_util.run_deprecated_v1569  def testNestedLoweringDisabledInXLA(self):570    # Build the cond_v2 in an XLA context571    xla_context = control_flow_ops.XLAControlFlowContext()572    xla_context.Enter()573    _, cond_op = self._createNestedCond("cond")574    xla_context.Exit()575    # Check lowering attr is not set for either If node.576    with self.assertRaises(ValueError):577      cond_op.get_attr("_lower_using_switch_merge")578    nested_if_ops = []579    for func in ops.get_default_graph()._functions.values():580      nested_if_ops.extend(op for op in func.graph.get_operations()581                           if op.type == "If")582    self.assertEqual(len(nested_if_ops), 1)583    with self.assertRaises(ValueError):584      nested_if_ops[0].get_attr("_lower_using_switch_merge")585    # TODO(skyewm): check the actual graphs that are run once we have a way to586    # programmatically access those graphs.587  # b/131355614588  @test_util.run_deprecated_v1589  def testNoOptionalsInXla(self):590    @def_function.function591    def func_with_cond():592      pred = constant_op.constant(True, name="pred")593      x = constant_op.constant(1.0, name="x")594      def true_fn():595        intermediate = x + 1596        return intermediate * x597      def false_fn():598        return x + 1599      output = cond_v2.cond_v2(pred, true_fn, false_fn)600      grad = gradients_impl.gradients(output, x)[0]601      forward_if_op = output.op.inputs[0].op602      gradient_if_op = grad.op.inputs[0].op603      def verify_no_optional_ops(op, branch_name):604        branch_function = ops.get_default_graph()._get_function(605            op.get_attr(branch_name).name)606        function_def = branch_function.definition607        for node_def in function_def.node_def:608          self.assertNotIn(node_def.op, _OPTIONAL_OPS)609      verify_no_optional_ops(forward_if_op, "then_branch")610      verify_no_optional_ops(forward_if_op, "else_branch")611      verify_no_optional_ops(gradient_if_op, "then_branch")612      verify_no_optional_ops(gradient_if_op, "else_branch")613      return grad614    xla_context = control_flow_ops.XLAControlFlowContext()615    xla_context.Enter()616    func_with_cond()617    xla_context.Exit()618  @test_util.run_deprecated_v1619  def testLoweringDisabledWithSingleThreadedExecutorContext(self):620    with self.session(graph=ops.Graph()) as sess:621      @function.defun622      def _add_cond(x):623        return cond_v2.cond_v2(624            constant_op.constant(True, name="pred"),625            lambda: x,626            lambda: x + 1)627      x = array_ops.placeholder(shape=None, dtype=dtypes.float32)628      with context.function_executor_type("SINGLE_THREADED_EXECUTOR"):629        out_cond = _add_cond(x)630      # The fact that sess.run() succeeds means lowering is disabled, because631      # the single threaded executor does not support cond v1 ops.632      sess.run(out_cond, feed_dict={x: 1.0})633  @test_util.enable_control_flow_v2634  def testStructuredOutputs(self):635    x = constant_op.constant(1.0, name="x")636    y = constant_op.constant(3.0, name="y")637    def true_fn():638      return ((x * y,), y)639    def false_fn():640      return ((x,), y * 3.0)641    output = control_flow_ops.cond(642        constant_op.constant(False), true_fn, false_fn)643    self.assertEqual(self.evaluate(output[0][0]), 1.)644    self.assertEqual(self.evaluate(output[1]), 9.)645  @test_util.enable_control_flow_v2646  @test_util.run_deprecated_v1647  def testRaisesOutputStructuresMismatch(self):648    x = constant_op.constant(1.0, name="x")649    y = constant_op.constant(3.0, name="y")650    def true_fn():651      return x * y, y652    def false_fn():653      return ((x,), y * 3.0)654    with self.assertRaisesRegexp(655        TypeError, "true_fn and false_fn arguments to tf.cond must have the "656        "same number, type, and overall structure of return values."):657      control_flow_ops.cond(constant_op.constant(False), true_fn, false_fn)658  @test_util.enable_control_flow_v2659  def testCondAndTensorArray(self):660    x = math_ops.range(-5, 5)661    output = tensor_array_ops.TensorArray(dtype=dtypes.int32, size=x.shape[0])662    def loop_body(i, output):663      def if_true():664        return output.write(i, x[i]**2)665      def if_false():666        return output.write(i, x[i])667      output = control_flow_ops.cond(x[i] > 0, if_true, if_false)668      return i + 1, output669    _, output = control_flow_ops.while_loop(670        lambda i, arr: i < x.shape[0],671        loop_body,672        loop_vars=(constant_op.constant(0), output))673    output_t = output.stack()674    self.assertAllEqual(675        self.evaluate(output_t), [-5, -4, -3, -2, -1, 0, 1, 4, 9, 16])676  @test_util.enable_control_flow_v2677  def testCondAndTensorArrayInDefun(self):678    @function.defun679    def f():680      x = math_ops.range(-5, 5)681      output = tensor_array_ops.TensorArray(dtype=dtypes.int32, size=x.shape[0])682      def loop_body(i, output):683        def if_true():684          return output.write(i, x[i]**2)685        def if_false():686          return output.write(i, x[i])687        output = control_flow_ops.cond(x[i] > 0, if_true, if_false)688        return i + 1, output689      _, output = control_flow_ops.while_loop(690          lambda i, arr: i < x.shape[0],691          loop_body,692          loop_vars=(constant_op.constant(0), output))693      return output.stack()694    output_t = f()695    self.assertAllEqual(696        self.evaluate(output_t), [-5, -4, -3, -2, -1, 0, 1, 4, 9, 16])697  @test_util.run_deprecated_v1698  def testForwardPassRewrite(self):699    x = constant_op.constant(1.0, name="x")700    output = cond_v2.cond_v2(constant_op.constant(True),701                             lambda: x * 2.0,702                             lambda: x)703    if_op = output.op.inputs[0].op704    self.assertEqual(if_op.type, "If")705    # pylint: disable=g-deprecated-assert706    self.assertEqual(len(if_op.outputs), 1)707    gradients_impl.gradients(output, x)708    # if_op should have been rewritten to output 2.0 intermediate.709    self.assertEqual(len(if_op.outputs), 2)710    gradients_impl.gradients(output, x)711    # Computing the gradient again shouldn't rewrite if_op again.712    self.assertEqual(len(if_op.outputs), 2)713    # pylint: enable=g-deprecated-assert714class CondV2CollectionTest(test.TestCase):715  def testCollectionIntValueAccessInCond(self):716    """Read values from graph collections inside of cond_v2."""717    with ops.Graph().as_default() as g:718      with self.session(graph=g):719        x = 2720        y = 5721        ops.add_to_collection("x", x)722        ops.add_to_collection("y", y)723        def fn():724          x_const = constant_op.constant(ops.get_collection("x")[0])725          y_const = constant_op.constant(ops.get_collection("y")[0])726          return math_ops.add(x_const, y_const)727        cnd = cond_v2.cond_v2(constant_op.constant(True), fn, fn)728        self.assertEquals(cnd.eval(), 7)729  def testCollectionTensorValueAccessInCond(self):730    """Read tensors from collections inside of cond_v2 & use them."""731    with ops.Graph().as_default() as g:732      with self.session(graph=g):733        x = constant_op.constant(2)734        y = constant_op.constant(5)735        ops.add_to_collection("x", x)736        ops.add_to_collection("y", y)737        def fn():738          x_read = ops.get_collection("x")[0]739          y_read = ops.get_collection("y")[0]740          return math_ops.add(x_read, y_read)741        cnd = cond_v2.cond_v2(math_ops.less(x, y), fn, fn)742        self.assertEquals(cnd.eval(), 7)743  def testCollectionIntValueWriteInCond(self):744    """Make sure Int writes to collections work inside of cond_v2."""745    with ops.Graph().as_default() as g:746      with self.session(graph=g):747        x = constant_op.constant(2)748        y = constant_op.constant(5)749        def true_fn():750          z = math_ops.add(x, y)751          ops.add_to_collection("z", 7)752          return math_ops.mul(x, z)753        def false_fn():754          z = math_ops.add(x, y)755          return math_ops.mul(x, z)756        cnd = cond_v2.cond_v2(constant_op.constant(True), true_fn, false_fn)757        self.assertEquals(cnd.eval(), 14)758        read_z_collection = ops.get_collection("z")759        self.assertEquals(read_z_collection, [7])760class CondV2ContainerTest(test.TestCase):761  def testContainer(self):762    """Set containers outside & inside of cond_v2.763    Make sure the containers are set correctly for both variable creation764    (tested by variables.Variable) and for stateful ops (tested by FIFOQueue)765    """766    self.skipTest("b/113048653")767    with ops.Graph().as_default() as g:768      with self.session(graph=g):769        v0 = variables.Variable([0])770        q0 = data_flow_ops.FIFOQueue(1, dtypes.float32)771        def container(node):772          return node.op.get_attr("container")773        self.assertEqual(compat.as_bytes(""), container(v0))774        self.assertEqual(compat.as_bytes(""), container(q0.queue_ref))775        def true_fn():776          # When this branch is created in cond below,777          # the container should begin with 'l1'778          v1 = variables.Variable([1])779          q1 = data_flow_ops.FIFOQueue(1, dtypes.float32)780          with ops.container("l2t"):781            v2 = variables.Variable([2])782            q2 = data_flow_ops.FIFOQueue(1, dtypes.float32)783          v3 = variables.Variable([1])784          q3 = data_flow_ops.FIFOQueue(1, dtypes.float32)785          self.assertEqual(compat.as_bytes("l1"), container(v1))786          self.assertEqual(compat.as_bytes("l1"), container(q1.queue_ref))787          self.assertEqual(compat.as_bytes("l2t"), container(v2))788          self.assertEqual(compat.as_bytes("l2t"), container(q2.queue_ref))789          self.assertEqual(compat.as_bytes("l1"), container(v3))790          self.assertEqual(compat.as_bytes("l1"), container(q3.queue_ref))791          return constant_op.constant(2.0)792        def false_fn():793          # When this branch is created in cond below,794          # the container should begin with 'l1'795          v1 = variables.Variable([1])796          q1 = data_flow_ops.FIFOQueue(1, dtypes.float32)797          with ops.container("l2f"):798            v2 = variables.Variable([2])799            q2 = data_flow_ops.FIFOQueue(1, dtypes.float32)800          v3 = variables.Variable([1])801          q3 = data_flow_ops.FIFOQueue(1, dtypes.float32)802          self.assertEqual(compat.as_bytes("l1"), container(v1))803          self.assertEqual(compat.as_bytes("l1"), container(q1.queue_ref))804          self.assertEqual(compat.as_bytes("l2f"), container(v2))805          self.assertEqual(compat.as_bytes("l2f"), container(q2.queue_ref))806          self.assertEqual(compat.as_bytes("l1"), container(v3))807          self.assertEqual(compat.as_bytes("l1"), container(q3.queue_ref))808          return constant_op.constant(6.0)809        with ops.container("l1"):810          cnd_true = cond_v2.cond_v2(811              constant_op.constant(True), true_fn, false_fn)812          self.assertEquals(cnd_true.eval(), 2)813          cnd_false = cond_v2.cond_v2(814              constant_op.constant(False), true_fn, false_fn)815          self.assertEquals(cnd_false.eval(), 6)816          v4 = variables.Variable([3])817          q4 = data_flow_ops.FIFOQueue(1, dtypes.float32)818        v5 = variables.Variable([4])819        q5 = data_flow_ops.FIFOQueue(1, dtypes.float32)820      self.assertEqual(compat.as_bytes("l1"), container(v4))821      self.assertEqual(compat.as_bytes("l1"), container(q4.queue_ref))822      self.assertEqual(compat.as_bytes(""), container(v5))823      self.assertEqual(compat.as_bytes(""), container(q5.queue_ref))824class CondV2ColocationGroupAndDeviceTest(test.TestCase):825  def testColocateWithBeforeCond(self):826    with ops.Graph().as_default() as g:827      with self.session(graph=g):828        a = constant_op.constant([2.0], name="a")829        b = constant_op.constant([2.0], name="b")830        def fn():831          c = constant_op.constant(3.0)832          self.assertEqual([b"loc:@a"], c.op.colocation_groups())833          return c834        with ops.colocate_with(a.op):835          self.assertEquals(836              cond_v2.cond_v2(constant_op.constant(True), fn, fn).eval(), 3)837        def fn2():838          c = constant_op.constant(3.0)839          self.assertEqual([b"loc:@a", b"loc:@b"], c.op.colocation_groups())840          return c841        with ops.colocate_with(a.op):842          with ops.colocate_with(b.op):843            self.assertEquals(844                cond_v2.cond_v2(constant_op.constant(True), fn2, fn2).eval(), 3)845  def testColocateWithInAndOutOfCond(self):846    with ops.Graph().as_default() as g:847      with self.session(graph=g):848        a = constant_op.constant([2.0], name="a")849        b = constant_op.constant([2.0], name="b")850        def fn2():851          with ops.colocate_with(b.op):852            c = constant_op.constant(3.0)853            self.assertEqual([b"loc:@a", b"loc:@b"], c.op.colocation_groups())854            return c855        with ops.colocate_with(a.op):856          self.assertEquals(857              cond_v2.cond_v2(constant_op.constant(True), fn2, fn2).eval(), 3)858          d = constant_op.constant([2.0], name="d")859          self.assertEqual([b"loc:@a"], d.op.colocation_groups())860  def testColocateWithInCondGraphPartitioning(self):861    with ops.Graph().as_default() as g:862      with self.session(863          graph=g,864          config=config_pb2.ConfigProto(device_count={"CPU": 2})865      ) as sess:866        with ops.device("/device:CPU:0"):867          a = constant_op.constant([2.0], name="a")868        with ops.device("/device:CPU:1"):869          b = constant_op.constant([2.0], name="b")870        def fn():871          with ops.colocate_with(b.op):872            c = math_ops.add(a, a, name="c")873          return c874        out_cond_2 = cond_v2.cond_v2(constant_op.constant(True), fn, fn)875        run_options = config_pb2.RunOptions(output_partition_graphs=True)876        run_metadata = config_pb2.RunMetadata()877        sess.run(out_cond_2, options=run_options, run_metadata=run_metadata)878        # We expect there to be two partitions because of the879        # colocate_with. We are only running the cond, which has a data880        # dependency on `a` but not on `b`. So, without the colocate_with881        # we would expect execution on just one device.882        self.assertTrue(len(run_metadata.partition_graphs) >= 2)883  def testDeviceBeforeCond(self):884    with ops.Graph().as_default() as g:885      with self.session(graph=g):886        def fn():887          self.assertEqual("", constant_op.constant(3.0).op.device)888          return test_ops.device_placement_op()889        with ops.device("/device:CPU:0"):890          self.assertIn(891              compat.as_bytes("CPU:0"),892              self.evaluate(cond_v2.cond_v2(constant_op.constant(True),893                                            fn, fn)))894        def fn2():895          self.assertEqual("", constant_op.constant(3.0).op.device)896          return test_ops.device_placement_op()897        if test_util.is_gpu_available():898          with ops.device("/device:GPU:0"):899            self.assertIn(900                compat.as_bytes("GPU:0"),901                self.evaluate(cond_v2.cond_v2(constant_op.constant(True),902                                              fn2, fn2)))903        else:904          self.skipTest("Test requires a GPU to check GPU device placement.")905  def testDeviceInAndOutOfCond(self):906    with ops.Graph().as_default() as g:907      with self.session(908          graph=g, config=config_pb2.ConfigProto(device_count={"CPU": 2})):909        def fn2():910          with ops.device("/device:CPU:1"):911            c = constant_op.constant(3.0)912            self.assertEqual("/device:CPU:1", c.op.device)913            return c914        with ops.device("/device:CPU:0"):915          self.assertEquals(916              cond_v2.cond_v2(constant_op.constant(True), fn2, fn2).eval(), 3)917          d = constant_op.constant(4.0)918          self.assertEqual("/device:CPU:0", d.op.device)919  def testDeviceInCondGraphPartitioning(self):920    with ops.Graph().as_default() as g:921      with self.session(922          graph=g,923          config=config_pb2.ConfigProto(device_count={"CPU": 2})924      ) as sess:925        def fn():926          with ops.device("/device:CPU:1"):927            c = math_ops.add(a, a, name="c")928          return c929        with ops.device("/device:CPU:0"):930          a = constant_op.constant([2.0], name="a")931          out_cond_2 = cond_v2.cond_v2(constant_op.constant(True), fn, fn)932        run_options = config_pb2.RunOptions(output_partition_graphs=True)933        run_metadata = config_pb2.RunMetadata()934        sess.run(out_cond_2, options=run_options, run_metadata=run_metadata)935        self.assertTrue(len(run_metadata.partition_graphs) >= 2)936def _cond(pred, true_fn, false_fn, name):937  if _is_old_cond():938    return control_flow_ops.cond(pred, true_fn, false_fn, name=name)939  else:940    return cond_v2.cond_v2(pred, true_fn, false_fn, name=name)941def _is_old_cond():942  return isinstance(ops.get_default_graph()._get_control_flow_context(),943                    control_flow_ops.CondContext)944if __name__ == "__main__":...

test_locks.py

Source:test_locks.py

...528        self.assertTrue(RGX_REPR.match(repr(cond)))529    def test_context_manager(self):530        cond = asyncio.Condition(loop=self.loop)531        @asyncio.coroutine532        def acquire_cond():533            return (yield from cond)534        with self.loop.run_until_complete(acquire_cond()):535            self.assertTrue(cond.locked())536        self.assertFalse(cond.locked())537    def test_context_manager_no_yield(self):538        cond = asyncio.Condition(loop=self.loop)539        try:540            with cond:541                self.fail('RuntimeError is not raised in with expression')542        except RuntimeError as err:543            self.assertEqual(544                str(err),545                '"yield from" should be used as context manager expression')546        self.assertFalse(cond.locked())547    def test_explicit_lock(self):548        lock = asyncio.Lock(loop=self.loop)...

mk_star_flag.py

Source:mk_star_flag.py

1import os2import numpy as np3import astropy.io.fits as fitsio4import matplotlib5import matplotlib.pyplot as plt6import matplotlib.gridspec as gridspec7from useful import calc_sn8def get_mags(catalog):9    flx_b,err_b,cov_b = catalog["FLUX_APER_supcam_b"][:,2], catalog["FLUXERR_APER_supcam_b"][:,2], catalog["COVERAGE_FLAG_supcam_b"]10    flx_z,err_z,cov_z = catalog["FLUX_APER_supcam_z"][:,2], catalog["FLUXERR_APER_supcam_z"][:,2], catalog["COVERAGE_FLAG_supcam_z"]11    flx_k,err_k,cov_k = catalog["FLUX_APER_video_ks"][:,2], catalog["FLUXERR_APER_video_ks"][:,2], catalog["COVERAGE_FLAG_video_ks"]12    sn_b = flx_b/err_b13    sn_z = flx_z/err_z14    sn_k = flx_k/err_k15    cond_cov = (cov_b == 1) & (cov_z == 1) & (cov_k == 1)16    cond_det = (sn_b>1) & (sn_z>3) & (sn_k>3) & cond_cov17    cond_non = (sn_b<1) & (sn_z>3) & (sn_k>3) & cond_cov18    mag_b,mag_z,mag_k = np.zeros((3,len(catalog))) - 99.19    mag_b[cond_det] = -2.5*np.log10(flx_b[cond_det]) + 23.9320    mag_z[cond_det] = -2.5*np.log10(flx_z[cond_det]) + 23.9321    mag_k[cond_det] = -2.5*np.log10(flx_k[cond_det]) + 23.9322    mag_b[cond_non] = -2.5*np.log10(err_b[cond_non]) + 23.9323    mag_z[cond_non] = -2.5*np.log10(flx_z[cond_non]) + 23.9324    mag_k[cond_non] = -2.5*np.log10(flx_k[cond_non]) + 23.9325    return mag_b, mag_z, mag_k, catalog["LPH_Z_BEST"], cond_det, cond_non, cond_cov26def get_star_flag(catalog):27    mag_b, mag_z, mag_k, z, cond_det, cond_non, cond_cov = get_mags(catalog)28    cond_chi = (catalog["LPH_CHI_BEST"] - catalog["LPH_CHI_STAR"]) > 029    cond_bzk = (mag_z - mag_k) < (mag_b - mag_z) * 0.3 - 0.2530    cond_star = cond_cov &  (cond_chi & cond_bzk)31    cond_gal  = cond_cov & ~(cond_chi & cond_bzk)32    print ("Star/Galaxy classification: %i stars and %i gals (no classification for %i)" % (np.sum(cond_star),np.sum(cond_gal),np.sum(~cond_cov)))33    return cond_star, cond_gal, cond_cov34def add_sg_classification(catalog):35    cond_star, cond_gal, cond_cov = get_star_flag(catalog)36    catalog["STAR_FLAG"][cond_star] = 137    catalog["STAR_FLAG"][cond_gal ] = 038    catalog["STAR_FLAG"][~cond_cov] = -9939    catalog["ZPHOT"][ cond_star] = 0.0040    return catalog41def mk_plot():42    catalog = fitsio.getdata("final_cats/final_catalog_errfix_zphot.fits")43    mag_b, mag_z, mag_k, z, cond_det, cond_non, cond_cov = get_mags(catalog)44    cond_star,cond_gal,cond_cov = get_star_flag(catalog)45    fig = plt.figure(figsize=(10,9),dpi=75)46    fig.subplots_adjust(left=0.09,right=0.91,top=0.98,bottom=0.08,wspace=0.02,hspace=0.14)47    ogs = gridspec.GridSpec(1,2,width_ratios=[25,1])48    ax  = fig.add_subplot(ogs[0,0])49    cax = fig.add_subplot(ogs[0,1])50    # ax2 = fig.add_subplot(ogs[1,:])51    vmax = 4.552    cmap = matplotlib.cm.get_cmap('RdYlBu_r')53    norm = matplotlib.colors.Normalize(vmin=0, vmax=vmax)54    zz = np.arange(-1,7,0.1)55    ss = np.linspace(0.5,1.5,len(zz)-1)**256    for z0,z1,s in zip (zz[:-1],zz[1:],ss):57        cond_z = (z0<=z) & (z<z1)58        im = ax.scatter(-99,-99,s=0.5,c=0,cmap=plt.cm.RdYlBu_r,vmin=0,vmax=vmax)59        ax.scatter((mag_b-mag_z)[cond_det&cond_z],(mag_z-mag_k)[cond_det&cond_z],c=cmap(norm(z[cond_det&cond_z])),s=s,alpha=0.4)60        ax.errorbar((mag_b-mag_z)[cond_non&cond_z],(mag_z-mag_k)[cond_non&cond_z],xerr=0.15,xlolims=True,ecolor=cmap(norm(0.5*(z0+z1))),linestyle='',marker='',alpha=0.4)61    ax.scatter((mag_b-mag_z)[cond_det&cond_star],(mag_z-mag_k)[cond_det&cond_star],s=2,c='k',alpha=0.4)62    ax.errorbar((mag_b-mag_z)[cond_non&cond_star],(mag_z-mag_k)[cond_non&cond_star],xerr=0.15,xlolims=True,ecolor='k',linestyle='',marker='',alpha=0.4)63    plt.colorbar(im, cax=cax)64    # ax2.hist(catalog["LPH_Z_BEST"],bins=np.arange(-1,7,0.05),color='k',alpha=0.4)65    # ax2.hist(catalog["LPH_Z_BEST"][cond_star],bins=np.arange(-1,7,0.05),color='k',alpha=0.4)66    ax.set_xlabel("$B-z$",fontsize=24)67    ax.set_ylabel("$z-K$",fontsize=24)68    ax.set_xlim(-0.8,7.8)69    ax.set_ylim(-1.5,4.0)70    cax.set_ylabel("photo-z",fontsize=24)71    # ax2.set_xlabel('z',fontsize=18)72    # ax2.set_xlim(0-0.1,6.1)73    _ = [label.set_fontsize(16) for label in ax.get_yticklabels()+ax.get_xticklabels()+cax.get_yticklabels()]74    # _ = [label.set_visible(False) for label in ax2.get_yticklabels()]75    fig.savefig("final_cats/plots/star_flag_bzk.png")76if __name__ == '__main__':77    mk_plot()...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.