author int64 658 755k | date stringlengths 19 19 | timezone int64 -46,800 43.2k | hash stringlengths 40 40 | message stringlengths 5 490 | mods list | language stringclasses 20 values | license stringclasses 3 values | repo stringlengths 5 68 | original_message stringlengths 12 491 |
|---|---|---|---|---|---|---|---|---|---|
260,430 | 15.03.2022 01:57:53 | -28,800 | 37e96de1eef6d85b58b8dc8828ad083e02f5fcf6 | Fix _lax_max_taylor_rule for broadcastable inputs
`lax.max(x, y)` allows x, y have different shape if they are mutually broadcastable. But `lax.select(p, x, y)` does not. | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jet.py",
"new_path": "jax/experimental/jet.py",
"diff": "@@ -649,7 +649,7 @@ def _select_n_taylor_rule(primal_in, series_in, **params):\njet_rules[lax.select_n_p] = _select_n_taylor_rule\ndef _lax_max_taylor_rule(primal_in, series_in):\n- x, y = primal_in\n+ x, y = jnp.broadcast_arrays(*primal_in)\nxgy = x > y # greater than mask\nxey = x == y # equal to mask\n@@ -661,7 +661,7 @@ def _lax_max_taylor_rule(primal_in, series_in):\nmax_i = lax.select(xey, (x_i + y_i)/2, max_i)\nreturn max_i\n- series_out = [select_max_and_avg_eq(*terms_in) for terms_in in zip(*series_in)]\n+ series_out = [select_max_and_avg_eq(*jnp.broadcast_arrays(*terms_in)) for terms_in in zip(*series_in)]\nreturn primal_out, series_out\njet_rules[lax.max_p] = _lax_max_taylor_rule\n"
}
] | Python | Apache License 2.0 | google/jax | Fix _lax_max_taylor_rule for broadcastable inputs
`lax.max(x, y)` allows x, y have different shape if they are mutually broadcastable. But `lax.select(p, x, y)` does not. |
260,631 | 15.03.2022 07:50:17 | 25,200 | 4fba0e787f464cc3e68358154f88b1ac13453667 | [JAX] Update ann to use XLA based fallback ApproxTopK.
Other small changes:
* Restricts the operand type to float.
* Add more format annotations to the docstring. | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/ann.py",
"new_path": "jax/_src/lax/ann.py",
"diff": "@@ -92,15 +92,15 @@ def approx_max_k(operand: Array,\n\"\"\"Returns max ``k`` values and their indices of the ``operand`` in an approximate manner.\nArgs:\n- operand : Array to search for max-k.\n+ operand : Array to search for max-k. Must be a floating number type.\nk : Specifies the number of max-k.\nreduction_dimension : Integer dimension along which to search. Default: -1.\nrecall_target : Recall target for the approximation.\nreduction_input_size_override : When set to a positive value, it overrides\n- the size determined by ``operands[reduction_dim]`` for evaluating the\n- recall. This option is useful when the given operand is only a subset of\n- the overall computation in SPMD or distributed pipelines, where the true\n- input size cannot be deferred by the operand shape.\n+ the size determined by ``operand[reduction_dim]`` for evaluating the\n+ recall. This option is useful when the given ``operand`` is only a subset\n+ of the overall computation in SPMD or distributed pipelines, where the\n+ true input size cannot be deferred by the operand shape.\naggregate_to_topk : When true, aggregates approximate results to top-k. When\nfalse, returns the approximate results. The number of the approximate\nresults is implementation defined and is greater equals to the specified\n@@ -108,14 +108,14 @@ def approx_max_k(operand: Array,\nReturns:\nTuple of two arrays. The arrays are the max ``k`` values and the\n- corresponding indices along the reduction_dimension of the input operand.\n- The arrays' dimensions are the same as the input operand except for the\n- ``reduction_dimension``: when ``aggregate_to_topk`` is true, the reduction\n- dimension is ``k``; otherwise, it is greater equals to k where the size is\n- implementation-defined.\n+ corresponding indices along the ``reduction_dimension`` of the input\n+ ``operand``. The arrays' dimensions are the same as the input ``operand``\n+ except for the ``reduction_dimension``: when ``aggregate_to_topk`` is true,\n+ the reduction dimension is ``k``; otherwise, it is greater equals to ``k``\n+ where the size is implementation-defined.\n- We encourage users to wrap the approx_*_k with jit. See the following example\n- for maximal inner production search (MIPS):\n+ We encourage users to wrap ``approx_max_k`` with jit. See the following\n+ example for maximal inner production search (MIPS):\n>>> import functools\n>>> import jax\n@@ -151,15 +151,15 @@ def approx_min_k(operand: Array,\n\"\"\"Returns min ``k`` values and their indices of the ``operand`` in an approximate manner.\nArgs:\n- operand : Array to search for min-k.\n+ operand : Array to search for min-k. Must be a floating number type.\nk : Specifies the number of min-k.\nreduction_dimension: Integer dimension along which to search. Default: -1.\nrecall_target: Recall target for the approximation.\nreduction_input_size_override : When set to a positive value, it overrides\n- the size determined by ``operands[reduction_dim]`` for evaluating the\n+ the size determined by ``operand[reduction_dim]`` for evaluating the\nrecall. This option is useful when the given operand is only a subset of\nthe overall computation in SPMD or distributed pipelines, where the true\n- input size cannot be deferred by the operand shape.\n+ input size cannot be deferred by the ``operand`` shape.\naggregate_to_topk: When true, aggregates approximate results to top-k. When\nfalse, returns the approximate results. The number of the approximate\nresults is implementation defined and is greater equals to the specified\n@@ -167,13 +167,13 @@ def approx_min_k(operand: Array,\nReturns:\nTuple of two arrays. The arrays are the least ``k`` values and the\n- corresponding indices along the reduction_dimension of the input operand.\n- The arrays' dimensions are the same as the input operand except for the\n- ``reduction_dimension``: when ``aggregate_to_topk`` is true, the reduction\n- dimension is ``k``; otherwise, it is greater equals to k where the size is\n- implementation-defined.\n+ corresponding indices along the ``reduction_dimension`` of the input\n+ ``operand``. The arrays' dimensions are the same as the input ``operand``\n+ except for the ``reduction_dimension``: when ``aggregate_to_topk`` is true,\n+ the reduction dimension is ``k``; otherwise, it is greater equals to ``k``\n+ where the size is implementation-defined.\n- We encourage users to wrap the approx_*_k with jit. See the following example\n+ We encourage users to wrap ``approx_min_k`` with jit. See the following example\nfor nearest neighbor search over the squared l2 distance:\n>>> import functools\n@@ -189,7 +189,7 @@ def approx_min_k(operand: Array,\n>>> half_db_norms = jax.numpy.linalg.norm(db, axis=1) / 2\n>>> dists, neighbors = l2_ann(qy, db, half_db_norms, k=10)\n- We compute ``db_norms/2 - dot(qy, db^T)`` instead of\n+ In the example above, we compute ``db_norms/2 - dot(qy, db^T)`` instead of\n``qy^2 - 2 dot(qy, db^T) + db^2`` for performance reason. The former uses less\narithmetics and produces the same set of neighbors.\n\"\"\"\n@@ -219,6 +219,8 @@ def _approx_top_k_abstract_eval(operand, *, k, reduction_dimension,\nraise ValueError(\n'k must be smaller than the size of reduction_dim {}, got {}'.format(\ndims[reduction_dimension], k))\n+ if not dtypes.issubdtype(operand.dtype, np.floating):\n+ raise ValueError('operand must be a floating type')\nif xc._version >= 45:\nreduction_input_size = dims[reduction_dimension]\ndims[reduction_dimension] = xc.ops.ApproxTopKReductionOutputSize(\n@@ -231,7 +233,7 @@ def _approx_top_k_abstract_eval(operand, *, k, reduction_dimension,\noperand.update(shape=dims, dtype=np.dtype(np.int32)))\n-def _comparator_builder(operand, op_type, is_max_k):\n+def _comparator_builder(op_type, is_max_k):\nc = xc.XlaBuilder(\n'top_k_{}_comparator'.format('gt' if is_max_k else 'lt'))\np0 = xla.parameter(c, 0, xc.Shape.scalar_shape(op_type))\n@@ -245,6 +247,9 @@ def _comparator_builder(operand, op_type, is_max_k):\nreturn c.build(cmp_result)\n+def _get_init_val_literal(op_type, is_max_k):\n+ return np.array(np.NINF if is_max_k else np.Inf, dtype=op_type)\n+\ndef _approx_top_k_tpu_translation(ctx, avals_in, avals_out, operand, *, k,\nreduction_dimension, recall_target, is_max_k,\nreduction_input_size_override,\n@@ -257,20 +262,11 @@ def _approx_top_k_tpu_translation(ctx, avals_in, avals_out, operand, *, k,\nop_type = op_shape.element_type()\nif reduction_dimension < 0:\nreduction_dimension = len(op_dims) + reduction_dimension\n- comparator = _comparator_builder(operand, op_type, is_max_k)\n- if is_max_k:\n- if dtypes.issubdtype(op_type, np.floating):\n- init_literal = np.array(np.NINF, dtype=op_type)\n- else:\n- init_literal = np.iinfo(op_type).min()\n- else:\n- if dtypes.issubdtype(op_type, np.floating):\n- init_literal = np.array(np.Inf, dtype=op_type)\n- else:\n- init_literal = np.iinfo(op_type).max()\n+ comparator = _comparator_builder(op_type, is_max_k)\n+ init_val_literal = _get_init_val_literal(op_type, is_max_k)\niota = xc.ops.Iota(c, xc.Shape.array_shape(np.dtype(np.int32), op_dims),\nreduction_dimension)\n- init_val = xc.ops.Constant(c, init_literal)\n+ init_val = xc.ops.Constant(c, init_val_literal)\ninit_arg = xc.ops.Constant(c, np.int32(-1))\nout = xc.ops.ApproxTopK(c, [operand, iota], [init_val, init_arg], k,\nreduction_dimension, comparator, recall_target,\n@@ -288,11 +284,22 @@ def _approx_top_k_fallback_translation(ctx, avals_in, avals_out, operand, *, k,\nraise ValueError('operand must be an array, but was {}'.format(op_shape))\nop_dims = op_shape.dimensions()\nop_type = op_shape.element_type()\n+\nif reduction_dimension < 0:\nreduction_dimension = len(op_dims) + reduction_dimension\n- comparator = _comparator_builder(operand, op_type, is_max_k)\n+ comparator = _comparator_builder(op_type, is_max_k)\niota = xc.ops.Iota(c, xc.Shape.array_shape(np.dtype(np.int32), op_dims),\nreduction_dimension)\n+ if xc._version >= 60:\n+ init_val_literal = _get_init_val_literal(op_type, is_max_k)\n+ init_val = xc.ops.Constant(c, init_val_literal)\n+ init_arg = xc.ops.Constant(c, np.int32(-1))\n+ out = xc.ops.ApproxTopKFallback(c, [operand, iota], [init_val, init_arg], k,\n+ reduction_dimension, comparator,\n+ recall_target, aggregate_to_topk,\n+ reduction_input_size_override)\n+ return xla.xla_destructure(c, out)\n+ else:\nval_arg = xc.ops.Sort(c, [operand, iota], comparator, reduction_dimension)\nvals = xc.ops.GetTupleElement(val_arg, 0)\nargs = xc.ops.GetTupleElement(val_arg, 1)\n"
}
] | Python | Apache License 2.0 | google/jax | [JAX] Update ann to use XLA based fallback ApproxTopK.
Other small changes:
* Restricts the operand type to float.
* Add more format annotations to the docstring.
PiperOrigin-RevId: 434749705 |
260,411 | 15.03.2022 13:14:34 | -3,600 | eb81d9e11cd87c60fecd9f4cccc2e8abbcbd32a8 | [shape_poly] Improve error message and docs for shape polynomials used as JAX values | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/README.md",
"new_path": "jax/experimental/jax2tf/README.md",
"diff": "@@ -446,6 +446,19 @@ as `False` and produce a converted function that returns `1` just because the di\nare not identical: there are some concrete input shapes for which the function\nshould return `0`.\n+Note that JAX will give an error when trying to use a dimension polynomial\n+as a JAX value, e.g., in the following code:\n+\n+```\n+jax2tf.convert(lambda x: jnp.prod(jnp.array(x.shape)),\n+ polymorphic_shapes=[\"(b, ...)\"])(np.ones((3, 4))\n+```\n+\n+Note that the above code would work if we replace `jnp.array` and `jnp.prod`\n+with `np.array`and `np.prod`, because dimension polynomials overload multiplication.\n+See the next section if you do need to convert a dimension polynomials to\n+a JAX value.\n+\n### Dimension variables appearing in the numeric computation\nThere are some situations when dimension variables arise in the staged computation itself.\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/shape_poly.py",
"new_path": "jax/experimental/jax2tf/shape_poly.py",
"diff": "@@ -369,7 +369,7 @@ class _DimPolynomial(dict):\nif self.is_constant:\nreturn op.index(next(iter(self.values())))\nelse:\n- raise InconclusiveDimensionOperation(f\"Dimension polynomial '{self}' is not constant\")\n+ raise InconclusiveDimensionOperation(f\"Dimension polynomial '{self}' used in a context that requires a constant\")\ndef bounds(self) -> Tuple[Optional[int], Optional[int]]:\n\"\"\"Returns the lower and upper bounds, if defined.\"\"\"\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/tests/shape_poly_test.py",
"new_path": "jax/experimental/jax2tf/tests/shape_poly_test.py",
"diff": "@@ -1074,6 +1074,27 @@ class DimAsValueTest(tf_test_util.JaxToTfTestCase):\n\"Shapes must be 1D sequences of concrete values of integer type\"):\ncore.dimension_as_value(np.float32(1))\n+ def test_error_jax_value(self):\n+\n+ x = np.ones([3, 5], dtype=np.float32)\n+\n+ with self.assertRaisesRegex(\n+ core.InconclusiveDimensionOperation,\n+ \"Dimension polynomial 'b' used in a context that requires a constant\"):\n+ self.CheckShapePolymorphism(\n+ # Cannot use dimension variable as a JAX value\n+ lambda x: jnp.array(x.shape[0]),\n+ input_signature=[tf.TensorSpec([None, 5], dtype=x.dtype)],\n+ polymorphic_shapes=[(\"b, _\")],\n+ expected_output_signature=tf.TensorSpec([]))\n+\n+ self.CheckShapePolymorphism(\n+ # We can convert a dimension variable to a JAX value\n+ lambda x: jnp.array(core.dimension_as_value(x.shape[0])),\n+ input_signature=[tf.TensorSpec([None, 5], dtype=x.dtype)],\n+ polymorphic_shapes=[(\"b, _\")],\n+ expected_output_signature=tf.TensorSpec([]))\n+\n###\n### We define primitive harnesses for which we will test shape-polymorphic\n### conversion.\n"
}
] | Python | Apache License 2.0 | google/jax | [shape_poly] Improve error message and docs for shape polynomials used as JAX values |
260,335 | 15.03.2022 20:06:37 | 25,200 | 43036e13164be4760932793220328c903ab743cb | improvements to autodidax reduce_sum
* generalize reduce_sum to handle multiple axes
* add reduce_sum transpose rule
also fix bug in AD jaxpr formation related to deduplicating consts | [
{
"change_type": "MODIFY",
"old_path": "docs/autodidax.ipynb",
"new_path": "docs/autodidax.ipynb",
"diff": "\"def neg(x): return bind1(neg_p, x)\\n\",\n\"def sin(x): return bind1(sin_p, x)\\n\",\n\"def cos(x): return bind1(cos_p, x)\\n\",\n- \"def reduce_sum(x, axis=None): return bind1(reduce_sum_p, x, axis=axis)\\n\",\n\"def greater(x, y): return bind1(greater_p, x, y)\\n\",\n\"def less(x, y): return bind1(less_p, x, y)\\n\",\n\"def transpose(x, perm): return bind1(transpose_p, x, perm=perm)\\n\",\n\"def broadcast(x, shape, axes): return bind1(broadcast_p, x, shape=shape, axes=axes)\\n\",\n+ \"def reduce_sum(x, axis=None):\\n\",\n+ \" if axis is None:\\n\",\n+ \" axis = tuple(range(np.ndim(x)))\\n\",\n+ \" if type(axis) is int:\\n\",\n+ \" axis = (axis,)\\n\",\n+ \" return bind1(reduce_sum_p, x, axis=axis)\\n\",\n\"\\n\",\n\"def bind1(prim, *args, **params):\\n\",\n\" out, = bind(prim, *args, **params)\\n\",\n\"\\n\",\n\"def reduce_sum_batching_rule(axis_size, vals_in, dims_in, *, axis):\\n\",\n\" (x,), (x_bdim,) = vals_in, dims_in\\n\",\n- \" new_axis = axis + (x_bdim <= axis)\\n\",\n- \" out_bdim = x_bdim - (new_axis < x_bdim)\\n\",\n+ \" new_axis = tuple(ax + (x_bdim <= ax) for ax in axis)\\n\",\n+ \" out_bdim = x_bdim - sum(ax < x_bdim for ax in axis)\\n\",\n\" return [reduce_sum(x, new_axis)], [out_bdim]\\n\",\n\"vmap_rules[reduce_sum_p] = reduce_sum_batching_rule\"\n]\n\"abstract_eval_rules[cos_p] = vectorized_unop_abstract_eval\\n\",\n\"abstract_eval_rules[neg_p] = vectorized_unop_abstract_eval\\n\",\n\"\\n\",\n- \"def reduce_sum_abstract_eval(x: ShapedArray, *, axis: int) -> List[ShapedArray]:\\n\",\n- \" new_shape = [d for i, d in enumerate(x.shape) if i != axis]\\n\",\n+ \"def reduce_sum_abstract_eval(x: ShapedArray, *, axis: Tuple[int, ...]\\n\",\n+ \" ) -> List[ShapedArray]:\\n\",\n+ \" axis_ = set(axis)\\n\",\n+ \" new_shape = [d for i, d in enumerate(x.shape) if i not in axis_]\\n\",\n\" return [ShapedArray(tuple(new_shape), x.dtype)]\\n\",\n\"abstract_eval_rules[reduce_sum_p] = reduce_sum_abstract_eval\\n\",\n\"\\n\",\n\" subc = xc.XlaBuilder('add')\\n\",\n\" shape = _xla_shape(ShapedArray((), x_aval.dtype))\\n\",\n\" xops.Add(xops.Parameter(subc, 0, shape), xops.Parameter(subc, 1, shape))\\n\",\n- \" return [xops.Reduce(c, [x], [zero], subc.build(), [axis])]\\n\",\n+ \" return [xops.Reduce(c, [x], [zero], subc.build(), axis)]\\n\",\n\"xla_translations[reduce_sum_p] = reduce_sum_translation\\n\",\n\"\\n\",\n\"def broadcast_translation(c, in_avals, in_vals, *, shape, axes):\\n\",\n\" var = constid_to_var.get(id(val))\\n\",\n\" if var is None:\\n\",\n\" aval = raise_to_shaped(get_aval(val))\\n\",\n- \" var = tracer_to_var[id(t)] = constid_to_var[id(val)] = Var(aval)\\n\",\n+ \" var = constid_to_var[id(val)] = Var(aval)\\n\",\n\" constvar_to_val[var] = val\\n\",\n+ \" tracer_to_var[id(t)] = var\\n\",\n\" elif isinstance(t.recipe, JaxprEqnRecipe):\\n\",\n\" if id(t.recipe) not in processed_eqns:\\n\",\n\" eqns.append(recipe_to_eqn(tracer_to_var, t.recipe))\\n\",\n\" return [z_bar, z_bar]\\n\",\n\"transpose_rules[add_p] = add_transpose_rule\\n\",\n\"\\n\",\n+ \"def reduce_sum_transpose_rule(cts, x, *, axis):\\n\",\n+ \" y_bar, = cts\\n\",\n+ \" return [broadcast(y_bar, x.aval.shape, axis)]\\n\",\n+ \"transpose_rules[reduce_sum_p] = reduce_sum_transpose_rule\\n\",\n+ \"\\n\",\n\"def xla_call_transpose_rule(cts, *invals, jaxpr, num_consts):\\n\",\n\" del num_consts # Unused\\n\",\n\" undef_primals = [type(x) is UndefPrimal for x in invals]\\n\",\n"
},
{
"change_type": "MODIFY",
"old_path": "docs/autodidax.md",
"new_path": "docs/autodidax.md",
"diff": "@@ -104,11 +104,16 @@ def mul(x, y): return bind1(mul_p, x, y)\ndef neg(x): return bind1(neg_p, x)\ndef sin(x): return bind1(sin_p, x)\ndef cos(x): return bind1(cos_p, x)\n-def reduce_sum(x, axis=None): return bind1(reduce_sum_p, x, axis=axis)\ndef greater(x, y): return bind1(greater_p, x, y)\ndef less(x, y): return bind1(less_p, x, y)\ndef transpose(x, perm): return bind1(transpose_p, x, perm=perm)\ndef broadcast(x, shape, axes): return bind1(broadcast_p, x, shape=shape, axes=axes)\n+def reduce_sum(x, axis=None):\n+ if axis is None:\n+ axis = tuple(range(np.ndim(x)))\n+ if type(axis) is int:\n+ axis = (axis,)\n+ return bind1(reduce_sum_p, x, axis=axis)\ndef bind1(prim, *args, **params):\nout, = bind(prim, *args, **params)\n@@ -873,8 +878,8 @@ vmap_rules[neg_p] = partial(vectorized_unop_batching_rule, neg)\ndef reduce_sum_batching_rule(axis_size, vals_in, dims_in, *, axis):\n(x,), (x_bdim,) = vals_in, dims_in\n- new_axis = axis + (x_bdim <= axis)\n- out_bdim = x_bdim - (new_axis < x_bdim)\n+ new_axis = tuple(ax + (x_bdim <= ax) for ax in axis)\n+ out_bdim = x_bdim - sum(ax < x_bdim for ax in axis)\nreturn [reduce_sum(x, new_axis)], [out_bdim]\nvmap_rules[reduce_sum_p] = reduce_sum_batching_rule\n```\n@@ -1269,8 +1274,10 @@ abstract_eval_rules[sin_p] = vectorized_unop_abstract_eval\nabstract_eval_rules[cos_p] = vectorized_unop_abstract_eval\nabstract_eval_rules[neg_p] = vectorized_unop_abstract_eval\n-def reduce_sum_abstract_eval(x: ShapedArray, *, axis: int) -> List[ShapedArray]:\n- new_shape = [d for i, d in enumerate(x.shape) if i != axis]\n+def reduce_sum_abstract_eval(x: ShapedArray, *, axis: Tuple[int, ...]\n+ ) -> List[ShapedArray]:\n+ axis_ = set(axis)\n+ new_shape = [d for i, d in enumerate(x.shape) if i not in axis_]\nreturn [ShapedArray(tuple(new_shape), x.dtype)]\nabstract_eval_rules[reduce_sum_p] = reduce_sum_abstract_eval\n@@ -1647,7 +1654,7 @@ def reduce_sum_translation(c, in_avals, in_vals, *, axis):\nsubc = xc.XlaBuilder('add')\nshape = _xla_shape(ShapedArray((), x_aval.dtype))\nxops.Add(xops.Parameter(subc, 0, shape), xops.Parameter(subc, 1, shape))\n- return [xops.Reduce(c, [x], [zero], subc.build(), [axis])]\n+ return [xops.Reduce(c, [x], [zero], subc.build(), axis)]\nxla_translations[reduce_sum_p] = reduce_sum_translation\ndef broadcast_translation(c, in_avals, in_vals, *, shape, axes):\n@@ -2207,8 +2214,9 @@ def tracers_to_jaxpr(tracers_in: List[PartialEvalTracer],\nvar = constid_to_var.get(id(val))\nif var is None:\naval = raise_to_shaped(get_aval(val))\n- var = tracer_to_var[id(t)] = constid_to_var[id(val)] = Var(aval)\n+ var = constid_to_var[id(val)] = Var(aval)\nconstvar_to_val[var] = val\n+ tracer_to_var[id(t)] = var\nelif isinstance(t.recipe, JaxprEqnRecipe):\nif id(t.recipe) not in processed_eqns:\neqns.append(recipe_to_eqn(tracer_to_var, t.recipe))\n@@ -2557,6 +2565,11 @@ def add_transpose_rule(cts, x, y):\nreturn [z_bar, z_bar]\ntranspose_rules[add_p] = add_transpose_rule\n+def reduce_sum_transpose_rule(cts, x, *, axis):\n+ y_bar, = cts\n+ return [broadcast(y_bar, x.aval.shape, axis)]\n+transpose_rules[reduce_sum_p] = reduce_sum_transpose_rule\n+\ndef xla_call_transpose_rule(cts, *invals, jaxpr, num_consts):\ndel num_consts # Unused\nundef_primals = [type(x) is UndefPrimal for x in invals]\n"
},
{
"change_type": "MODIFY",
"old_path": "docs/autodidax.py",
"new_path": "docs/autodidax.py",
"diff": "@@ -92,11 +92,16 @@ def mul(x, y): return bind1(mul_p, x, y)\ndef neg(x): return bind1(neg_p, x)\ndef sin(x): return bind1(sin_p, x)\ndef cos(x): return bind1(cos_p, x)\n-def reduce_sum(x, axis=None): return bind1(reduce_sum_p, x, axis=axis)\ndef greater(x, y): return bind1(greater_p, x, y)\ndef less(x, y): return bind1(less_p, x, y)\ndef transpose(x, perm): return bind1(transpose_p, x, perm=perm)\ndef broadcast(x, shape, axes): return bind1(broadcast_p, x, shape=shape, axes=axes)\n+def reduce_sum(x, axis=None):\n+ if axis is None:\n+ axis = tuple(range(np.ndim(x)))\n+ if type(axis) is int:\n+ axis = (axis,)\n+ return bind1(reduce_sum_p, x, axis=axis)\ndef bind1(prim, *args, **params):\nout, = bind(prim, *args, **params)\n@@ -873,8 +878,8 @@ vmap_rules[neg_p] = partial(vectorized_unop_batching_rule, neg)\ndef reduce_sum_batching_rule(axis_size, vals_in, dims_in, *, axis):\n(x,), (x_bdim,) = vals_in, dims_in\n- new_axis = axis + (x_bdim <= axis)\n- out_bdim = x_bdim - (new_axis < x_bdim)\n+ new_axis = tuple(ax + (x_bdim <= ax) for ax in axis)\n+ out_bdim = x_bdim - sum(ax < x_bdim for ax in axis)\nreturn [reduce_sum(x, new_axis)], [out_bdim]\nvmap_rules[reduce_sum_p] = reduce_sum_batching_rule\n@@ -1271,8 +1276,10 @@ abstract_eval_rules[sin_p] = vectorized_unop_abstract_eval\nabstract_eval_rules[cos_p] = vectorized_unop_abstract_eval\nabstract_eval_rules[neg_p] = vectorized_unop_abstract_eval\n-def reduce_sum_abstract_eval(x: ShapedArray, *, axis: int) -> List[ShapedArray]:\n- new_shape = [d for i, d in enumerate(x.shape) if i != axis]\n+def reduce_sum_abstract_eval(x: ShapedArray, *, axis: Tuple[int, ...]\n+ ) -> List[ShapedArray]:\n+ axis_ = set(axis)\n+ new_shape = [d for i, d in enumerate(x.shape) if i not in axis_]\nreturn [ShapedArray(tuple(new_shape), x.dtype)]\nabstract_eval_rules[reduce_sum_p] = reduce_sum_abstract_eval\n@@ -1643,7 +1650,7 @@ def reduce_sum_translation(c, in_avals, in_vals, *, axis):\nsubc = xc.XlaBuilder('add')\nshape = _xla_shape(ShapedArray((), x_aval.dtype))\nxops.Add(xops.Parameter(subc, 0, shape), xops.Parameter(subc, 1, shape))\n- return [xops.Reduce(c, [x], [zero], subc.build(), [axis])]\n+ return [xops.Reduce(c, [x], [zero], subc.build(), axis)]\nxla_translations[reduce_sum_p] = reduce_sum_translation\ndef broadcast_translation(c, in_avals, in_vals, *, shape, axes):\n@@ -2201,8 +2208,9 @@ def tracers_to_jaxpr(tracers_in: List[PartialEvalTracer],\nvar = constid_to_var.get(id(val))\nif var is None:\naval = raise_to_shaped(get_aval(val))\n- var = tracer_to_var[id(t)] = constid_to_var[id(val)] = Var(aval)\n+ var = constid_to_var[id(val)] = Var(aval)\nconstvar_to_val[var] = val\n+ tracer_to_var[id(t)] = var\nelif isinstance(t.recipe, JaxprEqnRecipe):\nif id(t.recipe) not in processed_eqns:\neqns.append(recipe_to_eqn(tracer_to_var, t.recipe))\n@@ -2556,6 +2564,11 @@ def add_transpose_rule(cts, x, y):\nreturn [z_bar, z_bar]\ntranspose_rules[add_p] = add_transpose_rule\n+def reduce_sum_transpose_rule(cts, x, *, axis):\n+ y_bar, = cts\n+ return [broadcast(y_bar, x.aval.shape, axis)]\n+transpose_rules[reduce_sum_p] = reduce_sum_transpose_rule\n+\ndef xla_call_transpose_rule(cts, *invals, jaxpr, num_consts):\ndel num_consts # Unused\nundef_primals = [type(x) is UndefPrimal for x in invals]\n"
}
] | Python | Apache License 2.0 | google/jax | improvements to autodidax reduce_sum
* generalize reduce_sum to handle multiple axes
* add reduce_sum transpose rule
also fix bug in AD jaxpr formation related to deduplicating consts |
260,424 | 17.03.2022 09:59:52 | 25,200 | 1d5833d2f15fe81d8866f4b5481e364262a6cb04 | Reshape top_k operand to 2D by collapsing the batch dimensions when lowering. | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/lax.py",
"new_path": "jax/_src/lax/lax.py",
"diff": "@@ -4043,7 +4043,14 @@ def _top_k_batch_rule(batched_args, batch_dims, *, k):\nreturn top_k(operand, k=k), (bdim, bdim)\ndef _top_k_translation_rule(ctx, avals_in, avals_out, x, *, k):\n- return xla.xla_destructure(ctx.builder, xops.TopK(x, k))\n+ x_shape = ctx.builder.get_shape(x).dimensions()\n+ batchdims = x_shape[:-1]\n+ if batchdims:\n+ # TODO(b/224554623): XLA does not support top-k beyond 2D, collapse the\n+ # batch dimensions here to get better performance (otherwise XLA uses sort).\n+ x = xops.Reshape(x, (prod(batchdims), x_shape[-1]))\n+ ks, idxs = xla.xla_destructure(ctx.builder, xops.TopK(x, k))\n+ return xops.Reshape(ks, batchdims+(k,)), xops.Reshape(idxs, batchdims+(k,))\ntop_k_p = Primitive('top_k')\ntop_k_p.multiple_results = True\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_test.py",
"new_path": "tests/lax_test.py",
"diff": "@@ -2104,7 +2104,7 @@ class LaxTest(jtu.JaxTestCase):\njtu.format_shape_dtype_string(shape, dtype), k),\n\"shape\": shape, \"dtype\": dtype, \"k\": k}\nfor dtype in [np.float32, np.int32, np.uint32]\n- for shape in [(3,), (5, 3)]\n+ for shape in [(3,), (5, 3), (7, 5, 3)]\nfor k in [1, 3]))\ndef testTopK(self, shape, dtype, k):\ndef args_maker():\n"
}
] | Python | Apache License 2.0 | google/jax | Reshape top_k operand to 2D by collapsing the batch dimensions when lowering.
PiperOrigin-RevId: 435374934 |
260,442 | 17.03.2022 23:10:46 | 25,200 | 6cd9804163203e4da13b33171c5889b6d17e5f43 | Replace (deprecated) StrEnumAttr with EnumAttr.
ref: | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/lax.py",
"new_path": "jax/_src/lax/lax.py",
"diff": "@@ -1579,13 +1579,23 @@ ad.defjvp_zero(sign_p)\ndef _sign_lower_mhlo(ctx, x):\nx_aval, = ctx.avals_in\nif dtypes.issubdtype(x_aval.dtype, np.unsignedinteger):\n+ if jax._src.lib.mlir_api_version >= 3:\nreturn mhlo.SelectOp(\nmhlo.CompareOp(\n- mlir.aval_to_ir_type(x_aval.update(dtype=np.dtype(np.bool_))),\n- x, mlir.full_like_aval(0, x_aval), ir.StringAttr.get(\"EQ\"),\n- ir.StringAttr.get(\"UNSIGNED\")).result,\n+ mlir.aval_to_ir_type(x_aval.update(dtype=np.dtype(np.bool_))), x,\nmlir.full_like_aval(0, x_aval),\n- mlir.full_like_aval(1, x_aval)).results\n+ mhlo.ComparisonDirectionAttr.get('EQ'),\n+ mhlo.ComparisonTypeAttr.get('UNSIGNED')).result,\n+ mlir.full_like_aval(0, x_aval), mlir.full_like_aval(1,\n+ x_aval)).results\n+ else:\n+ return mhlo.SelectOp(\n+ mhlo.CompareOp(\n+ mlir.aval_to_ir_type(x_aval.update(dtype=np.dtype(np.bool_))), x,\n+ mlir.full_like_aval(0, x_aval), ir.StringAttr.get('EQ'),\n+ ir.StringAttr.get('UNSIGNED')).result,\n+ mlir.full_like_aval(0, x_aval), mlir.full_like_aval(1,\n+ x_aval)).results\nreturn mhlo.SignOp(x).results\nmlir.register_lowering(sign_p, _sign_lower_mhlo)\n@@ -2216,8 +2226,14 @@ def _compare_lower_mhlo(direction: str, ctx, x, y):\ncompare_type = \"SIGNED\"\nelse:\ncompare_type = \"UNSIGNED\"\n- return mhlo.CompareOp(mlir.aval_to_ir_type(aval_out), x, y,\n- ir.StringAttr.get(direction),\n+ if jax._src.lib.mlir_api_version >= 3:\n+ return mhlo.CompareOp(\n+ mlir.aval_to_ir_type(aval_out), x, y,\n+ mhlo.ComparisonDirectionAttr.get(direction),\n+ mhlo.ComparisonTypeAttr.get(compare_type)).results\n+ else:\n+ return mhlo.CompareOp(\n+ mlir.aval_to_ir_type(aval_out), x, y, ir.StringAttr.get(direction),\nir.StringAttr.get(compare_type)).results\neq_p = naryop(_fixed_dtype(np.bool_), [_any, _any], 'eq')\n@@ -2630,8 +2646,14 @@ def precision_attr(precision: PrecisionType) -> ir.ArrayAttr:\nfull_precision = (precision, precision)\nelse:\nfull_precision = precision\n+ if jax._src.lib.mlir_api_version >= 3:\n+ return ir.ArrayAttr.get(\n+ [mhlo.PrecisionAttr.get(str(p)) for p in full_precision])\n+ else:\nreturn ir.ArrayAttr.get([ir.StringAttr.get(str(p)) for p in full_precision])\n+\n+\ndef _dot_general_lower(ctx, lhs, rhs, *, dimension_numbers,\nprecision, preferred_element_type: Optional[np.dtype]):\ndel preferred_element_type # Implied by the output aval\n@@ -3335,19 +3357,26 @@ def _select_mhlo_lowering(ctx, which, *cases):\nbool_shape = ir.RankedTensorType.get(which_aval.shape,\nir.IntegerType.get_signless(1))\nif dtypes.issubdtype(which_aval.dtype, np.signedinteger):\n- compare_type = ir.StringAttr.get(\"SIGNED\")\n+ compare_type = 'SIGNED'\nelse:\n- compare_type = ir.StringAttr.get(\"UNSIGNED\")\n- lt = ir.StringAttr.get(\"LT\")\n+ compare_type = 'UNSIGNED'\n+ lt = 'LT'\ndef _select(offset, cases):\nassert len(cases) > 0\nif len(cases) == 1:\nreturn cases[0]\nmid = len(cases) // 2\n- pred = mhlo.CompareOp(\n- bool_shape, which, mlir.full_like_aval(offset + mid, which_aval),\n- lt, compare_type)\n+ if jax._src.lib.mlir_api_version >= 3:\n+ pred = mhlo.CompareOp(bool_shape, which,\n+ mlir.full_like_aval(offset + mid, which_aval),\n+ mhlo.ComparisonDirectionAttr.get(lt),\n+ mhlo.ComparisonTypeAttr.get(compare_type))\n+ else:\n+ pred = mhlo.CompareOp(bool_shape, which,\n+ mlir.full_like_aval(offset + mid, which_aval),\n+ ir.StringAttr.get(lt),\n+ ir.StringAttr.get(compare_type))\nreturn mhlo.SelectOp(pred, _select(offset, cases[:mid]),\n_select(offset + mid, cases[mid:])).result\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/mlir.py",
"new_path": "jax/interpreters/mlir.py",
"diff": "@@ -28,6 +28,7 @@ from typing import (Any, Callable, Dict, List, Optional, Sequence, Set, Tuple,\nfrom typing_extensions import Protocol\nimport warnings\n+import jax\nfrom jax import core\nfrom jax import linear_util as lu\nfrom jax._src import ad_util\n@@ -820,14 +821,26 @@ def _minmax_mhlo(op, cmp, x, y):\nry = mhlo.RealOp(y).result\ndims = [tensor_type.get_dim_size(i) for i in range(tensor_type.rank)]\nbool_shape = ir.RankedTensorType.get(dims, ir.IntegerType.get_signless(1))\n+ if jax._src.lib.mlir_api_version >= 3:\n+ real_eq = mhlo.CompareOp(bool_shape, rx, ry,\n+ mhlo.ComparisonDirectionAttr.get(\"EQ\"),\n+ mhlo.ComparisonTypeAttr.get(\"FLOAT\"))\n+ real_cmp = mhlo.CompareOp(bool_shape, rx, ry,\n+ mhlo.ComparisonDirectionAttr.get(cmp),\n+ mhlo.ComparisonTypeAttr.get(\"FLOAT\"))\n+ imag_cmp = mhlo.CompareOp(bool_shape,\n+ mhlo.ImagOp(x).result,\n+ mhlo.ImagOp(y).result,\n+ mhlo.ComparisonDirectionAttr.get(cmp),\n+ mhlo.ComparisonTypeAttr.get(\"FLOAT\"))\n+ else:\nreal_eq = mhlo.CompareOp(bool_shape, rx, ry, ir.StringAttr.get(\"EQ\"),\nir.StringAttr.get(\"FLOAT\"))\n- real_cmp = mhlo.CompareOp(bool_shape, rx, ry,\n- ir.StringAttr.get(cmp),\n+ real_cmp = mhlo.CompareOp(bool_shape, rx, ry, ir.StringAttr.get(cmp),\nir.StringAttr.get(\"FLOAT\"))\n- imag_cmp = mhlo.CompareOp(bool_shape, mhlo.ImagOp(x).result,\n- mhlo.ImagOp(y).result,\n- ir.StringAttr.get(cmp),\n+ imag_cmp = mhlo.CompareOp(bool_shape,\n+ mhlo.ImagOp(x).result,\n+ mhlo.ImagOp(y).result, ir.StringAttr.get(cmp),\nir.StringAttr.get(\"FLOAT\"))\nwhich = mhlo.SelectOp(real_eq, imag_cmp, real_cmp).result\nreturn mhlo.SelectOp(which, x, y)\n@@ -850,6 +863,12 @@ def convert_mhlo(x, aval_in, aval_out):\ncompare_type = \"SIGNED\"\nelse:\ncompare_type = \"UNSIGNED\"\n+ if jax._src.lib.mlir_api_version >= 3:\n+ return mhlo.CompareOp(\n+ aval_to_ir_type(aval_out), x, full_like_aval(0, aval_in),\n+ mhlo.ComparisonDirectionAttr.get(\"NE\"),\n+ mhlo.ComparisonTypeAttr.get(compare_type)).result\n+ else:\nreturn mhlo.CompareOp(\naval_to_ir_type(aval_out), x, full_like_aval(0, aval_in),\nir.StringAttr.get(\"NE\"), ir.StringAttr.get(compare_type)).result\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -44,6 +44,7 @@ import sys\nfrom absl import logging\nimport numpy as np\n+import jax\nfrom jax._src.config import config\nfrom jax import core\nfrom jax import linear_util as lu\n@@ -1753,6 +1754,12 @@ def _mhlo_unshard(aval, axis_env, out_axis, xs, platform):\n# TODO(mattjj): remove this logic when AllReduce PRED supported on CPU / GPU\nif convert_bool:\nfloat_zero = mlir.full_like_aval(0, padded_aval)\n+ if jax._src.lib.mlir_api_version >= 3:\n+ out = mhlo.CompareOp(\n+ mlir.aval_to_ir_type(padded_aval.update(dtype=np.dtype(np.bool_))),\n+ out, float_zero, mhlo.ComparisonDirectionAttr.get(\"NE\"),\n+ mhlo.ComparisonTypeAttr.get(\"FLOAT\")).result\n+ else:\nout = mhlo.CompareOp(\nmlir.aval_to_ir_type(padded_aval.update(dtype=np.dtype(np.bool_))),\nout, float_zero, ir.StringAttr.get(\"NE\"),\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/filecheck/math.filecheck.py",
"new_path": "tests/filecheck/math.filecheck.py",
"diff": "@@ -199,29 +199,29 @@ def main(_):\n# CHECK-LABEL: TEST: eq float32[] float32[]\n# CHECK: mhlo.compare\n- # CHECK-SAME: compare_type = \"FLOAT\"\n- # CHECK-SAME: comparison_direction = \"EQ\"\n+ # CHECK-SAME: compare_type = #mhlo<\"comparison_type FLOAT\">\n+ # CHECK-SAME: comparison_direction = #mhlo<\"comparison_direction EQ\">\n# CHECK-SAME: tensor<f32>\nprint_ir(np.float32(1), np.float32(2))(lax.eq)\n# CHECK-LABEL: TEST: eq complex128[] complex128[]\n# CHECK: mhlo.compare\n- # CHECK-SAME: compare_type = \"FLOAT\"\n- # CHECK-SAME: comparison_direction = \"EQ\"\n+ # CHECK-SAME: compare_type = #mhlo<\"comparison_type FLOAT\">\n+ # CHECK-SAME: comparison_direction = #mhlo<\"comparison_direction EQ\">\n# CHECK-SAME: tensor<complex<f64>>\nprint_ir(np.complex128(1), np.complex128(2))(lax.eq)\n# CHECK-LABEL: TEST: eq int64[] int64[]\n# CHECK: mhlo.compare\n- # CHECK-SAME: compare_type = \"SIGNED\"\n- # CHECK-SAME: comparison_direction = \"EQ\"\n+ # CHECK-SAME: compare_type = #mhlo<\"comparison_type SIGNED\">\n+ # CHECK-SAME: comparison_direction = #mhlo<\"comparison_direction EQ\">\n# CHECK-SAME: tensor<i64>\nprint_ir(np.int64(1), np.int64(2))(lax.eq)\n# CHECK-LABEL: TEST: eq uint16[] uint16[]\n# CHECK: mhlo.compare\n- # CHECK-SAME: compare_type = \"UNSIGNED\"\n- # CHECK-SAME: comparison_direction = \"EQ\"\n+ # CHECK-SAME: compare_type = #mhlo<\"comparison_type UNSIGNED\">\n+ # CHECK-SAME: comparison_direction = #mhlo<\"comparison_direction EQ\">\n# CHECK-SAME: tensor<ui16>\nprint_ir(np.uint16(1), np.uint16(2))(lax.eq)\n@@ -257,15 +257,15 @@ def main(_):\n# CHECK-LABEL: TEST: ge float32[] float32[]\n# CHECK: mhlo.compare\n- # CHECK-SAME: compare_type = \"FLOAT\"\n- # CHECK-SAME: comparison_direction = \"GE\"\n+ # CHECK-SAME: compare_type = #mhlo<\"comparison_type FLOAT\">\n+ # CHECK-SAME: comparison_direction = #mhlo<\"comparison_direction GE\">\n# CHECK-SAME: tensor<f32>\nprint_ir(np.float32(1), np.float32(2))(lax.ge)\n# CHECK-LABEL: TEST: gt float32[] float32[]\n# CHECK: mhlo.compare\n- # CHECK-SAME: compare_type = \"FLOAT\"\n- # CHECK-SAME: comparison_direction = \"GT\"\n+ # CHECK-SAME: compare_type = #mhlo<\"comparison_type FLOAT\">\n+ # CHECK-SAME: comparison_direction = #mhlo<\"comparison_direction GT\">\n# CHECK-SAME: tensor<f32>\nprint_ir(np.float32(1), np.float32(2))(lax.gt)\n@@ -302,8 +302,8 @@ def main(_):\n# CHECK-LABEL: TEST: le float32[] float32[]\n# CHECK: mhlo.compare\n- # CHECK-SAME: compare_type = \"FLOAT\"\n- # CHECK-SAME: comparison_direction = \"LE\"\n+ # CHECK-SAME: compare_type = #mhlo<\"comparison_type FLOAT\">\n+ # CHECK-SAME: comparison_direction = #mhlo<\"comparison_direction LE\">\n# CHECK-SAME: tensor<f32>\nprint_ir(np.float32(1), np.float32(2))(lax.le)\n@@ -324,8 +324,8 @@ def main(_):\n# CHECK-LABEL: TEST: lt float32[] float32[]\n# CHECK: mhlo.compare\n- # CHECK-SAME: compare_type = \"FLOAT\"\n- # CHECK-SAME: comparison_direction = \"LT\"\n+ # CHECK-SAME: compare_type = #mhlo<\"comparison_type FLOAT\">\n+ # CHECK-SAME: comparison_direction = #mhlo<\"comparison_direction LT\">\n# CHECK-SAME: tensor<f32>\nprint_ir(np.float32(1), np.float32(2))(lax.lt)\n@@ -346,8 +346,8 @@ def main(_):\n# CHECK-LABEL: TEST: ne float32[] float32[]\n# CHECK: mhlo.compare\n- # CHECK-SAME: compare_type = \"FLOAT\"\n- # CHECK-SAME: comparison_direction = \"NE\"\n+ # CHECK-SAME: compare_type = #mhlo<\"comparison_type FLOAT\">\n+ # CHECK-SAME: comparison_direction = #mhlo<\"comparison_direction NE\">\n# CHECK-SAME: tensor<f32>\nprint_ir(np.float32(1), np.float32(2))(lax.ne)\n"
}
] | Python | Apache License 2.0 | google/jax | Replace (deprecated) StrEnumAttr with EnumAttr.
ref: https://reviews.llvm.org/D120834
PiperOrigin-RevId: 435550738 |
260,430 | 20.03.2022 13:55:03 | -28,800 | e5b3f0b537ae10ca9acceccc849b76254838156b | Fix
Fix hessian with options and add regression test | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/api.py",
"new_path": "jax/_src/api.py",
"diff": "@@ -1158,7 +1158,7 @@ _check_output_dtype_jacrev = partial(_check_output_dtype_revderiv, \"jacrev\")\ndef hessian(fun: Callable, argnums: Union[int, Sequence[int]] = 0,\n- holomorphic: bool = False) -> Callable:\n+ has_aux: bool = False, holomorphic: bool = False) -> Callable:\n\"\"\"Hessian of ``fun`` as a dense array.\nArgs:\n@@ -1168,6 +1168,9 @@ def hessian(fun: Callable, argnums: Union[int, Sequence[int]] = 0,\ncontainers thereof.\nargnums: Optional, integer or sequence of integers. Specifies which\npositional argument(s) to differentiate with respect to (default ``0``).\n+ has_aux: Optional, bool. Indicates whether ``fun`` returns a pair where the\n+ first element is considered the output of the mathematical function to be\n+ differentiated and the second element is auxiliary data. Default False.\nholomorphic: Optional, bool. Indicates whether ``fun`` is promised to be\nholomorphic. Default False.\n@@ -1218,7 +1221,8 @@ def hessian(fun: Callable, argnums: Union[int, Sequence[int]] = 0,\n``(out1, out2, ..., in1, in2, ..., in1, in2, ...)``. To flatten pytrees into\n1D vectors, consider using :py:func:`jax.flatten_util.flatten_pytree`.\n\"\"\"\n- return jacfwd(jacrev(fun, argnums, holomorphic), argnums, holomorphic)\n+ return jacfwd(jacrev(fun, argnums, has_aux=has_aux, holomorphic=holomorphic),\n+ argnums, has_aux=has_aux, holomorphic=holomorphic)\ndef _std_basis(pytree):\nleaves, _ = tree_flatten(pytree)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/api_test.py",
"new_path": "tests/api_test.py",
"diff": "@@ -1217,6 +1217,26 @@ class APITest(jtu.JaxTestCase):\nf = lambda x: jnp.dot(x, jnp.dot(A, x))\nassert np.allclose(hessian(f)(x), A + A.T)\n+ @jtu.skip_on_devices(\"tpu\")\n+ def test_hessian_holomorphic(self):\n+ R = self.rng().randn\n+ A = R(4, 4)\n+ x = R(4) * (1 + 2j)\n+\n+ f = lambda x: jnp.dot(x, jnp.dot(A, x))\n+ assert np.allclose(hessian(f, holomorphic=True)(x), A + A.T)\n+\n+ @jtu.skip_on_devices(\"tpu\")\n+ def test_hessian_aux(self):\n+ R = self.rng().randn\n+ A = R(4, 4)\n+ x = R(4)\n+\n+ f = lambda x: (jnp.dot(x, jnp.dot(A, x)), x)\n+ h, aux = hessian(f, has_aux=True)(x)\n+ assert np.allclose(h, A + A.T)\n+ assert np.allclose(aux, x)\n+\ndef test_std_basis(self):\nbasis = api._std_basis(jnp.zeros(3))\nassert getattr(basis, \"shape\", None) == (3, 3)\n"
}
] | Python | Apache License 2.0 | google/jax | Fix #9969
Fix hessian with options and add regression test |
260,341 | 23.03.2022 20:39:39 | 0 | 7915c6ce27772ac21419a95dfaefaad7ccb2125f | Rename jax.nn.normalize to standardize. Add normalize alias with DeprecationWarning. | [
{
"change_type": "MODIFY",
"old_path": "CHANGELOG.md",
"new_path": "CHANGELOG.md",
"diff": "@@ -13,8 +13,9 @@ PLEASE REMEMBER TO CHANGE THE '..main' WITH AN ACTUAL TAG in GITHUB LINK.\ncommits](https://github.com/google/jax/compare/jax-v0.3.4...main).\n* Changes:\n* added {func}`jax.random.loggamma` & improved behavior of {func}`jax.random.beta`\n- and {func}`jax.random.dirichlet` for small parameter values `({jax-issue}`9906`).\n-\n+ and {func}`jax.random.dirichlet` for small parameter values ({jax-issue}`#9906`).\n+* Deprecations:\n+ * {func}`jax.nn.normalize` is being deprecated. Use {func}`jax.nn.standardize` instead ({jax-issue}`#9899`).\n## jaxlib 0.3.3 (Unreleased)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/nn/functions.py",
"new_path": "jax/_src/nn/functions.py",
"diff": "from functools import partial\nimport operator\n+import warnings\nimport numpy as np\nfrom typing import Any, Optional, Tuple, Union\n@@ -333,7 +334,7 @@ def softmax(x: Array,\nreturn unnormalized / jnp.sum(unnormalized, axis, where=where, keepdims=True)\n@partial(jax.jit, static_argnames=(\"axis\",))\n-def normalize(x: Array,\n+def standardize(x: Array,\naxis: Optional[Union[int, Tuple[int, ...]]] = -1,\nmean: Optional[Array] = None,\nvariance: Optional[Array] = None,\n@@ -351,6 +352,15 @@ def normalize(x: Array,\njnp.square(x), axis, keepdims=True, where=where) - jnp.square(mean)\nreturn (x - mean) * lax.rsqrt(variance + epsilon)\n+def normalize(x: Array,\n+ axis: Optional[Union[int, Tuple[int, ...]]] = -1,\n+ mean: Optional[Array] = None,\n+ variance: Optional[Array] = None,\n+ epsilon: Array = 1e-5,\n+ where: Optional[Array] = None) -> Array:\n+ r\"\"\"Normalizes an array by subtracting ``mean`` and dividing by :math:`\\sqrt{\\mathrm{variance}}`.\"\"\"\n+ warnings.warn(\"jax.nn.normalize will be deprecated. Use jax.nn.standardize instead.\", DeprecationWarning)\n+ return standardize(x, axis, mean, variance, epsilon, where)\n@partial(jax.jit, static_argnames=(\"num_classes\", \"dtype\", \"axis\"))\ndef _one_hot(x: Array, num_classes: int, *,\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/example_libraries/stax.py",
"new_path": "jax/example_libraries/stax.py",
"diff": "@@ -34,7 +34,7 @@ from jax import random\nimport jax.numpy as jnp\nfrom jax.nn import (relu, log_softmax, softmax, softplus, sigmoid, elu,\n- leaky_relu, selu, gelu, normalize)\n+ leaky_relu, selu, gelu, standardize)\nfrom jax.nn.initializers import glorot_normal, normal, ones, zeros\n# aliases for backwards compatibility\n@@ -137,7 +137,7 @@ def BatchNorm(axis=(0, 1, 2), epsilon=1e-5, center=True, scale=True,\n# TODO(phawkins): jnp.expand_dims should accept an axis tuple.\n# (https://github.com/numpy/numpy/issues/12290)\ned = tuple(None if i in axis else slice(None) for i in range(jnp.ndim(x)))\n- z = normalize(x, axis, epsilon=epsilon)\n+ z = standardize(x, axis, epsilon=epsilon)\nif center and scale: return gamma[ed] * z + beta[ed]\nif center: return z + beta[ed]\nif scale: return gamma[ed] * z\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/nn/__init__.py",
"new_path": "jax/nn/__init__.py",
"diff": "@@ -32,6 +32,7 @@ from jax._src.nn.functions import (\nlog_softmax as log_softmax,\nlogsumexp as logsumexp,\nnormalize as normalize,\n+ standardize as standardize,\none_hot as one_hot,\nrelu as relu,\nrelu6 as relu6,\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/nn_test.py",
"new_path": "tests/nn_test.py",
"diff": "@@ -126,13 +126,13 @@ class NNFunctionsTest(jtu.JaxTestCase):\nself.assertAllClose(out_masked, out_filtered)\n- def testNormalizeWhereMask(self):\n+ def testStandardizeWhereMask(self):\nx = jnp.array([5.5, 1.3, -4.2, 0.9])\nm = jnp.array([True, False, True, True])\nx_filtered = jnp.take(x, jnp.array([0, 2, 3]))\n- out_masked = jnp.take(nn.normalize(x, where=m), jnp.array([0, 2, 3]))\n- out_filtered = nn.normalize(x_filtered)\n+ out_masked = jnp.take(nn.standardize(x, where=m), jnp.array([0, 2, 3]))\n+ out_filtered = nn.standardize(x_filtered)\nself.assertAllClose(out_masked, out_filtered)\n"
}
] | Python | Apache License 2.0 | google/jax | Rename jax.nn.normalize to standardize. Add normalize alias with DeprecationWarning. |
260,456 | 17.03.2022 05:04:02 | 0 | 8cd02946b5e729a9ee1980566b53e92153475486 | Fix for hipsparse in ROCm. | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/linalg.py",
"new_path": "jax/_src/lax/linalg.py",
"diff": "@@ -37,10 +37,9 @@ from jax._src.lib import lapack\nfrom jax._src.lib import cuda_linalg\nfrom jax._src.lib import cusolver\n-from jax._src.lib import cusparse\nfrom jax._src.lib import hip_linalg\nfrom jax._src.lib import hipsolver\n-from jax._src.lib import hipsparse\n+from jax._src.lib import sparse_apis\nfrom jax._src.lib import xla_client\n@@ -1406,10 +1405,7 @@ if hipsolver is not None:\ndef _tridiagonal_solve_gpu_translation_rule(ctx, avals_in, avals_out, dl, d, du,\nb, *, m, n, ldb, t):\n- if cusparse:\n- return [cusparse.gtsv2(ctx.builder, dl, d, du, b, m=m, n=n, ldb=ldb, t=t)]\n- if hipsparse:\n- return [hipsparse.gtsv2(ctx.builder, dl, d, du, b, m=m, n=n, ldb=ldb, t=t)]\n+ return [sparse_apis.gtsv2(ctx.builder, dl, d, du, b, m=m, n=n, ldb=ldb, t=t)]\ntridiagonal_solve_p = Primitive('tridiagonal_solve')\ntridiagonal_solve_p.multiple_results = False\n@@ -1417,11 +1413,7 @@ tridiagonal_solve_p.def_impl(\nfunctools.partial(xla.apply_primitive, tridiagonal_solve_p))\ntridiagonal_solve_p.def_abstract_eval(lambda dl, d, du, b, *, m, n, ldb, t: b)\n# TODO(tomhennigan): Consider AD rules using lax.custom_linear_solve?\n-if cusparse is not None and hasattr(cusparse, \"gtsv2\"):\n- xla.register_translation(tridiagonal_solve_p,\n- _tridiagonal_solve_gpu_translation_rule,\n- platform='gpu')\n-if hipsparse is not None and hasattr(hipsparse, \"gtsv2\"):\n+if sparse_apis and hasattr(sparse_apis, \"gtsv2\"):\nxla.register_translation(tridiagonal_solve_p,\n_tridiagonal_solve_gpu_translation_rule,\nplatform='gpu')\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lib/__init__.py",
"new_path": "jax/_src/lib/__init__.py",
"diff": "@@ -126,6 +126,8 @@ try:\nexcept ImportError:\nhipsparse = None\n+sparse_apis = cusparse or hipsparse or None\n+\ntry:\nimport jaxlib.cuda_prng as cuda_prng # pytype: disable=import-error\nexcept ImportError:\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/sparse/bcoo.py",
"new_path": "jax/experimental/sparse/bcoo.py",
"diff": "@@ -38,10 +38,11 @@ from jax._src.api_util import flatten_axes\nfrom jax._src.lax.lax import (\nranges_like, remaining, _dot_general_batch_dim_nums, _dot_general_shape_rule,\nDotDimensionNumbers)\n-from jax._src.lib import cusparse\nfrom jax._src.lib import xla_client as xc\nfrom jax._src.numpy.setops import _unique\n+from jax._src.lib import sparse_apis\n+\nxops = xc._xla.ops\nDtype = Any\n@@ -687,11 +688,12 @@ def _bcoo_dot_general_cuda_translation_rule(\nassert lhs_data_aval.dtype in [np.float32, np.float64, np.complex64, np.complex128]\nassert lhs_data_aval.dtype == rhs_aval.dtype\nassert lhs_indices_aval.dtype == np.int32\n+ assert sparse_apis is not None\nif rhs_ndim == 1:\n- bcoo_dot_general_fn = cusparse.coo_matvec\n+ bcoo_dot_general_fn = sparse_apis.coo_matvec\nelif rhs_ndim == 2:\n- bcoo_dot_general_fn = cusparse.coo_matmat\n+ bcoo_dot_general_fn = sparse_apis.coo_matmat\nif rhs_contract[0] == 1:\nrhs = xops.Transpose(rhs, permutation=[1, 0])\nelse:\n@@ -751,7 +753,7 @@ def _bcoo_dot_general_gpu_translation_rule(\ndtype = lhs_data_aval.dtype\nif dtype not in [np.float32, np.float64, np.complex64, np.complex128]:\n- warnings.warn(f'bcoo_dot_general cusparse lowering not available for '\n+ warnings.warn(f'bcoo_dot_general cusparse/hipsparse lowering not available for '\nf'dtype={dtype}. Falling back to default implementation.',\nCuSparseEfficiencyWarning)\nreturn _bcoo_dot_general_default_translation_rule(\n@@ -842,7 +844,7 @@ batching.primitive_batchers[bcoo_dot_general_p] = _bcoo_dot_general_batch_rule\nxla.register_translation(\nbcoo_dot_general_p, _bcoo_dot_general_default_translation_rule)\n-if cusparse and cusparse.is_supported:\n+if sparse_apis and sparse_apis.is_supported:\nxla.register_translation(bcoo_dot_general_p,\n_bcoo_dot_general_gpu_translation_rule,\nplatform='gpu')\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/sparse/coo.py",
"new_path": "jax/experimental/sparse/coo.py",
"diff": "@@ -27,19 +27,11 @@ from jax.interpreters import xla\nfrom jax.experimental.sparse._base import JAXSparse\nfrom jax.experimental.sparse.util import _coo_extract, _safe_asarray, CuSparseEfficiencyWarning\nfrom jax import tree_util\n+from jax._src.lib import sparse_apis\nfrom jax._src.numpy.lax_numpy import _promote_dtypes\nfrom jax._src.lib import xla_client\nimport jax.numpy as jnp\n-try:\n- from jax._src.lib import cusparse\n-except ImportError:\n- cusparse = None\n-\n-try:\n- from jax._src.lib import hipsparse\n-except ImportError:\n- hipsparse = None\nxops = xla_client.ops\n@@ -186,10 +178,8 @@ def _coo_todense_gpu_translation_rule(ctx, avals_in, avals_out, data, row, col,\nreturn _coo_todense_translation_rule(ctx, avals_in, avals_out, data, row, col,\nspinfo=spinfo)\n- if cusparse is not None:\n- result = cusparse.coo_todense(ctx.builder, data, row, col, shape=shape)\n- else:\n- result = hipsparse.coo_todense(ctx.builder, data, row, col, shape=spinfo.shape)\n+ result = sparse_apis.coo_todense(ctx.builder, data, row, col, shape=shape)\n+\nreturn [xops.Transpose(result, (1, 0))] if transpose else [result]\n@@ -210,7 +200,7 @@ def _coo_todense_transpose(ct, data, row, col, *, spinfo):\nad.defjvp(coo_todense_p, _coo_todense_jvp, None, None)\nad.primitive_transposes[coo_todense_p] = _coo_todense_transpose\nxla.register_translation(coo_todense_p, _coo_todense_translation_rule)\n-if (cusparse and cusparse.is_supported) or (hipsparse and hipsparse.is_supported):\n+if sparse_apis and sparse_apis.is_supported:\nxla.register_translation(coo_todense_p, _coo_todense_gpu_translation_rule,\nplatform='gpu')\n@@ -284,11 +274,7 @@ def _coo_fromdense_gpu_translation_rule(ctx, avals_in, avals_out, mat, *, nse,\n\"Falling back to default implementation.\", CuSparseEfficiencyWarning)\nreturn _coo_fromdense_translation_rule(ctx, avals_in, avals_out, mat,\nnse=nse, index_dtype=index_dtype)\n- if cusparse is not None:\n- data, row, col = cusparse.coo_fromdense(\n- ctx.builder, mat, nnz=nse, index_dtype=np.dtype(index_dtype))\n- else:\n- data, row, col = hipsparse.coo_fromdense(\n+ data, row, col = sparse_apis.coo_fromdense(\nctx.builder, mat, nnz=nse, index_dtype=np.dtype(index_dtype))\nreturn [data, row, col]\n@@ -321,7 +307,7 @@ ad.primitive_jvps[coo_fromdense_p] = _coo_fromdense_jvp\nad.primitive_transposes[coo_fromdense_p] = _coo_fromdense_transpose\nxla.register_translation(coo_fromdense_p, _coo_fromdense_translation_rule)\n-if (cusparse and cusparse.is_supported) or (hipsparse and hipsparse.is_supported):\n+if sparse_apis and sparse_apis.is_supported:\nxla.register_translation(coo_fromdense_p,\n_coo_fromdense_gpu_translation_rule,\nplatform='gpu')\n@@ -411,11 +397,7 @@ def _coo_matvec_gpu_translation_rule(ctx, avals_in, avals_out, data, row, col,\nreturn _coo_matvec_translation_rule(ctx, avals_in, avals_out, data, row, col, v,\nspinfo=spinfo, transpose=transpose)\n- if cusparse is not None:\n- return [cusparse.coo_matvec(ctx.builder, data, row, col, v, shape=shape,\n- transpose=transpose)]\n- else:\n- return [hipsparse.coo_matvec(ctx.builder, data, row, col, v, shape=shape,\n+ return [sparse_apis.coo_matvec(ctx.builder, data, row, col, v, shape=shape,\ntranspose=transpose)]\ndef _coo_matvec_jvp_mat(data_dot, data, row, col, v, *, spinfo, transpose):\n@@ -439,7 +421,7 @@ def _coo_matvec_transpose(ct, data, row, col, v, *, spinfo, transpose):\nad.defjvp(coo_matvec_p, _coo_matvec_jvp_mat, None, None, _coo_matvec_jvp_vec)\nad.primitive_transposes[coo_matvec_p] = _coo_matvec_transpose\nxla.register_translation(coo_matvec_p, _coo_matvec_translation_rule)\n-if (cusparse and cusparse.is_supported) or (hipsparse and hipsparse.is_supported):\n+if sparse_apis and sparse_apis.is_supported:\nxla.register_translation(coo_matvec_p, _coo_matvec_gpu_translation_rule,\nplatform='gpu')\n@@ -526,11 +508,7 @@ def _coo_matmat_gpu_translation_rule(ctx, avals_in, avals_out, data, row, col,\nreturn _coo_matmat_translation_rule(ctx, avals_in, avals_out, data, row, col, B,\nspinfo=spinfo, transpose=transpose)\n- if cusparse is not None:\n- return [cusparse.coo_matmat(ctx.builder, data, row, col, B, shape=shape,\n- transpose=transpose)]\n- else:\n- return [hipsparse.coo_matmat(ctx.builder, data, row, col, B, shape=shape,\n+ return [sparse_apis.coo_matmat(ctx.builder, data, row, col, B, shape=shape,\ntranspose=transpose)]\ndef _coo_matmat_jvp_left(data_dot, data, row, col, B, *, spinfo, transpose):\n@@ -551,6 +529,6 @@ def _coo_matmat_transpose(ct, data, row, col, B, *, spinfo, transpose):\nad.defjvp(coo_matmat_p, _coo_matmat_jvp_left, None, None, _coo_matmat_jvp_right)\nad.primitive_transposes[coo_matmat_p] = _coo_matmat_transpose\nxla.register_translation(coo_matmat_p, _coo_matmat_translation_rule)\n-if (cusparse and cusparse.is_supported) or (hipsparse and hipsparse.is_supported):\n+if sparse_apis and sparse_apis.is_supported:\nxla.register_translation(coo_matmat_p, _coo_matmat_gpu_translation_rule,\nplatform='gpu')\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/sparse/csr.py",
"new_path": "jax/experimental/sparse/csr.py",
"diff": "@@ -27,18 +27,10 @@ from jax.experimental.sparse._base import JAXSparse\nfrom jax.experimental.sparse.coo import _coo_matmat, _coo_matvec, _coo_todense, COOInfo\nfrom jax.experimental.sparse.util import _csr_to_coo, _csr_extract, _safe_asarray, CuSparseEfficiencyWarning\nfrom jax import tree_util\n+from jax._src.lib import sparse_apis\nfrom jax._src.numpy.lax_numpy import _promote_dtypes\nimport jax.numpy as jnp\n-try:\n- from jax._src.lib import cusparse\n-except ImportError:\n- cusparse = None\n-\n-try:\n- from jax._src.lib import hipsparse\n-except ImportError:\n- hipsparse = None\n@tree_util.register_pytree_node_class\nclass CSR(JAXSparse):\n@@ -190,10 +182,7 @@ def _csr_todense_gpu_translation_rule(ctx, avals_in, avals_out, data, indices,\n\"Falling back to default implementation.\", CuSparseEfficiencyWarning)\nreturn _csr_todense_translation_rule(ctx, avals_in, avals_out, data, indices,\nindptr, shape=shape)\n- if cusparse:\n- return [cusparse.csr_todense(ctx.builder, data, indices, indptr, shape=shape)]\n- else:\n- return [hipsparse.csr_todense(ctx.builder, data, indices, indptr, shape=shape)]\n+ return [sparse_apis.csr_todense(ctx.builder, data, indices, indptr, shape=shape)]\ndef _csr_todense_jvp(data_dot, data, indices, indptr, *, shape):\nreturn csr_todense(data_dot, indices, indptr, shape=shape)\n@@ -212,7 +201,7 @@ def _csr_todense_transpose(ct, data, indices, indptr, *, shape):\nad.defjvp(csr_todense_p, _csr_todense_jvp, None, None)\nad.primitive_transposes[csr_todense_p] = _csr_todense_transpose\nxla.register_translation(csr_todense_p, _csr_todense_translation_rule)\n-if (cusparse and cusparse.is_supported) or (hipsparse and hipsparse.is_supported):\n+if sparse_apis and sparse_apis.is_supported:\nxla.register_translation(csr_todense_p, _csr_todense_gpu_translation_rule,\nplatform='gpu')\n@@ -274,11 +263,7 @@ def _csr_fromdense_gpu_translation_rule(ctx, avals_in, avals_out, mat, *, nse,\n\"Falling back to default implementation.\", CuSparseEfficiencyWarning)\nreturn _csr_fromdense_translation_rule(ctx, avals_in, avals_out, mat,\nnse=nse, index_dtype=index_dtype)\n- if cusparse:\n- data, indices, indptr = cusparse.csr_fromdense(\n- ctx.builder, mat, nnz=nse, index_dtype=np.dtype(index_dtype))\n- else:\n- data, indices, indptr = hipsparse.csr_fromdense(\n+ data, indices, indptr = sparse_apis.csr_fromdense(\nctx.builder, mat, nnz=nse, index_dtype=np.dtype(index_dtype))\nreturn [data, indices, indptr]\n@@ -310,7 +295,7 @@ def _csr_fromdense_transpose(ct, M, *, nse, index_dtype):\nad.primitive_jvps[csr_fromdense_p] = _csr_fromdense_jvp\nad.primitive_transposes[csr_fromdense_p] = _csr_fromdense_transpose\nxla.register_translation(csr_fromdense_p, _csr_fromdense_translation_rule)\n-if (cusparse and cusparse.is_supported) or (hipsparse and hipsparse.is_supported):\n+if sparse_apis and sparse_apis.is_supported:\nxla.register_translation(csr_fromdense_p,\n_csr_fromdense_gpu_translation_rule,\nplatform='gpu')\n@@ -366,11 +351,7 @@ def _csr_matvec_gpu_translation_rule(ctx, avals_in, avals_out, data, indices,\n\"Falling back to default implementation.\", CuSparseEfficiencyWarning)\nreturn _csr_matvec_translation_rule(ctx, avals_in, avals_out, data, indices, indptr, v,\nshape=shape, transpose=transpose)\n- if cusparse:\n- return [cusparse.csr_matvec(ctx.builder, data, indices, indptr, v,\n- shape=shape, transpose=transpose)]\n- else:\n- return [hipsparse.csr_matvec(ctx.builder, data, indices, indptr, v,\n+ return [sparse_apis.csr_matvec(ctx.builder, data, indices, indptr, v,\nshape=shape, transpose=transpose)]\ndef _csr_matvec_jvp_mat(data_dot, data, indices, indptr, v, *, shape, transpose):\n@@ -395,7 +376,7 @@ def _csr_matvec_transpose(ct, data, indices, indptr, v, *, shape, transpose):\nad.defjvp(csr_matvec_p, _csr_matvec_jvp_mat, None, None, _csr_matvec_jvp_vec)\nad.primitive_transposes[csr_matvec_p] = _csr_matvec_transpose\nxla.register_translation(csr_matvec_p, _csr_matvec_translation_rule)\n-if (cusparse and cusparse.is_supported) or (hipsparse and hipsparse.is_supported):\n+if sparse_apis and sparse_apis.is_supported:\nxla.register_translation(csr_matvec_p, _csr_matvec_gpu_translation_rule,\nplatform='gpu')\n@@ -452,11 +433,7 @@ def _csr_matmat_gpu_translation_rule(ctx, avals_in, avals_out, data, indices,\n\"Falling back to default implementation.\", CuSparseEfficiencyWarning)\nreturn _csr_matmat_translation_rule(ctx, avals_in, avals_out, data, indices, indptr, B,\nshape=shape, transpose=transpose)\n- if cusparse is not None:\n- return [cusparse.csr_matmat(ctx.builder, data, indices, indptr, B,\n- shape=shape, transpose=transpose)]\n- else:\n- return [hipsparse.csr_matmat(ctx.builder, data, indices, indptr, B,\n+ return [sparse_apis.csr_matmat(ctx.builder, data, indices, indptr, B,\nshape=shape, transpose=transpose)]\ndef _csr_matmat_jvp_left(data_dot, data, indices, indptr, B, *, shape, transpose):\n@@ -479,6 +456,6 @@ def _csr_matmat_transpose(ct, data, indices, indptr, B, *, shape, transpose):\nad.defjvp(csr_matmat_p, _csr_matmat_jvp_left, None, None, _csr_matmat_jvp_right)\nad.primitive_transposes[csr_matmat_p] = _csr_matmat_transpose\nxla.register_translation(csr_matmat_p, _csr_matmat_translation_rule)\n-if (cusparse and cusparse.is_supported) or (hipsparse and hipsparse.is_supported):\n+if sparse_apis and sparse_apis.is_supported:\nxla.register_translation(csr_matmat_p, _csr_matmat_gpu_translation_rule,\nplatform='gpu')\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/sparse_test.py",
"new_path": "tests/sparse_test.py",
"diff": "@@ -32,8 +32,7 @@ from jax.experimental import sparse\nfrom jax.experimental.sparse import coo as sparse_coo\nfrom jax.experimental.sparse.bcoo import BCOOInfo\nfrom jax import lax\n-from jax._src.lib import cusparse\n-from jax._src.lib import hipsparse\n+from jax._src.lib import sparse_apis\nfrom jax._src.lib import xla_bridge\nfrom jax import jit\nfrom jax import tree_util\n@@ -56,7 +55,7 @@ MATMUL_TOL = {\nnp.complex128: 1E-10,\n}\n-GPU_LOWERING_ENABLED = (cusparse and cusparse.is_supported) or (hipsparse and hipsparse.is_supported)\n+GPU_LOWERING_ENABLED = (sparse_apis and sparse_apis.is_supported)\nclass BcooDotGeneralProperties(NamedTuple):\nlhs_shape: Tuple[int]\n@@ -441,7 +440,8 @@ class cuSparseTest(jtu.JaxTestCase):\nmat_resorted = mat_unsorted._sort_rows()\nself.assertArraysEqual(mat.todense(), mat_resorted.todense())\n- @unittest.skipIf(not GPU_LOWERING_ENABLED, \"test requires cusparse\")\n+ @unittest.skipIf(not GPU_LOWERING_ENABLED, \"test requires cusparse/hipsparse\")\n+ @jtu.skip_on_devices(\"rocm\") # TODO(rocm): see SWDEV-328107\ndef test_coo_sorted_indices_gpu_lowerings(self):\ndtype = jnp.float32\n@@ -510,15 +510,15 @@ class cuSparseTest(jtu.JaxTestCase):\ncuda_version = None if version == \"<unknown>\" else int(\nversion.split()[-1])\nif cuda_version is None or cuda_version < 11000:\n- self.assertFalse(cusparse and cusparse.is_supported)\n+ self.assertFalse(sparse_apis and sparse_apis.is_supported)\nself.assertNotIn(sparse.csr_todense_p,\nxla._backend_specific_translations[\"gpu\"])\nelse:\n- self.assertTrue(cusparse and cusparse.is_supported)\n+ self.assertTrue(sparse_apis and sparse_apis.is_supported)\nself.assertIn(sparse.csr_todense_p,\nxla._backend_specific_translations[\"gpu\"])\nelse:\n- self.assertTrue(hipsparse and hipsparse.is_supported)\n+ self.assertTrue(sparse_apis and sparse_apis.is_supported)\nself.assertIn(sparse.csr_todense_p,\nxla._backend_specific_translations[\"gpu\"])\n"
}
] | Python | Apache License 2.0 | google/jax | Fix for hipsparse in ROCm. |
260,681 | 23.03.2022 21:37:52 | 0 | 87671f4d85954c821dc671ded172662b9c6381aa | Add a documentation for the JAX transfer guard | [
{
"change_type": "MODIFY",
"old_path": "docs/index.rst",
"new_path": "docs/index.rst",
"diff": "@@ -58,6 +58,7 @@ parallelize, Just-In-Time compile to GPU/TPU, and more.\ndevice_memory_profiling\nrank_promotion_warning\ncustom_vjp_update\n+ transfer_guard\n.. toctree::\n:maxdepth: 2\n"
},
{
"change_type": "MODIFY",
"old_path": "docs/jax.config.rst",
"new_path": "docs/jax.config.rst",
"diff": "@@ -17,4 +17,4 @@ JAX configuration\ndefault_matmul_precision\ndefault_prng_impl\nnumpy_rank_promotion\n-\n\\ No newline at end of file\n+ transfer_guard\n"
},
{
"change_type": "ADD",
"old_path": null,
"new_path": "docs/transfer_guard.rst",
"diff": "+Transfer guard\n+==============\n+\n+JAX may transfer data between the host and devices and between devices during\n+type conversion and input sharding. To log or disallow any unintended\n+transfers, the user may configure a JAX transfer guard.\n+\n+JAX transfer guards distinguish between two types of transfers:\n+\n+* Explicit transfers: ``jax.device_put*()`` and ``jax.device_get()`` calls.\n+* Implicit transfers: Other transfers (e.g., printing a ``DeviceArray``).\n+\n+A transfer guard can take an action based on its guard level:\n+\n+* ``\"allow\"``: Silently allow all transfers (default).\n+* ``\"log\"``: Log and allow implicit transfers. Silently allow explicit\n+ transfers.\n+* ``\"disallow\"``: Disallow implicit transfers. Silently allow explicit\n+ transfers.\n+* ``\"log_explicit\"``: Log and allow all transfers.\n+* ``\"disallow_explicit\"``: Disallow all transfers.\n+\n+JAX will raise a ``RuntimeError`` when disallowing a transfer.\n+\n+The transfer guards use the standard JAX configuration system:\n+\n+* A ``--jax_transfer_guard=GUARD_LEVEL`` command-line flag and\n+ ``jax.config.update(\"jax_transfer_guard\", GUARD_LEVEL)`` will set the global\n+ option.\n+* A ``with jax.transfer_guard(GUARD_LEVEL): ...`` context manager will set the\n+ thread-local option within the scope of the context manager.\n+\n+Note that similar to other JAX configuration options, a newly spawned thread\n+will use the global option instead of any active thread-local option of the\n+scope where the thread was spawned.\n+\n+The transfer guards can also be applied more selectively, based on the\n+direction of transfer. The flag and context manager name is suffixed with a\n+corresponding transfer direction (e.g., ``--jax_transfer_guard_host_to_device``\n+and ``jax.config.transfer_guard_host_to_device``):\n+\n+* ``\"host_to_device\"``: Converting a Python value or NumPy array into a JAX\n+ on-device buffer.\n+* ``\"device_to_device\"``: Copying a JAX on-device buffer to a different device.\n+* ``\"device_to_host\"``: Fetching a JAX on-device buffer.\n+\n+Fetching a buffer on a CPU device is always allowed regardless of the transfer\n+guard level.\n+\n+The following shows an example of using the transfer guard.\n+\n+.. code-block:: python\n+\n+ >>> jax.config.update(\"jax_transfer_guard\", \"allow\") # This is default.\n+ >>>\n+ >>> x = jnp.array(1)\n+ >>> y = jnp.array(2)\n+ >>> z = jnp.array(3)\n+ >>>\n+ >>> print(\"x\", x) # All transfers are allowed.\n+ x 1\n+ >>> with jax.transfer_guard(\"disallow\"):\n+ ... print(\"x\", x) # x has already been fetched into the host.\n+ ... print(\"y\", jax.device_get(y)) # Explicit transfers are allowed.\n+ ... try:\n+ ... print(\"z\", z) # Implicit transfers are disallowed.\n+ ... assert False, \"This line is expected to be unreachable.\"\n+ ... except:\n+ ... print(\"z could not be fetched\") # doctest: +SKIP\n+ x 1\n+ y 2\n+ z could not be fetched\n"
}
] | Python | Apache License 2.0 | google/jax | Add a documentation for the JAX transfer guard |
260,335 | 25.03.2022 12:55:40 | 25,200 | bd765fecb59c57fcf202c0280834ff34dc6b67d1 | improve caching of jax.remat
See for discussion | [
{
"change_type": "MODIFY",
"old_path": "jax/core.py",
"new_path": "jax/core.py",
"diff": "@@ -17,7 +17,7 @@ import collections\nfrom collections import namedtuple\nfrom contextlib import contextmanager\nimport functools\n-from functools import partial, partialmethod, total_ordering\n+from functools import partialmethod, total_ordering\nimport gc\nimport itertools as it\nimport operator\n@@ -1712,7 +1712,8 @@ class CallPrimitive(Primitive):\ndef get_bind_params(self, params):\nnew_params = dict(params)\n- subfun = lu.wrap_init(partial(eval_jaxpr, new_params.pop('call_jaxpr'), ()))\n+ jaxpr = new_params.pop('call_jaxpr')\n+ subfun = lu.hashable_partial(lu.wrap_init(eval_jaxpr), jaxpr, ())\nreturn [subfun], new_params\ndef call_bind(primitive: CallPrimitive, fun, *args, **params):\n@@ -1806,7 +1807,8 @@ class MapPrimitive(Primitive):\ndef get_bind_params(self, params):\nnew_params = dict(params)\n- subfun = lu.wrap_init(partial(eval_jaxpr, new_params.pop('call_jaxpr'), ()))\n+ jaxpr = new_params.pop('call_jaxpr')\n+ subfun = lu.hashable_partial(lu.wrap_init(eval_jaxpr), jaxpr, ())\naxes = new_params.pop('out_axes')\nnew_params['out_axes_thunk'] = HashableFunction(lambda: axes, closure=axes)\nreturn [subfun], new_params\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/maps.py",
"new_path": "jax/experimental/maps.py",
"diff": "@@ -884,7 +884,8 @@ class XMapPrimitive(core.MapPrimitive):\ndef get_bind_params(self, params):\nnew_params = dict(params)\n- subfun = lu.wrap_init(partial(core.eval_jaxpr, new_params.pop('call_jaxpr'), ()))\n+ jaxpr = new_params.pop('call_jaxpr')\n+ subfun = lu.hashable_partial(lu.wrap_init(core.eval_jaxpr), jaxpr, ())\naxes = new_params.pop('out_axes')\nnew_params['out_axes_thunk'] = HashableFunction(lambda: axes, closure=axes)\nspmd_axes = new_params.pop('spmd_out_axes')\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/api_test.py",
"new_path": "tests/api_test.py",
"diff": "@@ -4323,6 +4323,15 @@ class RematTest(jtu.JaxTestCase):\n_ = api.linearize(partial(f, core.unit), 3.)\n+ def test_linearize_caching(self):\n+ # https://github.com/google/jax/issues/9661\n+ identity = jax.checkpoint(jax.jit(lambda x: 2 * x))\n+ _, f_lin = jax.linearize(identity, 1.)\n+ with jtu.count_jit_and_pmap_compiles() as count: # noqa: F841\n+ for _ in range(10):\n+ f_lin(1.).block_until_ready()\n+ self.assertEqual(count[0], 1) # cached after first execution\n+\nclass JaxprTest(jtu.JaxTestCase):\n"
}
] | Python | Apache License 2.0 | google/jax | improve caching of jax.remat
See #9661 for discussion |
260,335 | 25.03.2022 16:28:35 | 25,200 | 78cf4df21b61486fdc1c314c8da1d52b849deeca | improve remat transpose caching (cf. | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/ad.py",
"new_path": "jax/interpreters/ad.py",
"diff": "@@ -28,7 +28,7 @@ from jax.core import (Trace, Tracer, get_aval, call_p, Primitive, Literal,\nfrom jax._src.ad_util import (add_jaxvals, add_jaxvals_p, zeros_like_jaxval,\nzeros_like_aval, zeros_like_p, Zero)\nfrom jax._src.util import (unzip2, safe_map, safe_zip, split_list, wrap_name,\n- as_hashable_function, cache)\n+ as_hashable_function, weakref_lru_cache)\nfrom jax.tree_util import register_pytree_node\nfrom jax import linear_util as lu\nfrom jax._src.api_util import flatten_fun, flatten_fun_nokwargs\n@@ -586,7 +586,8 @@ def traceable(num_primals, in_tree_def, *primals_and_tangents):\ndef call_transpose(primitive, params, call_jaxpr, args, ct, _, reduce_axes):\nall_args, in_tree_def = tree_flatten(((), args, ct)) # empty consts\n- fun = lu.hashable_partial(lu.wrap_init(backward_pass), call_jaxpr, reduce_axes, False)\n+ fun = lu.hashable_partial(lu.wrap_init(backward_pass), call_jaxpr,\n+ reduce_axes, False)\nfun, out_tree = flatten_fun_nokwargs(fun, in_tree_def)\nif config.jax_experimental_name_stack:\nnew_params = params\n@@ -603,31 +604,29 @@ primitive_transposes[core.call_p] = partial(call_transpose, call_p)\ndef remat_transpose(params, call_jaxpr, primals_in, cotangents_in,\ncotangent_in_avals, reduce_axes):\n- # backward_pass can only transpose linear computations, but the call_jaxpr embedded in\n- # remat contains primal (non-linear) equations too. Hence, we have to eliminate those\n- # (in this case via partial_eval) before we call into backward_pass again.\n- typed_call_jaxpr = core.ClosedJaxpr(call_jaxpr, [])\n+ call_jaxpr = _close_jaxpr(call_jaxpr)\nunknowns = map(is_undefined_primal, primals_in)\n- primal_jaxpr, tangent_jaxpr, out_unknowns = \\\n- pe.partial_eval_jaxpr(typed_call_jaxpr, unknowns=unknowns, instantiate=True) # type: ignore\n-\n- def do_transpose(primals_in, cotangents_in):\n- # NOTE: This is passing in undefined primals in place of tangent arguments, but it\n- # should all work out, because we're only computing the primal part here.\n- residuals = core.jaxpr_as_fun(primal_jaxpr)(*primals_in)[len(cotangents_in):]\n- # Now that we have a purely linear jaxpr, we can transpose it\n- cotangents_out = backward_pass(\n- tangent_jaxpr.jaxpr, reduce_axes, False, (), primals_in + residuals, cotangents_in)\n- # backward_pass will return cotangents computed for all invars, but some of them\n- # are residuals appended by partial eval, so we need to skip those before we return.\n- return cotangents_out[:len(primals_in)]\n-\n- flat_args, in_tree_def = tree_flatten((primals_in, cotangents_in))\n- flat_do_transpose, out_tree = flatten_fun_nokwargs(lu.wrap_init(do_transpose), in_tree_def)\n- flat_cotangents_out = pe.remat_call_p.bind(flat_do_transpose, *flat_args, **params)\n+ primal_jaxpr, tangent_jaxpr, _ = \\\n+ pe.partial_eval_jaxpr(call_jaxpr, unknowns=unknowns, instantiate=True) # type: ignore\n+ args, in_tree_def = tree_flatten((primals_in, cotangents_in))\n+ transpose = lu.hashable_partial(lu.wrap_init(_remat_transpose), primal_jaxpr,\n+ tangent_jaxpr, reduce_axes)\n+ flat_transpose, out_tree = flatten_fun_nokwargs(transpose, in_tree_def)\n+ flat_cotangents_out = pe.remat_call_p.bind(flat_transpose, *args, **params)\nreturn tree_unflatten(out_tree(), flat_cotangents_out)\nprimitive_transposes[pe.remat_call_p] = remat_transpose\n+def _remat_transpose(primal_jaxpr, tangent_jaxpr, reduce_axes,\n+ primals_in, cotangents_in):\n+ res = core.jaxpr_as_fun(primal_jaxpr)(*primals_in)[len(cotangents_in):]\n+ cotangents_out = backward_pass(tangent_jaxpr.jaxpr, reduce_axes, False, (),\n+ (*primals_in, *res), cotangents_in)\n+ return cotangents_out[:len(primals_in)]\n+\n+@weakref_lru_cache\n+def _close_jaxpr(jaxpr: core.Jaxpr) -> core.ClosedJaxpr:\n+ return core.ClosedJaxpr(jaxpr, [])\n+\n@lu.transformation_with_aux\ndef nonzero_outputs(*args, **kwargs):\nresults = yield args, kwargs\n@@ -680,7 +679,7 @@ def jvp_jaxpr(jaxpr, nonzeros, instantiate):\ninst = tuple(instantiate) if isinstance(instantiate, list) else instantiate\nreturn _jvp_jaxpr(jaxpr, tuple(nonzeros), inst)\n-@cache()\n+@weakref_lru_cache\ndef _jvp_jaxpr(jaxpr, nonzeros, instantiate):\nassert len(jaxpr.in_avals) == len(nonzeros)\nf = lu.wrap_init(core.jaxpr_as_fun(jaxpr))\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/api_test.py",
"new_path": "tests/api_test.py",
"diff": "@@ -4328,10 +4328,19 @@ class RematTest(jtu.JaxTestCase):\nidentity = jax.checkpoint(jax.jit(lambda x: 2 * x))\n_, f_lin = jax.linearize(identity, 1.)\nwith jtu.count_jit_and_pmap_compiles() as count: # noqa: F841\n- for _ in range(10):\n+ for _ in range(20):\nf_lin(1.).block_until_ready()\nself.assertEqual(count[0], 1) # cached after first execution\n+ def test_vjp_caching(self):\n+ # https://github.com/google/jax/issues/9661\n+ identity = jax.checkpoint(jax.jit(lambda x: 2 * x))\n+ _, f_vjp = jax.vjp(identity, 1.)\n+ with jtu.count_jit_and_pmap_compiles() as count: # noqa: F841\n+ for _ in range(20):\n+ f_vjp(1.)[0].block_until_ready()\n+ self.assertEqual(count[0], 2) # eval_jaxpr on fwd, backward_pass on bwd\n+\nclass JaxprTest(jtu.JaxTestCase):\n"
}
] | Python | Apache License 2.0 | google/jax | improve remat transpose caching (cf. #9661) |
260,710 | 28.03.2022 14:51:54 | -32,400 | 2e70177385bd7b3bbf74b29f95b4ba62d82cdeef | Fix a bug in fft helper appears when nperseg=1. | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/scipy/signal.py",
"new_path": "jax/_src/scipy/signal.py",
"diff": "@@ -160,12 +160,12 @@ def _fft_helper(x, win, detrend_func, nperseg, noverlap, nfft, sides):\nif x.dtype.kind == 'i':\nx = x.astype(win.dtype)\n+ *batch_shape, signal_length = x.shape\n# Created strided array of data segments\nif nperseg == 1 and noverlap == 0:\nresult = x[..., np.newaxis]\nelse:\nstep = nperseg - noverlap\n- *batch_shape, signal_length = x.shape\nbatch_shape = tuple(batch_shape)\nx = x.reshape((int(np.prod(batch_shape)), signal_length))[..., np.newaxis]\nresult = jax.lax.conv_general_dilated_patches(\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/scipy_signal_test.py",
"new_path": "tests/scipy_signal_test.py",
"diff": "@@ -38,6 +38,7 @@ stft_test_shapes = [\n((3, 17, 2), 9, 3, 1),\n((2, 3, 389, 5), 17, 13, 2),\n((2, 1, 133, 3), 17, 13, -2),\n+ ((3, 7), 1, 0, 1),\n]\ncsd_test_shapes = [\n# (x_input_shape, y_input_shape, nperseg, noverlap, axis)\n"
}
] | Python | Apache License 2.0 | google/jax | Fix a bug in fft helper appears when nperseg=1. |
260,424 | 08.03.2022 14:41:18 | 0 | d72687c9909d8d06485d78278e085f6b06861fbe | Checkify: add way to embed runtime info in error messages. | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/checkify/checkify_impl.py",
"new_path": "jax/experimental/checkify/checkify_impl.py",
"diff": "@@ -56,23 +56,31 @@ def setnewattr(obj, name, val):\nBool = Union[bool, core.Tracer]\nInt = Union[int, core.Tracer]\n+Payload = Union[np.ndarray, jnp.ndarray, core.Tracer]\n+# For now, the payload needs to be a fixed-size array (int32 scalar).\n+# TODO(lenamartens): Relax this fixed-size constraint.\n+init_payload = np.ones((), np.int32)\n@dataclass(frozen=True)\nclass Error:\nerr: Bool\ncode: Int\nmsgs: Dict[int, str]\n+ # There might be many msgs with a {payload}, but only one msg will\n+ # ever be active for an Error instance, so only one Payload is tracked.\n+ payload: Payload = init_payload\ndef get(self) -> Optional[str]:\n\"\"\"Returns error message is error happened, None if no error happened.\"\"\"\nassert np.shape(self.err) == np.shape(self.code)\nif np.size(self.err) == 1:\nif self.err:\n- return self.msgs[int(self.code)]\n+ return self.msgs[int(self.code)].format(payload=self.payload)\nelse:\n- return '\\n'.join(f'at mapped index {\", \".join(map(str, idx))}: ' # type: ignore\n- f'{self.msgs[int(self.code[idx])]}' # type: ignore\n+ return '\\n'.join(\n+ f'at mapped index {\", \".join(map(str, idx))}: ' # type: ignore\n+ f'{self.msgs[int(self.code[idx])].format(payload=self.payload[idx])}' # type: ignore\nfor idx, e in np.ndenumerate(self.err) if e) or None\nreturn None\n@@ -82,19 +90,25 @@ class Error:\nif err:\nraise ValueError(err)\n+\nregister_pytree_node(Error,\n- lambda e: ((e.err, e.code), tuple(sorted(e.msgs.items()))),\n- lambda msgs, data: Error(*data, dict(msgs))) # type: ignore\n+ lambda e: ((e.err, e.code, e.payload),\n+ tuple(sorted(e.msgs.items()))),\n+ lambda msgs, data: Error(data[0], data[1], # type: ignore\n+ dict(msgs), data[2])) # type: ignore\ninit_error = Error(False, 0, {})\nnext_code = it.count(1).__next__ # globally unique ids, could be uuid4\n-def assert_func(error: Error, pred: Bool, msg: str) -> Error:\n+def assert_func(error: Error, pred: Bool, msg: str,\n+ payload: Optional[Payload]) -> Error:\ncode = next_code()\n+ payload = init_payload if payload is None else payload\nout_err = error.err | jnp.logical_not(pred)\nout_code = lax.select(error.err, error.code, code)\n- return Error(out_err, out_code, {code: msg, **error.msgs})\n+ out_payload = lax.select(error.err, error.payload, payload)\n+ return Error(out_err, out_code, {code: msg, **error.msgs}, out_payload)\n## Checkify transformation for plumbing functional error values.\n@@ -138,10 +152,11 @@ class CheckifyTrace(core.Trace):\ne = popattr(self.main, 'error')\nf, msgs = checkify_subtrace(f, self.main, tuple(e.msgs.items()))\nif 'donated_invars' in params:\n- params = dict(params, donated_invars=(False, False,\n+ params = dict(params, donated_invars=(False, False, False,\n*params['donated_invars']))\n- err, code, *out_vals = primitive.bind(f, e.err, e.code, *in_vals, **params)\n- setnewattr(self.main, 'error', Error(err, code, msgs()))\n+ err, code, payload, *out_vals = primitive.bind(f, e.err, e.code, e.payload,\n+ *in_vals, **params)\n+ setnewattr(self.main, 'error', Error(err, code, msgs(), payload))\nreturn [CheckifyTracer(self, x) for x in out_vals]\ndef process_map(self, primitive, f, tracers, params):\n@@ -151,42 +166,43 @@ class CheckifyTrace(core.Trace):\n@as_hashable_function(closure=params['out_axes_thunk'])\ndef new_out_axes_thunk():\n- return (0, 0, *params['out_axes_thunk']())\n+ return (0, 0, 0, *params['out_axes_thunk']())\n- params_ = dict(params, in_axes=(None, None, *params['in_axes']),\n+ params_ = dict(params, in_axes=(None, None, None, *params['in_axes']),\nout_axes_thunk=new_out_axes_thunk,\n- donated_invars=(False, False, *params['donated_invars']))\n- errs, codes, *outs = primitive.bind(f, e.err, e.code, *in_vals, **params_)\n- err, code = _reduce_any_error(errs, codes)\n- setnewattr(self.main, 'error', Error(err, code, msgs()))\n+ donated_invars=(False, False, False, *params['donated_invars']))\n+ errs, codes, payloads, *outs = primitive.bind(f, e.err, e.code, e.payload,\n+ *in_vals, **params_)\n+ err, code, payload = _reduce_any_error(errs, codes, payloads)\n+ setnewattr(self.main, 'error', Error(err, code, msgs(), payload))\nreturn [CheckifyTracer(self, x) for x in outs]\ndef post_process_call(self, primitive, tracers, params):\nvals = [t.val for t in tracers]\nmain = self.main\ne = popattr(main, 'error')\n- err, code, main.msgs = e.err, e.code, e.msgs\n+ err, code, payload, main.msgs = e.err, e.code, e.payload, e.msgs\ndef todo(vals):\n- err, code, *vals = vals\n- setnewattr(main, 'error', Error(err, code, popattr(main, 'msgs')))\n+ err, code, payload, *vals = vals\n+ setnewattr(main, 'error', Error(err, code, popattr(main, 'msgs'), payload))\ntrace = main.with_cur_sublevel()\nreturn [CheckifyTracer(trace, x) for x in vals]\n- return (err, code, *vals), todo\n+ return (err, code, payload, *vals), todo\ndef post_process_map(self, primitive, tracers, params):\nvals = [t.val for t in tracers]\nmain = self.main\ne = popattr(main, 'error')\n- err, code, main.msgs = e.err, e.code, e.msgs\n+ err, code, payload, main.msgs = e.err, e.code, e.payload, e.msgs\ndef todo(vals):\n- errs, codes, *vals = vals\n- err, code = _reduce_any_error(errs, codes)\n- setnewattr(main, 'error', Error(err, code, popattr(main, 'msgs')))\n+ errs, codes, payloads, *vals = vals\n+ err, code, payload = _reduce_any_error(errs, codes, payloads)\n+ setnewattr(main, 'error', Error(err, code, popattr(main, 'msgs'), payload))\ntrace = main.with_cur_sublevel()\nreturn [CheckifyTracer(trace, x) for x in vals]\ndef out_axes_transform(out_axes):\n- return (0, 0, *out_axes)\n- return (err, code, *vals), (todo, out_axes_transform)\n+ return (0, 0, 0, *out_axes)\n+ return (err, code, payload, *vals), (todo, out_axes_transform)\ndef process_custom_jvp_call(self, prim, fun, jvp, tracers):\nin_vals = [t.val for t in tracers]\n@@ -194,9 +210,10 @@ class CheckifyTrace(core.Trace):\nmsgs = tuple(e.msgs.items())\nfun, msgs1 = checkify_subtrace(fun, self.main, msgs)\njvp, msgs2 = checkify_custom_jvp_subtrace(jvp, self.main, msgs)\n- err, code, *out_vals = prim.bind(fun, jvp, e.err, e.code, *in_vals)\n+ err, code, payload, *out_vals = prim.bind(fun, jvp, e.err, e.code,\n+ e.payload, *in_vals)\nfst, out_msgs = lu.merge_linear_aux(msgs1, msgs2)\n- setattr(self.main, 'error', Error(err, code, out_msgs))\n+ setattr(self.main, 'error', Error(err, code, out_msgs, payload))\nreturn [CheckifyTracer(self, x) for x in out_vals]\ndef post_process_custom_jvp_call(self, out_tracers, jvp_was_run):\n@@ -208,13 +225,13 @@ class CheckifyTrace(core.Trace):\nvals = [t.val for t in out_tracers]\nmain = self.main\ne = popattr(main, 'error')\n- err, code, main.msgs = e.err, e.code, e.msgs\n+ err, code, payload, main.msgs = e.err, e.code, e.payload, e.msgs\ndef todo(vals):\n- err, code, *vals = vals\n- setnewattr(main, 'error', Error(err, code, popattr(main, 'msgs')))\n+ err, code, payload, *vals = vals\n+ setnewattr(main, 'error', Error(err, code, popattr(main, 'msgs'), payload))\ntrace = main.with_cur_sublevel()\nreturn [CheckifyTracer(trace, x) for x in vals]\n- return (err, code, *vals), todo\n+ return (err, code, payload, *vals), todo\ndef process_custom_vjp_call(self, prim, fun, fwd, bwd, tracers, out_trees):\nin_vals = [t.val for t in tracers]\n@@ -222,18 +239,20 @@ class CheckifyTrace(core.Trace):\nmsgs = tuple(e.msgs.items())\nfun, msgs1 = checkify_subtrace(fun, self.main, msgs)\nfwd, msgs2 = checkify_custom_vjp_subtrace(fwd, self.main, msgs)\n- out = prim.bind(fun, fwd, bwd, e.err, e.code, *in_vals, out_trees=out_trees)\n+ out = prim.bind(fun, fwd, bwd, e.err, e.code, e.payload,\n+ *in_vals, out_trees=out_trees)\nfst, out_msgs = lu.merge_linear_aux(msgs1, msgs2)\nif fst:\n- err, code, *out = out\n+ err, code, payload, *out = out\nelse:\n- err, code = e.err, e.code # forward input error values to output\n- setattr(self.main, 'error', Error(err, code, out_msgs))\n+ err, code, payload = e.err, e.code, e.payload # forward input error values to output\n+ setattr(self.main, 'error', Error(err, code, out_msgs, payload))\nreturn [CheckifyTracer(self, x) for x in out]\n-def _reduce_any_error(errs, codes):\n+def _reduce_any_error(errs, codes, payloads):\nerrs_, codes_ = lax.sort_key_val(errs, codes, dimension=0)\n- return errs_[-1], codes_[-1]\n+ errs_, payload_ = lax.sort_key_val(errs, payloads, dimension=0)\n+ return errs_[-1], codes_[-1], payload_[-1]\nErrorCheckRule = Callable # (Error, FrozenSet[ErrorCategory], *in_vals, **params) -> (Any, Error)\nerror_checks: Dict[core.Primitive, ErrorCheckRule] = {}\n@@ -242,27 +261,29 @@ def checkify_flat(fun: lu.WrappedFun, enabled_errors: FrozenSet['ErrorCategory']\n*args):\nfun, msgs = checkify_subtrace(fun)\nfun = checkify_traceable(fun, tuple(init_error.msgs.items()), enabled_errors)\n- err, code, *outvals = fun.call_wrapped(init_error.err, init_error.code, *args)\n- return (err, code, outvals), msgs()\n+ err, code, payload, *outvals = fun.call_wrapped(init_error.err,\n+ init_error.code,\n+ init_error.payload, *args)\n+ return (err, code, payload, outvals), msgs()\n@lu.transformation\n-def checkify_traceable(msgs, enabled_errors, err, code, *args):\n+def checkify_traceable(msgs, enabled_errors, err, code, payload, *args):\nwith core.new_main(CheckifyTrace, enabled_errors=enabled_errors) as main:\n- outs = yield (main, msgs, err, code, *args), {}\n+ outs = yield (main, msgs, err, code, payload, *args), {}\ndel main\nyield outs\n@lu.transformation_with_aux\n-def checkify_subtrace(main, msgs, err, code, *args):\n- setnewattr(main, 'error', Error(err, code, dict(msgs)))\n+def checkify_subtrace(main, msgs, err, code, payload, *args):\n+ setnewattr(main, 'error', Error(err, code, dict(msgs), payload))\ntrace = main.with_cur_sublevel()\nin_tracers = [CheckifyTracer(trace, x) for x in args]\nout = yield in_tracers, {}\nout_tracers = map(trace.full_raise, out)\nout_vals = [t.val for t in out_tracers]\n- err, code, msgs = main.error.err, main.error.code, main.error.msgs\n+ err, code, payload, msgs = main.error.err, main.error.code, main.error.payload, main.error.msgs\ndel main.error\n- yield (err, code, *out_vals), msgs\n+ yield (err, code, payload, *out_vals), msgs\n@lu.transformation_with_aux\ndef checkify_custom_jvp_subtrace(main, msgs, *args):\n@@ -284,18 +305,19 @@ def checkify_custom_jvp_subtrace(main, msgs, *args):\ndel main\nn, ragged = divmod(len(args), 2)\nassert not ragged\n- (err,), (code,), primals = split_list(args[:n], [1, 1])\n- (err_dot,), (code_dot,), tangents = split_list(args[n:], [1, 1])\n+ (err,), (code,), (payload,), primals = split_list(args[:n], [1, 1, 1])\n+ (err_dot,), (code_dot,), (pl_dot,), tangents = split_list(args[n:], [1, 1, 1])\nouts = yield (*primals, *tangents), {}\nm, ragged = divmod(len(outs), 2)\nassert not ragged\nout_primals, out_tangents = outs[:m], outs[m:]\n- yield (err, code, *out_primals, err_dot, code_dot, *out_tangents), dict(msgs)\n+ yield (err, code, payload, *out_primals,\n+ err_dot, code_dot, pl_dot, *out_tangents), dict(msgs)\n@lu.transformation_with_aux\n-def checkify_custom_vjp_subtrace(main, msgs, err, code, *args):\n+def checkify_custom_vjp_subtrace(main, msgs, err, code, payload, *args):\n# We don't add any checks; just drop input error values.\n- del main, err, code\n+ del main, err, code, payload\nouts = yield args, {}\nyield outs, dict(msgs)\n@@ -309,7 +331,8 @@ def checkify_fun_to_jaxpr(f, error, enabled_errors, in_avals):\nf = checkify_traceable(f, tuple(error.msgs.items()), enabled_errors)\nerr_aval = core.raise_to_shaped(core.get_aval(error.err))\ncode_aval = core.raise_to_shaped(core.get_aval(error.code))\n- avals_in = [err_aval, code_aval, *in_avals]\n+ payload_aval = core.raise_to_shaped(core.get_aval(error.payload))\n+ avals_in = [err_aval, code_aval, payload_aval, *in_avals]\njaxpr_out, _, literals_out = pe.trace_to_jaxpr_dynamic(f, avals_in)\nreturn core.ClosedJaxpr(jaxpr_out, literals_out), msgs()\n@@ -411,21 +434,21 @@ def check_error(error: Error) -> None:\n>>> error, _ = checkify.checkify(with_inner_jit)(-1)\n\"\"\"\nif np.shape(error.err):\n- err, code = _reduce_any_error(error.err, error.code)\n+ err, code, payload = _reduce_any_error(error.err, error.code, error.payload)\nelse:\n- err, code = error.err, error.code\n- return assert_p.bind(~err, code, msgs=error.msgs)\n+ err, code, payload = error.err, error.code, error.payload\n+ return assert_p.bind(~err, code, payload, msgs=error.msgs)\nassert_p = core.Primitive('assert') # TODO: rename to check?\nassert_p.multiple_results = True # zero results\n@assert_p.def_impl\n-def assert_impl(pred, code, *, msgs):\n- Error(~pred, code, msgs).throw()\n+def assert_impl(pred, code, payload, *, msgs):\n+ Error(~pred, code, msgs, payload).throw()\nreturn []\n@assert_p.def_abstract_eval\n-def assert_abstract_eval(pred, code, *, msgs):\n+def assert_abstract_eval(pred, code, payload, *, msgs):\n# TODO(lenamartens) add in-depth explanation to link to in module docs.\nraise ValueError('Cannot abstractly evaluate a checkify.check which was not'\n' functionalized. This probably means you tried to stage'\n@@ -444,7 +467,7 @@ def nan_error_check(prim, error, enabled_errors, *in_vals, **params):\nreturn out, error\nno_nans = jnp.logical_not(jnp.any(jnp.isnan(out)))\nmsg = f\"nan generated by primitive {prim.name} at {summary()}\"\n- return out, assert_func(error, no_nans, msg)\n+ return out, assert_func(error, no_nans, msg, None)\ndef gather_error_check(error, enabled_errors, operand, start_indices, *,\ndimension_numbers, slice_sizes, unique_indices,\n@@ -460,13 +483,21 @@ def gather_error_check(error, enabled_errors, operand, start_indices, *,\n# compare to OOB masking logic in lax._gather_translation_rule\ndnums = dimension_numbers\noperand_dims = np.array(operand.shape)\n+ num_batch_dims = len(start_indices.shape) - 1\nupper_bound = operand_dims[np.array(dnums.start_index_map)]\nupper_bound -= np.array(slice_sizes)[np.array(dnums.start_index_map)]\n- all_inbounds = jnp.all((start_indices >= 0) & (start_indices <= upper_bound))\n+ upper_bound = jnp.expand_dims(upper_bound, axis=tuple(range(num_batch_dims)))\n+ in_bounds = (start_indices >= 0) & (start_indices <= upper_bound)\n+\n+ msg = f'out-of-bounds indexing at {summary()}: '\n+ msg += 'index {payload} is out of bounds for '\n+ msg += f'array of shape {operand.shape}.'\n+ start_indices, in_bounds = jnp.ravel(start_indices), jnp.ravel(in_bounds)\n+ # Report first index which is out-of-bounds (in row-major order).\n+ payload = start_indices[jnp.argsort(in_bounds, axis=0)[0]]\n- msg = f\"out-of-bounds indexing at {summary()}\"\n- return out, assert_func(error, all_inbounds, msg)\n+ return out, assert_func(error, jnp.all(in_bounds), msg, payload)\nerror_checks[lax.gather_p] = gather_error_check\ndef div_error_check(error, enabled_errors, x, y):\n@@ -474,7 +505,7 @@ def div_error_check(error, enabled_errors, x, y):\nif ErrorCategory.DIV in enabled_errors:\nall_nonzero = jnp.logical_not(jnp.any(jnp.equal(y, 0)))\nmsg = f'divided by zero at {summary()}'\n- error = assert_func(error, all_nonzero, msg)\n+ error = assert_func(error, all_nonzero, msg, None)\nreturn nan_error_check(lax.div_p, error, enabled_errors, x, y)\nerror_checks[lax.div_p] = div_error_check\n@@ -515,11 +546,11 @@ def scatter_error_check(prim, error, enabled_errors, operand, indices, updates,\nin_bounds = scatter_in_bounds(operand, indices, updates, dimension_numbers)\noob_msg = f'out-of-bounds indexing while updating at {summary()}'\n- oob_error = assert_func(error, in_bounds, oob_msg)\n+ oob_error = assert_func(error, in_bounds, oob_msg, None)\nno_nans = jnp.logical_not(jnp.any(jnp.isnan(out)))\nnan_msg = f'nan generated by primitive {prim.name} at {summary()}'\n- return out, assert_func(oob_error, no_nans, nan_msg)\n+ return out, assert_func(oob_error, no_nans, nan_msg, None)\nerror_checks[lax.scatter_p] = partial(scatter_error_check, lax.scatter_p)\nerror_checks[lax.scatter_add_p] = partial(scatter_error_check, lax.scatter_add_p)\nerror_checks[lax.scatter_mul_p] = partial(scatter_error_check, lax.scatter_mul_p)\n@@ -529,28 +560,28 @@ error_checks[lax.scatter_max_p] = partial(scatter_error_check, lax.scatter_max_p\ndef cond_error_check(error, enabled_errors, index, *ops, branches, linear):\nnew_branches, msgs_ = unzip2(checkify_jaxpr(jxpr, error, enabled_errors)\nfor jxpr in branches)\n- new_linear = (False, False, *linear)\n- err, code, *outs = lax.cond_p.bind(\n- index, error.err, error.code, *ops,\n+ new_linear = (False, False, False, *linear)\n+ err, code, payload, *outs = lax.cond_p.bind(\n+ index, error.err, error.code, error.payload, *ops,\nbranches=tuple(new_branches), linear=new_linear)\nnew_msgs = {k:v for d in it.chain([error.msgs], msgs_) for k, v in d.items()}\n- return outs, Error(err, code, new_msgs)\n+ return outs, Error(err, code, new_msgs, payload)\nerror_checks[lax.cond_p] = cond_error_check\ndef scan_error_check(error, enabled_errors, *in_flat, reverse, length, jaxpr,\nnum_consts, num_carry, linear, unroll):\nconsts, carry, xs = split_list(in_flat, [num_consts, num_carry])\nchecked_jaxpr_, msgs_ = checkify_jaxpr(jaxpr, error, enabled_errors)\n- tomove = [False] * 2 + [True] * len(consts) + [False] * (len(carry) + len(xs))\n+ tomove = [False] * 3 + [True] * len(consts) + [False] * (len(carry) + len(xs))\nchecked_jaxpr = pe.move_binders_to_front(checked_jaxpr_, tomove)\n- new_linear = (False, False, *linear)\n- new_in_flat = [*consts, error.err, error.code, *carry, *xs]\n- err, code, *outs = lax.scan_p.bind(\n+ new_linear = (False, False, False, *linear)\n+ new_in_flat = [*consts, error.err, error.code, error.payload, *carry, *xs]\n+ err, code, payload, *outs = lax.scan_p.bind(\n*new_in_flat, reverse=reverse, length=length, jaxpr=checked_jaxpr,\n- num_consts=len(consts), num_carry=len(carry)+2,\n+ num_consts=len(consts), num_carry=len(carry)+3,\nlinear=new_linear, unroll=unroll)\nnew_msgs = {**error.msgs, **msgs_}\n- return outs, Error(err, code, new_msgs)\n+ return outs, Error(err, code, new_msgs, payload)\nerror_checks[lax.scan_p] = scan_error_check\ndef checkify_while_body_jaxpr(cond_jaxpr, body_jaxpr, error, enabled_errors, c_consts):\n@@ -568,10 +599,12 @@ def ignore_errors_jaxpr(jaxpr, error):\n\"\"\"Constructs a jaxpr which takes two extra args but ignores them.\"\"\"\nerr_aval = core.raise_to_shaped(core.get_aval(error.err))\ncode_aval = core.raise_to_shaped(core.get_aval(error.code))\n+ payload_aval = core.raise_to_shaped(core.get_aval(error.payload))\nconsts = jaxpr.consts\njaxpr = jaxpr.jaxpr\nnew_vars = core.gensym([jaxpr])\n- new_invars = (new_vars(err_aval), new_vars(code_aval), *jaxpr.invars)\n+ new_invars = (new_vars(err_aval), new_vars(code_aval),\n+ new_vars(payload_aval), *jaxpr.invars)\nnew_jaxpr = core.Jaxpr(jaxpr.constvars, new_invars,\njaxpr.outvars, jaxpr.eqns)\nreturn core.ClosedJaxpr(new_jaxpr, consts)\n@@ -582,23 +615,25 @@ def while_loop_error_check(error, enabled_errors, *in_flat, cond_nconsts,\n# Check if the first cond application will error.\ncond_jaxpr_, msgs_cond = checkify_jaxpr(cond_jaxpr, error, enabled_errors)\n- cond_err, cond_code, _ = core.jaxpr_as_fun(cond_jaxpr_)(error.err, error.code,\n- *c_consts, *carry)\n+ cond_err, cond_code, cond_payload, _ = core.jaxpr_as_fun(cond_jaxpr_)(\n+ error.err, error.code, error.payload, *c_consts, *carry)\ndel cond_jaxpr_\nchecked_body_jaxpr_, msgs_body = checkify_while_body_jaxpr(\ncond_jaxpr, body_jaxpr, error, enabled_errors, c_consts)\n- to_move = [False] * 2 + [True] * body_nconsts + [False] * len(carry)\n+ to_move = [False] * 3 + [True] * body_nconsts + [False] * len(carry)\nchecked_body_jaxpr = pe.move_binders_to_front(checked_body_jaxpr_, to_move)\n+\ncompat_cond_jaxpr_ = ignore_errors_jaxpr(cond_jaxpr, error)\n- to_move = [False] * 2 + [True] * cond_nconsts + [False] * len(carry)\n+ to_move = [False] * 3 + [True] * cond_nconsts + [False] * len(carry)\ncompat_cond_jaxpr = pe.move_binders_to_front(compat_cond_jaxpr_, to_move)\n- new_in_flat = [*c_consts, *b_consts, cond_err, cond_code, *carry]\n- err, code, *out = lax.while_p.bind(\n+ new_in_flat = [*c_consts, *b_consts, cond_err, cond_code, cond_payload, *carry]\n+\n+ err, code, payload, *out = lax.while_p.bind(\n*new_in_flat, cond_nconsts=cond_nconsts, cond_jaxpr=compat_cond_jaxpr,\nbody_nconsts=body_nconsts, body_jaxpr=checked_body_jaxpr)\nnew_msgs = {**error.msgs, **msgs_body, **msgs_cond}\n- return out, Error(err, code, new_msgs)\n+ return out, Error(err, code, new_msgs, payload)\nerror_checks[lax.while_p] = while_loop_error_check\ndef add_nan_check(prim):\n@@ -666,13 +701,13 @@ add_nan_check(lax.max_p)\nadd_nan_check(lax.min_p)\n-def assert_discharge_rule(error, enabled_errors, pred, code, *, msgs):\n+def assert_discharge_rule(error, enabled_errors, pred, code, payload, *, msgs):\nif ErrorCategory.USER_CHECK not in enabled_errors:\nreturn [], error\nout_err = error.err | jnp.logical_not(pred)\nout_code = lax.select(error.err, error.code, code)\n- return [], Error(out_err, out_code, {**error.msgs, **msgs})\n+ return [], Error(out_err, out_code, {**error.msgs, **msgs}, payload)\nerror_checks[assert_p] = assert_discharge_rule\n@@ -754,7 +789,7 @@ def checkify(fun: Callable[..., Out],\ndef checked_fun(*args, **kwargs):\nargs_flat, in_tree = tree_flatten((args, kwargs))\nf, out_tree = flatten_fun(lu.wrap_init(fun), in_tree)\n- (err, code, out_flat), msgs = checkify_flat(f, errors, *args_flat)\n+ (err, code, payload, out_flat), msgs = checkify_flat(f, errors, *args_flat)\nout = tree_unflatten(out_tree(), out_flat)\n- return Error(err, code, msgs), out\n+ return Error(err, code, msgs, payload), out\nreturn checked_fun\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/checkify_test.py",
"new_path": "tests/checkify_test.py",
"diff": "@@ -137,6 +137,29 @@ class CheckifyTransformTests(jtu.JaxTestCase):\nself.assertIsNotNone(err.get())\nself.assertStartsWith(err.get(), \"nan generated by primitive cos\")\n+ def test_numpy_indexing_oobs(self):\n+ x = jnp.ones((2, 3, 7))\n+ def assert_raises_oob(fn, idx, expected_str):\n+ err, _ = checkify.checkify(fn, errors=checkify.index_checks)(x, idx)\n+ error_txt = err.get()\n+ self.assertIsNotNone(error_txt)\n+ self.assertStartsWith(error_txt, \"out-of-bounds indexing\")\n+ self.assertIn(expected_str, error_txt)\n+\n+ simple_indexing = lambda x, i: x[i]\n+ assert_raises_oob(simple_indexing, 5, \"index 5\")\n+ assert_raises_oob(simple_indexing, -5, \"index -3\")\n+ assert_raises_oob(simple_indexing, (0, 100), \"index 100\")\n+ assert_raises_oob(simple_indexing, (0, 5, 100), \"index 5\")\n+ assert_raises_oob(simple_indexing, ((1, 20), (1, 4)), \"index 20\")\n+ assert_raises_oob(simple_indexing, ((1, 20), (3, 4)), \"index 3\")\n+\n+ multiple_axis_indexing = lambda x, i: x[i[0], :, i[1]]\n+ assert_raises_oob(multiple_axis_indexing, (0, 9), \"index 9\")\n+ assert_raises_oob(multiple_axis_indexing, (-5, 9), \"index -3\")\n+ assert_raises_oob(multiple_axis_indexing, (5, -9), \"index 5\")\n+ assert_raises_oob(multiple_axis_indexing, ((0, 9), 0), \"index 9\")\n+\n@parameterized.named_parameters(jtu.cases_from_list(\n{\"testcase_name\": \"_jit={}\".format(jit), \"jit\": jit}\nfor jit in [False, True]))\n@@ -559,6 +582,21 @@ class CheckifyTransformTests(jtu.JaxTestCase):\nself.assertIsNotNone(err.get())\nself.assertStartsWith(err.get(), \"divided by zero\")\n+ def test_multiple_payloads(self):\n+ def f(x):\n+ _ = x[5]\n+ _ = x[6]\n+\n+ err, _ = checkify.checkify(f, errors=checkify.index_checks)(jnp.ones((2,)))\n+ self.assertIsNotNone(err.get())\n+ self.assertIn(\"index 5\", err.get())\n+\n+ def test_nd_payloads(self):\n+ cf = checkify.checkify(lambda x, i: x[i], errors=checkify.index_checks)\n+ errs, _ = jax.vmap(cf)(jnp.ones((3, 2)), jnp.array([5, 0, 100]))\n+ self.assertIsNotNone(errs.get())\n+ self.assertIn(\"index 5\", errs.get())\n+ self.assertIn(\"index 100\", errs.get())\nclass AssertPrimitiveTests(jtu.JaxTestCase):\n"
}
] | Python | Apache License 2.0 | google/jax | Checkify: add way to embed runtime info in error messages. |
260,335 | 28.03.2022 15:40:49 | 25,200 | 65d05984f00fbf0e171b445723a19ac091ebad6c | remove unused arg in call param jvp updater | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/ad.py",
"new_path": "jax/interpreters/ad.py",
"diff": "@@ -328,8 +328,7 @@ class JVPTrace(Trace):\nout_axes_thunk=new_out_axes_thunk)\nf_jvp, out_tree_def = traceable(f_jvp, len(primals), tangent_tree_def)\nupdate_params = call_param_updaters.get(call_primitive)\n- new_params = (update_params(params, nz_tangents, nz_tangents_out)\n- if update_params else params)\n+ new_params = update_params(params, nz_tangents) if update_params else params\nresult = call_primitive.bind(f_jvp, *primals, *nonzero_tangents, **new_params)\nprimal_out, tangent_out = tree_unflatten(out_tree_def(), result)\nreturn [JVPTracer(self, p, t) for p, t in zip(primal_out, tangent_out)]\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/xla.py",
"new_path": "jax/interpreters/xla.py",
"diff": "@@ -833,7 +833,7 @@ def _xla_call_partial_eval_update_params(params, kept_inputs, num_new_inputs):\nreturn dict(params, donated_invars=tuple(donated_invars))\npe.call_param_updaters[xla_call_p] = _xla_call_partial_eval_update_params\n-def _xla_call_jvp_update_params(params, nz_tangents, nz_tangents_out_thunk):\n+def _xla_call_jvp_update_params(params, nz_tangents):\ndonated_invars = params['donated_invars']\ndonated_tangents = [d for d, nz in zip(donated_invars, nz_tangents) if nz]\nnew_donated_invars = (*donated_invars, *donated_tangents)\n"
}
] | Python | Apache License 2.0 | google/jax | remove unused arg in call param jvp updater |
260,688 | 29.03.2022 17:13:45 | 25,200 | 8884ce5b985f28c5e4e5d5d0e2de19fa83fe1124 | Migrate 'jaxlib' CPU custom-calls to the status-returning API | [
{
"change_type": "MODIFY",
"old_path": "jaxlib/BUILD",
"new_path": "jaxlib/BUILD",
"diff": "@@ -145,6 +145,7 @@ cc_library(\nsrcs = [\"lapack_kernels.cc\"],\nhdrs = [\"lapack_kernels.h\"],\ndeps = [\n+ \"@org_tensorflow//tensorflow/compiler/xla/service:custom_call_status\",\n\"@com_google_absl//absl/base:dynamic_annotations\",\n],\n)\n@@ -198,6 +199,7 @@ cc_library(\nfeatures = [\"-use_header_modules\"],\ndeps = [\n\":pocketfft_flatbuffers_cc\",\n+ \"@org_tensorflow//tensorflow/compiler/xla/service:custom_call_status\",\n\"@flatbuffers//:runtime_cc\",\n\"@pocketfft\",\n],\n"
},
{
"change_type": "MODIFY",
"old_path": "jaxlib/lapack.py",
"new_path": "jaxlib/lapack.py",
"diff": "@@ -94,7 +94,9 @@ def trsm(c, alpha, a, b, left_side=False, lower=False, trans_a=False,\nShape.array_shape(dtype, (), ()),\nShape.array_shape(dtype, a_shape.dimensions(), layout),\nShape.array_shape(dtype, b_shape.dimensions(), layout),\n- ))\n+ ),\n+ api_version=xla_client.ops.CustomCallApiVersion\n+ .API_VERSION_STATUS_RETURNING)\njax_trsm = trsm\n# # ?getrf: LU decomposition\n@@ -149,7 +151,9 @@ def getrf(c, a):\ndtype,\nbatch_dims + (m, n),\n(num_bd, num_bd + 1) + tuple(range(num_bd - 1, -1, -1))),\n- ))\n+ ),\n+ api_version=xla_client.ops.CustomCallApiVersion\n+ .API_VERSION_STATUS_RETURNING)\nreturn tuple(_ops.GetTupleElement(out, i) for i in range(3))\n# # ?geqrf: QR decomposition\n@@ -212,7 +216,9 @@ def geqrf(c, a):\ndtype,\nbatch_dims + (m, n),\n(num_bd, num_bd + 1) + tuple(range(num_bd - 1, -1, -1))),\n- ))\n+ ),\n+ api_version=xla_client.ops.CustomCallApiVersion\n+ .API_VERSION_STATUS_RETURNING)\nreturn tuple(_ops.GetTupleElement(out, i) for i in range(3))\n# # ?orgqr: product of elementary Householder reflectors:\n@@ -282,7 +288,9 @@ def orgqr(c, a, tau):\ndtype,\nbatch_dims + (k,),\ntuple(range(num_bd, -1, -1))),\n- ))\n+ ),\n+ api_version=xla_client.ops.CustomCallApiVersion\n+ .API_VERSION_STATUS_RETURNING)\nreturn tuple(_ops.GetTupleElement(out, i) for i in range(2))\n@@ -326,7 +334,9 @@ def potrf(c, a, lower=False):\nShape.array_shape(np.dtype(np.int32), (), ()),\nShape.array_shape(np.dtype(np.int32), (), ()),\nShape.array_shape(dtype, dims, layout),\n- ))\n+ ),\n+ api_version=xla_client.ops.CustomCallApiVersion\n+ .API_VERSION_STATUS_RETURNING)\nreturn tuple(_ops.GetTupleElement(out, i) for i in range(2))\n@@ -420,7 +430,9 @@ def gesdd(c, a, full_matrices=True, compute_uv=True):\nShape.array_shape(np.dtype(np.int32), (), ()),\nShape.array_shape(np.dtype(np.int32), (), ()),\nShape.array_shape(dtype, batch_dims + (m, n), matrix_layout),\n- ))\n+ ),\n+ api_version=xla_client.ops.CustomCallApiVersion\n+ .API_VERSION_STATUS_RETURNING)\nreturn (_ops.GetTupleElement(out, 1), _ops.GetTupleElement(out, 2),\n_ops.GetTupleElement(out, 3), _ops.GetTupleElement(out, 4))\n@@ -491,7 +503,9 @@ def syevd(c, a, lower=False):\nShape.array_shape(np.dtype(np.int32), (), ()),\nShape.array_shape(np.dtype(np.int32), (), ()),\nShape.array_shape(dtype, dims, layout),\n- ))\n+ ),\n+ api_version=xla_client.ops.CustomCallApiVersion\n+ .API_VERSION_STATUS_RETURNING)\nreturn (_ops.GetTupleElement(out, 0), _ops.GetTupleElement(out, 1),\n_ops.GetTupleElement(out, 2))\n@@ -575,7 +589,9 @@ def geev(c, a, jobvl=True, jobvr=True):\nShape.array_shape(np.dtype(np.uint8), (), ()),\nShape.array_shape(np.dtype(np.uint8), (), ()),\nShape.array_shape(dtype, dims, layout),\n- ))\n+ ),\n+ api_version=xla_client.ops.CustomCallApiVersion\n+ .API_VERSION_STATUS_RETURNING)\nif real:\nreturn (_ops.Complex(_ops.GetTupleElement(out, 3),\n_ops.GetTupleElement(out, 4)),\n@@ -653,7 +669,9 @@ def gees(c, a, jobvs=True, sort=False, select=None):\nShape.array_shape(np.dtype(np.uint8), (), ()),\nShape.array_shape(np.dtype(np.uint8), (), ()),\nShape.array_shape(dtype, dims, layout),\n- ))\n+ ),\n+ api_version=xla_client.ops.CustomCallApiVersion\n+ .API_VERSION_STATUS_RETURNING)\nif sort == ord('S'):\nreturn (_ops.GetTupleElement(out, 0), _ops.GetTupleElement(out, 3),\n_ops.GetTupleElement(out, 4), _ops.GetTupleElement(out, 5))\n"
},
{
"change_type": "MODIFY",
"old_path": "jaxlib/lapack_kernels.cc",
"new_path": "jaxlib/lapack_kernels.cc",
"diff": "@@ -30,7 +30,7 @@ template <typename T>\ntypename Trsm<T>::FnType* Trsm<T>::fn = nullptr;\ntemplate <typename T>\n-void Trsm<T>::Kernel(void* out, void** data) {\n+void Trsm<T>::Kernel(void* out, void** data, XlaCustomCallStatus*) {\nint32_t left_side = *reinterpret_cast<int32_t*>(data[0]);\nint32_t lower = *reinterpret_cast<int32_t*>(data[1]);\nint32_t trans_a = *reinterpret_cast<int32_t*>(data[2]);\n@@ -82,7 +82,7 @@ template <typename T>\ntypename Getrf<T>::FnType* Getrf<T>::fn = nullptr;\ntemplate <typename T>\n-void Getrf<T>::Kernel(void* out_tuple, void** data) {\n+void Getrf<T>::Kernel(void* out_tuple, void** data, XlaCustomCallStatus*) {\nint b = *(reinterpret_cast<int32_t*>(data[0]));\nint m = *(reinterpret_cast<int32_t*>(data[1]));\nint n = *(reinterpret_cast<int32_t*>(data[2]));\n@@ -116,7 +116,7 @@ template <typename T>\ntypename Geqrf<T>::FnType* Geqrf<T>::fn = nullptr;\ntemplate <typename T>\n-void Geqrf<T>::Kernel(void* out_tuple, void** data) {\n+void Geqrf<T>::Kernel(void* out_tuple, void** data, XlaCustomCallStatus*) {\nint b = *(reinterpret_cast<int32_t*>(data[0]));\nint m = *(reinterpret_cast<int32_t*>(data[1]));\nint n = *(reinterpret_cast<int32_t*>(data[2]));\n@@ -163,7 +163,7 @@ template <typename T>\ntypename Orgqr<T>::FnType* Orgqr<T>::fn = nullptr;\ntemplate <typename T>\n-void Orgqr<T>::Kernel(void* out_tuple, void** data) {\n+void Orgqr<T>::Kernel(void* out_tuple, void** data, XlaCustomCallStatus*) {\nint b = *(reinterpret_cast<int32_t*>(data[0]));\nint m = *(reinterpret_cast<int32_t*>(data[1]));\nint n = *(reinterpret_cast<int32_t*>(data[2]));\n@@ -211,7 +211,7 @@ template <typename T>\ntypename Potrf<T>::FnType* Potrf<T>::fn = nullptr;\ntemplate <typename T>\n-void Potrf<T>::Kernel(void* out_tuple, void** data) {\n+void Potrf<T>::Kernel(void* out_tuple, void** data, XlaCustomCallStatus*) {\nint32_t lower = *(reinterpret_cast<int32_t*>(data[0]));\nint b = *(reinterpret_cast<int32_t*>(data[1]));\nint n = *(reinterpret_cast<int32_t*>(data[2]));\n@@ -260,7 +260,7 @@ template <typename T>\ntypename RealGesdd<T>::FnType* RealGesdd<T>::fn = nullptr;\ntemplate <typename T>\n-void RealGesdd<T>::Kernel(void* out_tuple, void** data) {\n+void RealGesdd<T>::Kernel(void* out_tuple, void** data, XlaCustomCallStatus*) {\nint32_t job_opt_full_matrices = *(reinterpret_cast<int32_t*>(data[0]));\nint32_t job_opt_compute_uv = *(reinterpret_cast<int32_t*>(data[1]));\nint b = *(reinterpret_cast<int32_t*>(data[2]));\n@@ -332,7 +332,8 @@ template <typename T>\ntypename ComplexGesdd<T>::FnType* ComplexGesdd<T>::fn = nullptr;\ntemplate <typename T>\n-void ComplexGesdd<T>::Kernel(void* out_tuple, void** data) {\n+void ComplexGesdd<T>::Kernel(void* out_tuple, void** data,\n+ XlaCustomCallStatus*) {\nint32_t job_opt_full_matrices = *(reinterpret_cast<int32_t*>(data[0]));\nint32_t job_opt_compute_uv = *(reinterpret_cast<int32_t*>(data[1]));\nint b = *(reinterpret_cast<int32_t*>(data[2]));\n@@ -411,7 +412,7 @@ template <typename T>\ntypename RealSyevd<T>::FnType* RealSyevd<T>::fn = nullptr;\ntemplate <typename T>\n-void RealSyevd<T>::Kernel(void* out_tuple, void** data) {\n+void RealSyevd<T>::Kernel(void* out_tuple, void** data, XlaCustomCallStatus*) {\nint32_t lower = *(reinterpret_cast<int32_t*>(data[0]));\nint b = *(reinterpret_cast<int32_t*>(data[1]));\nint n = *(reinterpret_cast<int32_t*>(data[2]));\n@@ -459,7 +460,8 @@ template <typename T>\ntypename ComplexHeevd<T>::FnType* ComplexHeevd<T>::fn = nullptr;\ntemplate <typename T>\n-void ComplexHeevd<T>::Kernel(void* out_tuple, void** data) {\n+void ComplexHeevd<T>::Kernel(void* out_tuple, void** data,\n+ XlaCustomCallStatus*) {\nint32_t lower = *(reinterpret_cast<int32_t*>(data[0]));\nint b = *(reinterpret_cast<int32_t*>(data[1]));\nint n = *(reinterpret_cast<int32_t*>(data[2]));\n@@ -531,7 +533,7 @@ template <typename T>\ntypename RealGeev<T>::FnType* RealGeev<T>::fn = nullptr;\ntemplate <typename T>\n-void RealGeev<T>::Kernel(void* out_tuple, void** data) {\n+void RealGeev<T>::Kernel(void* out_tuple, void** data, XlaCustomCallStatus*) {\nint b = *(reinterpret_cast<int32_t*>(data[0]));\nint n_int = *(reinterpret_cast<int32_t*>(data[1]));\nint64_t n = n_int;\n@@ -590,7 +592,8 @@ template <typename T>\ntypename ComplexGeev<T>::FnType* ComplexGeev<T>::fn = nullptr;\ntemplate <typename T>\n-void ComplexGeev<T>::Kernel(void* out_tuple, void** data) {\n+void ComplexGeev<T>::Kernel(void* out_tuple, void** data,\n+ XlaCustomCallStatus*) {\nint b = *(reinterpret_cast<int32_t*>(data[0]));\nint n_int = *(reinterpret_cast<int32_t*>(data[1]));\nint64_t n = n_int;\n@@ -648,7 +651,7 @@ template <typename T>\ntypename RealGees<T>::FnType* RealGees<T>::fn = nullptr;\ntemplate <typename T>\n-void RealGees<T>::Kernel(void* out_tuple, void** data) {\n+void RealGees<T>::Kernel(void* out_tuple, void** data, XlaCustomCallStatus*) {\nint b = *(reinterpret_cast<int32_t*>(data[0]));\nint n_int = *(reinterpret_cast<int32_t*>(data[1]));\nint64_t n = n_int;\n@@ -708,7 +711,8 @@ template <typename T>\ntypename ComplexGees<T>::FnType* ComplexGees<T>::fn = nullptr;\ntemplate <typename T>\n-void ComplexGees<T>::Kernel(void* out_tuple, void** data) {\n+void ComplexGees<T>::Kernel(void* out_tuple, void** data,\n+ XlaCustomCallStatus*) {\nint b = *(reinterpret_cast<int32_t*>(data[0]));\nint n_int = *(reinterpret_cast<int32_t*>(data[1]));\nint64_t n = n_int;\n"
},
{
"change_type": "MODIFY",
"old_path": "jaxlib/lapack_kernels.h",
"new_path": "jaxlib/lapack_kernels.h",
"diff": "@@ -18,6 +18,7 @@ limitations under the License.\n#include <complex>\n#include <cstdint>\n+#include \"tensorflow/compiler/xla/service/custom_call_status.h\"\n// Underlying function pointers (e.g., Trsm<double>::Fn) are initialized either\n// by the pybind wrapper that links them to an existing SciPy lapack instance,\n@@ -35,7 +36,7 @@ struct Trsm {\nlapack_int* lda, T* b, lapack_int* ldb);\nstatic FnType* fn;\n- static void Kernel(void* out, void** data);\n+ static void Kernel(void* out, void** data, XlaCustomCallStatus*);\n};\ntemplate <typename T>\n@@ -44,7 +45,7 @@ struct Getrf {\nlapack_int* ipiv, lapack_int* info);\nstatic FnType* fn;\n- static void Kernel(void* out, void** data);\n+ static void Kernel(void* out, void** data, XlaCustomCallStatus*);\n};\ntemplate <typename T>\n@@ -53,7 +54,7 @@ struct Geqrf {\nT* tau, T* work, lapack_int* lwork, lapack_int* info);\nstatic FnType* fn;\n- static void Kernel(void* out, void** data);\n+ static void Kernel(void* out, void** data, XlaCustomCallStatus*);\nstatic int64_t Workspace(lapack_int m, lapack_int n);\n};\n@@ -64,7 +65,7 @@ struct Orgqr {\nlapack_int* lda, T* tau, T* work, lapack_int* lwork,\nlapack_int* info);\nstatic FnType* fn;\n- static void Kernel(void* out, void** data);\n+ static void Kernel(void* out, void** data, XlaCustomCallStatus*);\nstatic int64_t Workspace(lapack_int m, lapack_int n, lapack_int k);\n};\n@@ -73,7 +74,7 @@ struct Potrf {\nusing FnType = void(char* uplo, lapack_int* n, T* a, lapack_int* lda,\nlapack_int* info);\nstatic FnType* fn;\n- static void Kernel(void* out, void** data);\n+ static void Kernel(void* out, void** data, XlaCustomCallStatus*);\n};\nlapack_int GesddIworkSize(int64_t m, int64_t n);\n@@ -85,7 +86,7 @@ struct RealGesdd {\nlapack_int* ldvt, T* work, lapack_int* lwork,\nlapack_int* iwork, lapack_int* info);\nstatic FnType* fn;\n- static void Kernel(void* out, void** data);\n+ static void Kernel(void* out, void** data, XlaCustomCallStatus*);\nstatic int64_t Workspace(lapack_int m, lapack_int n,\nbool job_opt_compute_uv, bool job_opt_full_matrices);\n@@ -101,7 +102,7 @@ struct ComplexGesdd {\nlapack_int* lwork, typename T::value_type* rwork,\nlapack_int* iwork, lapack_int* info);\nstatic FnType* fn;\n- static void Kernel(void* out, void** data);\n+ static void Kernel(void* out, void** data, XlaCustomCallStatus*);\nstatic int64_t Workspace(lapack_int m, lapack_int n,\nbool job_opt_compute_uv, bool job_opt_full_matrices);\n@@ -117,7 +118,7 @@ struct RealSyevd {\nlapack_int* lda, T* w, T* work, lapack_int* lwork,\nlapack_int* iwork, lapack_int* liwork, lapack_int* info);\nstatic FnType* fn;\n- static void Kernel(void* out, void** data);\n+ static void Kernel(void* out, void** data, XlaCustomCallStatus*);\n};\nlapack_int HeevdWorkSize(int64_t n);\n@@ -131,7 +132,7 @@ struct ComplexHeevd {\nlapack_int* lrwork, lapack_int* iwork, lapack_int* liwork,\nlapack_int* info);\nstatic FnType* fn;\n- static void Kernel(void* out, void** data);\n+ static void Kernel(void* out, void** data, XlaCustomCallStatus*);\n};\ntemplate <typename T>\n@@ -141,7 +142,7 @@ struct RealGeev {\nT* vr, lapack_int* ldvr, T* work, lapack_int* lwork,\nlapack_int* info);\nstatic FnType* fn;\n- static void Kernel(void* out, void** data);\n+ static void Kernel(void* out, void** data, XlaCustomCallStatus*);\n};\ntemplate <typename T>\n@@ -151,7 +152,7 @@ struct ComplexGeev {\nlapack_int* ldvr, T* work, lapack_int* lwork,\ntypename T::value_type* rwork, lapack_int* info);\nstatic FnType* fn;\n- static void Kernel(void* out, void** data);\n+ static void Kernel(void* out, void** data, XlaCustomCallStatus*);\n};\ntemplate <typename T>\n@@ -161,7 +162,7 @@ struct RealGees {\nT* wr, T* wi, T* vs, lapack_int* ldvs, T* work,\nlapack_int* lwork, bool* bwork, lapack_int* info);\nstatic FnType* fn;\n- static void Kernel(void* out, void** data);\n+ static void Kernel(void* out, void** data, XlaCustomCallStatus*);\n};\ntemplate <typename T>\n@@ -172,7 +173,7 @@ struct ComplexGees {\ntypename T::value_type* rwork, bool* bwork,\nlapack_int* info);\nstatic FnType* fn;\n- static void Kernel(void* out, void** data);\n+ static void Kernel(void* out, void** data, XlaCustomCallStatus*);\n};\n} // namespace jax\n"
},
{
"change_type": "MODIFY",
"old_path": "jaxlib/pocketfft.py",
"new_path": "jaxlib/pocketfft.py",
"diff": "@@ -20,7 +20,6 @@ from . import _pocketfft\nfrom . import pocketfft_flatbuffers_py_generated as pd\nimport numpy as np\n-\nimport flatbuffers\nfrom jaxlib import xla_client\n@@ -53,8 +52,9 @@ def pocketfft(c, a, *, fft_type: FftType, fft_lengths: List[int]):\npd.PocketFftDtype.COMPLEX64\nif dtype == np.float32 else pd.PocketFftDtype.COMPLEX128)\n- assert list(shape.dimensions())[-len(fft_lengths):] == fft_lengths, (\n- shape, fft_lengths)\n+ assert list(\n+ shape.dimensions())[-len(fft_lengths):] == fft_lengths, (shape,\n+ fft_lengths)\nout_shape = list(shape.dimensions())\nout_shape[-1] = out_shape[-1] // 2 + 1\n@@ -80,8 +80,9 @@ def pocketfft(c, a, *, fft_type: FftType, fft_lengths: List[int]):\npd.PocketFftDtype.COMPLEX64\nif dtype == np.complex64 else pd.PocketFftDtype.COMPLEX128)\n- assert list(shape.dimensions())[-len(fft_lengths):] == fft_lengths, (\n- shape, fft_lengths)\n+ assert list(\n+ shape.dimensions())[-len(fft_lengths):] == fft_lengths, (shape,\n+ fft_lengths)\nout_shape = shape.dimensions()\n# PocketFft does not allow size 0 dimensions.\n@@ -156,4 +157,6 @@ def pocketfft(c, a, *, fft_type: FftType, fft_lengths: List[int]):\nnp.dtype(np.uint8), (len(descriptor_bytes),), (0,)),\nxla_client.Shape.array_shape(dtype, shape.dimensions(),\ntuple(range(n - 1, -1, -1))),\n- ))\n+ ),\n+ api_version=xla_client.ops.CustomCallApiVersion\n+ .API_VERSION_STATUS_RETURNING)\n"
},
{
"change_type": "MODIFY",
"old_path": "jaxlib/pocketfft_kernels.cc",
"new_path": "jaxlib/pocketfft_kernels.cc",
"diff": "@@ -18,10 +18,11 @@ limitations under the License.\n#include \"flatbuffers/flatbuffers.h\"\n#include \"pocketfft/pocketfft_hdronly.h\"\n#include \"jaxlib/pocketfft_generated.h\"\n+#include \"tensorflow/compiler/xla/service/custom_call_status.h\"\nnamespace jax {\n-void PocketFft(void* out, void** in) {\n+void PocketFft(void* out, void** in, XlaCustomCallStatus*) {\nconst PocketFftDescriptor* descriptor = GetPocketFftDescriptor(in[0]);\npocketfft::shape_t shape(descriptor->shape()->begin(),\ndescriptor->shape()->end());\n"
},
{
"change_type": "MODIFY",
"old_path": "jaxlib/pocketfft_kernels.h",
"new_path": "jaxlib/pocketfft_kernels.h",
"diff": "@@ -13,8 +13,10 @@ See the License for the specific language governing permissions and\nlimitations under the License.\n==============================================================================*/\n+#include \"tensorflow/compiler/xla/service/custom_call_status.h\"\n+\nnamespace jax {\n-void PocketFft(void* out, void** in);\n+void PocketFft(void* out, void** in, XlaCustomCallStatus*);\n} // namespace jax\n"
}
] | Python | Apache License 2.0 | google/jax | Migrate 'jaxlib' CPU custom-calls to the status-returning API
PiperOrigin-RevId: 438165260 |
260,631 | 30.03.2022 08:26:48 | 25,200 | 1555ba147c54a7bb0d507aed87512f604f836fc6 | Copybara import of the project:
by Jake VanderPlas
make device_array.copy() return a device array | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/api.py",
"new_path": "jax/_src/api.py",
"diff": "@@ -2784,11 +2784,11 @@ def _device_get(x):\nif isinstance(x, core.Tracer):\nreturn x\ntry:\n- toarray = x.__array__\n+ copy = x.copy\nexcept AttributeError:\nreturn x\nelse:\n- return toarray()\n+ return copy()\ndef device_get(x: Any):\n\"\"\"Transfer ``x`` to host.\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/device_array.py",
"new_path": "jax/_src/device_array.py",
"diff": "@@ -199,6 +199,12 @@ class _DeviceArray(DeviceArray): # type: ignore\n# pylint: disable=protected-access\nfor device_array in [DeviceArray]:\n+\n+ def copy(self):\n+ \"\"\"Returns an ndarray (backed by host memory, not device memory).\"\"\"\n+ return np.asarray(self)\n+ setattr(device_array, \"copy\", copy)\n+\ndef __repr__(self):\nline_width = np.get_printoptions()[\"linewidth\"]\nprefix = '{}('.format(self.__class__.__name__.lstrip('_'))\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/numpy/lax_numpy.py",
"new_path": "jax/_src/numpy/lax_numpy.py",
"diff": "@@ -4571,7 +4571,7 @@ _operators = {\n# These numpy.ndarray methods are just refs to an equivalent numpy function\n_nondiff_methods = [\"all\", \"any\", \"argmax\", \"argmin\", \"argpartition\", \"argsort\",\n\"nonzero\", \"searchsorted\", \"round\"]\n-_diff_methods = [\"choose\", \"conj\", \"conjugate\", \"copy\", \"cumprod\", \"cumsum\",\n+_diff_methods = [\"choose\", \"conj\", \"conjugate\", \"cumprod\", \"cumsum\",\n\"diagonal\", \"dot\", \"max\", \"mean\", \"min\", \"prod\", \"ptp\",\n\"ravel\", \"repeat\", \"sort\", \"squeeze\", \"std\", \"sum\",\n\"swapaxes\", \"take\", \"tile\", \"trace\", \"var\"]\n"
}
] | Python | Apache License 2.0 | google/jax | Copybara import of the project:
--
de9a948d1ce407056de545b5717c3441298e2f36 by Jake VanderPlas <jakevdp@google.com>:
make device_array.copy() return a device array
PiperOrigin-RevId: 438308145 |
260,440 | 30.03.2022 15:31:59 | 0 | b3152126433921d17c1e632b368e0271308d43ed | Fixed a typo in the return type of _array_ir_types
There could be other typing issues in that module, but I will address them separately. | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/mlir.py",
"new_path": "jax/interpreters/mlir.py",
"diff": "@@ -115,7 +115,7 @@ def dtype_to_ir_type(dtype: Union[np.dtype, np.generic]) -> ir.Type:\nf\"No dtype_to_ir_type handler for dtype: {dtype}\") from err\nreturn ir_type_factory()\n-def _array_ir_types(aval: core.ShapedArray) -> ir.Type:\n+def _array_ir_types(aval: core.ShapedArray) -> Sequence[ir.Type]:\nreturn (ir.RankedTensorType.get(aval.shape, dtype_to_ir_type(aval.dtype)),)\nir_type_handlers: Dict[Type[core.AbstractValue],\n"
}
] | Python | Apache License 2.0 | google/jax | Fixed a typo in the return type of _array_ir_types
There could be other typing issues in that module, but I will address them separately. |
260,510 | 30.03.2022 11:18:56 | 25,200 | c233a97b095c191d30702d660e878956a400441a | Remove redundant name-stack setting in `DynamicJaxprTrace` | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -1499,12 +1499,10 @@ class DynamicJaxprTrace(core.Trace):\ndim_tracers = _get_tracers_only_in_shapes(tracers)\nin_avals = _tracers_to_avals(dim_tracers + tracers)\nkeep_inputs = [False] * len(dim_tracers) + [True] * len(tracers)\n- name_stack = source_info_util.current_name_stack()\nwith core.new_sublevel():\njaxpr, out_avals, consts = trace_to_subjaxpr_dynamic(\nf, self.main, in_avals, keep_inputs=keep_inputs)\nif params.get('inline', False):\n- with source_info_util.set_name_stack(name_stack):\nreturn core.eval_jaxpr(jaxpr, consts, *dim_tracers, *tracers)\nsource_info = source_info_util.current()\nenv = {v: t for v, t in zip((*jaxpr.constvars, *jaxpr.invars),\n"
}
] | Python | Apache License 2.0 | google/jax | Remove redundant name-stack setting in `DynamicJaxprTrace` |
260,510 | 30.03.2022 11:22:26 | 25,200 | fb977176c1f882c9bdd5475972fc2dbc6a29e559 | Fix link to buffer-donation docs | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/mlir.py",
"new_path": "jax/interpreters/mlir.py",
"diff": "@@ -483,7 +483,7 @@ def lower_jaxpr_to_module(\n# TODO(tomhennigan): At call time we should mark these buffers as deleted.\nunused_donations = [str(a) for a, d in zip(in_avals, donated_args)\nif d]\n- msg = \"See an explanation at https://jax.readthedocs.io/en/latest/notebooks/faq.html#buffer-donation.\"\n+ msg = \"See an explanation at https://jax.readthedocs.io/en/latest/faq.html#buffer-donation.\"\nif platform not in platforms_with_donation:\nmsg = f\"Donation is not implemented for {platform}.\\n{msg}\"\nwarnings.warn(f\"Some donated buffers were not usable: {', '.join(unused_donations)}.\\n{msg}\")\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/xla.py",
"new_path": "jax/interpreters/xla.py",
"diff": "@@ -809,7 +809,7 @@ def lower_jaxpr_to_xla_module(\n# TODO(tomhennigan): At call time we should mark these buffers as deleted.\nunused_donations = [str(c.GetShape(a))\nfor a, d in zip(xla_args, donated_invars) if d]\n- msg = \"See an explanation at https://jax.readthedocs.io/en/latest/notebooks/faq.html#buffer-donation.\"\n+ msg = \"See an explanation at https://jax.readthedocs.io/en/latest/faq.html#buffer-donation.\"\nif platform not in platforms_with_donation:\nmsg = f\"Donation is not implemented for {platform}.\\n{msg}\"\nwarnings.warn(f\"Some donated buffers were not usable: {', '.join(unused_donations)}.\\n{msg}\")\n"
}
] | Python | Apache License 2.0 | google/jax | Fix link to buffer-donation docs |
260,447 | 30.03.2022 16:09:48 | 25,200 | 19e359221af2fdf8c26dfcee8a8a36db736f3ce4 | [jax2tf] Updates `custom_assert` for jax2tf SVD (primitive) limitations. | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/tests/jax2tf_limitations.py",
"new_path": "jax/experimental/jax2tf/tests/jax2tf_limitations.py",
"diff": "@@ -972,26 +972,145 @@ class Jax2TfLimitation(primitive_harness.Limitation):\n# TODO: slow test\ncompute_uv = harness.params[\"compute_uv\"]\n+ # Both `r_jax` and `r_tf` are 3-Tuples containing the SVD results:\n+ # `S` (singular values), `U` (left singular vectors), and `Vh` (the\n+ # adjoint of the right singular vectors). Note that the TF results are\n+ # obtained through `_svd` in jax/experimental/jax2tf/jax2tf.py.\ndef custom_assert(tst, r_jax, r_tf, *, args, tol, err_msg):\n- def _reconstruct_operand(result, is_tf: bool):\n+ def reconstruct_operand(result):\n# Reconstructing operand as documented in numpy.linalg.svd (see\n# https://numpy.org/doc/stable/reference/generated/numpy.linalg.svd.html)\ns, u, v = result\nU = u[..., :s.shape[-1]]\nV = v[..., :s.shape[-1], :]\nS = s[..., None, :]\n- return jnp.matmul(U * S, V), s.shape, u.shape, v.shape\n+ return jnp.matmul(U * S, V, precision=lax.Precision.HIGHEST)\n+\n+ # Compares the shapes.\n+ def compare_shapes(r_jax, r_tf):\n+ shapes_jax = [result.shape for result in r_jax]\n+ shapes_tf = [result.shape for result in r_tf]\n+ tst.assertEqual(shapes_jax, shapes_tf)\n+\n+ # Compares reconstructed operand.\n+ # Computes backward error https://www.netlib.org/lapack/lug/node97.html\n+ # and uses the maximum backward error if there are batch dimensions.\n+ # The backward error is bounded by some constant multiplying the machine\n+ # precision.\n+ # TODO: Compares the operand instead of the reconstructed operand.\n+ def compare_reconstructed_operand(r_jax, r_tf, tol):\n+ operand_jax = reconstruct_operand(r_jax)\n+ operand_tf = reconstruct_operand(r_tf)\n+ error_norm = jnp.linalg.norm(operand_jax - operand_tf,\n+ axis=(-2, -1))\n+ backward_error = (error_norm /\n+ jnp.linalg.norm(operand_jax, axis=(-2, -1)))\n+ max_backward_error = jnp.amax(backward_error)\n+ tst.assertLess(max_backward_error, tol)\n+\n+ # Computes the absolute gap between singular value `\\sigma_i` and the\n+ # nearest other singular value and for all singular values. The absolute\n+ # gap is used to approximate the upper bound of angular difference\n+ # between the computed and the true singular vectors. If the matrix is\n+ # rectangular `m != n`, the gap for the smallest nonzero singular value\n+ # should also consider the gap between it and zero. Note that this code\n+ # relies on the singular values being in descending order.\n+ def compute_absolute_gap(s, m, n):\n+ forward_appendant = np.Inf if m == n else 0\n+ forward_diff = jnp.diff(s, axis=-1, append=forward_appendant)\n+ backward_diff = jnp.diff(\n+ s[..., ::-1], axis=-1, append=np.Inf)[..., ::-1]\n+ absolute_gap = jnp.minimum(jnp.abs(forward_diff),\n+ jnp.abs(backward_diff))\n+ return absolute_gap\n+\n+ # See `CompareSingularVectors` in\n+ # tensorflow/python/kernel_tests/linalg/svd_op_test.py\n+ def compare_singular_vectors(x, y, *, error_bound):\n+ # Singular vectors are only unique up to sign (complex phase factor for\n+ # complex matrices), so we normalize the sign first.\n+ sum_of_ratios = jnp.sum(jnp.divide(y, x), -2, keepdims=True)\n+ phases = jnp.divide(sum_of_ratios, jnp.abs(sum_of_ratios))\n+ x *= phases\n+\n+ # Note that in general `sqrt(sum(squares))` is not a stable way to\n+ # compute l2 vector norms, but it should be OK for normalization\n+ # factors of vectors with norm ~= 1 as here.\n+ def dot_column_wise(a, b):\n+ output = jnp.sum(jnp.einsum('...ij,...ij->...ij', a.conj(), b,\n+ precision=lax.Precision.HIGHEST),\n+ axis=-2)\n+ return jnp.real(output)\n+\n+ cos_angular_diff = (\n+ dot_column_wise(x, y) /\n+ jnp.sqrt(dot_column_wise(x, x) * dot_column_wise(y, y)))\n+\n+ # Values of `\\cos(angular_diff)` outside the interval [0, 1] are clipped\n+ # to the interval edges. For example, `\\cos(angular_diff)` could contain\n+ # values like 1.0000001 on float32, which are clipped to 1.0. It is\n+ # possible that anything other than `cos_angular_diff` can be outside\n+ # the interval [0, 1] due to roundoff.\n+ cos_angular_diff = jnp.clip(cos_angular_diff, a_min=0.0, a_max=1.0)\n+\n+ angular_diff = jnp.arccos(cos_angular_diff)\n+\n+ # TODO: removes the slack factor on the angular difference.\n+ # It is possible that the singular vectors are not accurate to much more\n+ # than O(\\sqrt(eps)), which is likely a property of the SVD algorithms\n+ # in question; revisit with better understanding of the SVD algorithms.\n+ if x.dtype in [np.float32, np.complex64]:\n+ slack_factor = 1E4\n+ elif x.dtype in [np.float64, np.complex128]:\n+ slack_factor = 1E9\n+\n+ np.testing.assert_array_less(angular_diff,\n+ slack_factor * error_bound)\nif compute_uv:\n- r_jax_reconstructed = _reconstruct_operand(r_jax, False)\n- r_tf_reconstructed = _reconstruct_operand(r_tf, True)\n- tst.assertAllClose(\n- r_jax_reconstructed,\n- r_tf_reconstructed,\n- atol=tol,\n- rtol=tol,\n- err_msg=err_msg)\n+ # Compares the shapes.\n+ compare_shapes(r_jax, r_tf)\n+\n+ # Compares the singular values. Each computed singular value `\\sigma_i`\n+ # differs from the true `\\sigma_i`* by at most\n+ # `|\\sigma_i - \\sigma_i*| <= \\epsilon \\sigma_1`, where `\\sigma_1` is the\n+ # largest singular value and `\\epsilon` denotes the machine precision.\n+ s_jax, s_tf = r_jax[0], r_tf[0]\n+ tst.assertAllClose(s_jax, s_tf, atol=tol, rtol=tol, err_msg=err_msg)\n+\n+ # Compares the reconstructed operand.\n+ compare_reconstructed_operand(r_jax, r_tf, tol)\n+\n+ # Compares the singular vectors.\n+ # We only compare the first `rank` singular vectors since the remainder\n+ # forms an arbitrary orthonormal basis for the (row- or column-) null\n+ # space, whose exact value depends on implementation details.\n+ # TODO: A better estimation on the rank?\n+ rank = r_jax[0].shape[-1]\n+\n+ # Computes the upper bound for angular difference of singular vectors.\n+ # The upper bound has the shape of `[..., k]`, where `...` denotes the\n+ # batch dimensions and `k` is the number of nonzero singular values.\n+ m = r_jax[1].shape[-2]\n+ n = r_jax[2].shape[-2]\n+ absolute_gap = compute_absolute_gap(r_jax[0], m, n)\n+ epsilon = jnp.finfo(r_jax[0].dtype).eps\n+ sigma_largest = (r_jax[0][..., 0])[..., None]\n+ upperbound_singular_vectors = epsilon * sigma_largest / absolute_gap\n+ upperbound_singular_vectors = upperbound_singular_vectors[..., :rank]\n+\n+ # Left singular vectors.\n+ u_jax = r_jax[1][..., :rank]\n+ u_tf = r_tf[1][..., :rank]\n+ compare_singular_vectors(u_jax, u_tf,\n+ error_bound=upperbound_singular_vectors)\n+\n+ # Right singular vectors.\n+ v_jax = jnp.swapaxes(r_jax[2][..., :rank, :], -2, -1).conj()\n+ v_tf = jnp.swapaxes(r_tf[2][..., :rank, :], -2, -1).conj()\n+ compare_singular_vectors(v_jax, v_tf,\n+ error_bound=upperbound_singular_vectors)\nelse:\ntst.assertAllClose(r_jax, r_tf, atol=tol, rtol=tol, err_msg=err_msg)\n@@ -1020,11 +1139,11 @@ class Jax2TfLimitation(primitive_harness.Limitation):\ndevices=(\"cpu\", \"gpu\"),\nmodes=(\"eager\", \"graph\", \"compiled\")),\ncustom_numeric(\n- description=\"custom numeric comparison when compute_uv\",\n+ description=\"custom numeric comparison when compute_uv on CPU/GPU\",\ncustom_assert=custom_assert,\ndevices=(\"cpu\", \"gpu\"),\nmodes=(\"eager\", \"graph\", \"compiled\"),\n- enabled=(compute_uv == True))\n+ enabled=(compute_uv == True)),\n]\n@classmethod\n"
}
] | Python | Apache License 2.0 | google/jax | [jax2tf] Updates `custom_assert` for jax2tf SVD (primitive) limitations.
PiperOrigin-RevId: 438421090 |
260,424 | 30.03.2022 17:19:15 | -3,600 | 15d2ccaeba368b3fa22794cf923c31fe1e8abafe | Checkify: add axis and axis size to OOB error message. | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/checkify/checkify_impl.py",
"new_path": "jax/experimental/checkify/checkify_impl.py",
"diff": "@@ -58,9 +58,18 @@ Bool = Union[bool, core.Tracer]\nInt = Union[int, core.Tracer]\nPayload = Union[np.ndarray, jnp.ndarray, core.Tracer]\n-# For now, the payload needs to be a fixed-size array (int32 scalar).\n+# For now, the payload needs to be a fixed-size array: 3 int32s, used for the\n+# OOB message.\n# TODO(lenamartens): Relax this fixed-size constraint.\n-init_payload = np.ones((), np.int32)\n+init_payload = np.ones((3,), np.int32)\n+\n+\n+def _format_msg(msg, payloads):\n+ payload_mapping = {}\n+ for i, pl in enumerate(payloads):\n+ payload_mapping[f'payload{i}'] = pl\n+ return msg.format(**payload_mapping)\n+\n@dataclass(frozen=True)\nclass Error:\n@@ -76,11 +85,11 @@ class Error:\nassert np.shape(self.err) == np.shape(self.code)\nif np.size(self.err) == 1:\nif self.err:\n- return self.msgs[int(self.code)].format(payload=self.payload)\n+ return _format_msg(self.msgs[int(self.code)], self.payload)\nelse:\nreturn '\\n'.join(\nf'at mapped index {\", \".join(map(str, idx))}: ' # type: ignore\n- f'{self.msgs[int(self.code[idx])].format(payload=self.payload[idx])}' # type: ignore\n+ f'{_format_msg(self.msgs[int(self.code[idx])], self.payload[idx])}' # type: ignore\nfor idx, e in np.ndenumerate(self.err) if e) or None\nreturn None\n@@ -250,9 +259,8 @@ class CheckifyTrace(core.Trace):\nreturn [CheckifyTracer(self, x) for x in out]\ndef _reduce_any_error(errs, codes, payloads):\n- errs_, codes_ = lax.sort_key_val(errs, codes, dimension=0)\n- errs_, payload_ = lax.sort_key_val(errs, payloads, dimension=0)\n- return errs_[-1], codes_[-1], payload_[-1]\n+ reduced_idx = jnp.argsort(errs)[-1]\n+ return errs[reduced_idx], codes[reduced_idx], payloads[reduced_idx]\nErrorCheckRule = Callable # (Error, FrozenSet[ErrorCategory], *in_vals, **params) -> (Any, Error)\nerror_checks: Dict[core.Primitive, ErrorCheckRule] = {}\n@@ -490,12 +498,18 @@ def gather_error_check(error, enabled_errors, operand, start_indices, *,\nupper_bound = jnp.expand_dims(upper_bound, axis=tuple(range(num_batch_dims)))\nin_bounds = (start_indices >= 0) & (start_indices <= upper_bound)\n- msg = f'out-of-bounds indexing at {summary()}: '\n- msg += 'index {payload} is out of bounds for '\n- msg += f'array of shape {operand.shape}.'\n- start_indices, in_bounds = jnp.ravel(start_indices), jnp.ravel(in_bounds)\n- # Report first index which is out-of-bounds (in row-major order).\n- payload = start_indices[jnp.argsort(in_bounds, axis=0)[0]]\n+ # Get first OOB index, axis and axis size so it can be added to the error msg.\n+ flat_idx = jnp.argmin(in_bounds)\n+ multi_idx = jnp.unravel_index(flat_idx, start_indices.shape)\n+ oob_axis = jnp.array(dnums.start_index_map)[multi_idx[-1]]\n+ oob_axis_size = jnp.array(operand.shape)[oob_axis]\n+ oob_index = jnp.ravel(start_indices)[flat_idx]\n+ payload = jnp.array([oob_index, oob_axis, oob_axis_size], dtype=jnp.int32)\n+\n+ msg = (f'out-of-bounds indexing at {summary()} for array of '\n+ f'shape {operand.shape}: '\n+ 'index {payload0} is out of bounds for axis {payload1} '\n+ 'with size {payload2}.')\nreturn out, assert_func(error, jnp.all(in_bounds), msg, payload)\nerror_checks[lax.gather_p] = gather_error_check\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/checkify_test.py",
"new_path": "tests/checkify_test.py",
"diff": "@@ -138,27 +138,36 @@ class CheckifyTransformTests(jtu.JaxTestCase):\nself.assertStartsWith(err.get(), \"nan generated by primitive cos\")\ndef test_numpy_indexing_oobs(self):\n- x = jnp.ones((2, 3, 7))\n- def assert_raises_oob(fn, idx, expected_str):\n+ def raises_oob(fn, idx, *expected_strs):\nerr, _ = checkify.checkify(fn, errors=checkify.index_checks)(x, idx)\nerror_txt = err.get()\nself.assertIsNotNone(error_txt)\nself.assertStartsWith(error_txt, \"out-of-bounds indexing\")\n- self.assertIn(expected_str, error_txt)\n-\n- simple_indexing = lambda x, i: x[i]\n- assert_raises_oob(simple_indexing, 5, \"index 5\")\n- assert_raises_oob(simple_indexing, -5, \"index -3\")\n- assert_raises_oob(simple_indexing, (0, 100), \"index 100\")\n- assert_raises_oob(simple_indexing, (0, 5, 100), \"index 5\")\n- assert_raises_oob(simple_indexing, ((1, 20), (1, 4)), \"index 20\")\n- assert_raises_oob(simple_indexing, ((1, 20), (3, 4)), \"index 3\")\n-\n- multiple_axis_indexing = lambda x, i: x[i[0], :, i[1]]\n- assert_raises_oob(multiple_axis_indexing, (0, 9), \"index 9\")\n- assert_raises_oob(multiple_axis_indexing, (-5, 9), \"index -3\")\n- assert_raises_oob(multiple_axis_indexing, (5, -9), \"index 5\")\n- assert_raises_oob(multiple_axis_indexing, ((0, 9), 0), \"index 9\")\n+ for s in expected_strs:\n+ self.assertIn(s, error_txt)\n+\n+ x = jnp.ones((2, 3, 7))\n+ axis0_msg = \"axis 0 with size 2\"\n+ axis1_msg = \"axis 1 with size 3\"\n+ axis2_msg = \"axis 2 with size 7\"\n+\n+ single_idx = lambda x, i: x[i]\n+ raises_oob(single_idx, 5, \"index 5\", axis0_msg)\n+ raises_oob(single_idx, -5, \"index -3\", axis0_msg)\n+ raises_oob(single_idx, (0, 100), \"index 100\", axis1_msg)\n+ raises_oob(single_idx, (0, 5, 100), \"index 5\", axis1_msg)\n+ raises_oob(single_idx, (0, 0, 100), \"index 100\", axis2_msg)\n+ raises_oob(single_idx, ((1, 20), (1, 4)), \"index 20\", axis0_msg)\n+ raises_oob(single_idx, ((1, 20), (3, 4)), \"index 3\", axis1_msg)\n+ raises_oob(single_idx, (((1, 1), (1, 20)), 3), \"index 3\", axis1_msg)\n+ raises_oob(single_idx, (((1, 1), (1, 20)), 0), \"index 20\", axis0_msg)\n+\n+ multi_idx = lambda x, i: x[i[0], :, i[1]]\n+ raises_oob(multi_idx, (0, 9), \"index 9\", axis2_msg)\n+ # TODO(lenamartens): numpy reports index -5 here, need to normalize?\n+ raises_oob(multi_idx, (-5, 9), \"index -3\", axis0_msg)\n+ raises_oob(multi_idx, (5, -9), \"index 5\", axis0_msg)\n+ raises_oob(multi_idx, ((0, 9), 0), \"index 9\", axis0_msg)\n@parameterized.named_parameters(jtu.cases_from_list(\n{\"testcase_name\": \"_jit={}\".format(jit), \"jit\": jit}\n@@ -598,6 +607,17 @@ class CheckifyTransformTests(jtu.JaxTestCase):\nself.assertIn(\"index 5\", errs.get())\nself.assertIn(\"index 100\", errs.get())\n+ def test_mapped_error_one_payload(self):\n+ def f(x, i):\n+ x = x[i]\n+ return x/0\n+\n+ cf = checkify.checkify(f, errors=checkify.automatic_checks)\n+ errs, _ = jax.vmap(cf)(jnp.ones((2, 1)), jnp.array([0, 100]))\n+ self.assertIsNotNone(errs.get())\n+ self.assertIn(\"divided by zero\", errs.get())\n+ self.assertIn(\"index 100\", errs.get())\n+\nclass AssertPrimitiveTests(jtu.JaxTestCase):\n"
}
] | Python | Apache License 2.0 | google/jax | Checkify: add axis and axis size to OOB error message. |
260,710 | 28.03.2022 21:33:40 | -32,400 | a7fd751acf760024412a8a6417c5db43fa2d269a | Add istft to jax.scipy.signal. | [
{
"change_type": "MODIFY",
"old_path": "docs/jax.scipy.rst",
"new_path": "docs/jax.scipy.rst",
"diff": "@@ -79,6 +79,7 @@ jax.scipy.signal\ncorrelate\ncorrelate2d\ncsd\n+ istft\nstft\nwelch\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/scipy/signal.py",
"new_path": "jax/_src/scipy/signal.py",
"diff": "@@ -492,3 +492,138 @@ def welch(x, fs=1.0, window='hann', nperseg=None, noverlap=None, nfft=None,\naxis=axis, average=average)\nreturn freqs, Pxx.real\n+\n+\n+def _overlap_and_add(x, step_size):\n+ \"\"\"Utility function compatible with tf.signal.overlap_and_add.\n+\n+ Args:\n+ x: An array with `(..., frames, frame_length)`-shape.\n+ step_size: An integer denoting overlap offsets. Must be less than\n+ `frame_length`.\n+\n+ Returns:\n+ An array with `(..., output_size)`-shape containing overlapped signal.\n+ \"\"\"\n+ _check_arraylike(\"_overlap_and_add\", x)\n+ step_size = jax.core.concrete_or_error(int, step_size,\n+ \"step_size for overlap_and_add\")\n+ if x.ndim < 2:\n+ raise ValueError('Input must have (..., frames, frame_length) shape.')\n+\n+ *batch_shape, nframes, segment_len = x.shape\n+ flat_batchsize = np.prod(batch_shape, dtype=np.int64)\n+ x = x.reshape((flat_batchsize, nframes, segment_len))\n+ output_size = step_size * (nframes - 1) + segment_len\n+ nstep_per_segment = 1 + (segment_len - 1) // step_size\n+\n+ # Here, we use shorter notation for axes.\n+ # B: batch_size, N: nframes, S: nstep_per_segment,\n+ # T: segment_len divided by S\n+\n+ padded_segment_len = nstep_per_segment * step_size\n+ x = jnp.pad(x, ((0, 0), (0, 0), (0, padded_segment_len - segment_len)))\n+ x = x.reshape((flat_batchsize, nframes, nstep_per_segment, step_size))\n+\n+ # For obtaining shifted signals, this routine reinterprets flattened array\n+ # with a shrinked axis. With appropriate truncation/ padding, this operation\n+ # pushes the last padded elements of the previous row to the head of the\n+ # current row.\n+ # See implementation of `overlap_and_add` in Tensorflow for details.\n+ x = x.transpose((0, 2, 1, 3)) # x: (B, S, N, T)\n+ x = jnp.pad(x, ((0, 0), (0, 0), (0, nframes), (0, 0))) # x: (B, S, N*2, T)\n+ shrinked = x.shape[2] - 1\n+ x = x.reshape((flat_batchsize, -1))\n+ x = x[:, :(nstep_per_segment * shrinked * step_size)]\n+ x = x.reshape((flat_batchsize, nstep_per_segment, shrinked * step_size))\n+\n+ # Finally, sum shifted segments, and truncate results to the output_size.\n+ x = x.sum(axis=1)[:, :output_size]\n+ return x.reshape(tuple(batch_shape) + (-1,))\n+\n+\n+@_wraps(osp_signal.istft)\n+def istft(Zxx, fs=1.0, window='hann', nperseg=None, noverlap=None, nfft=None,\n+ input_onesided=True, boundary=True, time_axis=-1, freq_axis=-2):\n+ # Input validation\n+ _check_arraylike(\"istft\", Zxx)\n+ if Zxx.ndim < 2:\n+ raise ValueError('Input stft must be at least 2d!')\n+ freq_axis = canonicalize_axis(freq_axis, Zxx.ndim)\n+ time_axis = canonicalize_axis(time_axis, Zxx.ndim)\n+ if freq_axis == time_axis:\n+ raise ValueError('Must specify differing time and frequency axes!')\n+\n+ Zxx = jnp.asarray(Zxx, dtype=jax.dtypes.canonicalize_dtype(\n+ np.result_type(Zxx, np.complex64)))\n+\n+ n_default = (2 * (Zxx.shape[freq_axis] - 1) if input_onesided\n+ else Zxx.shape[freq_axis])\n+\n+ nperseg = jax.core.concrete_or_error(int, nperseg or n_default,\n+ \"nperseg: segment length of STFT\")\n+ if nperseg < 1:\n+ raise ValueError('nperseg must be a positive integer')\n+\n+ if nfft is None:\n+ nfft = n_default\n+ if input_onesided and nperseg == n_default + 1:\n+ nfft += 1 # Odd nperseg, no FFT padding\n+ else:\n+ nfft = jax.core.concrete_or_error(int, nfft, \"nfft of STFT\")\n+ if nfft < nperseg:\n+ raise ValueError(\n+ f'FFT length ({nfft}) must be longer than nperseg ({nperseg}).')\n+\n+ noverlap = jax.core.concrete_or_error(int, noverlap or nperseg // 2,\n+ \"noverlap of STFT\")\n+ if noverlap >= nperseg:\n+ raise ValueError('noverlap must be less than nperseg.')\n+ nstep = nperseg - noverlap\n+\n+ # Rearrange axes if necessary\n+ if time_axis != Zxx.ndim - 1 or freq_axis != Zxx.ndim - 2:\n+ outer_idxs = tuple(\n+ idx for idx in range(Zxx.ndim) if idx not in {time_axis, freq_axis})\n+ Zxx = jnp.transpose(Zxx, outer_idxs + (freq_axis, time_axis))\n+\n+ # Perform IFFT\n+ ifunc = jax.numpy.fft.irfft if input_onesided else jax.numpy.fft.ifft\n+ # xsubs: [..., T, N], N is the number of frames, T is the frame length.\n+ xsubs = ifunc(Zxx, axis=-2, n=nfft)[..., :nperseg, :]\n+\n+ # Get window as array\n+ if isinstance(window, (str, tuple)):\n+ win = osp_signal.get_window(window, nperseg)\n+ win = jnp.asarray(win)\n+ else:\n+ win = jnp.asarray(window)\n+ if len(win.shape) != 1:\n+ raise ValueError('window must be 1-D')\n+ if win.shape[0] != nperseg:\n+ raise ValueError('window must have length of {0}'.format(nperseg))\n+ win = win.astype(xsubs.dtype)\n+\n+ xsubs *= win.sum() # This takes care of the 'spectrum' scaling\n+\n+ # make win broadcastable over xsubs\n+ win = win.reshape((1, ) * (xsubs.ndim - 2) + win.shape + (1,))\n+ x = _overlap_and_add((xsubs * win).swapaxes(-2, -1), nstep)\n+ win_squared = jnp.repeat((win * win), xsubs.shape[-1], axis=-1)\n+ norm = _overlap_and_add(win_squared.swapaxes(-2, -1), nstep)\n+\n+ # Remove extension points\n+ if boundary:\n+ x = x[..., nperseg//2:-(nperseg//2)]\n+ norm = norm[..., nperseg//2:-(nperseg//2)]\n+ x /= jnp.where(norm > 1e-10, norm, 1.0)\n+\n+ # Put axes back\n+ if x.ndim > 1:\n+ if time_axis != Zxx.ndim - 1:\n+ if freq_axis < time_axis:\n+ time_axis -= 1\n+ x = jnp.moveaxis(x, -1, time_axis)\n+\n+ time = jnp.arange(x.shape[0]) / fs\n+ return time, x\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/scipy/signal.py",
"new_path": "jax/scipy/signal.py",
"diff": "@@ -21,6 +21,7 @@ from jax._src.scipy.signal import (\ncorrelate2d as correlate2d,\ndetrend as detrend,\ncsd as csd,\n+ istft as istft,\nstft as stft,\nwelch as welch,\n)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/scipy_signal_test.py",
"new_path": "tests/scipy_signal_test.py",
"diff": "from functools import partial\nimport unittest\n+import warnings\nfrom absl.testing import absltest, parameterized\n@@ -47,6 +48,12 @@ csd_test_shapes = [\n((3, 17, 2), (3, 12, 2), 9, 3, 1),\n]\nwelch_test_shapes = stft_test_shapes\n+istft_test_shapes = [\n+ # (input_shape, nperseg, noverlap, timeaxis, freqaxis)\n+ ((3, 2, 64, 31), 100, 75, -1, -2),\n+ ((17, 8, 5), 13, 7, 0, 1),\n+ ((65, 24), 24, 7, -2, -1),\n+]\ndefault_dtypes = jtu.dtypes.floating + jtu.dtypes.integer + jtu.dtypes.complex\n@@ -376,6 +383,63 @@ class LaxBackedScipySignalTests(jtu.JaxTestCase):\nself._CheckAgainstNumpy(osp_fun, jsp_fun, args_maker, rtol=tol, atol=tol)\nself._CompileAndCheck(jsp_fun, args_maker, rtol=tol, atol=tol)\n+ @parameterized.named_parameters(jtu.cases_from_list(\n+ {\"testcase_name\":\n+ f\"_shape={jtu.format_shape_dtype_string(shape, dtype)}\"\n+ f\"_fs={fs}_window={window}_boundary={boundary}\"\n+ f\"_nperseg={nperseg}_noverlap={noverlap}_onesided={onesided}\"\n+ f\"_timeaxis={timeaxis}_freqaxis{freqaxis}_nfft={nfft}\",\n+ \"shape\": shape, \"dtype\": dtype, \"fs\": fs, \"window\": window,\n+ \"nperseg\": nperseg, \"noverlap\": noverlap, \"nfft\": nfft,\n+ \"onesided\": onesided, \"boundary\": boundary,\n+ \"timeaxis\": timeaxis, \"freqaxis\": freqaxis}\n+ for shape, nperseg, noverlap, timeaxis, freqaxis in istft_test_shapes\n+ for dtype in default_dtypes\n+ for fs in [1.0, 16000.0]\n+ for window in ['boxcar', 'triang', 'blackman', 'hamming', 'hann']\n+ for nfft in [None, nperseg, int(nperseg * 1.5), nperseg * 2]\n+ for onesided in [False, True]\n+ for boundary in [False, True]))\n+ @jtu.skip_on_devices(\"rocm\") # will be fixed in ROCm 5.1\n+ def testIstftAgainstNumpy(self, *, shape, dtype, fs, window, nperseg,\n+ noverlap, nfft, onesided, boundary,\n+ timeaxis, freqaxis):\n+ if not onesided:\n+ new_freq_len = (shape[freqaxis] - 1) * 2\n+ shape = shape[:freqaxis] + (new_freq_len ,) + shape[freqaxis + 1:]\n+\n+ def osp_fun(x, fs):\n+ # Ignore UserWarning in osp so we can also test over ill-posed cases.\n+ with warnings.catch_warnings():\n+ warnings.simplefilter(\"ignore\")\n+ result = osp_signal.istft(\n+ x,\n+ fs=fs, window=window, nperseg=nperseg, noverlap=noverlap,\n+ nfft=nfft, input_onesided=onesided, boundary=boundary,\n+ time_axis=timeaxis, freq_axis=freqaxis)\n+ return result\n+\n+ jsp_fun = partial(jsp_signal.istft,\n+ window=window, nperseg=nperseg, noverlap=noverlap, nfft=nfft,\n+ input_onesided=onesided, boundary=boundary,\n+ time_axis=timeaxis, freq_axis=freqaxis)\n+\n+ tol = {\n+ np.float32: 1e-4, np.float64: 1e-6,\n+ np.complex64: 1e-4, np.complex128: 1e-6\n+ }\n+ if jtu.device_under_test() == 'tpu':\n+ tol = _TPU_FFT_TOL\n+\n+ rng = jtu.rand_default(self.rng())\n+ rng_fs = jtu.rand_uniform(self.rng(), 1.0, 16000.0)\n+ args_maker = lambda: [rng(shape, dtype), rng_fs((), np.float)]\n+\n+ # Here, dtype of output signal is different depending on osp versions,\n+ # and so depending on the test environment. Thus, dtype check is disabled.\n+ self._CheckAgainstNumpy(osp_fun, jsp_fun, args_maker, rtol=tol, atol=tol,\n+ check_dtypes=False)\n+ self._CompileAndCheck(jsp_fun, args_maker, rtol=tol, atol=tol)\nif __name__ == \"__main__\":\nabsltest.main(testLoader=jtu.JaxTestLoader())\n"
}
] | Python | Apache License 2.0 | google/jax | Add istft to jax.scipy.signal. |
260,510 | 01.04.2022 12:39:56 | 25,200 | aac8ec8649be69b7bbbe925c23985f74b6d1355f | Fixes `jax2tf`'s `test_name_scope` to use graph introspection instead of
side-effect | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/tests/jax2tf_test.py",
"new_path": "jax/experimental/jax2tf/tests/jax2tf_test.py",
"diff": "@@ -786,19 +786,24 @@ class Jax2TfTest(tf_test_util.JaxToTfTestCase):\nself.TransformConvertAndCompare(outer, np.ones((4,)), transform)\ndef test_name_scope(self):\n- log = []\n-\n+ @tf.function(autograph=False)\n+ def run():\n@jax.named_call\ndef my_test_function(x):\n- y = tf.Variable(1., name=\"foo\")\n- log.append(y.name)\nreturn x * x\ndef caller(x):\nreturn my_test_function(jnp.sin(x))\n- jax2tf.convert(caller)(2.)\n- self.assertIn(\"my_test_function/foo\", log[0])\n+ out = jax2tf.convert(caller, with_gradient=False)(2.)\n+ # When we use `with_gradient=False` the raw output of `caller` is passed\n+ # through a `tf.raw_ops.PreventGradient` and a `tf.identity`, clobbering\n+ # the name scope of the `mul` op. We need to get the grandparent of the\n+ # `out` tensor to see the name scope of the result of the `mul`.\n+ grandparent_op = out.op.inputs[0].op.inputs[0]\n+ self.assertIn(\"my_test_function\", grandparent_op.name)\n+ return out\n+ run()\ndef test_bfloat16_constant(self):\n# Re: https://github.com/google/jax/issues/3942\n"
}
] | Python | Apache License 2.0 | google/jax | Fixes `jax2tf`'s `test_name_scope` to use graph introspection instead of
side-effect |
260,335 | 03.04.2022 11:17:57 | 25,200 | c72d8f6b09a5a50978c71289c964f27d1cffa270 | remove string annotations from core.py | [
{
"change_type": "MODIFY",
"old_path": "jax/core.py",
"new_path": "jax/core.py",
"diff": "# 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+from __future__ import annotations\nimport collections\nfrom collections import namedtuple\n@@ -55,13 +55,13 @@ map, unsafe_map = safe_map, map\n# -------------------- jaxprs --------------------\nclass Jaxpr:\n- constvars: List['Var']\n- invars: List['Var']\n- outvars: List['Atom']\n- eqns: List['JaxprEqn']\n+ constvars: List[Var]\n+ invars: List[Var]\n+ outvars: List[Atom]\n+ eqns: List[JaxprEqn]\n- def __init__(self, constvars: Sequence['Var'], invars: Sequence['Var'],\n- outvars: Sequence['Atom'], eqns: Sequence['JaxprEqn']):\n+ def __init__(self, constvars: Sequence[Var], invars: Sequence[Var],\n+ outvars: Sequence[Atom], eqns: Sequence[JaxprEqn]):\n\"\"\"\nArgs:\nconstvars: list of variables introduced for constants. Array constants are\n@@ -114,7 +114,7 @@ def subjaxprs(jaxpr: Jaxpr) -> Iterator[Jaxpr]:\nclass ClosedJaxpr:\njaxpr: Jaxpr\n- consts: List['Any']\n+ consts: List[Any]\ndef __init__(self, jaxpr: Jaxpr, consts: Sequence):\nassert len(consts) == len(jaxpr.constvars)\n@@ -160,9 +160,9 @@ def jaxpr_as_fun(closed_jaxpr: ClosedJaxpr, *args):\nclass JaxprEqn(NamedTuple):\n- invars: List['Atom']\n- outvars: List['Var']\n- primitive: 'Primitive'\n+ invars: List[Atom]\n+ outvars: List[Var]\n+ primitive: Primitive\nparams: Dict[str, Any]\nsource_info: source_info_util.SourceInfo\n@@ -182,9 +182,9 @@ class Var:\n# by object id, but pretty printing might collide.\ncount: int\nsuffix: str\n- aval: 'AbstractValue'\n+ aval: AbstractValue\n- def __init__(self, count: int, suffix: str, aval: 'AbstractValue'):\n+ def __init__(self, count: int, suffix: str, aval: AbstractValue):\nself.count = count\nself.suffix = suffix\nself.aval = raise_to_shaped(aval)\n@@ -213,7 +213,7 @@ def _jaxpr_vars(jaxpr):\n(v for eqn in jaxpr.eqns for v in eqn.outvars))\ndef gensym(jaxprs: Optional[Sequence[Jaxpr]] = None,\n- suffix: str = '') -> Callable[['AbstractValue'], Var]:\n+ suffix: str = '') -> Callable[[AbstractValue], Var]:\n\"\"\"Produce distinct variables, printed with the optional suffix.\nIf `jaxprs` is provided, the variables produced will be distinct from those in\n@@ -232,7 +232,7 @@ def gensym(jaxprs: Optional[Sequence[Jaxpr]] = None,\n# be read. In that sense, `dropvar` is not a variable, but it is convenient to\n# treat it as a special case of one. Its `aval` is similarly inexact.\nclass DropVar(Var):\n- def __init__(self, aval: 'AbstractValue'):\n+ def __init__(self, aval: AbstractValue):\nsuper().__init__(-1, '', aval)\ndef __repr__(self): return '_'\n@@ -240,7 +240,7 @@ class Literal:\n__slots__ = [\"val\", \"aval\", \"hash\"]\nval: Any\n- aval: 'AbstractValue'\n+ aval: AbstractValue\nhash: Optional[int]\ndef __init__(self, val, aval):\n@@ -358,16 +358,16 @@ def eval_jaxpr(jaxpr: Jaxpr, consts, *args):\nclass Trace:\n__slots__ = ['main', 'level', 'sublevel']\n- main: 'MainTrace'\n+ main: MainTrace\nlevel: int\n- sublevel: 'Sublevel'\n+ sublevel: Sublevel\n- def __init__(self, main: 'MainTrace', sublevel: 'Sublevel') -> None:\n+ def __init__(self, main: MainTrace, sublevel: Sublevel) -> None:\nself.main = main\nself.level = main.level\nself.sublevel = sublevel\n- def full_raise(self, val) -> 'Tracer':\n+ def full_raise(self, val) -> Tracer:\nif not isinstance(val, Tracer):\nreturn self.pure(val)\nval._assert_live()\n@@ -960,10 +960,10 @@ class AbstractValue:\nexcept AttributeError:\nreturn self.__class__.__name__\n- def strip_weak_type(self) -> 'AbstractValue':\n+ def strip_weak_type(self) -> AbstractValue:\nreturn self\n- def strip_named_shape(self) -> 'AbstractValue':\n+ def strip_named_shape(self) -> AbstractValue:\nreturn self\ndef join(self, other):\n@@ -1167,7 +1167,7 @@ AxisSize = Union[AxisSizeForTracing, AxisSizeForJaxprType,\nclass DShapedArray(UnshapedArray):\n__slots__ = ['shape']\n- shape: Tuple[AxisSize, ...] # see comment above\n+ shape: Tuple[AxisSize, ...] # noqa: F821\narray_abstraction_level = 2\ndef __init__(self, shape, dtype, weak_type):\n@@ -1813,7 +1813,7 @@ class MapPrimitive(Primitive):\nnew_params['out_axes_thunk'] = HashableFunction(lambda: axes, closure=axes)\nreturn [subfun], new_params\n-def map_bind(primitive: 'MapPrimitive', fun, *args, out_axes_thunk, **params):\n+def map_bind(primitive: MapPrimitive, fun, *args, out_axes_thunk, **params):\n# The new thunk depends deterministically on the old thunk and the wrapped\n# function. Any caching already has to include the wrapped function as part\n# of the key, so we only use the previous thunk for equality checks.\n@@ -2134,7 +2134,7 @@ def check_jaxpr(jaxpr: Jaxpr):\nraise JaxprTypeError(msg) from None\ndef _check_jaxpr(\n- ctx_factory: Callable[[], Tuple['JaxprPpContext', 'JaxprPpSettings']],\n+ ctx_factory: Callable[[], Tuple[JaxprPpContext, JaxprPpSettings]],\njaxpr: Jaxpr,\nin_avals: Sequence[AbstractValue]) -> None:\n"
}
] | Python | Apache License 2.0 | google/jax | remove string annotations from core.py |
260,346 | 04.04.2022 23:38:51 | -7,200 | f7b749c99c07fe958f7d22cd8a02ff7aeaaa0eee | Explicit doc note about device_put* async | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/api.py",
"new_path": "jax/_src/api.py",
"diff": "@@ -2657,6 +2657,8 @@ def device_put(x, device: Optional[xc.Device] = None):\nFor more details on data placement see the\n:ref:`FAQ on data placement <faq-data-placement>`.\n+ This function is always asynchronous, i.e. returns immediately.\n+\nReturns:\nA copy of ``x`` that resides on ``device``.\n\"\"\"\n@@ -2674,6 +2676,8 @@ def device_put_sharded(shards: Sequence[Any], devices: Sequence[xc.Device]):\ndevices: A sequence of :py:class:`Device` instances representing the devices\nto which corresponding shards in ``shards`` will be transferred.\n+ This function is always asynchronous, i.e. returns immediately.\n+\nReturns:\nA ShardedDeviceArray or (nested) Python container thereof representing the\nelements of ``shards`` stacked together, with each shard backed by physical\n@@ -2743,6 +2747,8 @@ def device_put_replicated(x: Any, devices: Sequence[xc.Device]):\ndevices: A sequence of :py:class:`Device` instances representing the devices\nto which ``x`` will be transferred.\n+ This function is always asynchronous, i.e. returns immediately.\n+\nReturns:\nA ShardedDeviceArray or (nested) Python container thereof representing the\nvalue of ``x`` broadcasted along a new leading axis of size\n"
}
] | Python | Apache License 2.0 | google/jax | Explicit doc note about device_put* async |
260,510 | 05.04.2022 12:42:43 | 25,200 | d72a7b405419a8b05ba1d00c749f689dc9bba4ed | Add version int tuple `__version_info__` to JAX | [
{
"change_type": "MODIFY",
"old_path": "jax/__init__.py",
"new_path": "jax/__init__.py",
"diff": "@@ -123,6 +123,7 @@ from jax._src.api import (\n)\nfrom jax.experimental.maps import soft_pmap as soft_pmap\nfrom jax.version import __version__ as __version__\n+from jax.version import __version_info__ as __version_info__\n# These submodules are separate because they are in an import cycle with\n# jax and rely on the names imported above.\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/version.py",
"new_path": "jax/version.py",
"diff": "# See the License for the specific language governing permissions and\n# limitations under the License.\n+def _version_as_tuple(version_str):\n+ return tuple(int(i) for i in version_str.split(\".\") if i.isdigit())\n+\n__version__ = \"0.3.5\"\n+__version_info__ = _version_as_tuple(__version__)\n_minimum_jaxlib_version = \"0.3.0\"\n+_minimum_jaxlib_version_info = _version_as_tuple(_minimum_jaxlib_version)\n"
}
] | Python | Apache License 2.0 | google/jax | Add version int tuple `__version_info__` to JAX |
260,475 | 27.03.2022 12:31:12 | -3,600 | 869596fc2c249807504f9dae61b472a755f536c6 | Add jax.scipy.linalg.rsf2csf | [
{
"change_type": "MODIFY",
"old_path": "CHANGELOG.md",
"new_path": "CHANGELOG.md",
"diff": "@@ -18,6 +18,7 @@ PLEASE REMEMBER TO CHANGE THE '..main' WITH AN ACTUAL TAG in GITHUB LINK.\n* added array creation routines {func}`jax.numpy.frombuffer`, {func}`jax.numpy.fromfunction`,\nand {func}`jax.numpy.fromstring` ({jax-issue}`#10049`).\n* `DeviceArray.copy()` now returns a `DeviceArray` rather than a `np.ndarray` ({jax-issue}`#10069`)\n+ * added {func}`jax.scipy.linalg.rsf2csf`\n* Deprecations:\n* {func}`jax.nn.normalize` is being deprecated. Use {func}`jax.nn.standardize` instead ({jax-issue}`#9899`).\n* {func}`jax.tree_util.tree_multimap` is deprecated. Use {func}`jax.tree_util.tree_map` instead ({jax-issue}`#5746`).\n"
},
{
"change_type": "MODIFY",
"old_path": "docs/jax.scipy.rst",
"new_path": "docs/jax.scipy.rst",
"diff": "@@ -36,6 +36,7 @@ jax.scipy.linalg\npolar\npolar_unitary\nqr\n+ rsf2csf\nschur\nsqrtm\nsolve\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/scipy/linalg.py",
"new_path": "jax/_src/scipy/linalg.py",
"diff": "@@ -656,3 +656,70 @@ def sqrtm(A, blocksize=1):\nif blocksize > 1:\nraise NotImplementedError(\"Blocked version is not implemented yet.\")\nreturn _sqrtm(A)\n+\n+_no_asarray_chkfinite_doc = textwrap.dedent(\"\"\"\n+Does not currently support the Scipy argument ``jax.numpy.asarray_chkfinite``,\n+because `jax.numpy.asarray_chkfinite` does not exist at the moment.\n+\"\"\")\n+\n+@_wraps(scipy.linalg.rsf2csf, lax_description=_no_asarray_chkfinite_doc)\n+@partial(jit, static_argnames=('check_finite',))\n+def rsf2csf(T, Z, check_finite=True):\n+ T = jnp.asarray(T)\n+ Z = jnp.asarray(Z)\n+\n+ for ind, X in enumerate([Z, T]):\n+ if X.ndim != 2 or X.shape[0] != X.shape[1]:\n+ arg = 'ZT'[ind]\n+ raise ValueError(f\"Input '{arg}' must be square.\")\n+ if T.shape[0] != Z.shape[0]:\n+ raise ValueError(f\"Input array shapes must match: Z: {Z.shape} vs. T: {T.shape}\")\n+\n+ common_dtype = jnp.result_type(T, Z, jnp.complex64)\n+ eps = jnp.finfo(common_dtype).eps\n+\n+ T = jnp.asarray(T, dtype=common_dtype)\n+ Z = jnp.asarray(Z, dtype=common_dtype)\n+ N = T.shape[0]\n+\n+ if N == 1:\n+ return T, Z\n+\n+ def _update_T_Z(m, T, Z):\n+ mu = np_linalg.eigvals(lax.dynamic_slice(T, (m-1, m-1), (2, 2))) - T[m, m]\n+ r = np_linalg.norm([mu[0], T[m, m-1]])\n+ c = mu[0] / r\n+ s = T[m, m-1] / r\n+ G = jnp.array([[c.conj(), s], [-s, c]], dtype=common_dtype)\n+\n+ # T[m-1:m+1, m-1:] = G @ T[m-1:m+1, m-1:]\n+ T_rows = lax.dynamic_slice_in_dim(T, m-1, 2, axis=0)\n+ col_mask = jnp.arange(N) >= m-1\n+ G_dot_T_zeroed_cols = G @ jnp.where(col_mask, T_rows, 0)\n+ T_rows_new = jnp.where(~col_mask, T_rows, G_dot_T_zeroed_cols)\n+ T = lax.dynamic_update_slice_in_dim(T, T_rows_new, m-1, axis=0)\n+\n+ # T[:m+1, m-1:m+1] = T[:m+1, m-1:m+1] @ G.conj().T\n+ T_cols = lax.dynamic_slice_in_dim(T, m-1, 2, axis=1)\n+ row_mask = jnp.arange(N)[:, jnp.newaxis] < m+1\n+ T_zeroed_rows_dot_GH = jnp.where(row_mask, T_cols, 0) @ G.conj().T\n+ T_cols_new = jnp.where(~row_mask, T_cols, T_zeroed_rows_dot_GH)\n+ T = lax.dynamic_update_slice_in_dim(T, T_cols_new, m-1, axis=1)\n+\n+ # Z[:, m-1:m+1] = Z[:, m-1:m+1] @ G.conj().T\n+ Z_cols = lax.dynamic_slice_in_dim(Z, m-1, 2, axis=1)\n+ Z = lax.dynamic_update_slice_in_dim(Z, Z_cols @ G.conj().T, m-1, axis=1)\n+ return T, Z\n+\n+ def _rsf2scf_iter(i, TZ):\n+ m = N-i\n+ T, Z = TZ\n+ T, Z = lax.cond(\n+ jnp.abs(T[m, m-1]) > eps*(jnp.abs(T[m-1, m-1]) + jnp.abs(T[m, m])),\n+ _update_T_Z,\n+ lambda m, T, Z: (T, Z),\n+ m, T, Z)\n+ T = T.at[m, m-1].set(0.0)\n+ return T, Z\n+\n+ return lax.fori_loop(1, N, _rsf2scf_iter, (T, Z))\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/scipy/linalg.py",
"new_path": "jax/scipy/linalg.py",
"diff": "@@ -30,6 +30,7 @@ from jax._src.scipy.linalg import (\nlu_solve as lu_solve,\npolar as polar,\nqr as qr,\n+ rsf2csf as rsf2csf,\nschur as schur,\nsqrtm as sqrtm,\nsolve as solve,\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/linalg_test.py",
"new_path": "tests/linalg_test.py",
"diff": "@@ -1390,6 +1390,25 @@ class ScipyLinalgTest(jtu.JaxTestCase):\nself._CheckAgainstNumpy(osp.linalg.schur, jsp.linalg.schur, args_maker)\nself._CompileAndCheck(jsp.linalg.schur, args_maker)\n+ @parameterized.named_parameters(\n+ jtu.cases_from_list({\n+ \"testcase_name\":\n+ \"_shape={}\".format(jtu.format_shape_dtype_string(shape, dtype)),\n+ \"shape\": shape, \"dtype\": dtype\n+ } for shape in [(1, 1), (4, 4), (15, 15), (50, 50), (100, 100)]\n+ for dtype in float_types + complex_types))\n+ @jtu.skip_on_devices(\"gpu\", \"tpu\")\n+ def testRsf2csf(self, shape, dtype):\n+ rng = jtu.rand_default(self.rng())\n+ args_maker = lambda: [rng(shape, dtype), rng(shape, dtype)]\n+ if shape[0] >= 50:\n+ tol = 1e-5\n+ else:\n+ tol = 1e-6\n+ self._CheckAgainstNumpy(osp.linalg.rsf2csf, jsp.linalg.rsf2csf,\n+ args_maker, tol=tol)\n+ self._CompileAndCheck(jsp.linalg.rsf2csf, args_maker)\n+\n@parameterized.named_parameters(\njtu.cases_from_list({\n\"testcase_name\":\n"
}
] | Python | Apache License 2.0 | google/jax | Add jax.scipy.linalg.rsf2csf |
260,631 | 07.04.2022 08:33:10 | 25,200 | b713d3ce4b58e3cf62e43a0d09ee4bda736ecb54 | Minor change to lax to support jax2tf shape polymorphic concatenation. | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/lax.py",
"new_path": "jax/_src/lax/lax.py",
"diff": "@@ -2860,11 +2860,15 @@ def _concatenate_transpose_rule(t, *operands, dimension):\nreturn [ad_util.Zero(o.aval) if ad.is_undefined_primal(o) else None\nfor o in operands]\nelse:\n- limit_points = np.cumsum([shape[dimension] for shape in operand_shapes])\n- starts = np.zeros((len(operands), t.ndim), dtype=int)\n- starts[1:, dimension] = limit_points[:-1]\n- limits = np.tile(t.shape, (len(operands), 1))\n- limits[:, dimension] = limit_points\n+ limit_points = np.cumsum(\n+ [shape[dimension] for shape in operand_shapes]).tolist()\n+ starts = np.zeros((len(operands), t.ndim), dtype=int).tolist()\n+ limits = np.tile(t.shape, (len(operands), 1)).tolist()\n+\n+ for i, s in enumerate(starts[1:]):\n+ s[dimension] = limit_points[:-1][i]\n+ for i, l in enumerate(limits):\n+ l[dimension] = limit_points[i]\nreturn [slicing.slice(t, start, limit) if ad.is_undefined_primal(o)\nelse None for o, start, limit in zip(operands, starts, limits)]\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/tests/shape_poly_test.py",
"new_path": "jax/experimental/jax2tf/tests/shape_poly_test.py",
"diff": "@@ -1257,6 +1257,14 @@ _POLY_SHAPE_TEST_HARNESSES = [\nlambda x: lax.collapse(x, 1, 4),\n[RandArg((3, 4, 5, 6, 7), _f32)],\npoly_axes=[(0, 1, 3)]),\n+ _make_harness(\"concatenate\", \"\",\n+ lambda x: jnp.concatenate([x, x], axis=0),\n+ [RandArg((3, 4, 5), _f32)],\n+ poly_axes=[(0, 1)]),\n+ _make_harness(\"concatenate\", \"grad\",\n+ jax.grad(lambda x: jnp.sum(jnp.concatenate([x, x], axis=0))),\n+ [RandArg((3, 4, 5), _f32)],\n+ poly_axes=[(0, 1)]),\n_make_harness(\"conv_general_dilated\", \"\",\nlambda lhs, rhs: lax.conv_general_dilated(lhs, rhs,\nwindow_strides=(2, 3),\n"
}
] | Python | Apache License 2.0 | google/jax | Minor change to lax to support jax2tf shape polymorphic concatenation.
PiperOrigin-RevId: 440113799 |
260,631 | 07.04.2022 09:03:05 | 25,200 | 02fd8752bdac5271c7c5c8d9861ad093a6ddfdfb | Add __init__ to PolyShape. | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/shape_poly.py",
"new_path": "jax/experimental/jax2tf/shape_poly.py",
"diff": "@@ -518,8 +518,12 @@ class PolyShape(tuple):\nSee docstring of :func:`jax2tf.convert`.\n\"\"\"\n+\n+ def __init__(self, *dim_specs):\n+ tuple.__init__(dim_specs)\n+\ndef __new__(cls, *dim_specs):\n- for i, ds in enumerate(dim_specs):\n+ for ds in dim_specs:\nif not isinstance(ds, (int, str)) and ds != ...:\nmsg = (f\"Invalid polymorphic shape element: {repr(ds)}; must be a string \"\n\"representing a dimension variable, or an integer, or ...\")\n"
}
] | Python | Apache License 2.0 | google/jax | Add __init__ to PolyShape.
PiperOrigin-RevId: 440120323 |
260,424 | 07.04.2022 09:18:48 | 25,200 | 5522ed1702de3e806ecb41b7adc00f9841e27a62 | jax2tf: Support uint32 keys in rng_bit_generator.
This follows the rng_bit_generator_translation rule in JAX, which allows for
both uint32 and uint64 keys and casts between them. The default rbg prng
implementation in JAX uses a (4,) uint32 key. | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/jax2tf.py",
"new_path": "jax/experimental/jax2tf/jax2tf.py",
"diff": "@@ -2078,6 +2078,10 @@ tf_impl_with_avals[random.random_gamma_p] = _convert_jax_impl(\ndef _rng_bit_generator(key: TfVal, *, shape, dtype, algorithm) -> Sequence[TfVal]:\n+ is_uint32_key = key.dtype == _to_tf_dtype(jnp.uint32)\n+ if is_uint32_key:\n+ key = tf.reshape(key, (2, 2))\n+ key = tfxla.bitcast_convert_type(key, _to_tf_dtype(jnp.uint64))\nshape_tf = _eval_shape(shape)\n# JAX uses XLA algorithm enums; tfxla uses tf.random.Algorithm\nif algorithm == lax.RandomAlgorithm.RNG_THREE_FRY:\n@@ -2088,11 +2092,16 @@ def _rng_bit_generator(key: TfVal, *, shape, dtype, algorithm) -> Sequence[TfVal\nalgorithm_tf = tf.random.Algorithm.AUTO_SELECT\nelse:\nassert False\n- outs = tfxla.rng_bit_generator(algorithm_tf.value, key, shape_tf,\n+ (new_key, res) = tfxla.rng_bit_generator(algorithm_tf.value, key, shape_tf,\ndtype=_to_tf_dtype(dtype))\n+ if is_uint32_key:\n+ new_key = tfxla.bitcast_convert_type(new_key, _to_tf_dtype(jnp.uint32))\n+ new_key = tf.reshape(new_key, (4,))\nif _WRAP_JAX_JIT_WITH_TF_FUNCTION:\n- outs = tuple(tf.stop_gradient(out) for out in outs) # See #7839\n- return outs\n+ # See #7839\n+ new_key = tf.stop_gradient(new_key)\n+ res = tf.stop_gradient(res)\n+ return new_key, res\ntf_impl[lax.rng_bit_generator_p] = _rng_bit_generator\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/tests/primitive_harness.py",
"new_path": "jax/experimental/jax2tf/tests/primitive_harness.py",
"diff": "@@ -3022,19 +3022,22 @@ for padding, lhs_dilation, rhs_dilation in [\nlhs_dilation=lhs_dilation,\nrhs_dilation=rhs_dilation)\n-\n+key_types = [((4,), np.uint32)]\nif config.jax_enable_x64:\n+ key_types.append(((2,), np.uint64))\n+\nfor algorithm in [lax.RandomAlgorithm.RNG_THREE_FRY,\nlax.RandomAlgorithm.RNG_PHILOX,\nlax.RandomAlgorithm.RNG_DEFAULT]:\nfor dtype in [np.uint32, np.uint64]:\nfor shape in [(), (5, 7), (100, 100)]:\n+ for key_shape, key_dtype in key_types:\ndefine(\nlax.rng_bit_generator_p,\n- f\"shape={jtu.format_shape_dtype_string(shape, dtype)}_algorithm={algorithm}\",\n+ f\"key_dtype={key_dtype}_shape={jtu.format_shape_dtype_string(shape, dtype)}_algorithm={algorithm}\",\nlambda key, shape, dtype, algorithm: lax.rng_bit_generator(key, shape, dtype=dtype,\nalgorithm=algorithm),\n- [RandArg((2,), np.uint64),\n+ [RandArg(key_shape, key_dtype),\nStaticArg(shape), StaticArg(dtype), StaticArg(algorithm)],\nshape=shape,\ndtype=dtype,\n"
}
] | Python | Apache License 2.0 | google/jax | jax2tf: Support uint32 keys in rng_bit_generator.
This follows the rng_bit_generator_translation rule in JAX, which allows for
both uint32 and uint64 keys and casts between them. The default rbg prng
implementation in JAX uses a (4,) uint32 key.
PiperOrigin-RevId: 440124048 |
260,308 | 08.04.2022 01:08:24 | 25,200 | 0c02f7935aa90d1d895f34882186e889e2b8923e | Enable tests related to the Gamma distribution for non-default PRNG implementations only when jax_enable_custom_prng is enabled, for consistency with other tests. | [
{
"change_type": "MODIFY",
"old_path": "tests/random_test.py",
"new_path": "tests/random_test.py",
"diff": "@@ -869,14 +869,12 @@ class LaxRandomTest(jtu.JaxTestCase):\nself._CheckKolmogorovSmirnovCDF(samples, scipy.stats.expon().cdf)\n@parameterized.named_parameters(jtu.cases_from_list(\n- {\"testcase_name\": \"_a={}_dtype={}_prng={}\".format(a, np.dtype(dtype).name,\n- prng_name),\n- \"a\": a, \"dtype\": dtype, \"prng_impl\": prng_impl}\n- for prng_name, prng_impl in PRNG_IMPLS\n+ {\"testcase_name\": \"_a={}_dtype={}\".format(a, np.dtype(dtype).name),\n+ \"a\": a, \"dtype\": dtype}\nfor a in [0.1, 1., 10.]\nfor dtype in jtu.dtypes.floating))\n- def testGammaVsLogGamma(self, prng_impl, a, dtype):\n- key = prng.seed_with_impl(prng_impl, 0)\n+ def testGammaVsLogGamma(self, a, dtype):\n+ key = self.seed_prng(0)\nrand_gamma = lambda key, a: random.gamma(key, a, (10000,), dtype)\nrand_loggamma = lambda key, a: random.loggamma(key, a, (10000,), dtype)\ncrand_loggamma = jax.jit(rand_loggamma)\n@@ -885,14 +883,12 @@ class LaxRandomTest(jtu.JaxTestCase):\nself.assertAllClose(rand_gamma(key, a), jnp.exp(crand_loggamma(key, a)))\n@parameterized.named_parameters(jtu.cases_from_list(\n- {\"testcase_name\": \"_a={}_dtype={}_prng={}\".format(a, np.dtype(dtype).name,\n- prng_name),\n- \"a\": a, \"dtype\": dtype, \"prng_impl\": prng_impl}\n- for prng_name, prng_impl in PRNG_IMPLS\n+ {\"testcase_name\": \"_a={}_dtype={}\".format(a, np.dtype(dtype).name),\n+ \"a\": a, \"dtype\": dtype}\nfor a in [0.1, 1., 10.]\nfor dtype in jtu.dtypes.floating))\n- def testGamma(self, prng_impl, a, dtype):\n- key = prng.seed_with_impl(prng_impl, 0)\n+ def testGamma(self, a, dtype):\n+ key = self.seed_prng(0)\nrand = lambda key, a: random.gamma(key, a, (10000,), dtype)\ncrand = jax.jit(rand)\n@@ -908,13 +904,12 @@ class LaxRandomTest(jtu.JaxTestCase):\nassert x.shape == (3, 2)\n@parameterized.named_parameters(jtu.cases_from_list(\n- {\"testcase_name\": \"_a={}_prng={}_logspace={}\".format(alpha, prng_name, log_space),\n- \"alpha\": alpha, \"log_space\": log_space, \"prng_impl\": prng_impl}\n- for prng_name, prng_impl in PRNG_IMPLS\n+ {\"testcase_name\": \"_a={}_logspace={}\".format(alpha, log_space),\n+ \"alpha\": alpha, \"log_space\": log_space}\nfor log_space in [True, False]\nfor alpha in [1e-4, 1e-3, 1e-2, 1e-1, 1e0, 1e1, 1e2, 1e3, 1e4]))\n- def testGammaGrad(self, log_space, prng_impl, alpha):\n- rng = prng.seed_with_impl(prng_impl, 0)\n+ def testGammaGrad(self, log_space, alpha):\n+ rng = self.seed_prng(0)\nalphas = np.full((100,), alpha)\nz = random.gamma(rng, alphas)\nif log_space:\n@@ -1609,18 +1604,10 @@ def _sampler_unimplemented_with_custom_prng(*args, **kwargs):\nraise SkipTest('sampler only implemented for default RNG')\nfor test_prefix in [\n- 'testBeta',\n- 'testDirichlet',\n- 'testGamma',\n- 'testGammaGrad',\n- 'testGammaGradType',\n- 'testGammaShape',\n- 'testIssue1789',\n'testPoisson',\n'testPoissonBatched',\n'testPoissonShape',\n'testPoissonZeros',\n- 'testT',\n]:\nfor attr in dir(LaxRandomTest):\nif attr.startswith(test_prefix):\n"
}
] | Python | Apache License 2.0 | google/jax | Enable tests related to the Gamma distribution for non-default PRNG implementations only when jax_enable_custom_prng is enabled, for consistency with other tests.
PiperOrigin-RevId: 440300882 |
260,631 | 08.04.2022 13:50:04 | 25,200 | 0bfb3efcd758ce5b8b404169aac74e86c0274820 | [JAX] Fix batch logic for approx_min/max_k
Previous logic was copied from lax.sort and was incorrect.
Since approx_top_k can handle multi-rank tensors, the only mapping we need
is to set the reduction_dim correctly. | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/ann.py",
"new_path": "jax/_src/lax/ann.py",
"diff": "@@ -312,28 +312,23 @@ def _approx_top_k_fallback_translation(ctx, avals_in, avals_out, operand, *, k,\nreturn sliced_vals, sliced_args\n-def _approx_top_k_batch_rule(batched_args, batch_dims, *, k,\n+def _approx_top_k_batch_rule(batch_operands, batch_axes, *, k,\nreduction_dimension, recall_target, is_max_k,\nreduction_input_size_override, aggregate_to_topk):\n- prototype_arg, new_bdim = next(\n- (a, b) for a, b in zip(batched_args, batch_dims) if b is not None)\n- new_args = []\n- for arg, bdim in zip(batched_args, batch_dims):\n- if bdim is None:\n- dims = np.delete(np.arange(prototype_arg.ndim), new_bdim)\n- new_args.append(lax.broadcast_in_dim(arg, prototype_arg.shape, dims))\n- else:\n- new_args.append(batching.moveaxis(arg, bdim, new_bdim))\n- new_reduction_dim = reduction_dimension + (new_bdim <= reduction_dimension)\n- bdims = (new_bdim,) * len(new_args)\n- return (approx_top_k_p.bind(\n- *new_args,\n+ assert len(batch_operands) == 1\n+ assert len(batch_axes) == 1\n+ operand, = batch_operands\n+ batch_axis, = batch_axes\n+ dim_map = [d for d in range(operand.ndim) if d is not batch_axis]\n+ reduction_dimension = dim_map[reduction_dimension]\n+ return approx_top_k_p.bind(\n+ operand,\nk=k,\n- reduction_dimension=new_reduction_dim,\n+ reduction_dimension=reduction_dimension,\nrecall_target=recall_target,\n- is_max_k=False,\n+ is_max_k=is_max_k,\nreduction_input_size_override=reduction_input_size_override,\n- aggregate_to_topk=aggregate_to_topk), bdims)\n+ aggregate_to_topk=aggregate_to_topk), (batch_axis, batch_axis)\n# Slow jvp implementation using gather.\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/ann_test.py",
"new_path": "tests/ann_test.py",
"diff": "@@ -174,5 +174,58 @@ class AnnTest(jtu.JaxTestCase):\nself.assertGreater(ann_recall, recall)\n+ def test_vmap_before(self):\n+ batch = 4\n+ qy_size = 128\n+ db_size = 1024\n+ feature_dim = 32\n+ k = 10\n+ rng = jtu.rand_default(self.rng())\n+ qy = rng([batch, qy_size, feature_dim], np.float32)\n+ db = rng([batch, db_size, feature_dim], np.float32)\n+ recall = 0.95\n+\n+ # Create ground truth\n+ gt_scores = lax.dot_general(qy, db, (([2], [2]), ([0], [0])))\n+ _, gt_args = lax.top_k(gt_scores, k)\n+ gt_args = lax.reshape(gt_args, [qy_size * batch, k])\n+\n+ # test target\n+ def approx_max_k(qy, db):\n+ scores = qy @ db.transpose()\n+ return lax.approx_max_k(scores, k)\n+ _, ann_args = jax.vmap(approx_max_k, (0, 0))(qy, db)\n+ ann_args = lax.reshape(ann_args, [qy_size * batch, k])\n+ ann_recall = compute_recall(np.asarray(ann_args), np.asarray(gt_args))\n+ self.assertGreater(ann_recall, recall)\n+\n+\n+ def test_vmap_after(self):\n+ batch = 4\n+ qy_size = 128\n+ db_size = 1024\n+ feature_dim = 32\n+ k = 10\n+ rng = jtu.rand_default(self.rng())\n+ qy = rng([qy_size, feature_dim, batch], np.float32)\n+ db = rng([db_size, feature_dim, batch], np.float32)\n+ recall = 0.95\n+\n+ # Create ground truth\n+ gt_scores = lax.dot_general(qy, db, (([1], [1]), ([2], [2])))\n+ _, gt_args = lax.top_k(gt_scores, k)\n+ gt_args = lax.transpose(gt_args, [2, 0, 1])\n+ gt_args = lax.reshape(gt_args, [qy_size * batch, k])\n+\n+ # test target\n+ def approx_max_k(qy, db):\n+ scores = qy @ db.transpose()\n+ return lax.approx_max_k(scores, k)\n+ _, ann_args = jax.vmap(approx_max_k, (2, 2))(qy, db)\n+ ann_args = lax.transpose(ann_args, [2, 0, 1])\n+ ann_args = lax.reshape(ann_args, [qy_size * batch, k])\n+ ann_recall = compute_recall(np.asarray(ann_args), np.asarray(gt_args))\n+ self.assertGreater(ann_recall, recall)\n+\nif __name__ == \"__main__\":\nabsltest.main(testLoader=jtu.JaxTestLoader())\n"
}
] | Python | Apache License 2.0 | google/jax | [JAX] Fix batch logic for approx_min/max_k
Previous logic was copied from lax.sort and was incorrect.
Since approx_top_k can handle multi-rank tensors, the only mapping we need
is to set the reduction_dim correctly.
PiperOrigin-RevId: 440445041 |
260,447 | 09.04.2022 08:33:20 | 25,200 | a11b41f5810d98d65a4e1e2ab3ba4a5e1e1a0687 | [sparse] Use sorted indices instead of sorted rows only. | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/sparse/coo.py",
"new_path": "jax/experimental/sparse/coo.py",
"diff": "@@ -57,7 +57,8 @@ class COO(JAXSparse):\nnse = property(lambda self: self.data.size)\ndtype = property(lambda self: self.data.dtype)\n_info = property(lambda self: COOInfo(\n- shape=self.shape, rows_sorted=self._rows_sorted, cols_sorted=self._cols_sorted))\n+ shape=self.shape, rows_sorted=self._rows_sorted,\n+ cols_sorted=self._cols_sorted))\n_bufs = property(lambda self: (self.data, self.row, self.col))\n_rows_sorted: bool\n_cols_sorted: bool\n@@ -72,16 +73,18 @@ class COO(JAXSparse):\ndef fromdense(cls, mat, *, nse=None, index_dtype=np.int32):\nreturn coo_fromdense(mat, nse=nse, index_dtype=index_dtype)\n- def _sort_rows(self):\n- \"\"\"Return a copy of the COO matrix with sorted rows.\n+ def _sort_indices(self):\n+ \"\"\"Return a copy of the COO matrix with sorted indices.\n+ The matrix is sorted by row indices and column indices per row.\nIf self._rows_sorted is True, this returns ``self`` without a copy.\n\"\"\"\n# TODO(jakevdp): would be benefit from lowering this to cusparse sort_rows utility?\nif self._rows_sorted:\nreturn self\n- row, col, data = lax.sort((self.row, self.col, self.data), num_keys=1)\n- return self.__class__((data, row, col), shape=self.shape, rows_sorted=True)\n+ row, col, data = lax.sort((self.row, self.col, self.data), num_keys=2)\n+ return self.__class__((data, row, col), shape=self.shape,\n+ rows_sorted=True)\n@classmethod\ndef _empty(cls, shape, *, dtype=None, index_dtype='int32'):\n@@ -91,7 +94,8 @@ class COO(JAXSparse):\nraise ValueError(f\"COO must have ndim=2; got shape={shape}\")\ndata = jnp.empty(0, dtype)\nrow = col = jnp.empty(0, index_dtype)\n- return cls((data, row, col), shape=shape, rows_sorted=True, cols_sorted=True)\n+ return cls((data, row, col), shape=shape, rows_sorted=True,\n+ cols_sorted=True)\ndef todense(self):\nreturn coo_todense(self)\n@@ -185,7 +189,6 @@ def _coo_todense_gpu_translation_rule(ctx, avals_in, avals_out, data, row, col,\nreturn [xops.Transpose(result, (1, 0))] if transpose else [result]\n-\n_coo_todense_lowering = mlir.lower_fun(\n_coo_todense_impl, multiple_results=False)\n@@ -263,7 +266,8 @@ def coo_fromdense(mat, *, nse=None, index_dtype=jnp.int32):\nif nse is None:\nnse = (mat != 0).sum()\nnse = core.concrete_or_error(operator.index, nse, \"coo_fromdense nse argument\")\n- return COO(_coo_fromdense(mat, nse=nse, index_dtype=index_dtype), shape=mat.shape, rows_sorted=True)\n+ return COO(_coo_fromdense(mat, nse=nse, index_dtype=index_dtype),\n+ shape=mat.shape, rows_sorted=True)\ndef _coo_fromdense(mat, *, nse, index_dtype=jnp.int32):\n\"\"\"Create COO-format sparse matrix from a dense matrix.\n@@ -589,6 +593,7 @@ def _coo_matmat_gpu_translation_rule(ctx, avals_in, avals_out, data, row, col,\n\"Falling back to default implementation.\", CuSparseEfficiencyWarning)\nreturn _coo_matmat_translation_rule(ctx, avals_in, avals_out, data, row, col, B,\nspinfo=spinfo, transpose=transpose)\n+\nif spinfo.rows_sorted:\nshape = spinfo.shape\nelif spinfo.cols_sorted:\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/sparse_test.py",
"new_path": "tests/sparse_test.py",
"diff": "@@ -438,7 +438,7 @@ class cuSparseTest(jtu.JaxTestCase):\nmat = sparse.COO.fromdense(sprng((5, 6), np.float32))\nperm = rng.permutation(mat.nse)\nmat_unsorted = sparse.COO((mat.data[perm], mat.row[perm], mat.col[perm]), shape=mat.shape)\n- mat_resorted = mat_unsorted._sort_rows()\n+ mat_resorted = mat_unsorted._sort_indices()\nself.assertArraysEqual(mat.todense(), mat_resorted.todense())\n@unittest.skipIf(not GPU_LOWERING_ENABLED, \"test requires cusparse/hipsparse\")\n@@ -460,15 +460,15 @@ class cuSparseTest(jtu.JaxTestCase):\nself.assertFalse(mat_unsorted._rows_sorted)\nself.assertFalse(mat_unsorted._cols_sorted)\n- self.assertArraysEqual(mat, mat_rows_sorted._sort_rows().todense())\n- self.assertArraysEqual(mat, mat_cols_sorted._sort_rows().todense())\n- self.assertArraysEqual(mat, mat_unsorted._sort_rows().todense())\n+ self.assertArraysEqual(mat, mat_rows_sorted._sort_indices().todense())\n+ self.assertArraysEqual(mat, mat_cols_sorted._sort_indices().todense())\n+ self.assertArraysEqual(mat, mat_unsorted._sort_indices().todense())\ntodense = jit(sparse.coo_todense)\nwith self.assertNoWarnings():\ndense_rows_sorted = todense(mat_rows_sorted)\ndense_cols_sorted = todense(mat_cols_sorted)\n- dense_unsorted = todense(mat_unsorted._sort_rows())\n+ dense_unsorted = todense(mat_unsorted._sort_indices())\nwith self.assertWarnsRegex(sparse.CuSparseEfficiencyWarning, \"coo_todense GPU lowering requires matrices with sorted rows.*\"):\ndense_unsorted_fallback = todense(mat_unsorted)\nself.assertArraysEqual(mat, dense_rows_sorted)\n@@ -482,7 +482,7 @@ class cuSparseTest(jtu.JaxTestCase):\nwith self.assertNoWarnings():\nmatvec_rows_sorted = matvec(mat_rows_sorted, rhs_vec)\nmatvec_cols_sorted = matvec(mat_cols_sorted, rhs_vec)\n- matvec_unsorted = matvec(mat_unsorted._sort_rows(), rhs_vec)\n+ matvec_unsorted = matvec(mat_unsorted._sort_indices(), rhs_vec)\nwith self.assertWarnsRegex(sparse.CuSparseEfficiencyWarning, \"coo_matvec GPU lowering requires matrices with sorted rows.*\"):\nmatvec_unsorted_fallback = matvec(mat_unsorted, rhs_vec)\nself.assertArraysEqual(matvec_expected, matvec_rows_sorted)\n@@ -496,7 +496,7 @@ class cuSparseTest(jtu.JaxTestCase):\nwith self.assertNoWarnings():\nmatmat_rows_sorted = matmat(mat_rows_sorted, rhs_mat)\nmatmat_cols_sorted = matmat(mat_cols_sorted, rhs_mat)\n- matmat_unsorted = matmat(mat_unsorted._sort_rows(), rhs_mat)\n+ matmat_unsorted = matmat(mat_unsorted._sort_indices(), rhs_mat)\nwith self.assertWarnsRegex(sparse.CuSparseEfficiencyWarning, \"coo_matmat GPU lowering requires matrices with sorted rows.*\"):\nmatmat_unsorted_fallback = matmat(mat_unsorted, rhs_mat)\nself.assertArraysEqual(matmat_expected, matmat_rows_sorted)\n"
}
] | Python | Apache License 2.0 | google/jax | [sparse] Use sorted indices instead of sorted rows only.
PiperOrigin-RevId: 440579642 |
260,335 | 09.04.2022 10:56:14 | 25,200 | 9f1fab251935d98d4ba45d3a48f1944136520841 | dispatch.py: type annotations, other minor tweaks | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/dispatch.py",
"new_path": "jax/_src/dispatch.py",
"diff": "# limitations under the License.\n# Primitive dispatch and jit dispatch.\n+from __future__ import annotations\nimport contextlib\nfrom functools import partial\n@@ -48,6 +49,7 @@ from jax._src.lib.mlir import ir\nfrom jax._src.lib import xla_bridge as xb\nfrom jax._src.lib import xla_client as xc\nimport jax._src.util as util\n+from jax._src.util import flatten, unflatten\nFLAGS = flags.FLAGS\n@@ -253,7 +255,6 @@ def lower_xla_callable(fun: lu.WrappedFun, device, backend, name,\naxis_env = xla.AxisEnv(nreps, (), ())\nname_stack = xla.new_name_stack(xla.wrap_name(name, 'jit'))\nclosed_jaxpr = core.ClosedJaxpr(jaxpr, consts)\n- module: Union[str, xc.XlaComputation]\nmodule_name = f\"jit_{fun.__name__}\"\nmodule = mlir.lower_jaxpr_to_module(\nmodule_name, closed_jaxpr, backend.platform,\n@@ -434,35 +435,30 @@ def _execute_compiled(name: str, compiled: XlaExecutable,\noutput_buffer_counts: Optional[Sequence[int]],\nresult_handlers, kept_var_idx, *args):\ndevice, = compiled.local_devices()\n- input_bufs = util.flatten(\n- device_put(x, device) for i, x in enumerate(args) if i in kept_var_idx)\n- out_bufs = compiled.execute(input_bufs)\n- check_special(name, out_bufs)\n+ input_bufs_flat = flatten(device_put(x, device) for i, x in enumerate(args)\n+ if i in kept_var_idx)\n+ out_bufs_flat = compiled.execute(input_bufs_flat)\n+ check_special(name, out_bufs_flat)\nif output_buffer_counts is None:\n- return (result_handlers[0](*out_bufs),)\n- return tuple(\n- handler(*bs) for handler, bs in\n- unsafe_zip(result_handlers, util.unflatten(out_bufs, output_buffer_counts)))\n+ return (result_handlers[0](*out_bufs_flat),)\n+ out_bufs = unflatten(out_bufs_flat, output_buffer_counts)\n+ return tuple(h(*bs) for h, bs in unsafe_zip(result_handlers, out_bufs))\ndef _execute_replicated(name: str, compiled: XlaExecutable,\noutput_buffer_counts: Optional[Sequence[int]],\nresult_handlers, kept_var_idx, *args):\n- input_bufs = [\n- util.flatten(\n- device_put(x, device) for i, x in enumerate(args) if i in kept_var_idx)\n- for device in compiled.local_devices()\n- ]\n- out_bufs = [\n- buf[0] for buf in compiled.execute_sharded_on_local_devices(\n- list(zip(*input_bufs)))\n- ]\n- check_special(name, out_bufs)\n+ input_bufs = [flatten(device_put(x, device) for i, x in enumerate(args)\n+ if i in kept_var_idx)\n+ for device in compiled.local_devices()]\n+ input_bufs_flip = list(unsafe_zip(*input_bufs))\n+ out_bufs_flat_rep = compiled.execute_sharded_on_local_devices(input_bufs_flip)\n+ out_bufs_flat = [bufs[0] for bufs in out_bufs_flat_rep]\n+ check_special(name, out_bufs_flat)\nif output_buffer_counts is None:\n- return (result_handlers[0](*out_bufs),)\n- return tuple(\n- handler(*bs) for handler, bs in\n- unsafe_zip(result_handlers, util.unflatten(out_bufs, output_buffer_counts)))\n+ return (result_handlers[0](*out_bufs_flat),)\n+ out_bufs = unflatten(out_bufs_flat, output_buffer_counts)\n+ return tuple(h(*bs) for h, bs in unsafe_zip(result_handlers, out_bufs))\ndef _execute_trivial(jaxpr, device: Optional[Device], consts, avals, handlers,\n@@ -588,20 +584,19 @@ class XlaCompiledComputation(stages.Executable):\n@staticmethod\ndef from_xla_computation(\nname: str,\n- xla_computation,\n+ xla_computation: Optional[ir.Module],\nnreps: int,\ndevice: Optional[Device],\n- backend,\n+ backend: Backend,\ntuple_args: bool,\n- in_avals,\n- out_avals,\n- kept_var_idx) -> 'XlaCompiledComputation':\n+ in_avals: Sequence[core.AbstractValue],\n+ out_avals: Sequence[core.AbstractValue],\n+ kept_var_idx: Set[int]) -> XlaCompiledComputation:\nsticky_device = device\nresult_handlers = map(partial(aval_to_result_handler, sticky_device),\nout_avals)\noptions = xb.get_compile_options(\n- num_replicas=nreps,\n- num_partitions=1,\n+ num_replicas=nreps, num_partitions=1,\ndevice_assignment=(sticky_device,) if sticky_device else None)\noptions.parameter_is_tupled_arguments = tuple_args\nwith log_elapsed_time(f\"Finished XLA compilation of {name} \"\n"
}
] | Python | Apache License 2.0 | google/jax | dispatch.py: type annotations, other minor tweaks |
260,335 | 11.04.2022 07:56:18 | 25,200 | 902fc0c3d2b3ec9b6034c66074984386ec35606f | Remove invertible_ad since it's not in use. | [
{
"change_type": "MODIFY",
"old_path": "jax/__init__.py",
"new_path": "jax/__init__.py",
"diff": "@@ -64,7 +64,6 @@ from jax._src.api import (\ncheckpoint_policies as checkpoint_policies,\nclosure_convert as closure_convert,\ncurry, # TODO(phawkins): update users to avoid this.\n- custom_ivjp as custom_ivjp,\ncustom_gradient as custom_gradient,\ncustom_jvp as custom_jvp,\ncustom_vjp as custom_vjp,\n@@ -84,7 +83,6 @@ from jax._src.api import (\nhost_count as host_count,\nhost_id as host_id,\nhost_ids as host_ids,\n- invertible as invertible,\njacobian as jacobian,\njacfwd as jacfwd,\njacrev as jacrev,\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/api.py",
"new_path": "jax/_src/api.py",
"diff": "@@ -86,8 +86,6 @@ from jax.interpreters import pxla\nfrom jax.interpreters import ad\nfrom jax.interpreters import batching\nfrom jax.interpreters import masking\n-from jax.interpreters import invertible_ad as iad\n-from jax.interpreters.invertible_ad import custom_ivjp\nfrom jax._src.config import (\nflags, config, bool_env,\n@@ -3121,19 +3119,6 @@ def named_call(\nreturn named_call_f\n-def invertible(fun: Callable) -> Callable:\n- \"\"\"Asserts that the decorated function is invertible.\n-\n- Applying reverse-mode AD to a decorated function will use a more memory efficient\n- procedure than usual, which will reconstruct the necessary intermediate values\n- by inverting the function. Note that this might degrade the numerical accuracy of\n- obtained gradients if the inverse is unstable.\n-\n- Args:\n- fun: The function assumed to be invertible.\n- \"\"\"\n- return iad.invertible(fun)\n-\ndef block_until_ready(x):\n\"\"\"\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/lax.py",
"new_path": "jax/_src/lax/lax.py",
"diff": "@@ -44,7 +44,6 @@ from jax.interpreters import mlir\nfrom jax.interpreters import xla\nfrom jax.interpreters import pxla\nfrom jax.interpreters import ad\n-from jax.interpreters import invertible_ad as iad\nfrom jax.interpreters import batching\nfrom jax.interpreters import masking\nimport jax._src.pretty_printer as pp\n@@ -1642,15 +1641,12 @@ mlir.register_lowering(is_finite_p, partial(_nary_lower_mhlo, mhlo.IsFiniteOp))\nexp_p = standard_unop(_float | _complex, 'exp')\nad.defjvp2(exp_p, lambda g, ans, x: mul(g, ans))\n-iad.definverse(exp_p, lambda r, x: log(r))\n# For exp_p it is more efficient to use the reconstructed output for the vjp\n# rule instead of computing it again from the input.\n-iad.primitive_ivjps[exp_p] = lambda x, y, ct: [[log(y[0])], [ct[0] * y[0]]]\nmlir.register_lowering(exp_p, partial(_nary_lower_mhlo, mhlo.ExpOp))\nlog_p = standard_unop(_float | _complex, 'log')\nad.defjvp(log_p, lambda g, x: div(g, x))\n-iad.definverse(log_p, lambda r, x: exp(r))\nmlir.register_lowering(log_p, partial(_nary_lower_mhlo, mhlo.LogOp))\nexpm1_p = standard_unop(_float | _complex, 'expm1')\n@@ -2064,7 +2060,6 @@ def _add_inverse(r, x, y):\nadd_p: Primitive = standard_naryop([_num, _num], 'add')\nad.primitive_jvps[add_p] = _add_jvp\nad.primitive_transposes[add_p] = _add_transpose\n-iad.definverse(add_p, _add_inverse)\nmlir.register_lowering(add_p, partial(_nary_lower_mhlo, mhlo.AddOp))\ndef _sub_jvp(primals, tangents):\n@@ -2120,7 +2115,6 @@ ad.defjvp(mul_p,\nlambda xdot, x, y: mul(xdot, y),\nlambda ydot, x, y: mul(x, ydot))\nad.primitive_transposes[mul_p] = _mul_transpose\n-iad.definverse(mul_p, _mul_inverse)\nmlir.register_lowering(mul_p, partial(_nary_lower_mhlo, mhlo.MulOp))\ndef _div_transpose_rule(cotangent, x, y):\n"
},
{
"change_type": "DELETE",
"old_path": "jax/interpreters/invertible_ad.py",
"new_path": null,
"diff": "-# 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-# https://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-import warnings\n-from functools import partial\n-from typing import Dict, Any, Callable\n-\n-import jax\n-from jax import core\n-from jax import linear_util as lu\n-from jax.interpreters import ad\n-from jax.interpreters import partial_eval as pe\n-from jax.core import raise_to_shaped, get_aval, Literal, Jaxpr\n-from jax._src.api_util import flatten_fun_nokwargs\n-from jax.tree_util import tree_flatten, tree_unflatten, register_pytree_node\n-from jax._src.util import safe_map, safe_zip, split_list\n-from jax._src import custom_derivatives\n-\n-map = safe_map\n-zip = safe_zip\n-\n-def _initial_style_jaxpr(fun, in_avals):\n- jaxpr, _, consts = pe.trace_to_jaxpr_dynamic(fun, in_avals)\n- return core.ClosedJaxpr(jaxpr, consts)\n-\n-################################################################################\n-# Reverse call primitive\n-################################################################################\n-\n-class DontFlatten:\n- def __init__(self, val):\n- self.val = val\n-\n-register_pytree_node(DontFlatten,\n- lambda x: ((), x.val),\n- lambda val, _: DontFlatten(val))\n-\n-def get_concrete_array(aval):\n- assert isinstance(aval, core.ConcreteArray), aval\n- return aval.val\n-\n-def invertible(fun):\n- # TODO: Avoid materializing zeros!\n- ifun = custom_derivatives.custom_vjp(fun)\n-\n- def fwd(*args):\n- flat_args, in_tree = tree_flatten(args)\n- in_pvals = tuple(pe.PartialVal.unknown(raise_to_shaped(get_aval(arg))) for arg in flat_args)\n- fun_flat, out_tree = flatten_fun_nokwargs(lu.wrap_init(fun), in_tree)\n- jaxpr, out_pvals, consts = pe.trace_to_jaxpr(fun_flat, in_pvals)\n- # TODO: Don't warn if consts contain JVP tracers?\n- if consts:\n- warnings.warn(\"Values that an @invertible function closes over will not have their \" +\n- \"gradients computed correctly (their uses inside this function will be ignored)!\")\n- # TODO: This requires the body to be jittable, but this shouldn't be necessary.\n- # Is there a way to trace a jaxpr while running it?\n- flat_outs = core.eval_jaxpr(jaxpr, consts, *flat_args)\n- return tree_unflatten(out_tree(), flat_outs), (flat_args, flat_outs, consts, DontFlatten((jaxpr, in_tree)))\n-\n- def bwd(res, cts):\n- flat_args, flat_outs, consts, aux = res\n- jaxpr, in_tree = aux.val\n- flat_cts, _ = tree_flatten(cts)\n- return tree_unflatten(in_tree, inv_backward_pass(jaxpr, consts, flat_args, flat_outs, flat_cts))\n-\n- ifun.defvjp(fwd, bwd)\n-\n- return ifun\n-\n-################################################################################\n-# Custom inverse\n-################################################################################\n-\n-class custom_ivjp:\n- def __init__(self, fun):\n- self.fun = fun\n- self.ivjp = None\n-\n- def defivjp(self, ivjp):\n- # ivjp(inputs, outputs, output_cotangents) -> (inputs, input_cotangents)\n- self.ivjp = ivjp\n-\n- def __call__(self, *args, **kwargs):\n- if self.ivjp is None:\n- msg = \"No IVJP defined for custom_vjp function {}. Did you forget to use defivjp?\"\n- raise AttributeError(msg.format(self.__name__))\n- args = custom_derivatives._resolve_kwargs(self.fun, args, kwargs)\n- # TODO: Support nondiff_argnums\n- fun, ivjp = lu.wrap_init(self.fun), lu.wrap_init(self.ivjp)\n- args_flat, in_tree = tree_flatten(args)\n- flat_fun, out_tree = flatten_fun_nokwargs(fun, in_tree)\n- flat_ivjp = _flatten_ivjp(ivjp, in_tree, out_tree)\n- out_flat = _custom_ivjp(flat_fun, flat_ivjp, args_flat)\n- return tree_unflatten(out_tree(), out_flat)\n-\n-def zip_with(fun, *args):\n- return map(lambda p: fun(*p), zip(*args))\n-\n-@lu.transformation\n-def _flatten_ivjp(in_tree, out_tree, *args):\n- out_tree = out_tree()\n- num_inputs, num_outputs = in_tree.num_leaves, out_tree.num_leaves\n- assert len(args) == num_inputs + 2 * num_outputs\n- arg_leaves = split_list(args, [num_inputs, num_outputs])\n- py_args = zip_with(tree_unflatten, [in_tree, out_tree, out_tree], arg_leaves)\n- pair_out = yield py_args, {}\n- if not isinstance(pair_out, (list, tuple)) or len(pair_out) != 2:\n- raise TypeError(\"Expected a two element pair as output of custom ivjp\")\n- yield tree_flatten(pair_out)[0]\n-\n-def _custom_ivjp(fun, ivjp, args):\n- in_avals = [raise_to_shaped(get_aval(x)) for x in args]\n- fun_jaxpr = _initial_style_jaxpr(fun, in_avals)\n- try:\n- ivjp_jaxpr = _initial_style_jaxpr(ivjp, in_avals + fun_jaxpr.out_avals * 2)\n- except RecursionError:\n- raise ValueError(\"Calls to {} from its custom ivjp aren't supported yet\".format(fun.__name__))\n- return custom_ivjp_p.bind(*args, fun_jaxpr=fun_jaxpr,\n- ivjp_jaxpr=ivjp_jaxpr)\n-\n-def _custom_ivjp_impl(*args, fun_jaxpr, **_):\n- return core.jaxpr_as_fun(fun_jaxpr)(*args)\n-\n-custom_ivjp_p = core.Primitive('custom_ivjp')\n-custom_ivjp_p.multiple_results = True\n-custom_ivjp_p.def_impl(_custom_ivjp_impl)\n-custom_ivjp_p.def_abstract_eval(lambda *_, fun_jaxpr, **__: fun_jaxpr.out_avals)\n-\n-def _custom_ivjp_jvp(primals, tangents, *, fun_jaxpr, ivjp_jaxpr):\n- primals_out = custom_ivjp_p.bind(*primals, fun_jaxpr=fun_jaxpr,\n- ivjp_jaxpr=ivjp_jaxpr)\n- fun = core.jaxpr_as_fun(fun_jaxpr)\n- # FIXME: This might compute the primals multiple times, but we only need to do\n- # this trick while linearizing. It should be possible to do it through\n- # a custom partial eval rule.\n- _, tangents_out = ad.jvp(lu.wrap_init(fun)).call_wrapped(primals, tangents)\n- return primals_out, tangents_out\n-ad.primitive_jvps[custom_ivjp_p] = _custom_ivjp_jvp\n-\n-################################################################################\n-# Backward pass implementation\n-################################################################################\n-\n-def inv_backward_pass(jaxpr: core.Jaxpr, consts, primals_in, primals_out, cotangents_in):\n- if all(type(ct) is ad.Zero for ct in cotangents_in):\n- return map(lambda v: ad.Zero(v.aval), jaxpr.invars)\n-\n- def write_cotangent(v, ct):\n- # assert v not in primal_env\n- if ct is not None and type(v) is not Literal:\n- ct_env[v] = ad.add_tangents(ct_env[v], ct) if v in ct_env else ct\n-\n- def read_cotangent(v):\n- return ct_env.get(v, ad.Zero(v.aval))\n-\n- def read_primal(v):\n- if type(v) is Literal:\n- return v.val\n- else:\n- return primal_env.get(v, ad.UndefinedPrimal(v.aval))\n-\n- def write_primal(v, val):\n- if type(v) is Literal:\n- return\n- primal_env.setdefault(v, val)\n-\n- # Invert while computing cotangents\n- ct_env: Dict[Any, Any] = {}\n- primal_env: Dict[Any, Any] = {}\n- write_primal(core.unitvar, core.unit)\n- map(write_primal, jaxpr.invars, primals_in)\n- map(write_primal, jaxpr.outvars, primals_out)\n- map(write_primal, jaxpr.constvars, consts)\n- map(write_cotangent, jaxpr.outvars, cotangents_in)\n- for eqn in jaxpr.eqns[::-1]:\n- primals_in = map(read_primal, eqn.invars)\n- primals_out = map(read_primal, eqn.outvars)\n- cts_in = map(read_cotangent, eqn.outvars)\n- should_invert = any(type(primal) is not ad.UndefinedPrimal\n- for primal in primals_out)\n- should_vjp = any(type(ct) is not ad.Zero for ct in cts_in)\n- assert not eqn.primitive.call_primitive\n-\n- # Skip primals equations that are only jvp coefficients and don't affect\n- # primal outputs.\n- if not should_invert and not should_vjp:\n- continue\n-\n- def abstract(value):\n- return raise_to_shaped(value.aval if ad.is_undefined_primal(value) else get_aval(value))\n-\n- # Get the ivjp_jaxpr\n- if eqn.primitive is custom_ivjp_p:\n- ivjp_jaxpr = eqn.params['ivjp_jaxpr']\n- else:\n- if eqn.primitive in primitive_ivjps:\n- complete_ivjp = lu.wrap_init(primitive_ivjps[eqn.primitive])\n- else:\n- complete_ivjp = lu.wrap_init(partial(synthesize_ivjp, eqn, map(ad.is_undefined_primal, primals_in)))\n- _, in_tree = tree_flatten(\n- tuple(map(abstract, x) for x in (primals_in, primals_out, primals_out)))\n- complete_ivjp_flat, _ = flatten_fun_nokwargs(complete_ivjp, in_tree)\n-\n- in_avals = map(abstract, primals_in + primals_out + primals_out)\n- # TODO: Actually we do know some of the inputs, because they might be literals!\n- ivjp_jaxpr, out_pvals, _ = pe.trace_to_jaxpr(\n- complete_ivjp_flat, map(pe.PartialVal.unknown, in_avals), instantiate=True)\n- assert not ivjp_jaxpr.constvars # That might happen some time, but don't bother until then\n- ivjp_jaxpr = core.ClosedJaxpr(ivjp_jaxpr, [])\n-\n- # Once we know what the ivjp can do exactly, we have to isolate the part we are\n- # actually able to compute with the values we have at hand.\n- num_inputs = len(eqn.invars)\n- unknowns = (map(ad.is_undefined_primal, primals_in) +\n- map(ad.is_undefined_primal, primals_out) +\n- [False] * len(cts_in))\n- jaxpr_known, jaxpr_unknown, out_unknowns = pe.partial_eval_jaxpr( # type: ignore\n- ivjp_jaxpr, unknowns, instantiate=False) # type:ignore\n- unknown_rec_primals_in, unknown_cotangents = split_list(out_unknowns, [num_inputs])\n- # Make sure we're able to compute all cotangents. We don't really care if we\n- # can reconstruct or primals or not, although failure to do so might result in\n- # failing to compute cotangents later.\n- assert not any(unknown_cotangents)\n- # Remove residual outputs -- we won't be computing the unknown jaxpr anyway.\n- num_outputs = len(jaxpr_unknown.jaxpr.outvars)\n- jaxpr_known.jaxpr.outvars = jaxpr_known.jaxpr.outvars[:num_outputs]\n- # TODO: We could drop the outputs that correspond to primals that we already know.\n- # This only matters in eager mode, so leaving it out for now...\n- ivjp = core.jaxpr_as_fun(jaxpr_known)\n- rec_primals_in, cts_out = split_list(ivjp(*primals_in, *primals_out, *cts_in),\n- [num_inputs])\n- # Unknown rec_primals_in are core.units, so we have to replace them\n- # with UnknownPrimals because that's what write_primal will ignore.\n- rec_primals_in = [prev if unknown else rec\n- for prev, rec, unknown\n- in zip(primals_in, rec_primals_in, unknown_rec_primals_in)]\n- map(write_primal, eqn.invars, rec_primals_in)\n- map(write_cotangent, [v for v in eqn.invars if type(v) is not Literal], cts_out)\n-\n- # NOTE: We keep the cotangents associated with primal variables, while the contract of a\n- # transpose is to return them in positions associated with tangent variables, which\n- # is what causes this whole confusion.\n- return map(read_cotangent, jaxpr.invars)\n-\n-primitive_ivjps: Dict[core.Primitive, Callable] = {}\n-\n-def synthesize_ivjp(eqn, unknown_primals, primals_in, primals_out, cts_in):\n- # Invert eqn\n- if not eqn.primitive.multiple_results:\n- primals_out, = primals_out\n- rec_primals_in = get_primitive_inverse(eqn.primitive)(primals_out, *primals_in)\n- if len(eqn.invars) == 1:\n- rec_primals_in = (rec_primals_in,)\n-\n- # Use the reconstructed primals if some primals_in were unknown, because we\n- # might have reconstructed some of them.\n- primals_in = map(lambda p, rp, unknown: rp if unknown else p,\n- primals_in, rec_primals_in, unknown_primals)\n-\n- # Compute the VJP of eqn\n- variable_invars = [v for v in eqn.invars if type(v) is not Literal]\n- variable_primals_in = [p for p, v in zip(primals_in, eqn.invars) if type(v) is not Literal]\n- eqn_jaxpr = Jaxpr([], variable_invars, eqn.outvars, [eqn])\n- eqn_callable = lambda args: core.eval_jaxpr(eqn_jaxpr, (), *args)\n- _, eqn_vjp = jax.vjp(eqn_callable, variable_primals_in)\n- # TODO: Instantiate zeros or (better) figure out how to avoid it!\n- cts_out, = eqn_vjp(cts_in)\n-\n- return rec_primals_in, cts_out\n-\n-def split(l, parts):\n- assert len(l) % parts == 0\n- chunk = len(l) // parts\n- return [l[i:i + chunk] for i in range(0, len(l), chunk)]\n-\n-################################################################################\n-# Primitive inverses\n-################################################################################\n-\n-primitive_inverses: Dict[core.Primitive, Callable] = {}\n-\n-def get_primitive_inverse(p):\n- try:\n- return primitive_inverses[p]\n- except KeyError:\n- pass\n- raise NotImplementedError(\n- \"Inverse rule for '{}' not implemented\".format(p))\n-\n-\n-def definverse(primitive, inverse_rule):\n- primitive_inverses[primitive] = inverse_rule\n- return inverse_rule\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/api_test.py",
"new_path": "tests/api_test.py",
"diff": "@@ -7429,114 +7429,6 @@ class CustomApiTest(jtu.JaxTestCase):\nself.assertIsInstance(getattr(f, method), Callable)\n-class InvertibleADTest(jtu.JaxTestCase):\n-\n- @jtu.ignore_warning(message=\"Values that an @invertible function closes\")\n- def test_invertible_basic(self):\n- def f(x):\n- return lax.mul(lax.mul(lax.exp(x), 4.), x)\n-\n- finv = jax.invertible(f)\n- x = jnp.ones((5,))\n-\n- jaxpr = jax.make_jaxpr(lambda p, ct: jax.vjp(finv, p)[1](ct))(x, x)\n-\n- # expected = \"\"\"\n- # { lambda ; a b.\n- # let c = exp a\n- # d = mul c 4.0\n- # e = mul d a\n- # f = mul b a\n- # g = div e a\n- # h = mul b g\n- # i = mul f 4.0\n- # j = div g 4.0\n- # k = mul f j\n- # _ = reduce_sum[ axes=(0,) ] k\n- # _ = log j\n- # l = mul i j\n- # m = add_any h l\n- # in (m,) }\n- # \"\"\"\n- # self.assertMultiLineStrippedEqual(expected, str(jaxpr)) # no jaxpr test\n-\n- self.assertIn('div', str(jaxpr))\n- self.assertIn('log', str(jaxpr)) # assumes no DCE\n- self.assertAllClose(jax.value_and_grad(lambda x: np.sum(f(x)))(x),\n- jax.value_and_grad(lambda x: np.sum(finv(x)))(x),\n- check_dtypes=True)\n-\n- def test_invertible_blocks(self):\n- # NB: This is the reversible ResNet block\n- def mk_reversible_block(f, g):\n- @jax.custom_ivjp\n- def rev_block(x1, x2):\n- y1 = f(x2) + x1\n- y2 = g(y1) + x2\n- return y1, y2\n-\n- @rev_block.defivjp\n- def rev_block_ivjp(xs, ys, dys):\n- (y1, y2) = ys\n- (dy1, dy2) = dys\n-\n- dgo, dx2 = dy2, dy2\n- go, gvjp = jax.vjp(g, y1)\n- dy1 += gvjp(dgo)[0]\n- del gvjp\n- x2 = y2 - go\n-\n- dfo, dx1 = dy1, dy1\n- fo, fvjp = jax.vjp(f, x2)\n- dx2 += fvjp(dfo)[0]\n- del fvjp\n- x1 = y1 - fo\n-\n- return (x1, x2), (dx1, dx2)\n-\n- return rev_block\n-\n- rev_block = mk_reversible_block(jnp.sin, jnp.cos)\n-\n- def g(x1, x2):\n- for i in range(2):\n- x1, x2 = rev_block(x1, x2)\n- return x1, x2\n-\n- def reduce(f, x1, x2):\n- y1, y2 = f(x1, x2)\n- return np.sum(y1) + np.sum(y2)\n-\n- x = np.ones((1,))\n- # FIXME: This breaks when argnums is left as default (i.e. 0), because JVP prunes\n- # zero tangents from call primitives.\n- self.assertAllClose(jax.value_and_grad(partial(reduce, jax.invertible(g)), argnums=(0, 1))(x, x + 2),\n- jax.value_and_grad(partial(reduce, g), argnums=(0, 1))(x, x + 2),\n- check_dtypes=True)\n-\n- def test_invertible_partial_diff(self):\n- # Check that we don't have to differentiate with respect to inputs\n- # of the invertible function.\n- def f(x, y):\n- return lax.mul(lax.mul(lax.exp(x), 4.), x), lax.add(y, 4.)\n-\n- finv = jax.invertible(f)\n- o = np.ones((5,))\n- self.assertAllClose(jax.value_and_grad(lambda x: np.sum(f(x, o)[0]))(o),\n- jax.value_and_grad(lambda x: np.sum(finv(x, o)[0]))(o),\n- check_dtypes=True)\n-\n- def test_invertible_pytree(self):\n- def f(x, y):\n- return lax.add(lax.mul(lax.exp(x[0]), x[1]), y)\n-\n- finv = jax.invertible(f)\n- o = np.ones((5,))\n- self.assertAllClose(jax.value_and_grad(lambda x: np.sum(f((x, x), x)[0]))(o),\n- jax.value_and_grad(lambda x: np.sum(finv((x, x), x)[0]))(o),\n- check_dtypes=True)\n-\n-\nclass BufferDonationTest(jtu.BufferDonationTestCase):\n@jtu.skip_on_devices(\"cpu\") # In/out aliasing not supported on CPU.\n"
}
] | Python | Apache License 2.0 | google/jax | Remove invertible_ad since it's not in use.
PiperOrigin-RevId: 440890949 |
260,681 | 11.04.2022 14:59:04 | 0 | 36df8619d74672b0072e7880bcdd257c4a83e9f1 | Bump minimum jaxlib version to 0.3.2 and remove transfer guard compatibility code | [
{
"change_type": "MODIFY",
"old_path": "build/build_wheel.py",
"new_path": "build/build_wheel.py",
"diff": "@@ -99,7 +99,6 @@ _XLA_EXTENSION_STUBS = [\n\"transfer_guard_lib.pyi\",\n]\n_OPTIONAL_XLA_EXTENSION_STUBS = [\n- \"transfer_guard_lib.pyi\", # Will be required on xla_extension_version >= 58.\n]\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/config.py",
"new_path": "jax/_src/config.py",
"diff": "@@ -26,7 +26,6 @@ import warnings\nfrom jax._src import lib\nfrom jax._src.lib import jax_jit\n-if lib.xla_extension_version >= 58:\nfrom jax._src.lib import transfer_guard_lib\ndef bool_env(varname: str, default: bool) -> bool:\n@@ -714,27 +713,6 @@ config.define_bool_state(\ndefault=True,\nhelp=('Enables using optimization-barrier op for lowering remat.'))\n-if lib.xla_extension_version < 58:\n- @contextlib.contextmanager\n- def explicit_device_put_scope() -> Iterator[None]:\n- \"\"\"Indicates that the current context is an explicit device_put*() call.\"\"\"\n- yield\n-\n- @contextlib.contextmanager\n- def explicit_device_get_scope() -> Iterator[None]:\n- \"\"\"Indicates that the current context is an explicit device_get() call.\"\"\"\n- yield\n-\n- @contextlib.contextmanager\n- def _transfer_guard(new_val: str) -> Iterator[None]:\n- raise NotImplementedError(\"jaxlib version is too low for transfer guards\")\n-\n- transfer_guard_host_to_device = _transfer_guard\n- transfer_guard_device_to_device = _transfer_guard\n- transfer_guard_device_to_host = _transfer_guard\n- transfer_guard = _transfer_guard\n-\n-else:\n@contextlib.contextmanager\ndef explicit_device_put_scope() -> Iterator[None]:\n\"\"\"Indicates that the current context is an explicit device_put*() call.\"\"\"\n@@ -770,10 +748,9 @@ else:\nelif val == 'log_explicit':\nsetattr(state, key, transfer_guard_lib.TransferGuardLevel.LOG_EXPLICIT)\nelif val == 'disallow_explicit':\n- setattr(state, key,\n- transfer_guard_lib.TransferGuardLevel.DISALLOW_EXPLICIT)\n+ setattr(state, key, transfer_guard_lib.TransferGuardLevel.DISALLOW_EXPLICIT)\nelse:\n- assert False, f\"Invalid transfer guard level {val}\"\n+ assert False, f'Invalid transfer guard level {val}'\ntransfer_guard_host_to_device = config.define_enum_state(\nname='jax_transfer_guard_host_to_device',\n@@ -834,8 +811,7 @@ else:\n# The default is applied by transfer_guard_lib. Use None here to avoid\n# accidentally overriding --jax_transfer_guard_*.\ndefault=None,\n- help=(\n- 'Select the transfer guard level for all transfers. This option is '\n+ help=('Select the transfer guard level for all transfers. This option is '\n'set-only; the transfer guard level for a specific direction should '\n'be read using the per-transfer direction option. '\n'Default is \"allow\".'),\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lib/__init__.py",
"new_path": "jax/_src/lib/__init__.py",
"diff": "@@ -173,5 +173,4 @@ cuda_path = os.path.join(os.path.dirname(jaxlib.__file__), \"cuda\")\nif not os.path.isdir(cuda_path):\ncuda_path = None\n-if xla_extension_version >= 58:\ntransfer_guard_lib = xla_client._xla.transfer_guard_lib\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/version.py",
"new_path": "jax/version.py",
"diff": "@@ -18,5 +18,5 @@ def _version_as_tuple(version_str):\n__version__ = \"0.3.6\"\n__version_info__ = _version_as_tuple(__version__)\n-_minimum_jaxlib_version = \"0.3.0\"\n+_minimum_jaxlib_version = \"0.3.2\"\n_minimum_jaxlib_version_info = _version_as_tuple(_minimum_jaxlib_version)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/transfer_guard_test.py",
"new_path": "tests/transfer_guard_test.py",
"diff": "@@ -100,18 +100,12 @@ _COMMON_TEST_PARAMETERS = [\n(\"all\", _all_funcs, jax.transfer_guard),\n]\n-if jax._src.lib.xla_extension_version < 58:\nclass TransferGuardTest(jtu.JaxTestCase):\n- pass\n-\n-else:\n-\n- class TransferGuardTest(jtu.JaxTestCase):\n- # `_default_config` is used by `jtu.JaxTestCase` to update the JAX config\n- # for every test case. TransferGuardTest disables `--jax_enable_checks`\n- # because it can prematurely fetch the value of device arrays and make\n- # device-to-host tests to incur no transfers unexpectedly.\n+ # `_default_config` is used by `jtu.JaxTestCase` to update the JAX config for\n+ # every test case. TransferGuardTest disables `--jax_enable_checks` because it\n+ # can prematurely fetch the value of device arrays and make device-to-host\n+ # tests to incur no transfers unexpectedly.\n_default_config = {\"jax_enable_checks\": False}\n@contextlib.contextmanager\n@@ -127,8 +121,8 @@ else:\n@contextlib.contextmanager\ndef assertLogs(self, func_name):\n\"\"\"Asserts that a transfer in the context is logged and allowed.\"\"\"\n- # Only check if the transfer is allowed until Abseil provides an\n- # interface to capture logs.\n+ # Only check if the transfer is allowed until Abseil provides an interface\n+ # to capture logs.\nwith self.assertAllows(func_name):\nyield\n"
}
] | Python | Apache License 2.0 | google/jax | Bump minimum jaxlib version to 0.3.2 and remove transfer guard compatibility code |
260,631 | 12.04.2022 06:51:29 | 25,200 | a2c2d9af9133df73758ea060a21940fd6a4aa47d | [JAX] Adds the approx_top_k_p bridge. | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/jax2tf.py",
"new_path": "jax/experimental/jax2tf/jax2tf.py",
"diff": "@@ -983,7 +983,6 @@ tf_not_yet_impl = [\n# Not high priority?\n\"after_all\",\n\"all_to_all\",\n- \"approx_top_k\",\n\"create_token\",\n\"custom_transpose_call\",\n\"custom_vmap_call\",\n@@ -2380,6 +2379,23 @@ def _top_k(operand: TfVal, k: int) -> Tuple[TfVal, TfVal]:\ntf_impl[lax.top_k_p] = _top_k\n+def _approx_top_k(operand: TfVal, k: int, reduction_dimension: int,\n+ recall_target: float, is_max_k: bool,\n+ reduction_input_size_override: int,\n+ aggregate_to_topk: bool) -> Tuple[TfVal, TfVal]:\n+ if is_max_k:\n+ return tf.math.approx_max_k(operand, k, reduction_dimension, recall_target,\n+ reduction_input_size_override,\n+ aggregate_to_topk)\n+ else:\n+ return tf.math.approx_min_k(operand, k, reduction_dimension, recall_target,\n+ reduction_input_size_override,\n+ aggregate_to_topk)\n+\n+\n+tf_impl[lax.approx_top_k_p] = _approx_top_k\n+\n+\ndef _sort(*operands: TfVal, dimension: int, is_stable: bool,\nnum_keys: int) -> Tuple[TfVal, ...]:\nassert 1 <= num_keys <= len(operands)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/tests/jax2tf_limitations.py",
"new_path": "jax/experimental/jax2tf/tests/jax2tf_limitations.py",
"diff": "@@ -181,6 +181,16 @@ class Jax2TfLimitation(primitive_harness.Limitation):\ncls.helper_get_trig_custom_limitation(np.cosh)\n]\n+ @classmethod\n+ def approx_max_k(cls, harness: primitive_harness.Harness):\n+ supported_dtypes = jtu.supported_dtypes()\n+ return Jax2TfLimitation(\n+ \"eager is not supported in CPU or GPU.\",\n+ dtypes=[t for t in [jnp.bfloat16, np.float16, np.float32]\n+ if t in supported_dtypes],\n+ devices=(\"cpu\", \"gpu\", \"tpu\"),\n+ modes=(\"graph\", \"compiled\"))\n+\n@classmethod\ndef argmax(cls, harness: primitive_harness.Harness):\nreturn [\n"
}
] | Python | Apache License 2.0 | google/jax | [JAX] Adds the approx_top_k_p bridge.
PiperOrigin-RevId: 441172779 |
260,335 | 12.04.2022 14:40:19 | 25,200 | 8bc8e40e72f7b8acb10f4a9c4116a50fcce21fd1 | debug_nans: don't return results of successfully running de-optimized function | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/dispatch.py",
"new_path": "jax/_src/dispatch.py",
"diff": "@@ -149,24 +149,45 @@ def _xla_call_impl(fun: lu.WrappedFun, *args, device, backend, name,\ncompiled_fun = _xla_callable(fun, device, backend, name, donated_invars,\n*arg_specs)\ntry:\n- out = compiled_fun(*args)\n+ return compiled_fun(*args)\nexcept FloatingPointError:\nassert config.jax_debug_nans or config.jax_debug_infs # compiled_fun can only raise in this case\n- print(\"Invalid value encountered in the output of a jit/pmap-ed function. \"\n+ print(\"Invalid value encountered in the output of a jit-decorated function. \"\n\"Calling the de-optimized version.\")\n# We want to run the wrapped function again (after _xla_callable already ran\n# it), but linear_util.WrappedFun instances are meant to be run only once.\n# In addition to re-executing the Python code, which is usually undesirable\n- # but which config.jax_debug_nans is meant to opt into, we'll be re-executing\n- # any linear_util.py-style side effects, i.e. re-populating Stores created\n- # by any transformation_with_aux's applied to fun. Since this is\n- # intentional here, to avoid \"Store occupied\" errors we clone the WrappedFun\n- # with empty stores.\n+ # but which config.jax_debug_nans is meant to opt into, we'll be\n+ # re-executing any linear_util.py-style side effects, i.e. re-populating\n+ # Stores created by any transformation_with_aux's applied to fun. Since this\n+ # is intentional here, to avoid \"Store occupied\" errors we clone the\n+ # WrappedFun with empty stores.\nstores = [lu.Store() for _ in fun.stores]\nclone = lu.WrappedFun(fun.f, fun.transforms, stores, fun.params, fun.in_type)\n+\nwith core.new_sublevel():\n- _ = clone.call_wrapped(*args) # probably won't return\n- return out\n+ _ = clone.call_wrapped(*args) # may raise, not return\n+\n+ # If control reaches this line, we got a NaN on the output of `compiled_fun`\n+ # but not `clone.call_wrapped` on the same arguments. Let's tell the user.\n+ fun_info = pe.fun_sourceinfo(fun.f)\n+ msg = (\"An invalid value was encountered in the output of the \"\n+ f\"`jit`-decorated function {fun_info}. Because \"\n+ \"config.jax_debug_nans and/or config.jax_debug_infs is set, the \"\n+ \"de-optimized function (i.e., the function as if the `jit` \"\n+ \"decorator were removed) was called in an attempt to get a more \"\n+ \"precise error message. However, the de-optimized function did not \"\n+ \"produce invalid values during its execution. This behavior can \"\n+ \"result from `jit` optimizations causing the invalud value to be \"\n+ \"produced. It may also arise from having nan/inf constants as \"\n+ \"outputs, like `jax.jit(lambda ...: jax.numpy.nan)(...)`. \"\n+ \"\\n\\n\"\n+ \"It may be possible to avoid the invalid value by removing the \"\n+ \"`jit` decorator, at the cost of losing optimizations. \"\n+ \"\\n\\n\"\n+ \"If you see this error, consider opening a bug report at \"\n+ \"https://github.com/google/jax.\")\n+ raise FloatingPointError(msg)\nxla.xla_call_p.def_impl(_xla_call_impl)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/debug_nans_test.py",
"new_path": "tests/debug_nans_test.py",
"diff": "@@ -220,5 +220,16 @@ class DebugInfsTest(jtu.JaxTestCase):\nexcept FloatingPointError:\npass\n+ def testDebugNansDoesntReturnDeoptimizedResult(self):\n+ @jax.jit\n+ def f(x):\n+ x + 2 # avoid trivial dispatch path by adding some eqn\n+ return jnp.nan\n+\n+ with self.assertRaisesRegex(FloatingPointError, \"de-optimized\"):\n+ with jax.debug_nans(True):\n+ f(3)\n+\n+\nif __name__ == '__main__':\nabsltest.main(testLoader=jtu.JaxTestLoader())\n"
}
] | Python | Apache License 2.0 | google/jax | debug_nans: don't return results of successfully running de-optimized function |
260,335 | 12.04.2022 15:05:53 | 25,200 | 2a46c5e0d816771c58989315b162a586d94c94ae | add default values to config context managers | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/config.py",
"new_path": "jax/_src/config.py",
"diff": "@@ -257,7 +257,8 @@ class Config:\nsetattr(Config, name, property(get_state))\nreturn _StateContextManager(name, help, update_thread_local_hook,\n- extra_description=extra_description)\n+ extra_description=extra_description,\n+ default_value=True)\ndef define_enum_state(\nself, name: str, enum_values: List[str], default: Optional[str],\n@@ -352,18 +353,32 @@ class Config:\nreturn (self.x64_enabled, self.jax_numpy_rank_promotion,\nself.jax_default_matmul_precision, self.jax_dynamic_shapes)\n+class NoDefault: pass\n+no_default = NoDefault()\n+\nclass _StateContextManager:\ndef __init__(self, name, help, update_thread_local_hook,\nvalidate_new_val_hook: Optional[Callable[[Any], None]] = None,\n- extra_description: str = \"\"):\n+ extra_description: str = \"\", default_value: Any = no_default):\nself._name = name\nself.__name__ = name[4:] if name.startswith('jax_') else name\n- self.__doc__ = f\"Context manager for `{name}` config option{extra_description}.\\n\\n{help}\"\n+ self.__doc__ = (f\"Context manager for `{name}` config option\"\n+ f\"{extra_description}.\\n\\n{help}\")\nself._update_thread_local_hook = update_thread_local_hook\nself._validate_new_val_hook = validate_new_val_hook\n+ self._default_value = default_value\n@contextlib.contextmanager\n- def __call__(self, new_val):\n+ def __call__(self, new_val=no_default):\n+ if new_val is no_default:\n+ if self._default_value is not no_default:\n+ new_val = self._default_value # default_value provided to constructor\n+ else:\n+ # no default_value provided to constructor and no value provided as an\n+ # argument, so we raise an error\n+ raise TypeError(f\"Context manager for {self.__name__} config option \"\n+ \"requires an argument representing the new value for \"\n+ \"the config option.\")\nif self._validate_new_val_hook:\nself._validate_new_val_hook(new_val)\nprev_val = getattr(_thread_local_state, self._name, unset)\n"
}
] | Python | Apache License 2.0 | google/jax | add default values to config context managers |
260,510 | 12.04.2022 13:32:43 | 25,200 | 4392b0702259c006a22688b45fd64884e22a8004 | Add tests for higher order primitives | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/ad_checkpoint.py",
"new_path": "jax/_src/ad_checkpoint.py",
"diff": "@@ -276,10 +276,12 @@ def remat_impl(*args, jaxpr, prevent_cse, differentiated, policy):\ndel prevent_cse, differentiated, policy # Unused.\nreturn core.eval_jaxpr(jaxpr, (), *args)\n-@remat_p.def_abstract_eval\n+@remat_p.def_effectful_abstract_eval\ndef remat_abstract_eval(*args, jaxpr, prevent_cse, differentiated, policy):\ndel args, prevent_cse, differentiated, policy # Unused.\n- return [v.aval for v in jaxpr.outvars]\n+ if jaxpr.effects:\n+ raise NotImplementedError('Effects not supported in `remat`.')\n+ return [v.aval for v in jaxpr.outvars], jaxpr.effects\ndef remat_jvp(primals, tangents, jaxpr, prevent_cse, differentiated, policy):\nassert not jaxpr.constvars\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/custom_derivatives.py",
"new_path": "jax/_src/custom_derivatives.py",
"diff": "@@ -329,12 +329,14 @@ def _custom_jvp_call_jaxpr_impl(*args, fun_jaxpr: core.ClosedJaxpr, **params):\ndef _custom_jvp_call_jaxpr_abstract_eval(*args, fun_jaxpr: core.ClosedJaxpr, **params):\ndel args, params\n- return fun_jaxpr.out_avals\n+ if fun_jaxpr.effects:\n+ raise NotImplementedError('Effects not supported in `custom_jvp`.')\n+ return fun_jaxpr.out_avals, fun_jaxpr.effects\ncustom_jvp_call_jaxpr_p = core.AxisPrimitive('custom_jvp_call_jaxpr')\ncustom_jvp_call_jaxpr_p.multiple_results = True\ncustom_jvp_call_jaxpr_p.def_impl(_custom_jvp_call_jaxpr_impl)\n-custom_jvp_call_jaxpr_p.def_abstract_eval(_custom_jvp_call_jaxpr_abstract_eval)\n+custom_jvp_call_jaxpr_p.def_effectful_abstract_eval(_custom_jvp_call_jaxpr_abstract_eval)\nCustomJVPCallPrimitive.initial_style = custom_jvp_call_jaxpr_p\nmlir.register_lowering(custom_jvp_call_jaxpr_p, mlir.lower_fun(\n@@ -694,12 +696,14 @@ def _custom_vjp_call_jaxpr_impl(*args, fun_jaxpr, **_):\nreturn core.jaxpr_as_fun(fun_jaxpr)(*args)\ndef _custom_vjp_call_jaxpr_abstract_eval(*_, fun_jaxpr, **__):\n- return fun_jaxpr.out_avals\n+ if fun_jaxpr.effects:\n+ raise NotImplementedError('Effects not supported in `custom_vjp`.')\n+ return fun_jaxpr.out_avals, fun_jaxpr.effects\ncustom_vjp_call_jaxpr_p = core.AxisPrimitive('custom_vjp_call_jaxpr')\ncustom_vjp_call_jaxpr_p.multiple_results = True\ncustom_vjp_call_jaxpr_p.def_impl(_custom_vjp_call_jaxpr_impl)\n-custom_vjp_call_jaxpr_p.def_abstract_eval(_custom_vjp_call_jaxpr_abstract_eval)\n+custom_vjp_call_jaxpr_p.def_effectful_abstract_eval(_custom_vjp_call_jaxpr_abstract_eval)\nCustomVJPCallPrimitive.initial_style = custom_vjp_call_jaxpr_p\nmlir.register_lowering(custom_vjp_call_jaxpr_p, mlir.lower_fun(\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/dispatch.py",
"new_path": "jax/_src/dispatch.py",
"diff": "@@ -206,6 +206,8 @@ def lower_xla_callable(fun: lu.WrappedFun, device, backend, name,\n\"for jit in {elapsed_time} sec\"):\njaxpr, out_avals, consts = pe.trace_to_jaxpr_final(\nfun, abstract_args, pe.debug_info_final(fun, \"jit\"), which_explicit)\n+ if jaxpr.effects:\n+ raise NotImplementedError('Lowering jaxprs with effects not supported.')\nif any(isinstance(c, core.Tracer) for c in consts):\nraise UnexpectedTracerError(\"Encountered an unexpected tracer.\")\n# TODO(mattjj): handle argument pruning w/ dynamic shapes\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/control_flow.py",
"new_path": "jax/_src/lax/control_flow.py",
"diff": "@@ -314,23 +314,25 @@ def while_loop(cond_fun: Callable[[T], BooleanNumeric],\nnew_init_val, = tree_unflatten(in_tree, new_init_vals)\ninit_vals, init_avals, body_jaxpr, in_tree, *rest = _create_jaxpr(new_init_val)\ncond_jaxpr, cond_consts, body_consts, body_tree = rest\n- joined_effects = core.join_effects(body_jaxpr.effects, cond_jaxpr.effects)\n- if joined_effects:\n- raise NotImplementedError('Effects not supported in `while`.')\nin_tree_children = in_tree.children()\nassert len(in_tree_children) == 1\n_check_tree_and_avals(\"body_fun output and input\",\nbody_tree, body_jaxpr.out_avals,\nin_tree_children[0], init_avals)\n+ if cond_jaxpr.effects or body_jaxpr.effects:\n+ raise NotImplementedError('Effects not supported in `while`.')\nouts = while_p.bind(*cond_consts, *body_consts, *init_vals,\ncond_nconsts=len(cond_consts), cond_jaxpr=cond_jaxpr,\nbody_nconsts=len(body_consts), body_jaxpr=body_jaxpr)\nreturn tree_unflatten(body_tree, outs)\n-def _while_loop_abstract_eval(*args, body_jaxpr, **kwargs):\n+def _while_loop_abstract_eval(*args, cond_jaxpr, body_jaxpr, **kwargs):\ndel args, kwargs\n- return _map(raise_to_shaped, body_jaxpr.out_avals), core.no_effects\n+ if cond_jaxpr.effects or body_jaxpr.effects:\n+ raise NotImplementedError('Effects not supported in `while_loop`.')\n+ joined_effects = core.join_effects(cond_jaxpr.effects, body_jaxpr.effects)\n+ return _map(raise_to_shaped, body_jaxpr.out_avals), joined_effects\ndef _while_loop_translation_rule(ctx, avals_in, avals_out, *args, cond_jaxpr,\nbody_jaxpr, cond_nconsts, body_nconsts):\n@@ -796,11 +798,12 @@ def switch(index, branches: Sequence[Callable], *operands,\njaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\nbranches, ops_tree, ops_avals, primitive_name='switch')\n-\nfor i, (out_tree, jaxpr) in enumerate(zip(out_trees[1:], jaxprs[1:])):\n_check_tree_and_avals(f\"branch 0 and {i + 1} outputs\",\nout_trees[0], jaxprs[0].out_avals,\nout_tree, jaxpr.out_avals)\n+ if any(b.effects for b in jaxprs):\n+ raise NotImplementedError('Effects not supported in `switch`.')\nlinear = (False,) * (len(consts) + len(ops))\nout = cond_p.bind(\n@@ -879,15 +882,14 @@ def _cond(pred, true_fun: Callable, false_fun: Callable, *operands,\njaxprs, consts, out_trees = _initial_style_jaxprs_with_common_consts(\n(true_fun, false_fun), ops_tree, ops_avals, 'cond')\n- joined_effects = core.join_effects(*(jaxpr.effects for jaxpr in jaxprs))\n- if joined_effects:\n- raise NotImplementedError('Effects not supported in `cond`.')\ntrue_jaxpr, false_jaxpr = jaxprs\nout_tree, false_out_tree = out_trees\n_check_tree_and_avals(\"true_fun and false_fun output\",\nout_tree, true_jaxpr.out_avals,\nfalse_out_tree, false_jaxpr.out_avals)\n+ if any(b.effects for b in jaxprs):\n+ raise NotImplementedError('Effects not supported in `cond`.')\nindex = lax.convert_element_type(pred, np.int32)\n@@ -934,7 +936,10 @@ def _cond_with_per_branch_args(pred,\n(true_operand, false_operand))\ndef _cond_abstract_eval(*args, branches, **kwargs):\n- return _map(raise_to_shaped, branches[0].out_avals), core.no_effects\n+ if any(b.effects for b in branches):\n+ raise NotImplementedError('Effects not supported in `cond`.')\n+ joined_effects = core.join_effects(*(b.effects for b in branches))\n+ return _map(raise_to_shaped, branches[0].out_avals), joined_effects\ndef _cond_translation_rule(ctx, avals_in, avals_out, index, *args, branches,\nlinear):\n@@ -1128,8 +1133,6 @@ def _cond_partial_eval(trace, *tracers, branches, linear):\nlinear_2 = (False,) * num_res + linear\nparams = dict(branches=branches_2, linear=linear_2)\n- if any((branch.effects for branch in branches_2)):\n- raise NotImplementedError('Effects not supported in `cond`.')\nname_stack = source_info_util.current_name_stack()[len(trace.name_stack):]\nsource = source_info_util.current().replace(name_stack=name_stack)\neqn = pe.new_eqn_recipe(\n@@ -1282,6 +1285,8 @@ def _cond_typecheck(*avals, branches, linear):\njaxpr0 = branches[0]\njaxpr0_in_avals_str = _avals_short(jaxpr0.in_avals)\njaxpr0_out_avals_str = _avals_short(jaxpr0.out_avals)\n+ if any(b.effects for b in branches):\n+ raise NotImplementedError('Effects not supported in `cond`.')\nfor i, jaxpr in enumerate(branches[1:]):\nif len(jaxpr0.in_avals) != len(jaxpr.in_avals):\n@@ -1318,7 +1323,8 @@ def _cond_typecheck(*avals, branches, linear):\nraise core.JaxprTypeError(\nf'cond branches must have matching effect types: '\nf'{[b.effects for b in branches]}')\n- return None, core.no_effects\n+ joined_effects = core.join_effects(*(b.effects for b in branches))\n+ return None, joined_effects\ndef cond_bind(*args, branches, linear):\nif config.jax_enable_checks:\n@@ -1524,13 +1530,13 @@ def scan(f: Callable[[Carry, X], Tuple[Carry, Y]],\nnew_init = tree_unflatten(init_tree, new_init_flat)\ninit_flat, carry_avals, carry_avals_out, init_tree, *rest = _create_jaxpr(new_init)\nin_flat, jaxpr, consts, out_tree, out_tree_children = rest\n- if jaxpr.effects:\n- raise NotImplementedError('Effects not supported in `scan`.')\n_check_tree_and_avals(\"scan carry output and input\",\n# Extract the subtree and avals for the first element of the return tuple\nout_tree_children[0], carry_avals_out,\ninit_tree, carry_avals)\n+ if jaxpr.effects:\n+ raise NotImplementedError('Effects not supported in `scan`.')\nout = scan_p.bind(*consts, *in_flat,\nreverse=reverse, length=length, jaxpr=jaxpr,\n@@ -1723,6 +1729,8 @@ def _prepend_dim_to_aval(sz, aval):\ndef _scan_abstract_eval(*args, reverse, length, num_consts, num_carry, jaxpr,\nlinear, unroll):\n+ if jaxpr.effects:\n+ raise NotImplementedError('Effects not supported in `scan`.')\ncarry_avals, y_avals = split_list(jaxpr.out_avals, [num_carry])\nys_avals = _map(partial(_prepend_dim_to_aval, length), y_avals)\nreturn carry_avals + ys_avals, core.no_effects\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/core.py",
"new_path": "jax/core.py",
"diff": "@@ -2260,10 +2260,10 @@ def _check_jaxpr(\nelse:\nout_avals, effects = check_eqn(prim, in_avals, eqn.params)\nif eqn.effects != effects:\n- print(eqn.effects, effects)\nraise JaxprTypeError(\"Inferred effects do not match equation effects.\")\nif not eqn.effects.issubset(jaxpr.effects):\n- raise JaxprTypeError(\"Equation effects are not subset of Jaxpr effects.\")\n+ raise JaxprTypeError(\"Equation effects are not subset of Jaxpr effects. \"\n+ f\"Equation effects: {eqn.effects}. Jaxpr effects: {jaxpr.effects}\")\nmap(write, eqn.outvars, out_avals)\nexcept JaxprTypeError as e:\nctx, settings = ctx_factory()\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/maps.py",
"new_path": "jax/experimental/maps.py",
"diff": "@@ -1051,6 +1051,8 @@ def _dynamic_jaxpr_process_xmap(self, primitive, f, tracers, params):\nwith core.extend_axis_env_nd(global_axis_sizes.items()):\njaxpr, mapped_out_avals, consts = trace_to_subjaxpr_dynamic(\nf, self.main, mapped_in_avals)\n+ if jaxpr.effects:\n+ raise NotImplementedError('Effects not supported in `xmap`.')\nout_axes = params['out_axes_thunk']()\nif params['spmd_out_axes_thunk'] is not None:\nspmd_out_axes = params['spmd_out_axes_thunk']()\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/pjit.py",
"new_path": "jax/experimental/pjit.py",
"diff": "@@ -665,9 +665,11 @@ def _pjit_lower(\ndef _pjit_abstract_eval(*args, jaxpr, out_axis_resources, resource_env,\nout_positional_semantics, **_):\n+ if jaxpr.effects:\n+ raise NotImplementedError('Effects not supported in `pjit`.')\nreturn global_to_local(out_positional_semantics, resource_env.physical_mesh,\n- jaxpr.out_avals, out_axis_resources)\n-pjit_p.def_abstract_eval(_pjit_abstract_eval)\n+ jaxpr.out_avals, out_axis_resources), jaxpr.effects\n+pjit_p.def_effectful_abstract_eval(_pjit_abstract_eval)\ndef _pjit_translation_rule(ctx, avals_in, avals_out, *in_nodes, name,\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -1533,6 +1533,8 @@ class DynamicJaxprTrace(core.Trace):\nwith core.new_sublevel():\njaxpr, out_avals, consts = trace_to_subjaxpr_dynamic(\nf, self.main, in_avals, keep_inputs=keep_inputs)\n+ if jaxpr.effects:\n+ raise NotImplementedError('Effects not supported for call primitives.')\ntracers = [*im_tracers, *explicit_tracers]\nif params.get('inline', False):\nreturn core.eval_jaxpr(jaxpr, consts, *tracers)\n@@ -1552,7 +1554,7 @@ class DynamicJaxprTrace(core.Trace):\neqn = new_jaxpr_eqn([*constvars, *invars], outvars,\ncall_primitive, new_params,\nnew_params['call_jaxpr'].effects, source_info)\n- self.frame.eqns.append(eqn)\n+ self.frame.add_eqn(eqn)\nreturn out_tracers\ndef post_process_call(self, call_primitive, out_tracers, params):\n@@ -1568,6 +1570,8 @@ class DynamicJaxprTrace(core.Trace):\nwith core.new_sublevel():\njaxpr, reduced_out_avals, consts = trace_to_subjaxpr_dynamic(\nf, self.main, reduced_in_avals)\n+ if jaxpr.effects:\n+ raise NotImplementedError('Effects not supported for map primitives.')\nout_axes = params['out_axes_thunk']()\nout_avals = [core.unmapped_aval(axis_size, axis_name, out_axis, a)\nif out_axis is not None else a\n@@ -1586,7 +1590,7 @@ class DynamicJaxprTrace(core.Trace):\nnew_params = update_params(new_params, [True] * len(tracers), len(consts))\neqn = new_jaxpr_eqn([*constvars, *invars], outvars, map_primitive,\nnew_params, new_params['call_jaxpr'].effects, source_info)\n- self.frame.eqns.append(eqn)\n+ self.frame.add_eqn(eqn)\nreturn out_tracers\ndef post_process_map(self, map_primitive, out_tracers, params):\n@@ -1596,6 +1600,8 @@ class DynamicJaxprTrace(core.Trace):\nin_avals = [t.aval for t in tracers]\nwith core.new_sublevel():\nfun_jaxpr, out_avals, consts = trace_to_subjaxpr_dynamic(fun, self.main, in_avals)\n+ if fun_jaxpr.effects:\n+ raise NotImplementedError('Effects not supported in `custom_jvp`.')\nclosed_fun_jaxpr = core.ClosedJaxpr(convert_constvars_jaxpr(fun_jaxpr), ())\nmain_ = ref(self.main)\njvp_jaxpr_thunk = _memoize(\n@@ -1610,7 +1616,7 @@ class DynamicJaxprTrace(core.Trace):\nnum_consts=len(consts)),\nfun_jaxpr.effects,\nsource_info_util.current())\n- self.frame.eqns.append(eqn)\n+ self.frame.add_eqn(eqn)\nreturn out_tracers\ndef post_process_custom_jvp_call(self, out_tracers, _):\n@@ -1620,6 +1626,8 @@ class DynamicJaxprTrace(core.Trace):\nin_avals = [t.aval for t in tracers]\nwith core.new_sublevel():\nfun_jaxpr, out_avals, consts = trace_to_subjaxpr_dynamic(fun, self.main, in_avals)\n+ if fun_jaxpr.effects:\n+ raise NotImplementedError('Effects not supported in `custom_vjp`.')\nclosed_fun_jaxpr = core.ClosedJaxpr(convert_constvars_jaxpr(fun_jaxpr), ())\nmain_ = ref(self.main)\nfwd_jaxpr_thunk = _memoize(\n@@ -1635,7 +1643,7 @@ class DynamicJaxprTrace(core.Trace):\nbwd=bwd, out_trees=out_trees),\nfun_jaxpr.effects,\nsource_info_util.current())\n- self.frame.eqns.append(eqn)\n+ self.frame.add_eqn(eqn)\nreturn out_tracers\ndef post_process_custom_vjp_call(self, out_tracers, _):\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/jaxpr_effects_test.py",
"new_path": "tests/jaxpr_effects_test.py",
"diff": "# 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+import unittest\nfrom absl.testing import absltest\n+from absl.testing import parameterized\nimport jax\nimport jax.numpy as jnp\n+from jax import ad_checkpoint\nfrom jax import core\nfrom jax import lax\n+from jax import linear_util as lu\n+from jax.experimental import maps\n+from jax.experimental import pjit\nfrom jax.config import config\nfrom jax._src import test_util as jtu\n+import numpy as np\nconfig.parse_flags_with_absl()\n@@ -70,6 +77,114 @@ class JaxprEffectsTest(jtu.JaxTestCase):\n'Equation effects are not subset of Jaxpr effects.'):\ncore.check_jaxpr(jaxpr)\n+class HigherOrderPrimitiveTest(jtu.JaxTestCase):\n+\n+ def test_core_call_primitive_inherits_effects(self):\n+\n+ def f(x):\n+ @lu.wrap_init\n+ def f_(x):\n+ effect_p.bind(effect='foo')\n+ effect_p.bind(effect='bar')\n+ return [x]\n+ return core.call(f_, x)[0]\n+ with self.assertRaisesRegex(NotImplementedError, 'Effects not supported'):\n+ jax.make_jaxpr(f)(2.)\n+\n+ def test_xla_call_primitive_inherits_effects(self):\n+\n+ @jax.jit\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ effect_p.bind(effect='bar')\n+ return x\n+ with self.assertRaisesRegex(NotImplementedError, 'Effects not supported'):\n+ jax.make_jaxpr(f)(2.)\n+\n+ @parameterized.named_parameters(jtu.cases_from_list(\n+ dict(testcase_name=f\"_{flavor}\", flavor=flavor)\n+ for flavor in [\"old\", \"new\"]))\n+ def test_remat_call_primitive_inherits_effects(self, flavor):\n+ remat = jax.remat if flavor == \"old\" else ad_checkpoint.checkpoint\n+\n+ @remat\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ effect_p.bind(effect='bar')\n+ return x\n+ with self.assertRaisesRegex(NotImplementedError, 'Effects not supported'):\n+ jax.make_jaxpr(f)(2.)\n+\n+ def test_custom_jvp_primitive_inherits_effects(self):\n+\n+ @jax.custom_jvp\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ effect_p.bind(effect='bar')\n+ return x\n+ f.defjvp(lambda x, t: (x, t))\n+ with self.assertRaisesRegex(NotImplementedError, 'Effects not supported'):\n+ jax.make_jaxpr(f)(2.)\n+\n+ def test_custom_vjp_primitive_inherits_effects(self):\n+\n+ @jax.custom_vjp\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ effect_p.bind(effect='bar')\n+ return x\n+ f.defvjp(\n+ fwd=lambda x: (x, ()),\n+ bwd=lambda _, g: g)\n+ with self.assertRaisesRegex(NotImplementedError, 'Effects not supported'):\n+ jax.make_jaxpr(f)(2.)\n+\n+ def test_pmap_inherits_effects(self):\n+\n+ @jax.pmap\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ effect_p.bind(effect='bar')\n+ return x\n+ with self.assertRaisesRegex(NotImplementedError, 'Effects not supported'):\n+ jax.make_jaxpr(f)(jnp.arange(jax.local_device_count()))\n+\n+ def test_xmap_inherits_effects(self):\n+\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ effect_p.bind(effect='bar')\n+ return x\n+ f = maps.xmap(f, in_axes=['a'], out_axes=['a'])\n+ with self.assertRaisesRegex(NotImplementedError, 'Effects not supported'):\n+ jax.make_jaxpr(f)(jnp.arange(jax.local_device_count()))\n+\n+ def test_pjit_inherits_effects(self):\n+ if jax.default_backend() not in {'gpu', 'tpu'}:\n+ raise unittest.SkipTest(\"pjit only supports GPU and TPU backends\")\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ effect_p.bind(effect='bar')\n+ return x\n+ f = pjit.pjit(f, in_axis_resources=pjit.PartitionSpec('x'),\n+ out_axis_resources=pjit.PartitionSpec('x'))\n+ with self.assertRaisesRegex(NotImplementedError, 'Effects not supported'):\n+ with maps.Mesh(np.array(jax.devices()), ['x']):\n+ jax.make_jaxpr(f)(jnp.arange(jax.local_device_count()))\n+\n+\n+class EffectfulJaxprLoweringTest(jtu.JaxTestCase):\n+\n+ def test_cannot_lower_jaxpr_with_effects_in_hop(self):\n+ @jax.jit\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ return x + 1.\n+ with self.assertRaisesRegex(NotImplementedError, 'Lowering jaxprs with '\n+ 'effects not supported'):\n+ f(2.)\n+\n+\nclass ControlFlowEffectsTest(jtu.JaxTestCase):\ndef test_effects_disallowed_in_cond(self):\n"
}
] | Python | Apache License 2.0 | google/jax | Add tests for higher order primitives |
260,591 | 11.04.2022 13:53:44 | 0 | 128e51c6386be1af5acee294c146956a16b38c5f | Add polydiv to jax.numpy
Fix code style, fix tests
Add warning when use polydiv with trim_leading_zeros
Update warning for polydiv
Enable type check in _CompileAndCheck
Fix cutoff
Fix cut-off in polydiv
Add trim_zeros_tol, remove redundant code in polydiv
Remove unused import
Fix trim_zero_tol usage in polydiv | [
{
"change_type": "MODIFY",
"old_path": "docs/jax.numpy.rst",
"new_path": "docs/jax.numpy.rst",
"diff": "@@ -305,6 +305,7 @@ namespace; they are listed below.\npoly\npolyadd\npolyder\n+ polydiv\npolyfit\npolyint\npolymul\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/numpy/lax_numpy.py",
"new_path": "jax/_src/numpy/lax_numpy.py",
"diff": "@@ -2543,6 +2543,17 @@ def trim_zeros(filt, trim='fb'):\nreturn filt[start:len(filt) - end]\n+def trim_zeros_tol(filt, tol, trim='fb'):\n+ filt = core.concrete_or_error(asarray, filt,\n+ \"Error arose in the `filt` argument of trim_zeros_tol()\")\n+ nz = (abs(filt) < tol)\n+ if all(nz):\n+ return empty(0, _dtype(filt))\n+ start = argmin(nz) if 'f' in trim.lower() else 0\n+ end = argmin(nz[::-1]) if 'b' in trim.lower() else 0\n+ return filt[start:len(filt) - end]\n+\n+\n@_wraps(np.append)\n@partial(jit, static_argnames=('axis',))\ndef append(arr, values, axis: Optional[int] = None):\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/numpy/polynomial.py",
"new_path": "jax/_src/numpy/polynomial.py",
"diff": "@@ -21,7 +21,7 @@ from jax import jit\nfrom jax import lax\nfrom jax._src.numpy.lax_numpy import (\nall, arange, argmin, array, asarray, atleast_1d, concatenate, convolve, diag, dot, finfo,\n- full, hstack, maximum, ones, outer, sqrt, trim_zeros, true_divide, vander, zeros)\n+ full, hstack, maximum, ones, outer, sqrt, trim_zeros, trim_zeros_tol, true_divide, vander, zeros)\nfrom jax._src.numpy import linalg\nfrom jax._src.numpy.util import _check_arraylike, _promote_dtypes, _promote_dtypes_inexact, _wraps\nimport numpy as np\n@@ -277,6 +277,9 @@ def polyder(p, m=1):\n_LEADING_ZEROS_DOC = \"\"\"\\\nSetting trim_leading_zeros=True makes the output match that of numpy.\nBut prevents the function from being able to be used in compiled code.\n+Due to differences in accumulation of floating point arithmetic errors, the cutoff for values to be\n+considered zero may lead to inconsistent results between NumPy and JAX, and even between different\n+JAX backends. The result may lead to inconsistent output shapes when trim_leading_zeros=True.\n\"\"\"\n@_wraps(np.polymul, lax_description=_LEADING_ZEROS_DOC)\n@@ -292,6 +295,23 @@ def polymul(a1, a2, *, trim_leading_zeros=False):\nval = convolve(a1, a2, mode='full')\nreturn val\n+@_wraps(np.polydiv, lax_description=_LEADING_ZEROS_DOC)\n+def polydiv(u, v, *, trim_leading_zeros=False):\n+ _check_arraylike(\"polydiv\", u, v)\n+ u, v = _promote_dtypes_inexact(u, v)\n+ m = len(u) - 1\n+ n = len(v) - 1\n+ scale = 1. / v[0]\n+ q = zeros(max(m - n + 1, 1), dtype = u.dtype) # force same dtype\n+ for k in range(0, m-n+1):\n+ d = scale * u[k]\n+ q = q.at[k].set(d)\n+ u = u.at[k:k+n+1].add(-d*v)\n+ if trim_leading_zeros:\n+ # use the square root of finfo(dtype) to approximate the absolute tolerance used in numpy\n+ return q, trim_zeros_tol(u, tol=sqrt(finfo(u.dtype).eps), trim='f')\n+ else:\n+ return q, u\n@_wraps(np.polysub)\n@jit\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/numpy/__init__.py",
"new_path": "jax/numpy/__init__.py",
"diff": "@@ -298,6 +298,7 @@ from jax._src.numpy.polynomial import (\npoly as poly,\npolyadd as polyadd,\npolyder as polyder,\n+ polydiv as polydiv,\npolyfit as polyfit,\npolyint as polyint,\npolymul as polymul,\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_test.py",
"new_path": "tests/lax_numpy_test.py",
"diff": "@@ -2874,6 +2874,37 @@ class LaxBackedNumpyTests(jtu.JaxTestCase):\nself._CheckAgainstNumpy(np_fun, jnp_fun_np, args_maker, check_dtypes=False, tol=tol)\nself._CompileAndCheck(jnp_fun_co, args_maker, check_dtypes=False)\n+ @parameterized.named_parameters(jtu.cases_from_list(\n+ {\"testcase_name\": \"a_shape={} , b_shape={}\".format(\n+ jtu.format_shape_dtype_string(a_shape, dtype),\n+ jtu.format_shape_dtype_string(b_shape, dtype)),\n+ \"dtype\": dtype, \"a_shape\": a_shape, \"b_shape\" : b_shape}\n+ for dtype in default_dtypes\n+ for a_shape in one_dim_array_shapes\n+ for b_shape in one_dim_array_shapes))\n+ def testPolyDiv(self, a_shape, b_shape, dtype):\n+ rng = jtu.rand_default(self.rng())\n+\n+ def np_fun(arg1, arg2):\n+ q, r = np.polydiv(arg1, arg2)\n+ while r.size < max(arg1.size, arg2.size): # Pad residual to same size\n+ r = np.pad(r, (1, 0), 'constant')\n+ return q, r\n+\n+ def jnp_fun(arg1, arg2):\n+ q, r = jnp.polydiv(arg1, arg2, trim_leading_zeros=True)\n+ while r.size < max(arg1.size, arg2.size): # Pad residual to same size\n+ r = jnp.pad(r, (1, 0), 'constant')\n+ return q, r\n+\n+ args_maker = lambda: [rng(a_shape, dtype), rng(b_shape, dtype)]\n+ tol = {np.float16: 2e-1, np.float32: 5e-2, np.float64: 1e-13}\n+\n+ jnp_compile = jnp.polydiv # Without trim_leading_zeros (trim_zeros make it unable to be compiled by XLA)\n+ self._CheckAgainstNumpy(np_fun, jnp_fun, args_maker, check_dtypes=False, tol=tol)\n+ self._CompileAndCheck(jnp_compile, args_maker, check_dtypes=True, atol=tol, rtol=tol)\n+\n+\n@parameterized.named_parameters(jtu.cases_from_list(\n{\"testcase_name\": \"_shape={}_offset={}_axis1={}_axis2={}\".format(\njtu.format_shape_dtype_string(shape, dtype), offset, axis1, axis2),\n"
}
] | Python | Apache License 2.0 | google/jax | Add polydiv to jax.numpy
Fix code style, fix tests
Add warning when use polydiv with trim_leading_zeros
Update warning for polydiv
Co-authored-by: Jake Vanderplas <jakevdp@gmail.com>
Enable type check in _CompileAndCheck
Fix cutoff
Fix cut-off in polydiv
Add trim_zeros_tol, remove redundant code in polydiv
Remove unused import
Fix trim_zero_tol usage in polydiv |
260,510 | 06.04.2022 17:52:56 | 25,200 | 1b60e353a220c6f93ed6e5f1cef6e7aaae8aa763 | Enable context manager name stack with `jax2tf` | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/jax2tf.py",
"new_path": "jax/experimental/jax2tf/jax2tf.py",
"diff": "@@ -66,6 +66,7 @@ from tensorflow.compiler.xla.experimental.xla_sharding import xla_sharding # ty\nfrom tensorflow.python.framework import ops as tf_ops # type: ignore[import]\n# pylint: enable=g-direct-tensorflow-import\n+NameStack = source_info_util.NameStack\nPolyShape = shape_poly.PolyShape\n# A temporary internal flag, to enable the wrapping of jax.jit functions\n@@ -78,7 +79,7 @@ _WRAP_JAX_JIT_WITH_TF_FUNCTION = False\n# The scope name need to be a valid TensorFlow name. See\n# https://github.com/tensorflow/tensorflow/blob/r2.3/tensorflow/core/framework/node_def_util.cc#L731\n_VALID_SCOPE_REGEX = re.compile(\"^[A-Za-z0-9.][A-Za-z0-9_.\\\\/>-]*$\")\n-_INVALID_SCOPE_CHAR = re.compile(\"[^A-Za-z0-9_.\\\\/>-]\")\n+_INVALID_SCOPE_CHAR = re.compile(\"[^A-Za-z0-9_.\\\\/-]\")\nmap = util.safe_map\nzip = util.safe_zip\n@@ -177,7 +178,9 @@ class _ThreadLocalState(threading.local):\n_thread_local_state = _ThreadLocalState()\n-def _get_current_name_stack():\n+def _get_current_name_stack() -> Union[NameStack, str]:\n+ if config.jax_experimental_name_stack:\n+ return source_info_util.current_name_stack()\nreturn _thread_local_state.name_stack\n@contextlib.contextmanager\n@@ -263,7 +266,7 @@ def convert(fun: Callable,\n\"\"\"\napi._check_callable(fun)\nfun_name = getattr(fun, \"__name__\", \"unknown\")\n- name_stack = util.wrap_name(fun_name, \"jax2tf\") + \"/\"\n+ name_stack = util.wrap_name(fun_name, \"jax2tf\")\ndef converted_fun(*args: TfVal, **kwargs: TfVal) -> TfVal:\n# TODO: is there a better way to check if we are inside a transformation?\nif not core.trace_state_clean() and not _thread_local_state.inside_call_tf:\n@@ -477,6 +480,13 @@ def dtype_of_val(val: TfVal) -> DType:\n@contextlib.contextmanager\ndef _extended_name_stack(extra_name_stack: Optional[str]):\n+ if config.jax_experimental_name_stack:\n+ name_ctx = (source_info_util.extend_name_stack(extra_name_stack)\n+ if extra_name_stack\n+ else contextlib.nullcontext())\n+ with name_ctx:\n+ yield\n+ return\nprev_name_stack = _thread_local_state.name_stack\nif extra_name_stack:\nif not prev_name_stack:\n@@ -822,9 +832,24 @@ class TensorFlowTrace(core.Trace):\nelse:\nreturn impl(*args_tf, **params)\n+ current_name_stack = _get_current_name_stack()\n+ if config.jax_experimental_name_stack:\n+ # We don't use `str(name_stack)` because it uses parentheses for\n+ # transformations, which aren't allowed in `name_scope`.\n+ scope = '/'.join([s.name for s in current_name_stack.stack]) # type: ignore[union-attr]\n+ else:\n+ scope = str(current_name_stack)\n+ # We need to add a '/' to the name stack string to force `tf.name_scope`\n+ # to interpret it as an absolute scope, not a relative scope.\n+ scope = scope + '/'\n+ name_scope = (\n+ tf.name_scope(_sanitize_scope_name(scope)) if\n+ config.jax_experimental_name_stack else contextlib.nullcontext())\n+\n+ with name_scope:\nif _thread_local_state.include_xla_op_metadata:\nop_metadata = xla.make_op_metadata(primitive, params,\n- name_stack=_get_current_name_stack(),\n+ name_stack=current_name_stack,\nsource_info=source_info_util.current())\nop_metadata_proto = xla_data_pb2.OpMetadata(\nop_type=op_metadata.op_type,\n@@ -2254,6 +2279,10 @@ def _cond(index: TfVal, *operands: TfVal, branches: Sequence[core.ClosedJaxpr],\nfor jaxpr in branches\nfor i, jaxpr in enumerate(branches)\n]\n+ if config.jax_experimental_name_stack:\n+ # Same name stack as XLA translation of cond_p\n+ branches_tf = list(map(source_info_util.extend_name_stack(\"cond\"),\n+ branches_tf))\nreturn tf.switch_case(index, branches_tf)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/tests/jax2tf_test.py",
"new_path": "jax/experimental/jax2tf/tests/jax2tf_test.py",
"diff": "@@ -701,6 +701,10 @@ class Jax2TfTest(tf_test_util.JaxToTfTestCase):\nf_tf_graph = f_tf.get_concrete_function(arg).graph.as_graph_def()\nif flavor == \"old\":\nraise unittest.SkipTest(\"TODO: CSE widget not yet implemented for old-style remat\")\n+ if config.jax_experimental_name_stack:\n+ self.assertRegex(str(f_tf_graph),\n+ r'transpose/jax2tf_f_/jvp/checkpoint/remat_checkpoint_/cond/branch_1_fun/Sin')\n+ else:\nself.assertRegex(str(f_tf_graph),\nr'remat_checkpoint_/switch_case/indexed_case/Sin')\n"
}
] | Python | Apache License 2.0 | google/jax | Enable context manager name stack with `jax2tf` |
260,424 | 14.04.2022 04:31:55 | 25,200 | e187428a54d65114598807f92f12dd2efda0952b | Restructure checkify files. | [
{
"change_type": "RENAME",
"old_path": "jax/experimental/checkify/checkify_impl.py",
"new_path": "jax/_src/checkify.py",
"diff": ""
},
{
"change_type": "RENAME",
"old_path": "jax/experimental/checkify/__init__.py",
"new_path": "jax/experimental/checkify.py",
"diff": "# limitations under the License.\n# flake8: noqa: F401\n-from jax.experimental.checkify.checkify_impl import (\n+from jax._src.checkify import (\nError as Error,\nErrorCategory as ErrorCategory,\nall_checks as all_checks,\n"
}
] | Python | Apache License 2.0 | google/jax | Restructure checkify files.
PiperOrigin-RevId: 441726310 |
260,335 | 13.04.2022 13:44:42 | 25,200 | d21b958f30ea6f87c85ecc1c423061bd4f17ce1d | add some simple iree tests
This passes, though two of the interesting tests fail with what might be IREE
bugs (and so are currently skipped):
```shell
JAX_PLATFORMS='iree' pytest -n auto tests/core_test.py tests/api_test.py -k Dynamic
``` | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/dispatch.py",
"new_path": "jax/_src/dispatch.py",
"diff": "@@ -228,7 +228,7 @@ def lower_xla_callable(fun: lu.WrappedFun, device, backend, name,\nbackend = xb.get_device_backend(device) if device else xb.get_backend(backend)\nif (config.jax_dynamic_shapes and jaxpr_has_bints(jaxpr) and\n- backend.platform != 'iree'):\n+ not _backend_supports_unbounded_dynamic_shapes(backend)):\njaxpr, consts = pe.pad_jaxpr(jaxpr, consts)\n# Computations that only produce constants and/or only rearrange their inputs,\n@@ -281,6 +281,10 @@ def lower_xla_callable(fun: lu.WrappedFun, device, backend, name,\nin_avals=abstract_args, out_avals=out_avals, kept_var_idx=kept_var_idx)\n+def _backend_supports_unbounded_dynamic_shapes(backend: Backend) -> bool:\n+ return backend.platform == 'iree'\n+\n+\ndef prefetch(x):\nif isinstance(x, device_array.DeviceArray):\nx.copy_to_host_async()\n@@ -408,12 +412,14 @@ num_buffers_handlers[core.ShapedArray] = lambda _: 1\nnum_buffers_handlers[core.ConcreteArray] = lambda _: 1\n-def _input_handler(which_explicit: Optional[Sequence[bool]],\n+def _input_handler(backend: Backend,\n+ which_explicit: Optional[Sequence[bool]],\nin_avals: Sequence[core.AbstractValue]\n) -> Optional[Callable]:\n# Extract implicit inputs, and pad bounded-size inputs to their max size.\nneeds_implicit = which_explicit and not all(which_explicit)\n- needs_padding = any(type(in_avals[d.val]) is core.AbstractBInt # type: ignore\n+ needs_padding = any(backend.platform != 'iree' and\n+ type(in_avals[d.val]) is core.AbstractBInt # type: ignore\nfor a in in_avals if type(a) is core.DShapedArray\nfor d in a.shape if type(d) is pe.DBIdx)\n@@ -448,13 +454,16 @@ def _input_handler(which_explicit: Optional[Sequence[bool]],\nexplicit_args_ = iter(explicit_args)\nargs = [next(explicit_args_) if ex else None for ex in which_explicit]\nassert next(explicit_args_, None) is None\n+ assert needs_implicit\nfor i, j, k in implicit_args_from_axes:\nif args[i] is None:\nargs[i] = args[j].shape[k] # type: ignore\nelse:\nif args[i] != args[j].shape[k]:\nraise Exception(\"inconsistent argument axis sizes for type\")\n- return tuple([pad(x) if pad else x for x, pad in zip(args, padders)])\n+ if needs_padding:\n+ args = tuple([pad(x) if pad else x for x, pad in zip(args, padders)])\n+ return args\nreturn elaborate_and_pad\ndef _pad_arg(shape, x):\n@@ -686,7 +695,7 @@ class XlaCompiledComputation(stages.Executable):\nout_avals: Sequence[core.AbstractValue],\nkept_var_idx: Set[int]) -> XlaCompiledComputation:\nsticky_device = device\n- input_handler = _input_handler(explicit_args, in_avals)\n+ input_handler = _input_handler(backend, explicit_args, in_avals)\nresult_handlers = map(partial(aval_to_result_handler, sticky_device),\nout_avals)\noptions = xb.get_compile_options(\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/iree.py",
"new_path": "jax/_src/iree.py",
"diff": "@@ -20,7 +20,9 @@ using IREE to compile and run JAX computations instead of XLA.\n# pytype: skip-file\n-from typing import Any, List, Sequence\n+from __future__ import annotations\n+\n+from typing import Any, List, Sequence, Optional\nimport iree.compiler\nfrom iree import runtime as iree_runtime\n@@ -48,7 +50,7 @@ class IreeDevice:\ndef transfer_from_outfeed(self, shape: xla_client.Shape):\nraise NotImplementedError(\"transfer_to_outfeed\")\n- def live_buffers(self) -> List['IreeBuffer']:\n+ def live_buffers(self) -> List[IreeBuffer]:\nraise NotImplementedError(\"live_buffers\")\n@@ -57,6 +59,7 @@ class IreeBuffer(xla_client.DeviceArrayBase):\ndef __init__(self, client, device, npy_value):\nself.client = client\nself._device = device\n+ assert device is not None\nself._npy_value = np.asarray(npy_value)\ndef copy_to_device(self, device):\n@@ -74,6 +77,9 @@ class IreeBuffer(xla_client.DeviceArrayBase):\ndef device(self):\nreturn self._device\n+ def block_until_ready(self) -> IreeBuffer:\n+ return self # no async\n+\nclass IreeExecutable:\ndef __init__(self, client, devices, module_object, function_name):\n@@ -136,8 +142,12 @@ class IreeClient:\ndef compile(self, computation: str,\ncompile_options: xla_client.CompileOptions) -> IreeExecutable:\n+ del compile_options # Ignored.\niree_binary = iree.compiler.compile_str(\n- computation, target_backends=[\"dylib\"], input_type=\"mhlo\")\n+ computation, target_backends=[\"dylib\"], input_type=\"mhlo\",\n+ # extra_args=[\"--print-ir-after-all\"],\n+ # extended_diagnostics=True,\n+ )\n# Load it into the runtime.\nvm_module = iree_runtime.binding.VmModule.from_flatbuffer(iree_binary)\nmodule_object = iree_runtime.load_vm_module(vm_module, self.iree_config)\n@@ -146,13 +156,16 @@ class IreeClient:\ndef buffer_from_pyval(\nself,\nargument: Any,\n- device: IreeDevice,\n+ device: Optional[IreeDevice],\nforce_copy: bool = True,\nhost_buffer_semantics: xla_client.HostBufferSemantics = xla_client\n.HostBufferSemantics.ZERO_COPY\n) -> IreeBuffer:\n# TODO(phawkins): IREE's python API will accept a numpy array directly but\n# may want to explicitly construct a lower level BufferView to avoid copies.\n+ if device is None:\n+ assert type(argument) is np.ndarray\n+ device = self._devices[0]\nreturn IreeBuffer(self, device, np.array(argument, copy=True))\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/lax.py",
"new_path": "jax/_src/lax/lax.py",
"diff": "@@ -2784,9 +2784,19 @@ pe.forwarding_rules[broadcast_in_dim_p] = _broadcast_in_dim_fwd_rule\npe.custom_staging_rules[broadcast_in_dim_p] = _broadcast_in_dim_staging_rule\npe.padding_rules[broadcast_in_dim_p] = _broadcast_in_dim_padding_rule\n-def _broadcast_in_dim_lower(ctx, x, *, shape, broadcast_dimensions):\n- del shape\n+def _broadcast_in_dim_lower(ctx, x, *dyn_shape, shape, broadcast_dimensions):\naval_out, = ctx.avals_out\n+ if dyn_shape:\n+ dyn_shape = iter(dyn_shape)\n+ shape = [next(dyn_shape) if d is None else d for d in shape]\n+ assert next(dyn_shape, None) is None\n+ return mhlo.DynamicBroadcastInDimOp(\n+ mlir.aval_to_ir_type(aval_out), x,\n+ mlir.shape_tensor(shape),\n+ mlir.dense_int_elements(broadcast_dimensions),\n+ None, None,\n+ ).results\n+ else:\nreturn mhlo.BroadcastInDimOp(\nmlir.aval_to_ir_type(aval_out), x,\nmlir.dense_int_elements(broadcast_dimensions)\n@@ -4485,6 +4495,7 @@ def bint_abstract_eval(_, *, bd: int):\nreturn core.AbstractBInt(bound=bd)\npe.padding_rules[bint_p] = lambda _, __, i, bd: [i]\n+mlir.register_lowering(bint_p, lambda ctx, x, bd: [x])\n### util\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/slicing.py",
"new_path": "jax/_src/lax/slicing.py",
"diff": "@@ -812,7 +812,6 @@ batching.primitive_batchers[slice_p] = _slice_batching_rule\nmasking.masking_rules[slice_p] = _slice_masking_rule\ndef _slice_lower(ctx, x, *, start_indices, limit_indices, strides):\n- aval_out, = ctx.avals_out\nstrides = strides or [1] * len(start_indices)\nreturn mhlo.SliceOp(x,\nmlir.dense_int_elements(start_indices),\n@@ -2142,3 +2141,11 @@ def _getslice_padding_rule(in_avals, out_avals, x, lo, hi):\nxx = lax.concatenate([x, x], 0)\nreturn [dynamic_slice_in_dim(xx, lo, x.shape[0])]\npe.padding_rules[getslice_p] = _getslice_padding_rule\n+\n+def _getslice_lower(ctx, x, lo, hi):\n+ aval_out, = ctx.avals_out\n+ return mhlo.RealDynamicSliceOp(\n+ mlir.aval_to_ir_type(aval_out), x,\n+ mlir.shape_tensor([lo]), mlir.shape_tensor([hi]), mlir.shape_tensor([1])\n+ ).results\n+mlir.register_lowering(getslice_p, _getslice_lower)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/numpy/lax_numpy.py",
"new_path": "jax/_src/numpy/lax_numpy.py",
"diff": "@@ -41,7 +41,7 @@ from jax import jit\nfrom jax import core\nfrom jax import errors\nfrom jax import lax\n-from jax.core import ShapedArray, DShapedArray, ConcreteArray, canonicalize_shape\n+from jax.core import ShapedArray, DShapedArray, ConcreteArray\nfrom jax.interpreters import pxla\nfrom jax.tree_util import tree_leaves, tree_flatten, tree_map\n@@ -81,6 +81,15 @@ from jax._src.util import (unzip2, prod as _prod, subvals, safe_zip, ceil_of_rat\nnewaxis = None\n+# Like core.canonicalize_shape, but also accept int-like (non-sequence)\n+# arguments for `shape`.\n+def canonicalize_shape(\n+ shape: Union[core.Shape, int, core.Tracer], context: str=\"\") -> core.Shape:\n+ if isinstance(shape, core.Tracer) or ndim(shape) == 0:\n+ return core.canonicalize_shape((shape,), context)\n+ else:\n+ return core.canonicalize_shape(shape, context) # type: ignore\n+\n# Common docstring additions:\n_PRECISION_DOC = \"\"\"\\\n@@ -1923,15 +1932,15 @@ def zeros(shape, dtype=None):\nif isinstance(shape, types.GeneratorType):\nraise TypeError(\"expected sequence object with len >= 0 or a single integer\")\nlax_internal._check_user_dtype_supported(dtype, \"zeros\")\n- shape = canonicalize_shape((shape,) if ndim(shape) == 0 else shape)\n+ shape = canonicalize_shape(shape)\nreturn lax.full(shape, 0, _jnp_dtype(dtype))\n@_wraps(np.ones)\ndef ones(shape, dtype=None):\nif isinstance(shape, types.GeneratorType):\nraise TypeError(\"expected sequence object with len >= 0 or a single integer\")\n+ shape = canonicalize_shape(shape)\nlax_internal._check_user_dtype_supported(dtype, \"ones\")\n- shape = canonicalize_shape((shape,) if ndim(shape) == 0 else shape)\nreturn lax.full(shape, 1, _jnp_dtype(dtype))\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/mlir.py",
"new_path": "jax/interpreters/mlir.py",
"diff": "@@ -83,6 +83,14 @@ def dense_bool_elements(xs: Sequence[bool]) -> ir.DenseElementsAttr:\ndef i32_attr(i): return ir.IntegerAttr.get(ir.IntegerType.get_signless(32), i)\ndef i64_attr(i): return ir.IntegerAttr.get(ir.IntegerType.get_signless(64), i)\n+def shape_tensor(sizes: Sequence[Union[int, ir.RankedTensorType]]\n+ ) -> ir.RankedTensorType:\n+ sizes = [ir_constant(np.array(d, np.dtype('int32'))) if type(d) is int else d\n+ for d in sizes]\n+ int1d = aval_to_ir_type(core.ShapedArray((1,), np.dtype('int32')))\n+ return mhlo.ConcatenateOp([mhlo.ReshapeOp(int1d, d) for d in sizes],\n+ i64_attr(0)).results\n+\n# IR Types\n@@ -666,8 +674,7 @@ def lower_jaxpr_to_fun(\nif not use_sharding_annotations and ir_arg_shardings is not None:\nflat_args = map(wrap_with_sharding_op, flat_args, ir_arg_shardings)\n- unflattened_args = util.unflatten(flat_args,\n- map(len, input_types))\n+ unflattened_args = util.unflatten(flat_args, map(len, input_types))\nargs: List[List[ir.Value]] = []\nfor aval, arg in zip(jaxpr.in_avals, unflattened_args):\nif replace_units_with_dummy and aval is core.abstract_unit:\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/api_test.py",
"new_path": "tests/api_test.py",
"diff": "@@ -8116,21 +8116,46 @@ class DynamicShapeTest(jtu.JaxTestCase):\nself.assertIsInstance(three_, int)\nself.assertEqual(three_, 3)\n+ @unittest.skipIf(jtu.device_under_test() != 'iree', \"iree test\")\ndef test_jit_basic_iree(self):\nif not jtu.device_under_test() == 'iree':\nraise unittest.SkipTest(\"test only works on IREE\")\n+\n@jax.jit\ndef f(i):\nreturn jnp.sum(jnp.ones(i, dtype='float32'))\nself.assertAllClose(f(3), jnp.array(3., dtype='float32'), check_dtypes=True)\n+ @unittest.skipIf(jtu.device_under_test() != 'iree', \"iree test\")\n+ def test_jit_basic_iree_2(self):\n+ count = 0\n+\n+ @partial(jax.jit, abstracted_axes=('n',))\n+ def f(x):\n+ nonlocal count\n+ count += 1\n+ return jnp.sum(x)\n+\n+ x = f(jnp.arange(3))\n+ y = f(jnp.arange(4))\n+ self.assertAllClose(x, 3., check_dtypes=False)\n+ self.assertAllClose(y, 6., check_dtypes=False)\n+ self.assertEqual(count, 1)\n+\n+ # TODO(mattjj,dougalm,phawkins): debug iree failure, \"'arith.subi' op requires\n+ # the same type for all operands and results\"\n+ # https://github.com/google/iree/issues/8881\n+ @jtu.skip_on_devices('iree')\ndef test_slicing_basic(self):\nf = jax.jit(lambda x, n: jnp.sum(x[:n]))\nans = f(jnp.arange(10), 3)\nexpected = jnp.sum(jnp.arange(10)[:3])\nself.assertAllClose(ans, expected, check_dtypes=True)\n+ # TODO(mattjj,dougalm,phawkins): debug iree failure, \"failed to legalize\n+ # operation 'mhlo.while' that was explicitly marked illegal\"\n+ @jtu.skip_on_devices('iree')\ndef test_scan_basic(self):\ndef cumsum(x):\ndef body(i, _):\n"
}
] | Python | Apache License 2.0 | google/jax | add some simple iree tests
This passes, though two of the interesting tests fail with what might be IREE
bugs (and so are currently skipped):
```shell
JAX_PLATFORMS='iree' pytest -n auto tests/core_test.py tests/api_test.py -k Dynamic
``` |
260,430 | 15.04.2022 04:06:01 | -28,800 | f0b8d70d1558dded4fbf2d51f63b45611c7948b4 | simplify _IndexGrid | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/numpy/index_tricks.py",
"new_path": "jax/_src/numpy/index_tricks.py",
"diff": "@@ -43,14 +43,9 @@ class _IndexGrid(abc.ABC):\nop_name: str\ndef __getitem__(self, key):\n- single_slice = isinstance(key, slice)\n- if single_slice:\n- key = (key,)\n- output = []\n- for k in key:\n- output.append(_make_1d_grid_from_slice(k, op_name=self.op_name))\n- if single_slice:\n- return output[0]\n+ if isinstance(key, slice):\n+ return _make_1d_grid_from_slice(key, op_name=self.op_name)\n+ output = (_make_1d_grid_from_slice(k, op_name=self.op_name) for k in key)\noutput = meshgrid(*output, indexing='ij', sparse=self.sparse)\nreturn output if self.sparse else stack(output, 0)\n"
}
] | Python | Apache License 2.0 | google/jax | simplify _IndexGrid |
260,430 | 15.04.2022 04:09:42 | -28,800 | 4ff6b1fbca5a970a60146c17e34c3cea88b51b17 | Fix PRNGKeyArray.broadcast_to with scalar shape | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/prng.py",
"new_path": "jax/_src/prng.py",
"diff": "@@ -210,6 +210,8 @@ class PRNGKeyArray:\nreturn PRNGKeyArray(self.impl, jnp.concatenate(arrs, axis))\ndef broadcast_to(self, shape):\n+ if jnp.ndim(shape) == 0:\n+ shape = (shape,)\nnew_shape = (*shape, *self.impl.key_shape)\nreturn PRNGKeyArray(self.impl, jnp.broadcast_to(self._keys, new_shape))\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/random_test.py",
"new_path": "tests/random_test.py",
"diff": "@@ -1553,6 +1553,9 @@ class JnpWithPRNGKeyArrayTest(jtu.JaxTestCase):\nref = jnp.broadcast_to(like(key), (3,))\nself.assertEqual(out.shape, ref.shape)\nself.assertEqual(out.shape, (3,))\n+ out = jnp.broadcast_to(key, 3)\n+ self.assertEqual(out.shape, ref.shape)\n+ self.assertEqual(out.shape, (3,))\ndef test_expand_dims(self):\nkey = random.PRNGKey(123)\n"
}
] | Python | Apache License 2.0 | google/jax | Fix PRNGKeyArray.broadcast_to with scalar shape |
260,578 | 15.04.2022 13:46:59 | 25,200 | 9719cc89d3989733950d363f140a33d3b5ba7d9d | Add a docstring for maps.Mesh | [
{
"change_type": "MODIFY",
"old_path": "docs/jax.experimental.maps.rst",
"new_path": "docs/jax.experimental.maps.rst",
"diff": "@@ -9,5 +9,5 @@ API\n.. autosummary::\n:toctree: _autosummary\n- mesh\n+ Mesh\nxmap\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -1832,6 +1832,49 @@ mlir.register_lowering(xla_pmap_p, _pmap_lowering)\n# ------------------- xmap -------------------\nclass Mesh(ContextDecorator):\n+ \"\"\"Declare the hardware resources available in the scope of this manager.\n+\n+ In particular, all ``axis_names`` become valid resource names inside the\n+ managed block and can be used e.g. in the ``axis_resources`` argument of\n+ :py:func:`xmap`.\n+\n+ If you are compiling in multiple threads, make sure that the\n+ ``with Mesh`` context manager is inside the function that the threads will\n+ execute.\n+\n+ Args:\n+ devices: A NumPy ndarray object containing JAX device objects (as\n+ obtained e.g. from :py:func:`jax.devices`).\n+ axis_names: A sequence of resource axis names to be assigned to the\n+ dimensions of the ``devices`` argument. Its length should match the\n+ rank of ``devices``.\n+\n+ Example:\n+\n+ >>> from jax.experimental.maps import Mesh\n+ >>> from jax.experimental.pjit import pjit\n+ >>> from jax.experimental import PartitionSpec as P\n+ >>> import numpy as np\n+ ...\n+ >>> inp = np.arange(16).reshape((8, 2))\n+ >>> devices = np.array(jax.devices()).reshape(4, 2)\n+ ...g\n+ >>> # Declare a 2D mesh with axes `x` and `y`.\n+ >>> global_mesh = Mesh(devices, ('x', 'y'))\n+ >>> # Use the mesh object directly as a context manager.\n+ >>> with global_mesh:\n+ ... pjit(lambda x: x, in_axis_resources=None, out_axis_resources=None)(inp)\n+\n+ >>> # Initialize the Mesh and use the mesh as the context manager.\n+ >>> with Mesh(devices, ('x', 'y')) as global_mesh:\n+ ... pjit(lambda x: x, in_axis_resources=None, out_axis_resources=None)(inp)\n+\n+ >>> # Also you can use it as `with ... as ...`.\n+ >>> global_mesh = Mesh(devices, ('x', 'y'))\n+ >>> with global_mesh as m:\n+ ... pjit(lambda x: x, in_axis_resources=None, out_axis_resources=None)(inp)\n+ \"\"\"\n+\ndevices: np.ndarray\naxis_names: Tuple[MeshAxisName, ...]\n"
}
] | Python | Apache License 2.0 | google/jax | Add a docstring for maps.Mesh |
260,534 | 18.04.2022 16:39:01 | 25,200 | 59d8b8d6b25cff8a5d794cac997c1605a5a5bf95 | Remove flags set for all v4 TPUs. Topology flags will now be set in libTPU.
Remove deprecated fields `TPU_MESH_CONTROLLER_ADDRESS` and `TPU_MESH_CONTROLLER_PORT`. | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/cloud_tpu_init.py",
"new_path": "jax/_src/cloud_tpu_init.py",
"diff": "import os\n+\ndef cloud_tpu_init():\n\"\"\"Automatically sets Cloud TPU topology and other env vars.\n@@ -63,16 +64,18 @@ def cloud_tpu_init():\n# pylint: enable=import-outside-toplevel\n# Based on https://github.com/tensorflow/tensorflow/pull/40317\n- gce_metadata_endpoint = 'http://' + os.environ.get('GCE_METADATA_IP',\n- 'metadata.google.internal')\n+ gce_metadata_endpoint = 'http://' + os.environ.get(\n+ 'GCE_METADATA_IP', 'metadata.google.internal')\n+\ndef get_metadata(key):\nreturn requests.get(\nf'{gce_metadata_endpoint}/computeMetadata/v1/instance/attributes/{key}',\n- headers={'Metadata-Flavor': 'Google'}).text\n+ headers={\n+ 'Metadata-Flavor': 'Google'\n+ }).text\nworker_id = get_metadata('agent-worker-number')\naccelerator_type = get_metadata('accelerator-type')\n- worker_network_endpoints = get_metadata('worker-network-endpoints')\naccelerator_type_to_host_bounds = {\n'v2-8': '1,1,1',\n@@ -88,27 +91,12 @@ def cloud_tpu_init():\n'v3-512': '8,8,1',\n'v3-1024': '8,16,1',\n'v3-2048': '16,16,1',\n- 'v4-8': '1,1,1',\n- 'v4-16': '1,1,2',\n- 'v4-32': '1,1,4',\n- 'v4-64': '1,2,4',\n- 'v4-128': '2,2,4',\n- 'v4-256': '2,2,8',\n- 'v4-512': '2,4,8',\n- 'v4-1024': '4,4,8',\n- 'v4-2048': '4,4,16',\n- 'v4-4096': '4,8,16',\n}\nos.environ['CLOUD_TPU_TASK_ID'] = worker_id\n+\n+ # If v4 TPU don't set any topology related flags, libtpu will set these values.\n+ if not accelerator_type.startswith('v4-'):\nos.environ['TPU_CHIPS_PER_HOST_BOUNDS'] = '2,2,1'\nos.environ['TPU_HOST_BOUNDS'] = accelerator_type_to_host_bounds[\naccelerator_type]\n- os.environ['TPU_MESH_CONTROLLER_ADDRESS'] = worker_network_endpoints.split(\n- ',')[0].split(':')[2] + ':8476'\n- os.environ['TPU_MESH_CONTROLLER_PORT'] = '8476'\n-\n- if (not os.environ.get('TPU_TOPOLOGY_WRAP', None)\n- and 'v4' in accelerator_type\n- and accelerator_type not in ['v4-8', 'v4-16', 'v4-32', 'v4-64']):\n- os.environ['TPU_TOPOLOGY_WRAP'] = 'true,true,true'\n"
}
] | Python | Apache License 2.0 | google/jax | Remove flags set for all v4 TPUs. Topology flags will now be set in libTPU.
Remove deprecated fields `TPU_MESH_CONTROLLER_ADDRESS` and `TPU_MESH_CONTROLLER_PORT`.
PiperOrigin-RevId: 442663216 |
260,631 | 18.04.2022 19:34:06 | 25,200 | fc2a12c47843bc84ac1191b29ce86646ca92107f | Temporarily revert by Lukas Geiger
Prefer `jnp.tile` over `concatenate` | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/numpy/lax_numpy.py",
"new_path": "jax/_src/numpy/lax_numpy.py",
"diff": "@@ -3267,9 +3267,7 @@ def _roll(a, shift, axis):\nnp.broadcast_to(axis, b_shape)):\ni = _canonicalize_axis(i, a_ndim)\nx = remainder(x, (a_shape[i] or 1))\n- reps = [1] * a_ndim\n- reps[i] = 2\n- a = tile(a, reps)\n+ a = lax.concatenate((a, a), i)\na = lax.dynamic_slice_in_dim(a, a_shape[i] - x, a_shape[i], axis=i)\nreturn a\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/prng.py",
"new_path": "jax/_src/prng.py",
"diff": "@@ -545,7 +545,7 @@ threefry_prng_impl = PRNGImpl(\ndef _rbg_seed(seed: int) -> jnp.ndarray:\nhalfkey = threefry_seed(seed)\n- return jnp.tile(halfkey, 2)\n+ return jnp.concatenate([halfkey, halfkey])\ndef _rbg_split(key: jnp.ndarray, num: int) -> jnp.ndarray:\nreturn vmap(_threefry_split, (0, None), 1)(key.reshape(2, 2), num).reshape(num, 4)\n"
}
] | Python | Apache License 2.0 | google/jax | Temporarily revert fff370d78d107ed81431becf9dfe97eba77863fb by Lukas Geiger <lukas.geiger94@gmail.com>:
Prefer `jnp.tile` over `concatenate`
PiperOrigin-RevId: 442693096 |
260,424 | 19.04.2022 13:48:20 | -3,600 | e4836f5663b2cbaadcdbb06f4c89f1093b0f43eb | Checkify: support checks on data-independent values.
You can now check values which do not depend on checkified args. | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/checkify.py",
"new_path": "jax/_src/checkify.py",
"diff": "@@ -445,6 +445,8 @@ def check_error(error: Error) -> None:\nerr, code, payload = _reduce_any_error(error.err, error.code, error.payload)\nelse:\nerr, code, payload = error.err, error.code, error.payload\n+\n+ err = core.raise_as_much_as_possible(err)\nreturn assert_p.bind(~err, code, payload, msgs=error.msgs)\nassert_p = core.Primitive('assert') # TODO: rename to check?\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/core.py",
"new_path": "jax/core.py",
"diff": "@@ -478,6 +478,25 @@ class Trace:\n\"to handle custom_vjp primitives\")\nraise NotImplementedError(msg)\n+\n+def raise_as_much_as_possible(tracer) -> Tracer:\n+ # Find 'true' bottom of trace stack (highest dynamic Trace on the stack).\n+ trace_stack = thread_local_state.trace_state.trace_stack.stack\n+ idx = next(i for i, m in enumerate(trace_stack) if m is\n+ thread_local_state.trace_state.trace_stack.dynamic)\n+\n+ # Only pay attention to 'true' part of trace stack.\n+ trace_stack = trace_stack[idx:]\n+\n+ # Lift tracer into everything in the 'true' part of the stack.\n+ for trace in trace_stack:\n+ trace = trace.with_cur_sublevel()\n+ if (not isinstance(tracer, Tracer) or tracer._trace.level < trace.level):\n+ tracer = trace.full_raise(tracer)\n+\n+ return tracer\n+\n+\ndef escaped_tracer_error(tracer, detail=None):\nnum_frames = FLAGS.jax_tracer_error_num_traceback_frames\nmsg = ('Encountered an unexpected tracer. A function transformed by JAX '\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/checkify_test.py",
"new_path": "tests/checkify_test.py",
"diff": "@@ -628,7 +628,7 @@ class AssertPrimitiveTests(jtu.JaxTestCase):\nwith self.assertRaisesRegex(ValueError, \"hi\"):\nf()\n- def test_assert_primitive_(self):\n+ def test_assert_primitive_staging(self):\n@jax.jit\ndef f():\ncheckify.check(False, \"hi\")\n@@ -658,15 +658,32 @@ class AssertPrimitiveTests(jtu.JaxTestCase):\nself.assertIsNotNone(err.get())\nself.assertStartsWith(err.get(), \"must be positive\")\n+ def test_assert_discharging_no_data_dependence(self):\n+ @jax.jit\n+ def g(x):\n+ @checkify.checkify\n+ def f():\n+ # Note that x is not an argument to the checkified function.\n+ checkify.check(x > 0, \"must be positive!\")\n+ return jnp.log(x)\n+ return f()\n+\n+ err, _ = g(1.)\n+ self.assertIsNone(err.get())\n+\n+ err, _ = g(0.)\n+ self.assertIsNotNone(err.get())\n+ self.assertStartsWith(err.get(), \"must be positive\")\n+\ndef test_check_error(self):\n- def f(pred): # note: data dependence needed!\n- checkify.check_error(checkify.Error(~pred, 0, {0: \"hi\"}))\n+ def f():\n+ checkify.check_error(checkify.Error(True, 0, {0: \"hi\"}))\nwith self.assertRaisesRegex(ValueError, \"hi\"):\n- f(False)\n+ f()\nf = checkify.checkify(f)\n- err, none = f(False)\n+ err, none = f()\nself.assertIsNone(none)\nself.assertIsNotNone(err.get())\n"
}
] | Python | Apache License 2.0 | google/jax | Checkify: support checks on data-independent values.
You can now check values which do not depend on checkified args.
Co-authored-by: Matthew Johnson <mattjj@google.com> |
260,631 | 19.04.2022 07:12:00 | 25,200 | b8971b9f28fb92e5395b117f9673e50cce8d9aa9 | Reapply: by Lukas Geiger
Prefer `jnp.tile` over `concatenate` | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/numpy/lax_numpy.py",
"new_path": "jax/_src/numpy/lax_numpy.py",
"diff": "@@ -3267,7 +3267,9 @@ def _roll(a, shift, axis):\nnp.broadcast_to(axis, b_shape)):\ni = _canonicalize_axis(i, a_ndim)\nx = remainder(x, (a_shape[i] or 1))\n- a = lax.concatenate((a, a), i)\n+ reps = [1] * a_ndim\n+ reps[i] = 2\n+ a = tile(a, reps)\na = lax.dynamic_slice_in_dim(a, a_shape[i] - x, a_shape[i], axis=i)\nreturn a\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/prng.py",
"new_path": "jax/_src/prng.py",
"diff": "@@ -545,7 +545,7 @@ threefry_prng_impl = PRNGImpl(\ndef _rbg_seed(seed: int) -> jnp.ndarray:\nhalfkey = threefry_seed(seed)\n- return jnp.concatenate([halfkey, halfkey])\n+ return jnp.tile(halfkey, 2)\ndef _rbg_split(key: jnp.ndarray, num: int) -> jnp.ndarray:\nreturn vmap(_threefry_split, (0, None), 1)(key.reshape(2, 2), num).reshape(num, 4)\n"
}
] | Python | Apache License 2.0 | google/jax | Reapply: fff370d78d107ed81431becf9dfe97eba77863fb by Lukas Geiger <lukas.geiger94@gmail.com>:
Prefer `jnp.tile` over `concatenate`
PiperOrigin-RevId: 442803459 |
260,301 | 19.04.2022 17:54:32 | -3,600 | 342923335ada3776f28a9517e0a11267da49e71e | fix: explicit reexport
Explicitly reexports PRNGKeyArray as KeyArray in accordance with PEP 484
See also: | [
{
"change_type": "MODIFY",
"old_path": "jax/random.py",
"new_path": "jax/random.py",
"diff": "@@ -122,7 +122,8 @@ Here is a short summary:\n# TODO(frostig): replace with KeyArray from jax._src.random once we\n# always enable_custom_prng\n-from jax._src.prng import PRNGKeyArray as KeyArray\n+from jax._src.prng import PRNGKeyArray\n+KeyArray = PRNGKeyArray\nfrom jax._src.random import (\nPRNGKey as PRNGKey,\n"
}
] | Python | Apache License 2.0 | google/jax | fix: explicit reexport
Explicitly reexports PRNGKeyArray as KeyArray in accordance with PEP 484
See also: https://github.com/python/mypy/issues/11706 |
260,522 | 19.04.2022 12:23:52 | 18,000 | 554b02e97872c29795460e016813cf805ce4e5f0 | Add quotes to install commands in README | [
{
"change_type": "MODIFY",
"old_path": "README.md",
"new_path": "README.md",
"diff": "@@ -463,10 +463,10 @@ version for jaxlib explicitly:\npip install --upgrade pip\n# Installs the wheel compatible with Cuda >= 11.4 and cudnn >= 8.2\n-pip install jax[cuda11_cudnn82] -f https://storage.googleapis.com/jax-releases/jax_releases.html\n+pip install \"jax[cuda11_cudnn82]\" -f https://storage.googleapis.com/jax-releases/jax_releases.html\n# Installs the wheel compatible with Cuda >= 11.1 and cudnn >= 8.0.5\n-pip install jax[cuda11_cudnn805] -f https://storage.googleapis.com/jax-releases/jax_releases.html\n+pip install \"jax[cuda11_cudnn805]\" -f https://storage.googleapis.com/jax-releases/jax_releases.html\n```\nYou can find your CUDA version with the command:\n"
}
] | Python | Apache License 2.0 | google/jax | Add quotes to install commands in README |
260,510 | 14.04.2022 15:22:58 | 25,200 | 5ff2e8eb4cc8613415defbfb9c08d47a3ca6a840 | Fix name stack bugs | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/dispatch.py",
"new_path": "jax/_src/dispatch.py",
"diff": "@@ -290,7 +290,7 @@ def lower_xla_callable(fun: lu.WrappedFun, device, backend, name,\n# pass long arg lists as tuple for TPU\ntuple_args = len(abstract_args) > 100\naxis_env = xla.AxisEnv(nreps, (), ())\n- name_stack = xla.new_name_stack(xla.wrap_name(name, 'jit'))\n+ name_stack = util.new_name_stack(util.wrap_name(name, 'jit'))\nclosed_jaxpr = core.ClosedJaxpr(jaxpr, consts)\nmodule_name = f\"jit_{fun.__name__}\"\nmodule = mlir.lower_jaxpr_to_module(\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/lax.py",
"new_path": "jax/_src/lax/lax.py",
"diff": "@@ -3389,7 +3389,7 @@ def _reduce_lower(ctx, *values, computation, jaxpr, consts, dimensions):\nir_types = [mlir.aval_to_ir_type(aval) for aval in init_value_avals]\nreducer = op.regions[0].blocks.append(*(ir_types + ir_types))\nwith ir.InsertionPoint(reducer):\n- reducer_ctx = ctx.module_context.replace(name_stack='')\n+ reducer_ctx = ctx.module_context.replace(name_stack=util.new_name_stack())\nout_nodes = mlir.jaxpr_subcomp(reducer_ctx, jaxpr, consts,\n*([a] for a in reducer.arguments))\nmhlo.ReturnOp(util.flatten(out_nodes))\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/slicing.py",
"new_path": "jax/_src/lax/slicing.py",
"diff": "@@ -1933,7 +1933,7 @@ def _scatter_lower(ctx, operand, indices, updates, *,\nscalar_type = mlir.aval_to_ir_type(core.ShapedArray((), aval_out.dtype))\nupdate = op.update_computation.blocks.append(scalar_type, scalar_type)\nwith ir.InsertionPoint(update):\n- update_ctx = ctx.module_context.replace(name_stack='')\n+ update_ctx = ctx.module_context.replace(name_stack=util.new_name_stack())\nout_nodes = mlir.jaxpr_subcomp(\nupdate_ctx, update_jaxpr, update_consts,\n(update.arguments[0],), (update.arguments[1],))\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/maps.py",
"new_path": "jax/experimental/maps.py",
"diff": "@@ -1407,7 +1407,7 @@ def _xmap_lowering_rule_replica(ctx, *in_nodes,\n# translation rule just because the extra tuple stuff is a pain.\nsub_ctx = ctx.module_context.replace(\nname_stack=xla.extend_name_stack(ctx.module_context.name_stack,\n- xla.wrap_name(name, 'xmap')))\n+ wrap_name(name, 'xmap')))\ntiled_outs = mlir.jaxpr_subcomp(sub_ctx, vectorized_jaxpr, (), *tiled_ins)\nouts = [\n@@ -1472,7 +1472,7 @@ def _xmap_lowering_rule_spmd(ctx, *global_in_nodes,\n# translation rule just because the extra tuple stuff is a pain.\nsub_ctx = ctx.module_context.replace(\nname_stack=xla.extend_name_stack(ctx.module_context.name_stack,\n- xla.wrap_name(name, 'xmap')))\n+ wrap_name(name, 'xmap')))\nglobal_out_nodes = mlir.jaxpr_subcomp(sub_ctx, vectorized_jaxpr, (),\n*sharded_global_in_nodes)\n@@ -1520,7 +1520,7 @@ def _xmap_lowering_rule_spmd_manual(ctx, *global_in_nodes,\nassert isinstance(ctx.module_context.axis_context, mlir.SPMDAxisContext)\nsub_ctx = ctx.module_context.replace(\nname_stack=xla.extend_name_stack(ctx.module_context.name_stack,\n- xla.wrap_name(name, 'xmap')),\n+ wrap_name(name, 'xmap')),\naxis_context=ctx.module_context.axis_context.extend_manual(manual_mesh_axes))\nglobal_out_nodes = mlir.jaxpr_subcomp(sub_ctx, vectorized_jaxpr, (),\n*([n] for n in global_in_nodes))\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/mlir.py",
"new_path": "jax/interpreters/mlir.py",
"diff": "@@ -673,7 +673,7 @@ def lower_jaxpr_to_fun(\nelse:\nargs.append(arg)\ncallee_name_stack = xla.extend_name_stack(ctx.name_stack,\n- xla.wrap_name(name, 'jit'))\n+ util.wrap_name(name, 'jit'))\nout_vals = jaxpr_subcomp(ctx.replace(name_stack=callee_name_stack),\njaxpr.jaxpr, map(ir_constants, jaxpr.consts),\n*args)\n@@ -834,7 +834,7 @@ def _xla_call_lower(ctx, *args,\nbackend=None, name, call_jaxpr, donated_invars, inline=None,\ndevice=None):\ndel device, donated_invars, inline # Ignored.\n- return _call_lowering(name, xla.wrap_name(name, \"jit\"), call_jaxpr,\n+ return _call_lowering(name, util.wrap_name(name, \"jit\"), call_jaxpr,\nbackend, ctx.module_context, ctx.avals_in, ctx.avals_out,\n*args)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/jax_to_ir_test.py",
"new_path": "tests/jax_to_ir_test.py",
"diff": "@@ -18,6 +18,7 @@ from absl.testing import absltest\nimport jax.numpy as jnp\nfrom jax.tools import jax_to_ir\nfrom jax._src import test_util as jtu\n+from jax.config import config\ntry:\nimport tensorflow as tf\n@@ -89,6 +90,11 @@ class JaxToIRTest(absltest.TestCase):\n])\n# Check that tf debug txt contains a broadcast, add, and multiply.\n+ if config.jax_experimental_name_stack:\n+ self.assertIn('BroadcastTo', tf_text)\n+ self.assertIn('AddV2', tf_text)\n+ self.assertIn('Mul', tf_text)\n+ else:\nself.assertIn('name: \"BroadcastTo\"', tf_text)\nself.assertIn('name: \"AddV2\"', tf_text)\nself.assertIn('name: \"Mul\"', tf_text)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/metadata_test.py",
"new_path": "tests/metadata_test.py",
"diff": "@@ -62,6 +62,11 @@ class MetadataTest(jtu.JaxTestCase):\ndef foo(x):\nreturn jnp.sin(x)\nhlo = jax.xla_computation(jax.grad(foo))(1.).get_hlo_module().to_string()\n+ if config.jax_experimental_name_stack:\n+ self.assertRegex(hlo, 'op_name=\".*jvp\\\\(jit\\\\(foo\\\\)\\\\)/sin\"')\n+ self.assertRegex(hlo, 'op_name=\".*jvp\\\\(jit\\\\(foo\\\\)\\\\)/cos\"')\n+ self.assertRegex(hlo, 'op_name=\".*transpose\\\\(jvp\\\\(jit\\\\(foo\\\\)\\\\)\\\\)/mul\"')\n+ else:\nself.assertRegex(hlo, 'op_name=\".*jit\\\\(jvp\\\\(foo\\\\)\\\\)/sin\"')\nself.assertRegex(hlo, 'op_name=\".*jit\\\\(jvp\\\\(foo\\\\)\\\\)/cos\"')\nself.assertRegex(hlo, 'op_name=\".*jit\\\\(transpose\\\\(jvp\\\\(foo\\\\)\\\\)\\\\)/mul\"')\n"
}
] | Python | Apache License 2.0 | google/jax | Fix name stack bugs |
260,447 | 19.04.2022 11:28:04 | 25,200 | 5a1c5ba1141024e08d8ddafa0f7e0fb1368839c1 | [linalg] Adds `compute_uv` to TPU SVD. | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/svd.py",
"new_path": "jax/_src/lax/svd.py",
"diff": "@@ -35,7 +35,7 @@ https://epubs.siam.org/doi/abs/10.1137/090774999\nimport functools\n-from typing import Sequence\n+from typing import Sequence, Union\nimport jax\nfrom jax import core\n@@ -43,31 +43,37 @@ from jax import lax\nimport jax.numpy as jnp\n-@functools.partial(jax.jit, static_argnums=(1, 2))\n+@functools.partial(jax.jit, static_argnums=(1, 2, 3))\ndef _svd(a: jnp.ndarray,\nis_hermitian: bool,\n- max_iterations: int) -> Sequence[jnp.ndarray]:\n+ compute_uv: bool,\n+ max_iterations: int) -> Union[jnp.ndarray, Sequence[jnp.ndarray]]:\n\"\"\"Singular value decomposition for m x n matrix and m >= n.\nArgs:\na: A matrix of shape `m x n` with `m >= n`.\nis_hermitian: True if `a` is Hermitian.\n+ compute_uv: Whether to compute also `u` and `v` in addition to `s`.\nmax_iterations: The predefined maximum number of iterations of QDWH.\nReturns:\nA 3-tuple (`u`, `s`, `v`), where `u` is a unitary matrix of shape `m x n`,\n`s` is vector of length `n` containing the singular values in the descending\norder, `v` is a unitary matrix of shape `n x n`, and\n- `a = (u * s) @ v.T.conj()`.\n+ `a = (u * s) @ v.T.conj()`. For `compute_uv=False`, only `s` is returned.\n\"\"\"\nu, h, _, _ = lax.linalg.qdwh(a, is_hermitian, max_iterations)\n+ # TODO: Uses `eigvals_only=True` if `compute_uv=False`.\nv, s = lax.linalg.eigh(h)\n# Flips the singular values in descending order.\ns_out = jnp.flip(s)\n+ if not compute_uv:\n+ return s_out\n+\n# Reorders eigenvectors.\nv_out = jnp.fliplr(v)\n@@ -92,22 +98,24 @@ def _svd(a: jnp.ndarray,\nreturn (u_out, s_out, v_out)\n-@functools.partial(jax.jit, static_argnums=(1, 2))\n+@functools.partial(jax.jit, static_argnums=(1, 2, 3))\ndef svd(a: jnp.ndarray,\nis_hermitian: bool = False,\n- max_iterations: int = 10) -> Sequence[jnp.ndarray]:\n+ compute_uv: bool = True,\n+ max_iterations: int = 10) -> Union[jnp.ndarray, Sequence[jnp.ndarray]]:\n\"\"\"Singular value decomposition.\nArgs:\na: A matrix of shape `m x n`.\nis_hermitian: True if `a` is Hermitian.\n+ compute_uv: Whether to compute also `u` and `v` in addition to `s`.\nmax_iterations: The predefined maximum number of iterations of QDWH.\nReturns:\nA 3-tuple (`u`, `s`, `vh`), where `u` is a unitary matrix of shape `m x k`,\n`s` is vector of length `k` containing the singular values in the descending\norder, `vh` is a unitary matrix of shape `k x n`, `k = min(m, n)`, and\n- `a = (u * s) @ vh`.\n+ `a = (u * s) @ vh`. For `compute_uv=False`, only `s` is returned.\n\"\"\"\nis_hermitian = core.concrete_or_error(\n@@ -132,7 +140,10 @@ def svd(a: jnp.ndarray,\nq, a = lax.linalg.qr(a, full_matrices=False)\nreduce_to_square = True\n- u_out, s_out, v_out = _svd(a, is_hermitian, max_iterations)\n+ if not compute_uv:\n+ return _svd(a, is_hermitian, compute_uv, max_iterations)\n+\n+ u_out, s_out, v_out = _svd(a, is_hermitian, compute_uv, max_iterations)\nif reduce_to_square:\nu_out = q @ u_out\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/svd_test.py",
"new_path": "tests/svd_test.py",
"diff": "@@ -131,6 +131,46 @@ class SvdTest(jtu.JaxTestCase):\nnp.testing.assert_almost_equal(diff, 1E-4, decimal=2)\n+ @parameterized.named_parameters(jtu.cases_from_list(\n+ { # pylint:disable=g-complex-comprehension\n+ 'testcase_name': '_m={}_by_n={}_log_cond={}'.format(m, n, log_cond),\n+ 'm': m, 'n': n, 'log_cond': log_cond}\n+ for m, n in zip([2, 8, 10, 20], [4, 6, 10, 18])\n+ for log_cond in np.linspace(1, _MAX_LOG_CONDITION_NUM, 4)))\n+ @jtu.skip_on_devices(\"rocm\") # will be fixed on rocm-5.1\n+ def testSingularValues(self, m, n, log_cond):\n+ \"\"\"Tests singular values.\"\"\"\n+ with jax.default_matmul_precision('float32'):\n+ a = np.random.uniform(\n+ low=0.3, high=0.9, size=(m, n)).astype(_SVD_TEST_DTYPE)\n+ u, s, v = osp_linalg.svd(a, full_matrices=False)\n+ cond = 10**log_cond\n+ s = np.linspace(cond, 1, min(m, n))\n+ a = (u * s) @ v\n+ a = a + 1j * a\n+\n+ # Only computes singular values.\n+ compute_uv = False\n+\n+ osp_linalg_fn = functools.partial(\n+ osp_linalg.svd, full_matrices=False, compute_uv=compute_uv)\n+ actual_s = svd.svd(a, compute_uv=compute_uv)\n+\n+ expected_s = osp_linalg_fn(a)\n+\n+ args_maker = lambda: [a]\n+\n+ with self.subTest('Test JIT compatibility'):\n+ self._CompileAndCheck(svd.svd, args_maker)\n+\n+ with self.subTest('Test s.'):\n+ self.assertAllClose(expected_s, actual_s, rtol=_SVD_RTOL, atol=1E-6)\n+\n+ with self.subTest('Test non-increasing order.'):\n+ # Computes `actual_diff[i] = s[i+1] - s[i]`.\n+ actual_diff = jnp.diff(actual_s, append=0)\n+ np.testing.assert_array_less(actual_diff, np.zeros_like(actual_diff))\n+\nif __name__ == '__main__':\nabsltest.main(testLoader=jtu.JaxTestLoader())\n"
}
] | Python | Apache License 2.0 | google/jax | [linalg] Adds `compute_uv` to TPU SVD.
PiperOrigin-RevId: 442864883 |
260,430 | 20.04.2022 16:23:16 | -28,800 | f6ca60ec292829ed9c1f97b31c46dc2a741aaa89 | DOC: lax.linalg.eigh
Fix the inconsistency of variable name between docstring and source code.
Add description of eigenvalues | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/linalg.py",
"new_path": "jax/_src/lax/linalg.py",
"diff": "@@ -106,13 +106,14 @@ def eigh(x, lower: bool = True, symmetrize_input: bool = True):\neigendecomposition by computing :math:`\\\\frac{1}{2}(x + x^H)`.\nReturns:\n- A tuple ``(w, v)``.\n+ A tuple ``(v, w)``.\n- ``w`` is an array with the same dtype as ``x`` such that ``w[..., :, i]`` is\n- the eigenvector corresponding to ``v[..., i]``.\n+ ``v`` is an array with the same dtype as ``x`` such that ``v[..., :, i]`` is\n+ the normalized eigenvector corresponding to eigenvalue ``w[..., i]``.\n- ``v`` is an array with the same dtype as ``x`` (or its real counterpart if\n- complex) with shape ``[..., n]`` containing the eigenvalues of ``x``.\n+ ``w`` is an array with the same dtype as ``x`` (or its real counterpart if\n+ complex) with shape ``[..., n]`` containing the eigenvalues of ``x`` in\n+ ascending order(each repeated according to its multiplicity).\n\"\"\"\nif symmetrize_input:\nx = symmetrize(x)\n"
}
] | Python | Apache License 2.0 | google/jax | DOC: lax.linalg.eigh
Fix the inconsistency of variable name between docstring and source code.
Add description of eigenvalues |
260,430 | 20.04.2022 21:54:58 | -28,800 | bb2682db6df5b9388ce0b161e3f449624238718b | remove numpy.linalg._promote_arg_dtypes
in favor of numpy.util._promote_dtypes_inexact | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/numpy/linalg.py",
"new_path": "jax/_src/numpy/linalg.py",
"diff": "@@ -23,35 +23,20 @@ from typing import Tuple, Union, cast\nfrom jax import jit, custom_jvp\nfrom jax import lax\n-from jax._src import dtypes\nfrom jax._src.lax import lax as lax_internal\nfrom jax._src.lax import linalg as lax_linalg\nfrom jax._src.numpy import lax_numpy as jnp\n-from jax._src.numpy.util import _wraps\n+from jax._src.numpy.util import _wraps, _promote_dtypes_inexact\nfrom jax._src.util import canonicalize_axis\n_T = lambda x: jnp.swapaxes(x, -1, -2)\n_H = lambda x: jnp.conjugate(jnp.swapaxes(x, -1, -2))\n-def _promote_arg_dtypes(*args):\n- \"\"\"Promotes `args` to a common inexact type.\"\"\"\n- dtype, weak_type = dtypes._lattice_result_type(*args)\n- if not jnp.issubdtype(dtype, jnp.inexact):\n- dtype, weak_type = jnp.float_, False\n- dtype = dtypes.canonicalize_dtype(dtype)\n- args = [lax_internal._convert_element_type(arg, dtype, weak_type)\n- for arg in args]\n- if len(args) == 1:\n- return args[0]\n- else:\n- return args\n-\n-\n@_wraps(np.linalg.cholesky)\n@jit\ndef cholesky(a):\n- a = _promote_arg_dtypes(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\nreturn lax_linalg.cholesky(a)\n@@ -59,7 +44,7 @@ def cholesky(a):\n@partial(jit, static_argnames=('full_matrices', 'compute_uv', 'hermitian'))\ndef svd(a, full_matrices: bool = True, compute_uv: bool = True,\nhermitian: bool = False):\n- a = _promote_arg_dtypes(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\nif hermitian:\nw, v = lax_linalg.eigh(a)\ns = lax.abs(v)\n@@ -82,7 +67,7 @@ def svd(a, full_matrices: bool = True, compute_uv: bool = True,\n@_wraps(np.linalg.matrix_power)\n@partial(jit, static_argnames=('n',))\ndef matrix_power(a, n):\n- a = _promote_arg_dtypes(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\nif a.ndim < 2:\nraise TypeError(\"{}-dimensional array given. Array must be at least \"\n@@ -120,7 +105,7 @@ def matrix_power(a, n):\n@_wraps(np.linalg.matrix_rank)\n@jit\ndef matrix_rank(M, tol=None):\n- M = _promote_arg_dtypes(jnp.asarray(M))\n+ M, = _promote_dtypes_inexact(jnp.asarray(M))\nif M.ndim > 2:\nraise TypeError(\"array should have 2 or fewer dimensions\")\nif M.ndim < 2:\n@@ -135,7 +120,7 @@ def matrix_rank(M, tol=None):\n@_wraps(np.linalg.slogdet)\n@jit\ndef slogdet(a):\n- a = _promote_arg_dtypes(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\ndtype = lax.dtype(a)\na_shape = jnp.shape(a)\nif len(a_shape) < 2 or a_shape[-1] != a_shape[-2]:\n@@ -215,8 +200,8 @@ def _cofactor_solve(a, b):\nReturns:\ndet(a) and cofactor(a)^T*b, aka adjugate(a)*b\n\"\"\"\n- a = _promote_arg_dtypes(jnp.asarray(a))\n- b = _promote_arg_dtypes(jnp.asarray(b))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\n+ b, = _promote_dtypes_inexact(jnp.asarray(b))\na_shape = jnp.shape(a)\nb_shape = jnp.shape(b)\na_ndims = len(a_shape)\n@@ -281,7 +266,7 @@ def _det_3x3(a):\n@_wraps(np.linalg.det)\n@jit\ndef det(a):\n- a = _promote_arg_dtypes(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\na_shape = jnp.shape(a)\nif len(a_shape) >= 2 and a_shape[-1] == 2 and a_shape[-2] == 2:\nreturn _det_2x2(a)\n@@ -313,7 +298,7 @@ backend. However eigendecomposition for symmetric/Hermitian matrices is\nimplemented more widely (see :func:`jax.numpy.linalg.eigh`).\n\"\"\")\ndef eig(a):\n- a = _promote_arg_dtypes(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\nreturn lax_linalg.eig(a, compute_left_eigenvectors=False)\n@@ -335,7 +320,7 @@ def eigh(a, UPLO=None, symmetrize_input=True):\nmsg = \"UPLO must be one of None, 'L', or 'U', got {}\".format(UPLO)\nraise ValueError(msg)\n- a = _promote_arg_dtypes(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\nv, w = lax_linalg.eigh(a, lower=lower, symmetrize_input=symmetrize_input)\nreturn w, v\n@@ -406,7 +391,7 @@ def inv(a):\n@partial(jit, static_argnames=('ord', 'axis', 'keepdims'))\ndef norm(x, ord=None, axis : Union[None, Tuple[int, ...], int] = None,\nkeepdims=False):\n- x = _promote_arg_dtypes(jnp.asarray(x))\n+ x, = _promote_dtypes_inexact(jnp.asarray(x))\nx_shape = jnp.shape(x)\nndim = len(x_shape)\n@@ -498,7 +483,7 @@ def qr(a, mode=\"reduced\"):\nfull_matrices = True\nelse:\nraise ValueError(\"Unsupported QR decomposition mode '{}'\".format(mode))\n- a = _promote_arg_dtypes(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\nq, r = lax_linalg.qr(a, full_matrices)\nif mode == \"r\":\nreturn r\n@@ -508,14 +493,14 @@ def qr(a, mode=\"reduced\"):\n@_wraps(np.linalg.solve)\n@jit\ndef solve(a, b):\n- a, b = _promote_arg_dtypes(jnp.asarray(a), jnp.asarray(b))\n+ a, b = _promote_dtypes_inexact(jnp.asarray(a), jnp.asarray(b))\nreturn lax_linalg._solve(a, b)\ndef _lstsq(a, b, rcond, *, numpy_resid=False):\n# TODO: add lstsq to lax_linalg and implement this function via those wrappers.\n# TODO: add custom jvp rule for more robust lstsq differentiation\n- a, b = _promote_arg_dtypes(a, b)\n+ a, b = _promote_dtypes_inexact(a, b)\nif a.shape[0] != b.shape[0]:\nraise ValueError(\"Leading dimensions of input arrays must match\")\nb_orig_ndim = b.ndim\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/scipy/linalg.py",
"new_path": "jax/_src/scipy/linalg.py",
"diff": "@@ -23,7 +23,7 @@ from jax import jit, vmap, jvp\nfrom jax import lax\nfrom jax._src.lax import linalg as lax_linalg\nfrom jax._src.lax import polar as lax_polar\n-from jax._src.numpy.util import _wraps\n+from jax._src.numpy.util import _wraps, _promote_dtypes_inexact\nfrom jax._src.numpy import lax_numpy as jnp\nfrom jax._src.numpy import linalg as np_linalg\n@@ -31,7 +31,7 @@ _T = lambda x: jnp.swapaxes(x, -1, -2)\n@partial(jit, static_argnames=('lower',))\ndef _cholesky(a, lower):\n- a = np_linalg._promote_arg_dtypes(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\nl = lax_linalg.cholesky(a if lower else jnp.conj(_T(a)), symmetrize_input=False)\nreturn l if lower else jnp.conj(_T(l))\n@@ -46,7 +46,7 @@ def cho_factor(a, lower=False, overwrite_a=False, check_finite=True):\n@partial(jit, static_argnames=('lower',))\ndef _cho_solve(c, b, lower):\n- c, b = np_linalg._promote_arg_dtypes(jnp.asarray(c), jnp.asarray(b))\n+ c, b = _promote_dtypes_inexact(jnp.asarray(c), jnp.asarray(b))\nlax_linalg._check_solve_shapes(c, b)\nb = lax_linalg.triangular_solve(c, b, left_side=True, lower=lower,\ntranspose_a=not lower, conjugate_a=not lower)\n@@ -63,7 +63,7 @@ def cho_solve(c_and_lower, b, overwrite_b=False, check_finite=True):\n@partial(jit, static_argnames=('full_matrices', 'compute_uv'))\ndef _svd(a, *, full_matrices, compute_uv):\n- a = np_linalg._promote_arg_dtypes(jnp.asarray(a))\n+ a = _promote_dtypes_inexact(jnp.asarray(a))\nreturn lax_linalg.svd(a, full_matrices, compute_uv)\n@_wraps(scipy.linalg.svd)\n@@ -88,7 +88,7 @@ def _eigh(a, b, lower, eigvals_only, eigvals, type):\nraise NotImplementedError(\n\"Only the eigvals=None case of eigh is implemented.\")\n- a = np_linalg._promote_arg_dtypes(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\nv, w = lax_linalg.eigh(a, lower=lower)\nif eigvals_only:\n@@ -126,7 +126,7 @@ def inv(a, overwrite_a=False, check_finite=True):\n@partial(jit, static_argnames=('overwrite_a', 'check_finite'))\ndef lu_factor(a, overwrite_a=False, check_finite=True):\ndel overwrite_a, check_finite\n- a = np_linalg._promote_arg_dtypes(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\nlu, pivots, _ = lax_linalg.lu(a)\nreturn lu, pivots\n@@ -143,7 +143,7 @@ def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):\n@partial(jit, static_argnums=(1,))\ndef _lu(a, permute_l):\n- a = np_linalg._promote_arg_dtypes(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\nlu, pivots, permutation = lax_linalg.lu(a)\ndtype = lax.dtype(a)\nm, n = jnp.shape(a)\n@@ -173,7 +173,7 @@ def _qr(a, mode, pivoting):\nfull_matrices = False\nelse:\nraise ValueError(\"Unsupported QR decomposition mode '{}'\".format(mode))\n- a = np_linalg._promote_arg_dtypes(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\nq, r = lax_linalg.qr(a, full_matrices)\nif mode == \"r\":\nreturn r\n@@ -191,7 +191,7 @@ def _solve(a, b, sym_pos, lower):\nif not sym_pos:\nreturn np_linalg.solve(a, b)\n- a, b = np_linalg._promote_arg_dtypes(jnp.asarray(a), jnp.asarray(b))\n+ a, b = _promote_dtypes_inexact(jnp.asarray(a), jnp.asarray(b))\nlax_linalg._check_solve_shapes(a, b)\n# With custom_linear_solve, we can reuse the same factorization when\n@@ -227,7 +227,7 @@ def _solve_triangular(a, b, trans, lower, unit_diagonal):\nelse:\nraise ValueError(\"Invalid 'trans' value {}\".format(trans))\n- a, b = np_linalg._promote_arg_dtypes(jnp.asarray(a), jnp.asarray(b))\n+ a, b = _promote_dtypes_inexact(jnp.asarray(a), jnp.asarray(b))\n# lax_linalg.triangular_solve only supports matrix 'b's at the moment.\nb_is_vector = jnp.ndim(a) == jnp.ndim(b) + 1\n"
}
] | Python | Apache License 2.0 | google/jax | remove numpy.linalg._promote_arg_dtypes
in favor of numpy.util._promote_dtypes_inexact |
260,430 | 21.04.2022 02:17:09 | -28,800 | af7b94b1103a07d66f0ecd5e3dea76ceaafe3a6f | Fix typo of
and add a basic regression test | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/scipy/linalg.py",
"new_path": "jax/_src/scipy/linalg.py",
"diff": "@@ -63,7 +63,7 @@ def cho_solve(c_and_lower, b, overwrite_b=False, check_finite=True):\n@partial(jit, static_argnames=('full_matrices', 'compute_uv'))\ndef _svd(a, *, full_matrices, compute_uv):\n- a = _promote_dtypes_inexact(jnp.asarray(a))\n+ a, = _promote_dtypes_inexact(jnp.asarray(a))\nreturn lax_linalg.svd(a, full_matrices, compute_uv)\n@_wraps(scipy.linalg.svd)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/linalg_test.py",
"new_path": "tests/linalg_test.py",
"diff": "@@ -615,6 +615,11 @@ class NumpyLinalgTest(jtu.JaxTestCase):\natol = 5e-4\nself.assertArraysAllClose(t_out, b.real, atol=atol)\n+ def testJspSVDBasic(self):\n+ # since jax.scipy.linalg.svd is almost the same as jax.numpy.linalg.svd\n+ # do not check it functionality here\n+ jsp.linalg.svd(np.ones((2, 2), dtype=np.float32))\n+\n@parameterized.named_parameters(jtu.cases_from_list(\n{\"testcase_name\": \"_shape={}_fullmatrices={}\".format(\njtu.format_shape_dtype_string(shape, dtype), full_matrices),\n"
}
] | Python | Apache License 2.0 | google/jax | Fix typo of #10381
and add a basic regression test |
260,447 | 20.04.2022 12:31:30 | 25,200 | 455c9f823e204ebc9586392bd8714687233696c8 | [linalg] Adds `full_matrices` option to TPU SVD. | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/svd.py",
"new_path": "jax/_src/lax/svd.py",
"diff": "@@ -45,14 +45,14 @@ import jax.numpy as jnp\n@functools.partial(jax.jit, static_argnums=(1, 2, 3))\ndef _svd(a: jnp.ndarray,\n- is_hermitian: bool,\n+ hermitian: bool,\ncompute_uv: bool,\nmax_iterations: int) -> Union[jnp.ndarray, Sequence[jnp.ndarray]]:\n\"\"\"Singular value decomposition for m x n matrix and m >= n.\nArgs:\na: A matrix of shape `m x n` with `m >= n`.\n- is_hermitian: True if `a` is Hermitian.\n+ hermitian: True if `a` is Hermitian.\ncompute_uv: Whether to compute also `u` and `v` in addition to `s`.\nmax_iterations: The predefined maximum number of iterations of QDWH.\n@@ -63,7 +63,7 @@ def _svd(a: jnp.ndarray,\n`a = (u * s) @ v.T.conj()`. For `compute_uv=False`, only `s` is returned.\n\"\"\"\n- u, h, _, _ = lax.linalg.qdwh(a, is_hermitian, max_iterations)\n+ u, h, _, _ = lax.linalg.qdwh(a, hermitian, max_iterations)\n# TODO: Uses `eigvals_only=True` if `compute_uv=False`.\nv, s = lax.linalg.eigh(h)\n@@ -98,28 +98,33 @@ def _svd(a: jnp.ndarray,\nreturn (u_out, s_out, v_out)\n-@functools.partial(jax.jit, static_argnums=(1, 2, 3))\n+@functools.partial(jax.jit, static_argnums=(1, 2, 3, 4))\ndef svd(a: jnp.ndarray,\n- is_hermitian: bool = False,\n+ full_matrices: bool,\ncompute_uv: bool = True,\n+ hermitian: bool = False,\nmax_iterations: int = 10) -> Union[jnp.ndarray, Sequence[jnp.ndarray]]:\n\"\"\"Singular value decomposition.\nArgs:\na: A matrix of shape `m x n`.\n- is_hermitian: True if `a` is Hermitian.\n+ full_matrices: If True, `u` and `vh` have the shapes `m x m` and `n x n`,\n+ respectively. If False, the shapes are `m x k` and `k x n`, respectively,\n+ where `k = min(m, n)`.\ncompute_uv: Whether to compute also `u` and `v` in addition to `s`.\n+ hermitian: True if `a` is Hermitian.\nmax_iterations: The predefined maximum number of iterations of QDWH.\nReturns:\n- A 3-tuple (`u`, `s`, `vh`), where `u` is a unitary matrix of shape `m x k`,\n- `s` is vector of length `k` containing the singular values in the descending\n- order, `vh` is a unitary matrix of shape `k x n`, `k = min(m, n)`, and\n- `a = (u * s) @ vh`. For `compute_uv=False`, only `s` is returned.\n+ A 3-tuple (`u`, `s`, `vh`), where `u` and `vh` are unitary matrices,\n+ `s` is vector of length `k` containing the singular values in the\n+ non-increasing order, and `k = min(m, n)`. The shapes of `u` and `vh`\n+ depend on the value of `full_matrices`. For `compute_uv=False`,\n+ only `s` is returned.\n\"\"\"\n- is_hermitian = core.concrete_or_error(\n- bool, is_hermitian, 'The `is_hermitian` argument must be statically '\n+ hermitian = core.concrete_or_error(\n+ bool, hermitian, 'The `hermitian` argument must be statically '\n'specified to use `qdwh` within JAX transformations.')\nmax_iterations = core.concrete_or_error(\n@@ -135,19 +140,30 @@ def svd(a: jnp.ndarray,\nis_flip = True\nreduce_to_square = False\n+ if full_matrices:\n+ q_full, a_full = lax.linalg.qr(a, full_matrices=True)\n+ q = q_full[:, :n]\n+ u_out_null = q_full[:, n:]\n+ a = a_full[:n, :]\n+ reduce_to_square = True\n+ else:\n+ # The constant `1.15` comes from Yuji Nakatsukasa's implementation\n+ # https://www.mathworks.com/matlabcentral/fileexchange/36830-symmetric-eigenvalue-decomposition-and-the-svd?s_tid=FX_rc3_behav\nif m > 1.15 * n:\n- m = n\nq, a = lax.linalg.qr(a, full_matrices=False)\nreduce_to_square = True\nif not compute_uv:\n- return _svd(a, is_hermitian, compute_uv, max_iterations)\n+ return _svd(a, hermitian, compute_uv, max_iterations)\n- u_out, s_out, v_out = _svd(a, is_hermitian, compute_uv, max_iterations)\n+ u_out, s_out, v_out = _svd(a, hermitian, compute_uv, max_iterations)\nif reduce_to_square:\nu_out = q @ u_out\n+ if full_matrices:\n+ u_out = jnp.hstack((u_out, u_out_null))\n+\nif is_flip:\nreturn(v_out, s_out, u_out.T.conj())\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/svd_test.py",
"new_path": "tests/svd_test.py",
"diff": "@@ -47,45 +47,55 @@ class SvdTest(jtu.JaxTestCase):\n@parameterized.named_parameters(jtu.cases_from_list(\n{ # pylint:disable=g-complex-comprehension\n- 'testcase_name': '_m={}_by_n={}_log_cond={}'.format(m, n, log_cond),\n- 'm': m, 'n': n, 'log_cond': log_cond}\n+ 'testcase_name': '_m={}_by_n={}_log_cond={}_full_matrices={}'.format(\n+ m, n, log_cond, full_matrices),\n+ 'm': m, 'n': n, 'log_cond': log_cond, 'full_matrices': full_matrices}\nfor m, n in zip([2, 8, 10, 20], [4, 6, 10, 18])\n- for log_cond in np.linspace(1, _MAX_LOG_CONDITION_NUM, 4)))\n+ for log_cond in np.linspace(1, _MAX_LOG_CONDITION_NUM, 4)\n+ for full_matrices in [True, False]))\n@jtu.skip_on_devices(\"rocm\") # will be fixed on rocm-5.1\n- def testSvdWithRectangularInput(self, m, n, log_cond):\n+ def testSvdWithRectangularInput(self, m, n, log_cond, full_matrices):\n\"\"\"Tests SVD with rectangular input.\"\"\"\nwith jax.default_matmul_precision('float32'):\na = np.random.uniform(\nlow=0.3, high=0.9, size=(m, n)).astype(_SVD_TEST_DTYPE)\n- u, s, v = jnp.linalg.svd(a, full_matrices=False)\n+ u, s, v = osp_linalg.svd(a, full_matrices=False)\ncond = 10**log_cond\ns = jnp.linspace(cond, 1, min(m, n))\na = (u * s) @ v\na = a + 1j * a\n- osp_linalg_fn = functools.partial(osp_linalg.svd, full_matrices=False)\n- actual_u, actual_s, actual_v = svd.svd(a)\n+ osp_linalg_fn = functools.partial(\n+ osp_linalg.svd, full_matrices=full_matrices)\n+ actual_u, actual_s, actual_v = svd.svd(a, full_matrices=full_matrices)\nk = min(m, n)\nif m > n:\n- unitary_u = jnp.abs(actual_u.T.conj() @ actual_u)\n- unitary_v = jnp.abs(actual_v.T.conj() @ actual_v)\n+ unitary_u = jnp.real(actual_u.T.conj() @ actual_u)\n+ unitary_v = jnp.real(actual_v.T.conj() @ actual_v)\n+ unitary_u_size = m if full_matrices else k\n+ unitary_v_size = k\nelse:\n- unitary_u = jnp.abs(actual_u @ actual_u.T.conj())\n- unitary_v = jnp.abs(actual_v @ actual_v.T.conj())\n+ unitary_u = jnp.real(actual_u @ actual_u.T.conj())\n+ unitary_v = jnp.real(actual_v @ actual_v.T.conj())\n+ unitary_u_size = k\n+ unitary_v_size = n if full_matrices else k\n_, expected_s, _ = osp_linalg_fn(a)\n+ svd_fn = lambda a: svd.svd(a, full_matrices=full_matrices)\nargs_maker = lambda: [a]\nwith self.subTest('Test JIT compatibility'):\n- self._CompileAndCheck(svd.svd, args_maker)\n+ self._CompileAndCheck(svd_fn, args_maker)\nwith self.subTest('Test unitary u.'):\n- self.assertAllClose(np.eye(k), unitary_u, rtol=_SVD_RTOL, atol=2E-3)\n+ self.assertAllClose(np.eye(unitary_u_size), unitary_u, rtol=_SVD_RTOL,\n+ atol=2E-3)\nwith self.subTest('Test unitary v.'):\n- self.assertAllClose(np.eye(k), unitary_v, rtol=_SVD_RTOL, atol=2E-3)\n+ self.assertAllClose(np.eye(unitary_v_size), unitary_v, rtol=_SVD_RTOL,\n+ atol=2E-3)\nwith self.subTest('Test s.'):\nself.assertAllClose(\n@@ -100,7 +110,7 @@ class SvdTest(jtu.JaxTestCase):\nwith jax.default_matmul_precision('float32'):\nnp.random.seed(1235)\na = np.random.randn(m, n).astype(_SVD_TEST_DTYPE)\n- u, s, v = svd.svd(a, is_hermitian=False)\n+ u, s, v = svd.svd(a, full_matrices=False, hermitian=False)\nrelative_diff = np.linalg.norm(a - (u * s) @ v) / np.linalg.norm(a)\n@@ -126,19 +136,21 @@ class SvdTest(jtu.JaxTestCase):\na = (u * s) @ v\nwith jax.default_matmul_precision('float32'):\n- u, s, v = svd.svd(a, is_hermitian=False)\n+ u, s, v = svd.svd(a, full_matrices=False, hermitian=False)\ndiff = np.linalg.norm(a - (u * s) @ v)\nnp.testing.assert_almost_equal(diff, 1E-4, decimal=2)\n@parameterized.named_parameters(jtu.cases_from_list(\n{ # pylint:disable=g-complex-comprehension\n- 'testcase_name': '_m={}_by_n={}_log_cond={}'.format(m, n, log_cond),\n- 'm': m, 'n': n, 'log_cond': log_cond}\n+ 'testcase_name': '_m={}_by_n={}_log_cond={}_full_matrices={}'.format(\n+ m, n, log_cond, full_matrices),\n+ 'm': m, 'n': n, 'log_cond': log_cond, 'full_matrices': full_matrices}\nfor m, n in zip([2, 8, 10, 20], [4, 6, 10, 18])\n- for log_cond in np.linspace(1, _MAX_LOG_CONDITION_NUM, 4)))\n+ for log_cond in np.linspace(1, _MAX_LOG_CONDITION_NUM, 4)\n+ for full_matrices in [True, False]))\n@jtu.skip_on_devices(\"rocm\") # will be fixed on rocm-5.1\n- def testSingularValues(self, m, n, log_cond):\n+ def testSingularValues(self, m, n, log_cond, full_matrices):\n\"\"\"Tests singular values.\"\"\"\nwith jax.default_matmul_precision('float32'):\na = np.random.uniform(\n@@ -153,15 +165,16 @@ class SvdTest(jtu.JaxTestCase):\ncompute_uv = False\nosp_linalg_fn = functools.partial(\n- osp_linalg.svd, full_matrices=False, compute_uv=compute_uv)\n- actual_s = svd.svd(a, compute_uv=compute_uv)\n+ osp_linalg.svd, full_matrices=full_matrices, compute_uv=compute_uv)\n+ actual_s = svd.svd(a, full_matrices=full_matrices, compute_uv=compute_uv)\nexpected_s = osp_linalg_fn(a)\n+ svd_fn = lambda a: svd.svd(a, full_matrices=full_matrices)\nargs_maker = lambda: [a]\nwith self.subTest('Test JIT compatibility'):\n- self._CompileAndCheck(svd.svd, args_maker)\n+ self._CompileAndCheck(svd_fn, args_maker)\nwith self.subTest('Test s.'):\nself.assertAllClose(expected_s, actual_s, rtol=_SVD_RTOL, atol=1E-6)\n"
}
] | Python | Apache License 2.0 | google/jax | [linalg] Adds `full_matrices` option to TPU SVD.
PiperOrigin-RevId: 443163571 |
260,335 | 20.04.2022 14:47:15 | 25,200 | e313428f2e72a9aa4a0e0f78fac69403b8a3a42d | remove lax._device_put_raw | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/control_flow.py",
"new_path": "jax/_src/lax/control_flow.py",
"diff": "@@ -1823,7 +1823,7 @@ def _scan_partial_eval(trace, *tracers, reverse, length, num_consts, num_carry,\ndef _maybe_device_put(x):\nif isinstance(x, np.ndarray):\n- return lax._device_put_raw(x)\n+ return jax.device_put(x, jax.devices('cpu')[0])\nelse:\nreturn x\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/lax.py",
"new_path": "jax/_src/lax/lax.py",
"diff": "@@ -30,7 +30,6 @@ from jax._src import ad_util\nfrom jax._src import api\nfrom jax._src import api_util\nfrom jax._src import device_array\n-from jax._src import dispatch\nfrom jax import linear_util as lu\nfrom jax._src import dtypes\nfrom jax import tree_util\n@@ -1090,13 +1089,6 @@ def full(shape: Shape, fill_value: Array, dtype: Optional[DType] = None) -> Arra\nfill_value = _convert_element_type(fill_value, dtype, weak_type)\nreturn broadcast(fill_value, shape)\n-def _device_put_raw(x, weak_type=None):\n- if isinstance(x, device_array.DeviceArray):\n- return x\n- else:\n- aval = raise_to_shaped(core.get_aval(x), weak_type=weak_type)\n- return dispatch.array_result_handler(None, aval)(*dispatch.device_put(x))\n-\ndef zeros_like_shaped_array(aval: Array) -> Array:\nassert isinstance(aval, ShapedArray)\nif aval.dtype == dtypes.float0:\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/call_tf.py",
"new_path": "jax/experimental/jax2tf/call_tf.py",
"diff": "@@ -33,7 +33,6 @@ from jax import dtypes\nfrom jax import tree_util\nfrom jax._src import util\nfrom jax._src import ad_util\n-from jax._src.lax.lax import _device_put_raw\nfrom jax.interpreters import mlir\nfrom jax.interpreters import xla\nfrom jax._src.lib.mlir import ir\n@@ -220,7 +219,7 @@ def _call_tf_impl(*args_jax_flat, callable_flat_tf, **_):\nres_dlpack = tf.experimental.dlpack.to_dlpack(res_tf)\nreturn jax.dlpack.from_dlpack(res_dlpack)\n- return _device_put_raw(np.asarray(res_tf))\n+ return jax.device_put(np.asarray(res_tf))\nreturn list(map(_res_tf_to_jax, res_tf_flat))\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_test.py",
"new_path": "tests/lax_test.py",
"diff": "@@ -38,7 +38,6 @@ from jax._src import test_util as jtu\nfrom jax._src import lax_reference\nfrom jax._src.util import prod\nfrom jax._src.lax import lax as lax_internal\n-from jax._src.lax.lax import _device_put_raw\nfrom jax.config import config\n@@ -2796,7 +2795,7 @@ class LazyConstantTest(jtu.JaxTestCase):\nfor dtype_in in all_dtypes for dtype_out in all_dtypes))\n@jtu.ignore_warning(category=np.ComplexWarning)\ndef testConvertElementTypeAvoidsCopies(self, dtype_in, dtype_out):\n- x = _device_put_raw(np.zeros(5, dtype_in))\n+ x = jax.device_put(np.zeros(5, dtype_in))\nself.assertEqual(x.dtype, dtype_in)\ny = lax.convert_element_type(x, dtype_out)\nself.assertEqual(y.dtype, dtype_out)\n"
}
] | Python | Apache License 2.0 | google/jax | remove lax._device_put_raw |
260,510 | 19.04.2022 10:45:09 | 25,200 | f17c09eb8d96a8b77bfad92684a06e6467fdece6 | add in mlir lowering for tokens | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/dispatch.py",
"new_path": "jax/_src/dispatch.py",
"diff": "@@ -227,8 +227,6 @@ def lower_xla_callable(fun: lu.WrappedFun, device, backend, name,\n\"for jit in {elapsed_time} sec\"):\njaxpr, out_avals, consts = pe.trace_to_jaxpr_final(\nfun, abstract_args, pe.debug_info_final(fun, \"jit\"), which_explicit)\n- if jaxpr.effects:\n- raise NotImplementedError('Lowering jaxprs with effects not supported.')\nif any(isinstance(c, core.Tracer) for c in consts):\nraise UnexpectedTracerError(\"Encountered an unexpected tracer.\")\n# TODO(mattjj): handle argument pruning w/ dynamic shapes\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/control_flow.py",
"new_path": "jax/_src/lax/control_flow.py",
"diff": "@@ -592,6 +592,8 @@ def _while_lowering(ctx, *args, cond_jaxpr, body_jaxpr, cond_nconsts,\n# Loop condition\ncond_block = while_op.regions[0].blocks.append(*flat_loop_carry_types)\nname_stack = extend_name_stack(ctx.module_context.name_stack, 'while')\n+ if cond_jaxpr.effects:\n+ raise NotImplementedError('`while_loop` with effects in `cond` not supported.')\nwith ir.InsertionPoint(cond_block):\nflat_cond_args = [\ncond_block.arguments[i] for i in range(len(flat_loop_carry_types))\n@@ -600,7 +602,7 @@ def _while_lowering(ctx, *args, cond_jaxpr, body_jaxpr, cond_nconsts,\nx, _, z = util.split_list(cond_args, [cond_nconsts, body_nconsts])\ncond_ctx = ctx.module_context.replace(\nname_stack=xla.extend_name_stack(name_stack, 'cond'))\n- (pred,), = mlir.jaxpr_subcomp(cond_ctx, cond_jaxpr.jaxpr,\n+ ((pred,),), _ = mlir.jaxpr_subcomp(cond_ctx, cond_jaxpr.jaxpr, mlir.TokenSet(),\n_map(mlir.ir_constants, cond_jaxpr.consts),\n*(x + z))\nif batched:\n@@ -608,7 +610,9 @@ def _while_lowering(ctx, *args, cond_jaxpr, body_jaxpr, cond_nconsts,\nmodule_context=ctx.module_context,\nprimitive=None,\navals_in=[pred_aval],\n- avals_out=[pred_aval.update(shape=())])\n+ avals_out=[pred_aval.update(shape=())],\n+ tokens_in=mlir.TokenSet(),\n+ tokens_out=None)\npred, = lax._unary_reduce_lower(\nmhlo.OrOp,\nlambda dtype: np.array(False, dtype),\n@@ -627,15 +631,17 @@ def _while_lowering(ctx, *args, cond_jaxpr, body_jaxpr, cond_nconsts,\nx, y, z = util.split_list(body_args, [cond_nconsts, body_nconsts])\nbody_ctx = ctx.module_context.replace(\nname_stack=xla.extend_name_stack(name_stack, 'body'))\n- new_z = mlir.jaxpr_subcomp(body_ctx, body_jaxpr.jaxpr,\n+ if body_jaxpr.effects:\n+ raise NotImplementedError('`while_loop` with effects in `body` not supported.')\n+ new_z, _ = mlir.jaxpr_subcomp(body_ctx, body_jaxpr.jaxpr, mlir.TokenSet(),\n_map(mlir.ir_constants, body_jaxpr.consts),\n*(y + z))\nif batched:\nbody_pred_ctx = ctx.module_context.replace(\nname_stack=xla.extend_name_stack(name_stack,\n'body_pred'))\n- (body_pred,), = mlir.jaxpr_subcomp(\n- body_pred_ctx, cond_jaxpr.jaxpr,\n+ ((body_pred,),), _ = mlir.jaxpr_subcomp(\n+ body_pred_ctx, cond_jaxpr.jaxpr, mlir.TokenSet(),\n_map(mlir.ir_constants, cond_jaxpr.consts), *(x + z))\nnew_z = _map(\npartial(_pred_bcast_select_mhlo, pred_aval, body_pred), new_z, z,\n@@ -1271,10 +1277,12 @@ def _cond_lowering(ctx, index, *args, branches, linear):\nfor i, jaxpr in enumerate(branches):\nbranch = case_op.regions[i].blocks.append()\nwith ir.InsertionPoint(branch):\n+ if jaxpr.effects:\n+ raise NotImplementedError('Cannot lower effectful `cond`.')\nsub_ctx = ctx.module_context.replace(\nname_stack=xla.extend_name_stack(name_stack, f'branch_{i}_fun'))\n- out_vals = mlir.jaxpr_subcomp(\n- sub_ctx, jaxpr.jaxpr,\n+ out_vals, _ = mlir.jaxpr_subcomp(\n+ sub_ctx, jaxpr.jaxpr, mlir.TokenSet(),\n_map(mlir.ir_constants, jaxpr.consts),\n*_map(mlir.wrap_singleton_ir_values, args))\nmhlo.ReturnOp(util.flatten(out_vals))\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/lax.py",
"new_path": "jax/_src/lax/lax.py",
"diff": "@@ -3390,7 +3390,9 @@ def _reduce_lower(ctx, *values, computation, jaxpr, consts, dimensions):\nreducer = op.regions[0].blocks.append(*(ir_types + ir_types))\nwith ir.InsertionPoint(reducer):\nreducer_ctx = ctx.module_context.replace(name_stack=util.new_name_stack())\n- out_nodes = mlir.jaxpr_subcomp(reducer_ctx, jaxpr, consts,\n+ if jaxpr.effects:\n+ raise NotImplementedError('Cannot lower effectful `reduce`.')\n+ out_nodes, _ = mlir.jaxpr_subcomp(reducer_ctx, jaxpr, mlir.TokenSet(), consts,\n*([a] for a in reducer.arguments))\nmhlo.ReturnOp(util.flatten(out_nodes))\nreturn op.results\n@@ -3782,7 +3784,9 @@ def _sort_lower(ctx, *operands, dimension, is_stable, num_keys):\nmodule_context = ctx.module_context,\nprimitive=None,\navals_in=util.flatten(zip(scalar_avals, scalar_avals)),\n- avals_out=[core.ShapedArray((), np.bool_)])\n+ avals_out=[core.ShapedArray((), np.bool_)],\n+ tokens_in=ctx.tokens_in,\n+ tokens_out=ctx.tokens_out)\nout = lower_comparator(sub_ctx, *[[a] for a in comparator.arguments],\nnum_keys=num_keys)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/linalg.py",
"new_path": "jax/_src/lax/linalg.py",
"diff": "@@ -1054,7 +1054,9 @@ def _lu_cpu_gpu_lowering(getrf_impl, ctx, operand):\nsub_ctx = mlir.LoweringRuleContext(module_context=ctx.module_context,\nprimitive=None,\navals_in=[pivot_aval],\n- avals_out=[perm_aval])\n+ avals_out=[perm_aval],\n+ tokens_in=ctx.tokens_in,\n+ tokens_out=ctx.tokens_out)\nperm_fn = mlir.lower_fun(lambda x: lu_pivots_to_permutation(x, m),\nmultiple_results=False)\nperm, = perm_fn(sub_ctx, pivot)\n@@ -1234,7 +1236,9 @@ def _qr_cpu_gpu_lowering(geqrf_impl, orgqr_impl, ctx, operand, *,\nsub_ctx = mlir.LoweringRuleContext(module_context=ctx.module_context,\nprimitive=None,\navals_in=[r_aval],\n- avals_out=[r_aval])\n+ avals_out=[r_aval],\n+ tokens_in=ctx.tokens_in,\n+ tokens_out=ctx.tokens_out)\nr, = mlir.lower_fun(jnp.triu, multiple_results=False)(sub_ctx, r)\nreturn [q, r]\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/parallel.py",
"new_path": "jax/_src/lax/parallel.py",
"diff": "@@ -683,7 +683,9 @@ def _allreduce_lowering(prim, pos_fn, ctx, *args, axes, axis_index_groups):\nmodule_context=ctx.module_context,\nprimitive=None,\navals_in=[aval],\n- avals_out=[aval_out])\n+ avals_out=[aval_out],\n+ tokens_in=ctx.tokens_in,\n+ tokens_out=ctx.tokens_out)\nout, = reducer(reducer_ctx, arg, axes=tuple(positional_axes))[0]\nreturn out\nargs = map(_positional_reduce, ctx.avals_in, args)\n@@ -702,7 +704,8 @@ def _allreduce_lowering(prim, pos_fn, ctx, *args, axes, axis_index_groups):\nlower_reducer = mlir.lower_fun(prim.bind, multiple_results=False)\nreducer_ctx = mlir.LoweringRuleContext(\nmodule_context = ctx.module_context,\n- primitive=None, avals_in=[scalar_aval] * 2, avals_out=[scalar_aval])\n+ primitive=None, avals_in=[scalar_aval] * 2, avals_out=[scalar_aval],\n+ tokens_in=ctx.tokens_in, tokens_out=ctx.tokens_out)\nout_nodes = lower_reducer(\nreducer_ctx, *([a] for a in reducer_block.arguments))\nmhlo.ReturnOp(util.flatten(out_nodes))\n@@ -1267,7 +1270,8 @@ def _reduce_scatter_lowering(prim, reducer, ctx, x,\nlower_reducer = mlir.lower_fun(prim.bind, multiple_results=False)\nreducer_ctx = mlir.LoweringRuleContext(\nmodule_context = ctx.module_context,\n- primitive=None, avals_in=[scalar_aval] * 2, avals_out=[scalar_aval])\n+ primitive=None, avals_in=[scalar_aval] * 2, avals_out=[scalar_aval],\n+ tokens_in=ctx.tokens_in, tokens_out=ctx.tokens_out)\nout_nodes = lower_reducer(\nreducer_ctx, *([a] for a in reducer_block.arguments))\nmhlo.ReturnOp(util.flatten(out_nodes))\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/slicing.py",
"new_path": "jax/_src/lax/slicing.py",
"diff": "@@ -1934,8 +1934,10 @@ def _scatter_lower(ctx, operand, indices, updates, *,\nupdate = op.update_computation.blocks.append(scalar_type, scalar_type)\nwith ir.InsertionPoint(update):\nupdate_ctx = ctx.module_context.replace(name_stack=util.new_name_stack())\n- out_nodes = mlir.jaxpr_subcomp(\n- update_ctx, update_jaxpr, update_consts,\n+ if update_jaxpr.effects:\n+ raise NotImplementedError('Cannot lower effectful `scatter`.')\n+ out_nodes, _ = mlir.jaxpr_subcomp(\n+ update_ctx, update_jaxpr, mlir.TokenSet(), update_consts,\n(update.arguments[0],), (update.arguments[1],))\nmhlo.ReturnOp(util.flatten(out_nodes))\nreturn op.results\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/windowed_reductions.py",
"new_path": "jax/_src/lax/windowed_reductions.py",
"diff": "@@ -310,8 +310,10 @@ def _generic_reduce_window_lower(ctx, *args, jaxpr, consts,\nir.DenseIntElementsAttr.get(np.asarray(padding, np.int64)))\nreducer = rw.regions[0].blocks.append(*(scalar_types + scalar_types))\nwith ir.InsertionPoint(reducer):\n- out_nodes = mlir.jaxpr_subcomp(ctx.module_context, jaxpr, consts,\n- *([a] for a in reducer.arguments))\n+ if jaxpr.effects:\n+ raise NotImplementedError('Cannot lower effectful `reduce_window`.')\n+ out_nodes, _ = mlir.jaxpr_subcomp(ctx.module_context, jaxpr,\n+ mlir.TokenSet(), consts, *([a] for a in reducer.arguments))\nmhlo.ReturnOp(util.flatten(out_nodes))\nreturn rw.results\n@@ -499,14 +501,18 @@ def _select_and_scatter_lower(\nir.DenseIntElementsAttr.get(np.asarray(padding, np.int64)))\nselect = op.select.blocks.append(scalar_type, scalar_type)\nwith ir.InsertionPoint(select):\n- out_nodes = mlir.jaxpr_subcomp(ctx.module_context, select_jaxpr,\n- select_consts,\n+ if select_jaxpr.effects:\n+ raise NotImplementedError('Cannot lower effectful `select`.')\n+ out_nodes, _ = mlir.jaxpr_subcomp(ctx.module_context, select_jaxpr,\n+ mlir.TokenSet(), select_consts,\n*([a] for a in select.arguments))\nmhlo.ReturnOp(util.flatten(out_nodes))\nscatter = op.scatter.blocks.append(scalar_type, scalar_type)\nwith ir.InsertionPoint(scatter):\n- out_nodes = mlir.jaxpr_subcomp(ctx.module_context, scatter_jaxpr,\n- scatter_consts,\n+ if scatter_jaxpr.effects:\n+ raise NotImplementedError('Cannot lower effectful `scatter`.')\n+ out_nodes, _ = mlir.jaxpr_subcomp(ctx.module_context, scatter_jaxpr,\n+ mlir.TokenSet(), scatter_consts,\n*([a] for a in scatter.arguments))\nmhlo.ReturnOp(util.flatten(out_nodes))\nreturn op.results\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/core.py",
"new_path": "jax/core.py",
"diff": "@@ -59,6 +59,8 @@ Effects = Set[Effect]\nno_effects: Effects = set()\n+ordered_effects: Set[Effect] = set()\n+\nclass Jaxpr:\nconstvars: List[Var]\ninvars: List[Var]\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/maps.py",
"new_path": "jax/experimental/maps.py",
"diff": "@@ -1394,7 +1394,9 @@ def _xmap_lowering_rule_replica(ctx, *in_nodes,\nmultiple_results=False)(\nmlir.LoweringRuleContext(module_context=ctx.module_context,\nprimitive=None,\n- avals_in=[aval], avals_out=None),\n+ avals_in=[aval], avals_out=None,\n+ tokens_in=ctx.tokens_in,\n+ tokens_out=ctx.tokens_out),\nin_node)[0]\nif v.aval is not core.abstract_unit else in_node\nfor v, aval, in_node, arg_in_axes\n@@ -1408,7 +1410,9 @@ def _xmap_lowering_rule_replica(ctx, *in_nodes,\nsub_ctx = ctx.module_context.replace(\nname_stack=xla.extend_name_stack(ctx.module_context.name_stack,\nwrap_name(name, 'xmap')))\n- tiled_outs = mlir.jaxpr_subcomp(sub_ctx, vectorized_jaxpr, (), *tiled_ins)\n+ if vectorized_jaxpr.effects:\n+ raise NotImplementedError('Cannot lower effectful `xmap`')\n+ tiled_outs, _ = mlir.jaxpr_subcomp(sub_ctx, vectorized_jaxpr, mlir.TokenSet(), (), *tiled_ins)\nouts = [\nmlir.lower_fun(\n@@ -1418,7 +1422,9 @@ def _xmap_lowering_rule_replica(ctx, *in_nodes,\nmlir.LoweringRuleContext(module_context=ctx.module_context,\nprimitive=None,\navals_in=[vectorized_outvar.aval],\n- avals_out=None), tiled_out)[0]\n+ avals_out=None,\n+ tokens_in=ctx.tokens_in,\n+ tokens_out=ctx.tokens_out), tiled_out)[0]\nif v.aval is not core.abstract_unit else tiled_out\nfor v, vectorized_outvar, tiled_out, ans_out_axes\nin zip(call_jaxpr.outvars, vectorized_jaxpr.outvars, tiled_outs,\n@@ -1473,8 +1479,10 @@ def _xmap_lowering_rule_spmd(ctx, *global_in_nodes,\nsub_ctx = ctx.module_context.replace(\nname_stack=xla.extend_name_stack(ctx.module_context.name_stack,\nwrap_name(name, 'xmap')))\n- global_out_nodes = mlir.jaxpr_subcomp(sub_ctx, vectorized_jaxpr, (),\n- *sharded_global_in_nodes)\n+ if vectorized_jaxpr.effects:\n+ raise NotImplementedError('Cannot lower effectful `xmap`')\n+ global_out_nodes, _ = mlir.jaxpr_subcomp(sub_ctx, vectorized_jaxpr,\n+ mlir.TokenSet(), (), *sharded_global_in_nodes)\nsharded_global_out_nodes = [\nmlir.wrap_with_sharding_op(node, global_sharding_spec(aval, aval_axes).sharding_proto())\n@@ -1522,8 +1530,10 @@ def _xmap_lowering_rule_spmd_manual(ctx, *global_in_nodes,\nname_stack=xla.extend_name_stack(ctx.module_context.name_stack,\nwrap_name(name, 'xmap')),\naxis_context=ctx.module_context.axis_context.extend_manual(manual_mesh_axes))\n- global_out_nodes = mlir.jaxpr_subcomp(sub_ctx, vectorized_jaxpr, (),\n- *([n] for n in global_in_nodes))\n+ if vectorized_jaxpr.effects:\n+ raise NotImplementedError('Cannot lower effectful `xmap`')\n+ global_out_nodes, _ = mlir.jaxpr_subcomp(sub_ctx, vectorized_jaxpr,\n+ mlir.TokenSet(), (), *([n] for n in global_in_nodes))\nreturn global_out_nodes\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/pjit.py",
"new_path": "jax/experimental/pjit.py",
"diff": "@@ -712,7 +712,7 @@ def _pjit_lowering(ctx, *args, name, jaxpr, in_axis_resources,\n# TODO(b/228598865): inlined calls cannot have shardings set directly on the\n# inputs or outputs because they are lost during MHLO->HLO conversion.\n# using_sharding_annotation=False means we add an identity operation instead.\n- func = mlir.lower_jaxpr_to_fun(sub_ctx, f\"pjit_{name}\", jaxpr,\n+ func = mlir.lower_jaxpr_to_fun(sub_ctx, f\"pjit_{name}\", jaxpr, (),\narg_shardings=arg_shardings,\nresult_shardings=result_shardings,\nuse_sharding_annotations=False)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/experimental/sparse/bcoo.py",
"new_path": "jax/experimental/sparse/bcoo.py",
"diff": "@@ -825,7 +825,9 @@ def _bcoo_dot_general_gpu_lowering(\nsub_ctx = mlir.LoweringRuleContext(module_context=ctx.module_context,\nprimitive=None,\navals_in=ctx.avals_in[:2],\n- avals_out=ctx.avals_in[:2])\n+ avals_out=ctx.avals_in[:2],\n+ tokens_in=ctx.tokens_in,\n+ tokens_out=ctx.tokens_out)\n(lhs_data,), (lhs_indices,) = _bcoo_sort_indices_mhlo(\nsub_ctx, lhs_data, lhs_indices, spinfo=lhs_spinfo)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/mlir.py",
"new_path": "jax/interpreters/mlir.py",
"diff": "# Lowering and execution path that converts jaxprs into the MLIR MHLO/CHLO\n# dialects.\n+from __future__ import annotations\nimport collections\nimport dataclasses\n@@ -54,6 +55,8 @@ T = typing.TypeVar(\"T\")\n# mypy implicitly sets this variable to true when type checking.\nMYPY = False\n+lowerable_effects: Set[core.Effect] = set()\n+\n# IR Helpers\n@@ -399,6 +402,12 @@ class LoweringRuleContext:\nprimitive: Optional[core.Primitive]\navals_in: Sequence[core.AbstractValue]\navals_out: Any # Usually Sequence[core.AbstractValue], but sometimes None.\n+ tokens_in: TokenSet\n+ tokens_out: Optional[TokenSet] # Mutable store for output containers\n+\n+ def set_tokens_out(self, tokens_out: TokenSet):\n+ assert self.tokens_out is None, 'Should only set `tokens_out` once.'\n+ self.tokens_out = tokens_out\ndef replace(self, **kw): return dataclasses.replace(self, **kw)\n@@ -510,8 +519,15 @@ def lower_jaxpr_to_module(\nctx.module.operation.attributes[\"sym_name\"] = ir.StringAttr.get(\nf\"{module_name}.{next(_module_unique_id)}\")\n# TODO(phawkins): represent units with zero buffers at the runtime level.\n+ unlowerable_effects = {eff for eff in jaxpr.effects\n+ if eff not in lowerable_effects}\n+ if unlowerable_effects:\n+ raise ValueError(\n+ f'Cannot lower jaxpr with unlowerable effects: {unlowerable_effects}')\n+ effects = [eff for eff in jaxpr.effects if eff in core.ordered_effects]\nlower_jaxpr_to_fun(\n- ctx, \"main\", jaxpr, public=True, replace_units_with_dummy=True,\n+ ctx, \"main\", jaxpr, effects, public=True, create_tokens=True,\n+ replace_units_with_dummy=True,\nreplace_tokens_with_dummy=True, replicated_args=replicated_args,\narg_shardings=arg_shardings, result_shardings=result_shardings,\ninput_output_aliases=input_output_aliases)\n@@ -547,11 +563,69 @@ def _set_up_aliases(avals_in, avals_out, donated_args):\nreturn input_output_aliases, out_donated_args\n+Token = Sequence[ir.Value]\n+\n+def token_type() -> Sequence[ir.Type]:\n+ return [mhlo.TokenType.get()]\n+\n+def token() -> Token:\n+ return wrap_singleton_ir_values(\n+ mhlo.CreateTokenOp(mhlo.TokenType.get()).result)\n+\n+class TokenSet:\n+ \"\"\"An immutable container of tokens to be used to lower effectful jaxprs. When lowering\n+ effectful jaxprs, we need to thread MHLO tokens to sequence them. Each effect\n+ will need its own token that will be threaded in and out of the effectful\n+ primitives. A `TokenSet` encapsulates a set of MHLO tokens that will be\n+ used by the lowering rules.\n+ \"\"\"\n+ _tokens: typing.OrderedDict[core.Effect, Token]\n+\n+ def __init__(self, *args, **kwargs):\n+ self._tokens = collections.OrderedDict(*args, **kwargs)\n+\n+ def __len__(self):\n+ return len(self._tokens)\n+\n+ def get(self, effect: core.Effect) -> Token:\n+ return self._tokens[effect]\n+\n+ @classmethod\n+ def create(cls, effects: Sequence[core.Effect]) -> TokenSet:\n+ \"\"\"Creates a `TokenSet` corresponding to a list of `core.Effect`s.\"\"\"\n+ tokens = [token() for _ in effects]\n+ return TokenSet(zip(effects, tokens))\n+\n+ def items(self) -> Sequence[Tuple[core.Effect, Token]]:\n+ return tuple(self._tokens.items())\n+\n+ def effects(self) -> Sequence[core.Effect]:\n+ return tuple(self._tokens.keys())\n+\n+ def tokens(self) -> Sequence[Token]:\n+ return tuple(self._tokens.values())\n+\n+ def subset(self, effects: Sequence[core.Effect]) -> TokenSet:\n+ \"\"\"Return a subset of the `TokenSet` restricted to a set of `core.Effect`s.\"\"\"\n+ return TokenSet((eff, self._tokens[eff]) for eff in effects)\n+\n+ def update_tokens(self, tokens: TokenSet) -> TokenSet:\n+ \"\"\"Returns a new `TokenSet` with tokens replaced with ones from the input `TokenSet`.\"\"\"\n+ new_tokens = []\n+ for eff in self.effects():\n+ if eff in tokens._tokens:\n+ new_tokens.append(tokens._tokens[eff])\n+ else:\n+ new_tokens.append(self._tokens[eff])\n+ return TokenSet(zip(self.effects(), new_tokens))\n+\ndef lower_jaxpr_to_fun(\nctx: ModuleContext,\nname: str,\njaxpr: core.ClosedJaxpr,\n+ effects: Sequence[core.Effect],\n*,\n+ create_tokens: bool = False,\npublic: bool = False,\nreplace_units_with_dummy: bool = False,\nreplace_tokens_with_dummy: bool = False,\n@@ -570,6 +644,8 @@ def lower_jaxpr_to_fun(\nname: the function name. The name will be uniquified by the symbol table,\nso it is ok to use the same name multiple times.\njaxpr: the jaxpr to lower.\n+ effects: a sequence of `core.Effect`s corresponding to an ordering of tokens\n+ that will be created in or used by the lowered function.\npublic: if true, the function's visibility is set to \"public\".\nreplace_units_with_dummy: if true, unit arguments/return values are\nreplaced with bool arrays of size [0].\n@@ -596,6 +672,29 @@ def lower_jaxpr_to_fun(\ninput_types = map(aval_to_types, jaxpr.in_avals)\noutput_types = map(aval_to_types, jaxpr.out_avals)\n+ if create_tokens:\n+ # If we create the tokens they won't be inputs to the MLIR function.\n+ num_tokens = 0\n+ token_types = []\n+ else:\n+ # If we aren't creating tokens they will be the initial inputs to the\n+ # MLIR function.\n+ num_tokens = len(effects)\n+ token_types = [token_type() for _ in effects]\n+ input_types = [*token_types, *input_types]\n+ output_types = [*token_types, *output_types]\n+ if input_output_aliases:\n+ token_input_output_aliases = [None] * num_tokens\n+ input_output_aliases = [*token_input_output_aliases, *input_output_aliases]\n+ if arg_shardings:\n+ token_shardings = [None] * num_tokens\n+ arg_shardings = [*token_shardings, *arg_shardings]\n+ if result_shardings:\n+ token_shardings = [None] * num_tokens\n+ result_shardings = [*token_shardings, *result_shardings]\n+ if replicated_args:\n+ token_replicated_args = [False] * num_tokens\n+ replicated_args = [*token_replicated_args, *replicated_args]\nflat_input_types = util.flatten(input_types)\nflat_output_types = util.flatten(output_types)\nftype = ir.FunctionType.get(flat_input_types, flat_output_types)\n@@ -664,6 +763,13 @@ def lower_jaxpr_to_fun(\nflat_args = map(wrap_with_sharding_op, flat_args, ir_arg_shardings)\nunflattened_args = util.unflatten(flat_args, map(len, input_types))\n+ # We separate out the token inputs and the usual inputs. The token inputs\n+ # will be passed to `jaxpr_subcomp` separately from the `args`.\n+ token_args, unflattened_args = util.split_list(unflattened_args, [num_tokens])\n+ if create_tokens:\n+ tokens_in = TokenSet.create(effects)\n+ else:\n+ tokens_in = TokenSet(zip(effects, token_args))\nargs: List[List[ir.Value]] = []\nfor aval, arg in zip(jaxpr.in_avals, unflattened_args):\nif replace_units_with_dummy and aval is core.abstract_unit:\n@@ -674,10 +780,17 @@ def lower_jaxpr_to_fun(\nargs.append(arg)\ncallee_name_stack = xla.extend_name_stack(ctx.name_stack,\nutil.wrap_name(name, 'jit'))\n- out_vals = jaxpr_subcomp(ctx.replace(name_stack=callee_name_stack),\n- jaxpr.jaxpr, map(ir_constants, jaxpr.consts),\n+ out_vals, tokens_out = jaxpr_subcomp(ctx.replace(name_stack=callee_name_stack),\n+ jaxpr.jaxpr, tokens_in, map(ir_constants, jaxpr.consts),\n*args)\nouts = []\n+ if create_tokens:\n+ # If we created the tokens in this function, we are done with them and can\n+ # ignore `tokens_out`.\n+ pass\n+ else:\n+ for token in tokens_out.tokens():\n+ outs.append(token)\nfor aval, out in zip(jaxpr.out_avals, out_vals):\nif replace_units_with_dummy and aval is core.abstract_unit:\nouts.append(ir_constants(np.zeros((), np.bool_)))\n@@ -699,6 +812,10 @@ def _emit_lowering_rule_as_fun(lowering_rule,\n\"\"\"Emits the contents of a lowering rule as a private function.\"\"\"\ninput_types = map(aval_to_ir_types, ctx.avals_in)\noutput_types = map(aval_to_ir_types, ctx.avals_out)\n+ token_types = [token_type() for _ in ctx.tokens_in.items()]\n+ input_types = [*token_types, *input_types]\n+ output_types = [*token_types, *output_types]\n+\nflat_input_types = util.flatten(input_types)\nflat_output_types = util.flatten(output_types)\nftype = ir.FunctionType.get(flat_input_types, flat_output_types)\n@@ -711,13 +828,19 @@ def _emit_lowering_rule_as_fun(lowering_rule,\nwith ir.InsertionPoint(entry_block):\nunflattened_args = util.unflatten(entry_block.arguments,\nmap(len, input_types))\n- outs = lowering_rule(ctx, *_unwrap_singleton_ir_values(unflattened_args))\n+ token_args, unflattened_args = util.split_list(unflattened_args, [len(ctx.tokens_in)])\n+ sub_ctx = ctx.replace(tokens_in=TokenSet(zip(ctx.tokens_in.effects(), token_args)))\n+ outs = lowering_rule(sub_ctx, *_unwrap_singleton_ir_values(unflattened_args))\n+ if sub_ctx.tokens_out:\n+ outs = [*sub_ctx.tokens_out.tokens(), outs]\nfunc_dialect.ReturnOp(util.flatten(map(wrap_singleton_ir_values, outs)))\nreturn func_op\ndef jaxpr_subcomp(ctx: ModuleContext, jaxpr: core.Jaxpr,\n+ tokens: TokenSet,\nconsts: Sequence[Sequence[ir.Value]],\n- *args: Sequence[ir.Value]) -> Sequence[Sequence[ir.Value]]:\n+ *args: Sequence[ir.Value]\n+ ) -> Tuple[Sequence[Sequence[ir.Value]], TokenSet]:\n\"\"\"Lowers a jaxpr into mHLO, inlined into an existing function.\nAssumes that an MLIR context, location, and insertion point are set.\n@@ -773,11 +896,28 @@ def jaxpr_subcomp(ctx: ModuleContext, jaxpr: core.Jaxpr,\neqn_ctx = (ctx.replace(name_stack=source_info.name_stack) if\nconfig.jax_experimental_name_stack else ctx)\n+ effects = [eff for eff in eqn.effects if eff in core.ordered_effects]\n+ tokens_in = tokens.subset(effects)\nrule_ctx = LoweringRuleContext(\nmodule_context=eqn_ctx, primitive=eqn.primitive,\n- avals_in=map(aval, eqn.invars), avals_out=map(aval, eqn.outvars))\n+ avals_in=map(aval, eqn.invars), avals_out=map(aval, eqn.outvars),\n+ tokens_in=tokens_in, tokens_out=None)\nans = rule(rule_ctx, *map(_unwrap_singleton_ir_values, in_nodes),\n**eqn.params)\n+ if effects:\n+ # If there were ordered effects in the primitive, there should be output\n+ # tokens we need for subsequent ordered effects.\n+ tokens_out = rule_ctx.tokens_out\n+ if tokens_out is None:\n+ raise ValueError(\n+ f'Lowering rule for `{eqn.primitive}` needs to set `tokens_out` '\n+ f'because it has effects: {eqn.effects}.')\n+ if tokens_out.effects() != tokens_in.effects():\n+ raise ValueError(\n+ f'Lowering rule for `{eqn.primitive}` '\n+ 'returns incorrect set of output tokens. '\n+ f'Expected: {tuple(tokens_in.effects())} vs. Actual: {tuple(tokens_out.effects())}')\n+ tokens = tokens.update_tokens(tokens_out)\ntry:\nout_nodes = tuple(map(wrap_singleton_ir_values, ans))\n@@ -789,7 +929,7 @@ def jaxpr_subcomp(ctx: ModuleContext, jaxpr: core.Jaxpr,\nassert all(isinstance(v, ir.Value) for w in out_nodes for v in w), (ans, eqn)\nassert len(ans) == len(eqn.outvars), (ans, eqn)\nmap(write, eqn.outvars, out_nodes)\n- return map(read, jaxpr.outvars)\n+ return map(read, jaxpr.outvars), tokens\ndef _ir_consts(consts):\nunique_consts = {id(const): const for const in consts}\n@@ -811,39 +951,52 @@ def lower_fun(fun: Callable, multiple_results: bool = True) -> Callable:\naxis_env = ctx.module_context.axis_env\nwith core.extend_axis_env_nd(zip(axis_env.names, axis_env.sizes)):\njaxpr, _, consts = pe.trace_to_jaxpr_dynamic(wrapped_fun, ctx.avals_in)\n- return jaxpr_subcomp(ctx.module_context, jaxpr, _ir_consts(consts),\n+ out, tokens = jaxpr_subcomp(ctx.module_context, jaxpr, ctx.tokens_in, _ir_consts(consts),\n*map(wrap_singleton_ir_values, args))\n+ ctx.set_tokens_out(tokens)\n+ return out\nreturn f_lowered\ndef _call_lowering(fn_name, stack_name, call_jaxpr, backend, ctx, avals_in,\n- avals_out, *args):\n+ avals_out, tokens_in, *args):\nxla.check_backend_matches(backend, ctx.platform)\noutput_types = map(aval_to_ir_types, avals_out)\nflat_output_types = util.flatten(output_types)\n+ effects = tokens_in.effects()\nsymbol_name = lower_jaxpr_to_fun(ctx, fn_name,\n- core.ClosedJaxpr(call_jaxpr, ())).name.value\n+ core.ClosedJaxpr(call_jaxpr, ()),\n+ effects).name.value\n+ args = [*tokens_in.tokens(), *args]\ncall = func_dialect.CallOp(flat_output_types,\nir.FlatSymbolRefAttr.get(symbol_name),\nflatten_lowering_ir_args(args))\n- return util.unflatten(call.results, map(len, output_types))\n+ out_nodes = util.unflatten(call.results, map(len, output_types))\n+ tokens, out_nodes = util.split_list(out_nodes, [len(effects)])\n+ tokens_out = tokens_in.update_tokens(TokenSet(zip(effects, tokens)))\n+ return out_nodes, tokens_out\ndef _xla_call_lower(ctx, *args,\nbackend=None, name, call_jaxpr, donated_invars, inline=None,\ndevice=None):\ndel device, donated_invars, inline # Ignored.\n- return _call_lowering(name, util.wrap_name(name, \"jit\"), call_jaxpr,\n- backend, ctx.module_context, ctx.avals_in, ctx.avals_out,\n- *args)\n+ out_nodes, tokens = _call_lowering(\n+ name, util.wrap_name(name, \"jit\"), call_jaxpr, backend,\n+ ctx.module_context, ctx.avals_in, ctx.avals_out, ctx.tokens_in, *args)\n+ ctx.set_tokens_out(tokens)\n+ return out_nodes\nregister_lowering(xla.xla_call_p, _xla_call_lower)\ndef _named_call_lowering(ctx, *args, name, backend=None,\ncall_jaxpr):\n- return _call_lowering(name, name, call_jaxpr, backend, ctx.module_context,\n- ctx.avals_in, ctx.avals_out, *args)\n+ out_nodes, tokens = _call_lowering(\n+ name, name, call_jaxpr, backend, ctx.module_context,\n+ ctx.avals_in, ctx.avals_out, ctx.tokens_in, *args)\n+ ctx.set_tokens_out(tokens)\n+ return out_nodes\nregister_lowering(core.named_call_p, _named_call_lowering)\nregister_lowering(core.call_p, partial(_named_call_lowering, name=\"core_call\"))\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -1699,7 +1699,7 @@ def _pmap_lowering(ctx, *in_nodes, axis_name,\naxis_context=mlir.ReplicaAxisContext(new_env),\nname_stack=xla.extend_name_stack(ctx.module_context.name_stack,\nutil.wrap_name(name, 'pmap')))\n- sharded_outs = mlir.jaxpr_subcomp(sub_ctx, call_jaxpr, (),\n+ sharded_outs, _ = mlir.jaxpr_subcomp(sub_ctx, call_jaxpr, mlir.TokenSet(), (),\n*in_nodes_sharded)\nout_avals = [v.aval for v in call_jaxpr.outvars]\nouts = [_mhlo_unshard(aval, new_env, out_axis, shard,\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/sharded_jit.py",
"new_path": "jax/interpreters/sharded_jit.py",
"diff": "@@ -203,7 +203,8 @@ def _sharded_jit_lowering(ctx, *in_nodes,\nsub_ctx = ctx.module_context.replace(\nname_stack=new_name_stack(wrap_name(name, \"sharded_jit\")))\nfn = mlir.lower_jaxpr_to_fun(sub_ctx, f\"sharded_jit_{name}\",\n- core.ClosedJaxpr(call_jaxpr, ()))\n+ core.ClosedJaxpr(call_jaxpr, ()),\n+ ())\noutput_types = safe_map(mlir.aval_to_ir_types, ctx.avals_out)\nflat_output_types = util.flatten(output_types)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/jaxpr_effects_test.py",
"new_path": "tests/jaxpr_effects_test.py",
"diff": "@@ -24,7 +24,9 @@ from jax import linear_util as lu\nfrom jax.experimental import maps\nfrom jax.experimental import pjit\nfrom jax.config import config\n+from jax.interpreters import mlir\nfrom jax._src import test_util as jtu\n+from jax._src import util\nimport numpy as np\nconfig.parse_flags_with_absl()\n@@ -36,6 +38,34 @@ effect_p.multiple_results = True\ndef _(*, effect):\nreturn [], {effect}\n+mlir.lowerable_effects.add('foo')\n+mlir.lowerable_effects.add('foo2')\n+mlir.lowerable_effects.add('bar')\n+core.ordered_effects.add('foo')\n+core.ordered_effects.add('foo2')\n+\n+\n+def trivial_effect_lowering(ctx, *, effect):\n+ ctx.set_tokens_out(ctx.tokens_in)\n+ return []\n+\n+def function_effect_lowering(ctx, *, effect):\n+ def _f(ctx):\n+ ctx.set_tokens_out(ctx.tokens_in)\n+ return []\n+ func = mlir._emit_lowering_rule_as_fun(_f, ctx)\n+\n+ output_types = map(mlir.aval_to_ir_types, ctx.avals_out)\n+ token_types = [mlir.token_type() for _ in ctx.tokens_in.items()]\n+ output_types = [*token_types, *output_types]\n+ flat_output_types = util.flatten(output_types)\n+ call = mlir.func_dialect.CallOp(flat_output_types,\n+ mlir.ir.FlatSymbolRefAttr.get(func.name.value),\n+ mlir.flatten_lowering_ir_args(ctx.tokens_in.tokens()))\n+ tokens, out = util.split_list(call.results, [len(ctx.tokens_in)])\n+ ctx.set_tokens_out(mlir.TokenSet(zip(ctx.tokens_in.effects(), tokens)))\n+ return out\n+\nclass JaxprEffectsTest(jtu.JaxTestCase):\n@@ -175,14 +205,153 @@ class HigherOrderPrimitiveTest(jtu.JaxTestCase):\nclass EffectfulJaxprLoweringTest(jtu.JaxTestCase):\n- def test_cannot_lower_jaxpr_with_effects_in_hop(self):\n+ def test_should_pass_tokens_into_ordered_effect(self):\n+\n+ def _effect_lowering(ctx, *, effect):\n+ self.assertListEqual(list(ctx.tokens_in.effects()), ['foo'])\n+ ctx.set_tokens_out(ctx.tokens_in)\n+ return []\n+ mlir.register_lowering(effect_p, _effect_lowering)\n+\n+ @jax.jit\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ return x + 1.\n+ f.lower(2.)\n+\n+ def test_should_not_pass_tokens_into_unordered_effect(self):\n+\n+ def effect_lowering(ctx, *, effect):\n+ self.assertEmpty(ctx.tokens_in)\n+ return []\n+ mlir.register_lowering(effect_p, effect_lowering)\n+\n+ @jax.jit\n+ def f(x):\n+ effect_p.bind(effect='bar')\n+ return x + 1.\n+ f.lower(2.)\n+\n+ def test_lowering_that_doesnt_set_tokens_should_cause_error(self):\n+\n+ def bad_effect_lowering(ctx, *, effect):\n+ # Doesn't call `ctx.set_tokens_out`!\n+ return []\n+ mlir.register_lowering(effect_p, bad_effect_lowering)\n+\n+ @jax.jit\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ return x + 1.\n+ with self.assertRaisesRegex(ValueError, 'Lowering rule for `effect` needs to '\n+ 'set `tokens_out`'):\n+ f.lower(2.)\n+\n+ def test_lowering_that_sets_wrong_tokens_should_cause_error(self):\n+\n+ def bad_effect_lowering(ctx, *, effect):\n+ ctx.set_tokens_out(mlir.TokenSet(bar=ctx.tokens_in.get('foo')))\n+ return []\n+ mlir.register_lowering(effect_p, bad_effect_lowering)\n+\n+ @jax.jit\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ return x + 1.\n+ with self.assertRaisesRegex(ValueError, 'Lowering rule for `effect` returns '\n+ 'incorrect set of output token.'):\n+ f.lower(2.)\n+\n+ def test_lowering_ordered_effect_should_create_tokens(self):\n+\n+ def effect_lowering(ctx, *, effect):\n+ ctx.set_tokens_out(ctx.tokens_in)\n+ return []\n+ mlir.register_lowering(effect_p, effect_lowering)\n+\n+ @jax.jit\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ return x + 1.\n+ mhlo = f.lower(2.).compiler_ir()\n+ main = mhlo.body.operations[0]\n+ first_op = main.body.blocks[0].operations[0]\n+ self.assertEqual(first_op.operation.name, \"mhlo.create_token\")\n+\n+ @jax.jit\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ effect_p.bind(effect='foo2')\n+ return x + 1.\n+ mhlo = f.lower(2.).compiler_ir()\n+ main = mhlo.body.operations[0]\n+ first_op = main.body.blocks[0].operations[0]\n+ self.assertEqual(first_op.operation.name, \"mhlo.create_token\")\n+ second_op = main.body.blocks[0].operations[1]\n+ self.assertEqual(second_op.operation.name, \"mhlo.create_token\")\n+\n+ @jax.jit\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ return x + 1.\n+ mhlo = f.lower(2.).compiler_ir()\n+ main = mhlo.body.operations[0]\n+ first_op = main.body.blocks[0].operations[0]\n+ self.assertEqual(first_op.operation.name, \"mhlo.create_token\")\n+\n@jax.jit\ndef f(x):\neffect_p.bind(effect='foo')\n+ effect_p.bind(effect='foo2')\nreturn x + 1.\n- with self.assertRaisesRegex(NotImplementedError, 'Lowering jaxprs with '\n- 'effects not supported'):\n- f(2.)\n+ mhlo = f.lower(2.).compiler_ir()\n+ main = mhlo.body.operations[0]\n+ first_op = main.body.blocks[0].operations[0]\n+ self.assertEqual(first_op.operation.name, \"mhlo.create_token\")\n+ second_op = main.body.blocks[0].operations[1]\n+ self.assertEqual(second_op.operation.name, \"mhlo.create_token\")\n+\n+ def test_nontrivial_lowering_with_ordered_effect_should_consume_token(self):\n+\n+ mlir.register_lowering(effect_p, function_effect_lowering)\n+\n+ @jax.jit\n+ def f(x):\n+ effect_p.bind(effect='foo')\n+ return x + 1.\n+\n+ mhlo = f.lower(2.).compiler_ir()\n+ main = mhlo.body.operations[0]\n+ first_op = main.body.blocks[0].operations[0]\n+ self.assertEqual(first_op.operation.name, \"mhlo.create_token\")\n+ second_op = main.body.blocks[0].operations[1]\n+ self.assertEqual(second_op.operation.name, \"func.call\")\n+ self.assertEqual(str(second_op.attributes[\"callee\"]), \"@effect\")\n+ self.assertEqual(second_op.operands[0].owner, first_op)\n+ func = mhlo.body.operations[1]\n+ self.assertEqual(func.name.value, \"effect\")\n+ self.assertEqual(str(func.type.inputs[0]), \"!mhlo.token\")\n+ self.assertEqual(str(func.type.results[0]), \"!mhlo.token\")\n+\n+ def test_nontrivial_lowering_with_unordered_effect_should_consume_token(self):\n+\n+ mlir.register_lowering(effect_p, function_effect_lowering)\n+\n+ @jax.jit\n+ def f(x):\n+ effect_p.bind(effect='bar')\n+ return x + 1.\n+\n+ mhlo = f.lower(2.).compiler_ir()\n+ main = mhlo.body.operations[0]\n+ first_op = main.body.blocks[0].operations[0]\n+ self.assertEqual(first_op.operation.name, \"func.call\")\n+ self.assertEqual(str(first_op.attributes[\"callee\"]), \"@effect\")\n+ self.assertLen(list(first_op.operands), 0)\n+ func = mhlo.body.operations[1]\n+ self.assertEqual(func.name.value, \"effect\")\n+ self.assertLen(list(func.type.inputs), 0)\n+ self.assertLen(list(func.type.results), 0)\nclass ControlFlowEffectsTest(jtu.JaxTestCase):\n"
}
] | Python | Apache License 2.0 | google/jax | add in mlir lowering for tokens |
260,430 | 22.04.2022 23:15:44 | -28,800 | 75e990bbc39c7613bb83aee85b04767c54460eed | Fix typo in _scatter_add_lower_gpu
doesn't notice `_scatter_add_lower_gpu` using `mlir.lower_fun` instead of `xla.lower_fun`.
I follow the change done in that commit for _scatter_lower. | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/slicing.py",
"new_path": "jax/_src/lax/slicing.py",
"diff": "@@ -1965,7 +1965,7 @@ def _scatter_add_lower_gpu(ctx, operand, indices, updates,\nif mode == GatherScatterMode.CLIP:\nclip_fn = mlir.lower_fun(_clamp_scatter_indices, multiple_results=False)\n- (indices,), = clip_fn(ctx, ctx.avals_in, None, operand, indices, updates,\n+ (indices,), = clip_fn(ctx.replace(avals_out=None), operand, indices, updates,\ndnums=dimension_numbers)\naval_out, = ctx.avals_out\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_test.py",
"new_path": "tests/lax_test.py",
"diff": "@@ -2272,11 +2272,11 @@ class LaxTest(jtu.JaxTestCase):\nlax.gather(operand, indices, dimension_numbers, slice_sizes)\n@parameterized.named_parameters(jtu.cases_from_list(\n- {\"testcase_name\": \"_shape={}_idxs={}_update={}_dnums={}\".format(\n+ {\"testcase_name\": \"_shape={}_idxs={}_update={}_dnums={}_mode={}\".format(\njtu.format_shape_dtype_string(arg_shape, dtype),\n- idxs, update_shape, dnums),\n+ idxs, update_shape, dnums, mode),\n\"arg_shape\": arg_shape, \"dtype\": dtype, \"idxs\": idxs,\n- \"update_shape\": update_shape, \"dnums\": dnums}\n+ \"update_shape\": update_shape, \"dnums\": dnums, \"mode\": mode}\nfor dtype in inexact_dtypes\nfor arg_shape, idxs, update_shape, dnums in [\n((5,), np.array([[0], [2]]), (2,), lax.ScatterDimensionNumbers(\n@@ -2288,14 +2288,15 @@ class LaxTest(jtu.JaxTestCase):\n((10, 5,), np.array([[0], [2], [1]]), (3, 3), lax.ScatterDimensionNumbers(\nupdate_window_dims=(1,), inserted_window_dims=(0,),\nscatter_dims_to_operand_dims=(0,))),\n- ]))\n- def testScatterAdd(self, arg_shape, dtype, idxs, update_shape, dnums):\n+ ]\n+ for mode in [\"clip\", \"fill\", None]))\n+ def testScatterAdd(self, arg_shape, dtype, idxs, update_shape, dnums, mode):\nrng = jtu.rand_default(self.rng())\nrng_idx = jtu.rand_int(self.rng(), high=max(arg_shape))\nrand_idxs = lambda: rng_idx(idxs.shape, idxs.dtype)\nargs_maker = lambda: [rng(arg_shape, dtype), rand_idxs(),\nrng(update_shape, dtype)]\n- fun = partial(lax.scatter_add, dimension_numbers=dnums)\n+ fun = partial(lax.scatter_add, dimension_numbers=dnums, mode=mode)\nself._CompileAndCheck(fun, args_maker)\n@parameterized.named_parameters(jtu.cases_from_list(\n"
}
] | Python | Apache License 2.0 | google/jax | Fix typo in _scatter_add_lower_gpu
https://github.com/google/jax/commit/a87b21148c6d7eb9b46c751dde40b17ca0e7b03e doesn't notice `_scatter_add_lower_gpu` using `mlir.lower_fun` instead of `xla.lower_fun`.
I follow the change done in that commit for _scatter_lower. |
260,430 | 21.04.2022 13:15:03 | -28,800 | 667d63aa2d4fbf7c9da73aab0e24c5c4c33cb5ba | replace int with operator.index part2
This change align the behavior of `ravel_multi_index`, `split` and `indices` to their `numpy` counterparts.
Also ensure size argument of `nonzero` should be integer.
The changes with `*space` are only simplification | [
{
"change_type": "MODIFY",
"old_path": "CHANGELOG.md",
"new_path": "CHANGELOG.md",
"diff": "@@ -25,6 +25,22 @@ PLEASE REMEMBER TO CHANGE THE '..main' WITH AN ACTUAL TAG in GITHUB LINK.\nare not of an integer type, matching the behavior of\n{func}`numpy.take_along_axis`. Previously non-integer indices were silently\ncast to integers.\n+ * {func}`jax.numpy.ravel_multi_index` now raises a `TypeError` if its `dims` argument\n+ is not of an integer type, matching the behavior of\n+ {func}`numpy.ravel_multi_index`. Previously non-integer `dims` was silently\n+ cast to integers.\n+ * {func}`jax.numpy.split` now raises a `TypeError` if its `axis` argument\n+ is not of an integer type, matching the behavior of\n+ {func}`numpy.split`. Previously non-integer `axis` was silently\n+ cast to integers.\n+ * {func}`jax.numpy.indices` now raises a `TypeError` if its dimensions\n+ are not of an integer type, matching the behavior of\n+ {func}`numpy.indices`. Previously non-integer dimensions were silently\n+ cast to integers.\n+ * {func}`jax.numpy.diag` now raises a `TypeError` if its `k` argument\n+ is not of an integer type, matching the behavior of\n+ {func}`numpy.diag`. Previously non-integer `k` was silently\n+ cast to integers.\n* Deprecations\n* Many functions and objects available in {mod}`jax.test_util` are now deprecated and will raise a\nwarning on import. This includes `cases_from_list`, `check_close`, `check_eq`, `device_under_test`,\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/numpy/lax_numpy.py",
"new_path": "jax/_src/numpy/lax_numpy.py",
"diff": "@@ -774,7 +774,7 @@ def ravel(a, order=\"C\"):\n@_wraps(np.ravel_multi_index)\ndef ravel_multi_index(multi_index, dims, mode='raise', order='C'):\nassert len(multi_index) == len(dims), f\"len(multi_index)={len(multi_index)} != len(dims)={len(dims)}\"\n- dims = tuple(core.concrete_or_error(int, d, \"in `dims` argument of ravel_multi_index().\") for d in dims)\n+ dims = tuple(core.concrete_or_error(operator.index, d, \"in `dims` argument of ravel_multi_index().\") for d in dims)\n_check_arraylike(\"ravel_multi_index\", *multi_index)\nfor index in multi_index:\nif mode == 'raise':\n@@ -1057,7 +1057,7 @@ The JAX version does not necessarily return a view of the input.\ndef _split(op, ary, indices_or_sections, axis=0):\n_check_arraylike(op, ary)\nary = asarray(ary)\n- axis = core.concrete_or_error(int, axis, f\"in jax.numpy.{op} argument `axis`\")\n+ axis = core.concrete_or_error(operator.index, axis, f\"in jax.numpy.{op} argument `axis`\")\nsize = ary.shape[axis]\nif isinstance(indices_or_sections, (tuple, list)):\nindices_or_sections = np.array(\n@@ -1216,7 +1216,7 @@ def nonzero(a, *, size=None, fill_value=None):\nmask = a != 0\nif size is None:\nsize = mask.sum()\n- size = core.concrete_or_error(int, size,\n+ size = core.concrete_or_error(operator.index, size,\n\"The size argument of jnp.nonzero must be statically specified \"\n\"to use jnp.nonzero within JAX transformations.\")\nif a.size == 0 or size == 0:\n@@ -2097,8 +2097,7 @@ def linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None,\naxis: int = 0):\nnum = core.concrete_or_error(operator.index, num, \"'num' argument of jnp.linspace\")\naxis = core.concrete_or_error(operator.index, axis, \"'axis' argument of jnp.linspace\")\n- return _linspace(start, stop, int(num), endpoint, retstep, dtype,\n- operator.index(axis))\n+ return _linspace(start, stop, num, endpoint, retstep, dtype, axis)\n@partial(jit, static_argnames=('num', 'endpoint', 'retstep', 'dtype', 'axis'))\ndef _linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None,\n@@ -2160,8 +2159,7 @@ def logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None,\naxis: int = 0):\nnum = core.concrete_or_error(operator.index, num, \"'num' argument of jnp.logspace\")\naxis = core.concrete_or_error(operator.index, axis, \"'axis' argument of jnp.logspace\")\n- return _logspace(start, stop, int(num), endpoint, base, dtype,\n- operator.index(axis))\n+ return _logspace(start, stop, num, endpoint, base, dtype, axis)\n@partial(jit, static_argnames=('num', 'endpoint', 'dtype', 'axis'))\ndef _logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None,\n@@ -2184,8 +2182,7 @@ def _logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None,\ndef geomspace(start, stop, num=50, endpoint=True, dtype=None, axis: int = 0):\nnum = core.concrete_or_error(operator.index, num, \"'num' argument of jnp.geomspace\")\naxis = core.concrete_or_error(operator.index, axis, \"'axis' argument of jnp.geomspace\")\n- return _geomspace(start, stop, int(num), endpoint, dtype,\n- operator.index(axis))\n+ return _geomspace(start, stop, num, endpoint, dtype, axis)\n@partial(jit, static_argnames=('num', 'endpoint', 'dtype', 'axis'))\ndef _geomspace(start, stop, num=50, endpoint=True, dtype=None, axis: int = 0):\n@@ -2267,7 +2264,7 @@ def ix_(*args):\n@_wraps(np.indices)\ndef indices(dimensions, dtype=int32, sparse=False):\ndimensions = tuple(\n- core.concrete_or_error(int, d, \"dimensions argument of jnp.indices\")\n+ core.concrete_or_error(operator.index, d, \"dimensions argument of jnp.indices\")\nfor d in dimensions)\nN = len(dimensions)\noutput = []\n@@ -2486,7 +2483,7 @@ def diagonal(a, offset=0, axis1: int = 0, axis2: int = 1):\n@_wraps(np.diag, lax_description=_ARRAY_VIEW_DOC)\ndef diag(v, k=0):\n- return _diag(v, int(k))\n+ return _diag(v, operator.index(k))\n@partial(jit, static_argnames=('k',))\ndef _diag(v, k):\n"
}
] | Python | Apache License 2.0 | google/jax | replace int with operator.index part2
This change align the behavior of `ravel_multi_index`, `split` and `indices` to their `numpy` counterparts.
Also ensure size argument of `nonzero` should be integer.
The changes with `*space` are only simplification |
260,430 | 20.04.2022 22:38:50 | -28,800 | b485b8e5ce927a07d1b9377ffe3850239cff89e8 | implement scipy.cluster.vq.vq
also add no check_finite and overwrite_* docstring for some scipy.linalg functions | [
{
"change_type": "MODIFY",
"old_path": "CHANGELOG.md",
"new_path": "CHANGELOG.md",
"diff": "@@ -13,6 +13,7 @@ PLEASE REMEMBER TO CHANGE THE '..main' WITH AN ACTUAL TAG in GITHUB LINK.\n* [GitHub\ncommits](https://github.com/google/jax/compare/jax-v0.3.7...main).\n* Changes\n+ * {func}`jax.scipy.cluster.vq.vq` has been added.\n* `jax.experimental.maps.mesh` has been deleted.\nPlease use `jax.experimental.maps.Mesh`. Please see https://jax.readthedocs.io/en/latest/_autosummary/jax.experimental.maps.Mesh.html#jax.experimental.maps.Mesh\nfor more information.\n"
},
{
"change_type": "ADD",
"old_path": null,
"new_path": "jax/_src/scipy/cluster/vq.py",
"diff": "+# Copyright 2022 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+# https://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+import operator\n+\n+import scipy.cluster.vq\n+import textwrap\n+\n+from jax import vmap\n+from jax._src.numpy.util import _wraps, _check_arraylike, _promote_dtypes_inexact\n+from jax._src.numpy.lax_numpy import argmin\n+from jax._src.numpy.linalg import norm\n+\n+\n+_no_chkfinite_doc = textwrap.dedent(\"\"\"\n+Does not support the Scipy argument ``check_finite=True``,\n+because compiled JAX code cannot perform checks of array values at runtime\n+\"\"\")\n+\n+\n+@_wraps(scipy.cluster.vq.vq, lax_description=_no_chkfinite_doc, skip_params=('check_finite',))\n+def vq(obs, code_book, check_finite=True):\n+ _check_arraylike(\"scipy.cluster.vq.vq\", obs, code_book)\n+ if obs.ndim != code_book.ndim:\n+ raise ValueError(\"Observation and code_book should have the same rank\")\n+ obs, code_book = _promote_dtypes_inexact(obs, code_book)\n+ if obs.ndim == 1:\n+ obs, code_book = obs[..., None], code_book[..., None]\n+ if obs.ndim != 2:\n+ raise ValueError(\"ndim different than 1 or 2 are not supported\")\n+\n+ # explicitly rank promotion\n+ dist = vmap(lambda ob: norm(ob[None] - code_book, axis=-1))(obs)\n+ code = argmin(dist, axis=-1)\n+ dist_min = vmap(operator.getitem)(dist, code)\n+ return code, dist_min\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/scipy/__init__.py",
"new_path": "jax/scipy/__init__.py",
"diff": "@@ -20,3 +20,4 @@ from jax.scipy import sparse as sparse\nfrom jax.scipy import special as special\nfrom jax.scipy import stats as stats\nfrom jax.scipy import fft as fft\n+from jax.scipy import cluster as cluster\n"
},
{
"change_type": "ADD",
"old_path": null,
"new_path": "jax/scipy/cluster/__init__.py",
"diff": "+# Copyright 2022 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+# https://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+from jax.scipy.cluster import vq as vq\n"
},
{
"change_type": "ADD",
"old_path": null,
"new_path": "jax/scipy/cluster/vq.py",
"diff": "+# Copyright 2022 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+# https://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+from jax._src.scipy.cluster.vq import vq as vq\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_scipy_test.py",
"new_path": "tests/lax_scipy_test.py",
"diff": "@@ -24,6 +24,7 @@ from absl.testing import parameterized\nimport numpy as np\nimport scipy.special as osp_special\n+import scipy.cluster as osp_cluster\nimport jax\nfrom jax import numpy as jnp\n@@ -31,6 +32,7 @@ from jax import lax\nfrom jax import scipy as jsp\nfrom jax._src import test_util as jtu\nfrom jax.scipy import special as lsp_special\n+from jax.scipy import cluster as lsp_cluster\nimport jax._src.scipy.eigh\nfrom jax.config import config\n@@ -610,6 +612,19 @@ class LaxBackedScipyTests(jtu.JaxTestCase):\nv_eye = jnp.eye(v_unitary_delta.shape[0], dtype=dtype)\nself.assertAllClose(v_unitary_delta, v_eye, atol=eps)\n+ @parameterized.named_parameters(jtu.cases_from_list(\n+ {\"testcase_name\": f\"_{jtu.format_shape_dtype_string((n_obs, n_codes, *n_feats), dtype)}\",\n+ \"n_obs\": n_obs, \"n_codes\": n_codes, \"n_feats\": n_feats, \"dtype\": dtype}\n+ for n_obs in [1, 3, 5]\n+ for n_codes in [1, 2, 4]\n+ for n_feats in [()] + [(i,) for i in range(1, 3)]\n+ for dtype in float_dtypes + int_dtypes)) # scipy doesn't support complex\n+ def test_vq(self, n_obs, n_codes, n_feats, dtype):\n+ rng = jtu.rand_default(self.rng())\n+ args_maker = lambda: [rng((n_obs, *n_feats), dtype), rng((n_codes, *n_feats), dtype)]\n+ self._CheckAgainstNumpy(osp_cluster.vq.vq, lsp_cluster.vq.vq, args_maker, check_dtypes=False)\n+ self._CompileAndCheck(lsp_cluster.vq.vq, args_maker)\n+\nif __name__ == \"__main__\":\nabsltest.main(testLoader=jtu.JaxTestLoader())\n"
}
] | Python | Apache License 2.0 | google/jax | implement scipy.cluster.vq.vq
also add no check_finite and overwrite_* docstring for some scipy.linalg functions |
260,335 | 22.04.2022 22:23:35 | 25,200 | 221680fed58c23f7ee16228e4a15f106e5df751f | remove old cond todos | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/control_flow.py",
"new_path": "jax/_src/lax/control_flow.py",
"diff": "@@ -994,9 +994,8 @@ def _cond_partial_eval(trace, *tracers, branches, linear):\nmove = [False] * len(ops_uk) + [True] * branch_num_res\nbranch_jaxpr_2 = pe.move_binders_to_front(branch_jaxpr_2, move)\n- # TODO(frostig,mattjj): pe.partial_eval_jaxpr should raise to shaped avals\n- res_avals = _map(\n- raise_to_shaped, branch_jaxpr_2.in_avals[:branch_num_res])\n+ res_avals = branch_jaxpr_2.in_avals[:branch_num_res]\n+ assert not any(isinstance(a, core.ConcreteArray) for a in res_avals)\nbranches_1.append(branch_jaxpr_1)\nbranches_2.append(branch_jaxpr_2)\n@@ -1018,19 +1017,16 @@ def _cond_partial_eval(trace, *tracers, branches, linear):\nbranches_2 = _join_cond_pe_staged_jaxpr_inputs(\nbranches_2, all_res_avals, res_avals_per_branch)\n- # TODO(frostig,mattjj): reinstate this assertion once pe.partial_eval_jaxpr\n- # raises to shaped avals\n- # for j in branches_1[1:]:\n- # assert j.out_avals == branches_1[0].out_avals\n+ for j in branches_1[1:]:\n+ assert all(_map(core.typematch, j.out_avals, branches_1[0].out_avals))\nnum_res = len(all_res_avals)\n_, in_consts = unzip2([t.pval for t in tracers])\nout_consts_res = cond_p.bind(*in_consts, branches=branches_1, linear=linear)\nout_consts, res = split_list(out_consts_res, [len(out_consts_res) - num_res])\n- # TODO(frostig,mattjj): remove raised_to_shaped of avals once\n- # pe.partial_eval_jaxpr handles it\n- out_avals = _map(raise_to_shaped, branches_2[0].out_avals)\n+ out_avals = branches_2[0].out_avals\n+ assert not any(isinstance(a, core.ConcreteArray) for a in out_avals)\nout_pvs = [aval if uk else None for aval, uk in zip(out_avals, out_uks)]\nindex_tracer = trace.instantiate_const(tracers[0])\n"
}
] | Python | Apache License 2.0 | google/jax | remove old cond todos |
260,335 | 23.04.2022 12:08:57 | 25,200 | 6a432fade1c1c023b518a3d4adc3ca921f94a6a6 | add partial_eval_jaxpr_nounits
No callers yet, but this is to be used for initial-style higher-order
primitives (HOPs, like in lax/control_flow.py) to remove units. Follow-up PRs
will switch the HOPs one-by-one to use this new function. | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -609,6 +609,19 @@ def trace_to_jaxpr(\nreturn jaxpr, out_pvals, consts\n+@profiler.annotate_function\n+def trace_to_jaxpr_nounits(\n+ fun: lu.WrappedFun, pvals: Sequence[PartialVal],\n+ instantiate: Union[bool, Sequence[bool]] = False,\n+ ) -> Tuple[Jaxpr, List[PartialVal], List[core.Value]]:\n+ current_name_stack = source_info_util.current_name_stack()\n+ with core.new_main(JaxprTrace, name_stack=current_name_stack) as main:\n+ fun = trace_to_subjaxpr_nounits(fun, main, instantiate)\n+ jaxpr, (out_pvals, consts, env) = fun.call_wrapped(pvals)\n+ assert not env\n+ del main, fun, env\n+ return jaxpr, out_pvals, consts\n+\n@lu.transformation\ndef trace_to_subjaxpr_nounits(\n@@ -785,88 +798,65 @@ def convert_envvars_to_constvars(jaxpr: Jaxpr, num_env_vars: int) -> Jaxpr:\ndef _split_aval(unknown: bool, aval: AbstractValue) -> Tuple[AbstractValue, AbstractValue]:\nreturn (abstract_unit, aval) if unknown else (aval, abstract_unit)\n-def partial_eval_jaxpr(jaxpr: ClosedJaxpr, unknowns: Sequence[bool],\n+\n+def partial_eval_jaxpr_nounits(\n+ jaxpr: ClosedJaxpr, unknowns: Sequence[bool],\ninstantiate: Union[bool, Sequence[bool]],\n- ) -> Tuple[ClosedJaxpr, ClosedJaxpr, Sequence[bool]]:\n- \"\"\"Specializes a Jaxpr given an indication of which inputs are known.\n-\n- Returns: (jaxpr_known, jaxpr_unknown, out_unknowns).\n-\n- `out_unknowns` specifies which outputs are unknown (depend on some unknown inputs).\n- `jaxpr_known` takes the same inputs as `jaxpr`, ignores the unknown inputs,\n- and performs *all* the computation in `jaxpr` that depends only on the known inputs.\n- Outputs correspond to those of `jaxpr`, with the unknown ones replaced with `*`,\n- appended with the known residuals (the intermediate computations in `jaxpr`\n- that depend only on known inputs and that are needed to compute the unknown outputs).\n-\n- `jaxpr_unknown` takes the same inputs as `jaxpr` along with the known residuals\n- computed by `jaxpr_known` and returns the same outputs as `jaxpr` with the known\n- outputs replaced by `*`.\n-\n- Roughly, `jaxpr(ki, ui)` is decomposed assuming `ki` and `ui` are the known and respectively\n- unknown inputs into:\n-\n- jaxpr(ki, ui) = let kout, _, kresidual = jaxpr_known(kin, *)\n- let _, uout = jaxpr_unknown(ki, ui, kresidual)\n- in (kout, uout)\n-\n- For example, if `jaxpr` is lambda ki, ui: let ka = ki + 2\n- in (ki + 3, ui + ka)\"\n- then\n- `jaxpr_known` = lambda ki, ui: let ka = ki + 2\n- in (ki + 3, *, ka)\n- 'jaxpr_unknown` = lambda ki, ui, ka: (*, ui + ka)\n-\n- Note that if instantiate is True for a given output, then jaxpr_known always returns a\n- unit in its place. So when instantiate is True, the expectation is the one doesn't\n- run `jaxpr_known` for any of its outputs, but only to generate residuals that will allow\n- to obtain the full outputs once `jaxpr_unknown` is ran. Outputs known ahead of time will\n- simply get passed as residual constants and returned immediately.\n- \"\"\"\n+ ) -> Tuple[ClosedJaxpr, ClosedJaxpr, List[bool]]:\ninstantiate = tuple(instantiate) if isinstance(instantiate, list) else instantiate\n- return _partial_eval_jaxpr(jaxpr, tuple(unknowns), instantiate)\n+ return _partial_eval_jaxpr_nounits(jaxpr, tuple(unknowns), instantiate)\n@weakref_lru_cache\n-def _partial_eval_jaxpr(jaxpr, unknowns, instantiate):\n+def _partial_eval_jaxpr_nounits(jaxpr, in_unknowns, instantiate):\nf = lu.wrap_init(core.jaxpr_as_fun(jaxpr))\ncell = []\n- def fun(*vals):\n- pvals = [PartialVal.unknown(aval) if uk else PartialVal.known(val)\n- for aval, val, uk in zip(jaxpr.in_avals, vals, unknowns)]\n- jaxpr_2, out_pvals_2, consts_2 = trace_to_jaxpr(f, pvals, instantiate=instantiate)\n- out_pvs_2, out_consts_2 = unzip2(out_pvals_2)\n- cell.append((out_pvs_2, jaxpr_2, len(consts_2)))\n- return out_consts_2 + consts_2\n-\n- # For jaxpr_known we pass core.unit for the unknown inputs, and known\n- # PartialVal for the known inputs.\n- in_avals = [abstract_unit if uk else a for a, uk in zip(jaxpr.in_avals, unknowns)]\n- jaxpr_1, out_avals, consts_1 = trace_to_jaxpr_dynamic(lu.wrap_init(fun), in_avals)\n- (out_pvs_2, jaxpr_2, num_res), = cell\n- assert len(jaxpr_2.constvars) == num_res\n-\n- # jaxpr :: a -> b\n- # jaxpr_1 :: a1 -> [b1, res]\n- # jaxpr_2 :: res | a2 -> b2\n- # jaxpr_2 :: [a2, res] -> b2\n- jaxpr_2 = convert_constvars_jaxpr(jaxpr_2)\n- jaxpr_2.invars = jaxpr_2.invars[num_res:] + jaxpr_2.invars[:num_res]\n- for var, unknown in zip(jaxpr_2.invars[:len(unknowns)], unknowns):\n- if not unknown:\n- var.aval = abstract_unit\n-\n- uk_out = [pv is not None for pv in out_pvs_2]\n-\n- in_avals_1, in_avals_2 = unzip2(map(_split_aval, unknowns, jaxpr.in_avals))\n- out_avals_1, out_avals_2 = unzip2(map(_split_aval, uk_out, jaxpr.out_avals))\n- # out_avals_1 and in_avals_2 need the residuals added\n- res_avals = out_avals[len(jaxpr.out_avals):]\n- assert len(res_avals) == num_res\n- out_avals_1 = [*out_avals_1, *res_avals]\n- in_avals_2 = [*in_avals_2, *res_avals]\n-\n- return ClosedJaxpr(jaxpr_1, consts_1), ClosedJaxpr(jaxpr_2, ()), uk_out\n+ def fun(*known_vals_in):\n+ known_vals_in = iter(known_vals_in)\n+ unknown_avals = (a for a, uk in zip(jaxpr.in_avals, in_unknowns) if uk)\n+ in_pvals = [PartialVal.unknown(next(unknown_avals)) if uk\n+ else PartialVal.known(next(known_vals_in)) for uk in in_unknowns]\n+ assert next(known_vals_in, None) is next(unknown_avals, None) is None\n+ jaxpr_unknown, out_pvals, residuals = trace_to_jaxpr_nounits(\n+ f, in_pvals, instantiate=instantiate)\n+ out_unknowns = [not pval.is_known() for pval in out_pvals]\n+ res_avals = [core.raise_to_shaped(core.get_aval(r)) for r in residuals]\n+ cell.append((out_unknowns, jaxpr_unknown, res_avals))\n+ known_vals_out = [pval.get_known() for pval in out_pvals if pval.is_known()]\n+ return [*known_vals_out, *residuals]\n+\n+ in_avals = [a for a, uk in zip(jaxpr.in_avals, in_unknowns) if not uk]\n+ jaxpr_known, _, consts_known = trace_to_jaxpr_dynamic(lu.wrap_init(fun), in_avals)\n+ (out_unknowns, jaxpr_unknown, res_avals), = cell\n+ num_res = len(res_avals)\n+\n+ # move jaxpr_unknown's residual inputs from constvars to the end of invars\n+ assert [v.aval for v in jaxpr_unknown.constvars] == res_avals\n+ jaxpr_unknown = convert_constvars_jaxpr(jaxpr_unknown)\n+ jaxpr_unknown.invars = (jaxpr_unknown.invars[num_res:] +\n+ jaxpr_unknown.invars[:num_res])\n+\n+ # check jaxpr_known and jaxpr_unknown in isolation\n+ if config.jax_enable_checks:\n+ core.check_jaxpr(jaxpr_known)\n+ core.check_jaxpr(jaxpr_unknown)\n+ # check jaxpr_known has input type corresponding to known inputs of jaxpr\n+ assert ([v.aval for v in jaxpr_known.invars] ==\n+ [a for a, uk in zip(jaxpr.in_avals, in_unknowns) if not uk])\n+ # check jaxpr_known has out type corresponding to known outs of jaxpr plus res\n+ assert ([v.aval for v in jaxpr_known.outvars] ==\n+ [a for a, uk in zip(jaxpr.out_avals, out_unknowns) if not uk] +\n+ res_avals)\n+ # check jaxpr_unknown has input type corresponding to unknown inputs plus res\n+ assert ([v.aval for v in jaxpr_unknown.invars] ==\n+ [a for a, uk in zip(jaxpr.in_avals, in_unknowns) if uk] + res_avals)\n+ # check jaxpr_unknown has output type corresponding to unknown outputs\n+ assert ([v.aval for v in jaxpr_unknown.outvars] ==\n+ [a for a, uk in zip(jaxpr.out_avals, out_unknowns) if uk])\n+\n+ closed_jaxpr_known = ClosedJaxpr(jaxpr_known, consts_known)\n+ closed_jaxpr_unknown = ClosedJaxpr(jaxpr_unknown, ())\n+ return closed_jaxpr_known, closed_jaxpr_unknown, out_unknowns\nremat_call_p: Primitive = core.CallPrimitive('remat_call')\n@@ -2141,3 +2131,51 @@ def partial_eval_wrapper(pvs: Sequence[Optional[AbstractValue]], *consts):\nout_pvs, out_consts = unzip2(out_pvals)\nout = tuple(out_consts) + tuple(consts)\nyield out, (out_pvs, jaxpr, env)\n+\n+def partial_eval_jaxpr(jaxpr: ClosedJaxpr, unknowns: Sequence[bool],\n+ instantiate: Union[bool, Sequence[bool]],\n+ ) -> Tuple[ClosedJaxpr, ClosedJaxpr, Sequence[bool]]:\n+ instantiate = tuple(instantiate) if isinstance(instantiate, list) else instantiate\n+ return _partial_eval_jaxpr(jaxpr, tuple(unknowns), instantiate)\n+\n+@weakref_lru_cache\n+def _partial_eval_jaxpr(jaxpr, unknowns, instantiate):\n+ f = lu.wrap_init(core.jaxpr_as_fun(jaxpr))\n+\n+ cell = []\n+ def fun(*vals):\n+ pvals = [PartialVal.unknown(aval) if uk else PartialVal.known(val)\n+ for aval, val, uk in zip(jaxpr.in_avals, vals, unknowns)]\n+ jaxpr_2, out_pvals_2, consts_2 = trace_to_jaxpr(f, pvals, instantiate=instantiate)\n+ out_pvs_2, out_consts_2 = unzip2(out_pvals_2)\n+ cell.append((out_pvs_2, jaxpr_2, len(consts_2)))\n+ return out_consts_2 + consts_2\n+\n+ # For jaxpr_known we pass core.unit for the unknown inputs, and known\n+ # PartialVal for the known inputs.\n+ in_avals = [abstract_unit if uk else a for a, uk in zip(jaxpr.in_avals, unknowns)]\n+ jaxpr_1, out_avals, consts_1 = trace_to_jaxpr_dynamic(lu.wrap_init(fun), in_avals)\n+ (out_pvs_2, jaxpr_2, num_res), = cell\n+ assert len(jaxpr_2.constvars) == num_res\n+\n+ # jaxpr :: a -> b\n+ # jaxpr_1 :: a1 -> [b1, res]\n+ # jaxpr_2 :: res | a2 -> b2\n+ # jaxpr_2 :: [a2, res] -> b2\n+ jaxpr_2 = convert_constvars_jaxpr(jaxpr_2)\n+ jaxpr_2.invars = jaxpr_2.invars[num_res:] + jaxpr_2.invars[:num_res]\n+ for var, unknown in zip(jaxpr_2.invars[:len(unknowns)], unknowns):\n+ if not unknown:\n+ var.aval = abstract_unit\n+\n+ uk_out = [pv is not None for pv in out_pvs_2]\n+\n+ in_avals_1, in_avals_2 = unzip2(map(_split_aval, unknowns, jaxpr.in_avals))\n+ out_avals_1, out_avals_2 = unzip2(map(_split_aval, uk_out, jaxpr.out_avals))\n+ # out_avals_1 and in_avals_2 need the residuals added\n+ res_avals = out_avals[len(jaxpr.out_avals):]\n+ assert len(res_avals) == num_res\n+ out_avals_1 = [*out_avals_1, *res_avals]\n+ in_avals_2 = [*in_avals_2, *res_avals]\n+\n+ return ClosedJaxpr(jaxpr_1, consts_1), ClosedJaxpr(jaxpr_2, ()), uk_out\n"
}
] | Python | Apache License 2.0 | google/jax | add partial_eval_jaxpr_nounits
No callers yet, but this is to be used for initial-style higher-order
primitives (HOPs, like in lax/control_flow.py) to remove units. Follow-up PRs
will switch the HOPs one-by-one to use this new function. |
260,335 | 23.04.2022 15:05:26 | 25,200 | bf64f1843fd5a969d404f7a4509b3324169f64fe | [remove-units] prevent cond partial eval from introducing units | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/abstract_arrays.py",
"new_path": "jax/_src/abstract_arrays.py",
"diff": "@@ -65,9 +65,8 @@ def _zeros_like_python_scalar(t, x):\nreturn ad_util.zeros_like_aval(aval)\ndef _make_concrete_python_scalar(t, x):\n- return canonical_concrete_aval(\n- np.array(x, dtype=dtypes._scalar_type_to_dtype(t, x)),\n- weak_type=True)\n+ dtype = dtypes._scalar_type_to_dtype(t, x)\n+ return canonical_concrete_aval(np.array(x, dtype=dtype), weak_type=True)\nfor t in dtypes.python_scalar_dtypes:\ncore.pytype_aval_mappings[t] = partial(_make_concrete_python_scalar, t)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/control_flow.py",
"new_path": "jax/_src/lax/control_flow.py",
"diff": "@@ -970,85 +970,63 @@ def _cond_jvp(primals, tangents, branches, linear):\nreturn out_primals, out_tangents\ndef _cond_partial_eval(trace, *tracers, branches, linear):\n- unknowns = [t.pval[0] is not None for t in tracers]\n- index_uk, *ops_uk = unknowns\n+ in_unknowns = [t.pval[0] is not None for t in tracers]\n+ index_uk, *ops_uk = in_unknowns\nif index_uk:\n# When the branch index is unknown, we stage out the whole cond.\n+ # TODO(mattjj): remove this path when old remat is removed\nparams = dict(branches=branches, linear=linear)\nreturn trace.default_process_primitive(cond_p, tracers, params)\nbranches_out_uks = []\nfor branch_jaxpr in branches:\n- _, _, out_uks = pe.partial_eval_jaxpr(branch_jaxpr, ops_uk, instantiate=False)\n+ _, _, out_uks, _ = pe.partial_eval_jaxpr_nounits(\n+ branch_jaxpr, ops_uk, instantiate=False)\nbranches_out_uks.append(out_uks)\nout_uks = [any(uks) for uks in zip(*branches_out_uks)]\n- branches_1, branches_2, branch_res_avals = [], [], []\n+ branches_known, branches_unknown, branch_res_avals = [], [], []\nfor branch_jaxpr in branches:\n- branch_jaxpr_1, branch_jaxpr_2, _ = pe.partial_eval_jaxpr(\n- branch_jaxpr, ops_uk, instantiate=out_uks)\n- branch_num_res = len(branch_jaxpr_1.out_avals) - len(out_uks)\n-\n- # move residuals to the front\n- move = [False] * len(ops_uk) + [True] * branch_num_res\n- branch_jaxpr_2 = pe.move_binders_to_front(branch_jaxpr_2, move)\n-\n- res_avals = branch_jaxpr_2.in_avals[:branch_num_res]\n- assert not any(isinstance(a, core.ConcreteArray) for a in res_avals)\n-\n- branches_1.append(branch_jaxpr_1)\n- branches_2.append(branch_jaxpr_2)\n+ branch_jaxpr_known, branch_jaxpr_unknown, _, res_avals = \\\n+ pe.partial_eval_jaxpr_nounits(branch_jaxpr, ops_uk, instantiate=out_uks)\n+ branches_known.append(branch_jaxpr_known)\n+ branches_unknown.append(branch_jaxpr_unknown)\nbranch_res_avals.append(res_avals)\n- branches_1 = tuple(branches_1)\n- branches_2 = tuple(branches_2)\n-\n- for jaxpr in branches_2[1:]:\n- assert len(jaxpr.out_avals) == len(branches_2[0].out_avals)\n-\n- num_outs = len(branches_2[0].out_avals)\n-\n- all_res_avals, res_avals_per_branch = _merge_branch_residuals(\n- branch_res_avals)\n-\n- branches_1 = _join_cond_outputs(\n- branches_1, all_res_avals, res_avals_per_branch, num_outs)\n- branches_2 = _join_cond_pe_staged_jaxpr_inputs(\n- branches_2, all_res_avals, res_avals_per_branch)\n-\n- for j in branches_1[1:]:\n- assert all(_map(core.typematch, j.out_avals, branches_1[0].out_avals))\n+ all_res_avals, res_avals_per_branch = _merge_branch_residuals(branch_res_avals)\nnum_res = len(all_res_avals)\n- _, in_consts = unzip2([t.pval for t in tracers])\n- out_consts_res = cond_p.bind(*in_consts, branches=branches_1, linear=linear)\n+ num_known_outs = len(out_uks) - sum(out_uks)\n+ branches_known = _join_cond_outputs(\n+ branches_known, all_res_avals, res_avals_per_branch, num_known_outs)\n+ branches_unknown = _join_cond_pe_staged_jaxpr_inputs(\n+ branches_unknown, all_res_avals, res_avals_per_branch)\n+ assert all(all(_map(core.typematch, j.out_avals, branches_known[0].out_avals))\n+ for j in branches_known[1:])\n+\n+ in_consts = [t.pval.get_known() for t in tracers if t.pval.is_known()]\n+ linear_known = [l for l, uk in zip(linear, ops_uk) if not uk]\n+ out_consts_res = cond_p.bind(*in_consts, branches=branches_known,\n+ linear=tuple(linear_known))\nout_consts, res = split_list(out_consts_res, [len(out_consts_res) - num_res])\n- out_avals = branches_2[0].out_avals\n- assert not any(isinstance(a, core.ConcreteArray) for a in out_avals)\n- out_pvs = [aval if uk else None for aval, uk in zip(out_avals, out_uks)]\n-\nindex_tracer = trace.instantiate_const(tracers[0])\n-\n- ops_tracers = [trace.instantiate_const(t) if uk\n- else trace.new_instantiated_literal(core.unit)\n- for uk, t in zip(unknowns[1:], tracers[1:])]\n-\n+ ops_tracers = [trace.instantiate_const(t)\n+ for uk, t in zip(in_unknowns[1:], tracers[1:]) if uk]\nres_tracers = _map(trace.new_instantiated_const, res)\n-\n- out_tracers = [pe.JaxprTracer(trace, pe.PartialVal((pv, const)), None)\n- for pv, const in zip(out_pvs, out_consts)]\n-\n- linear_2 = (False,) * num_res + linear\n- params = dict(branches=branches_2, linear=linear_2)\n+ out_tracers = [pe.JaxprTracer(trace, pe.PartialVal.unknown(aval), None)\n+ for aval in branches_unknown[0].out_avals]\n+ linear_unknown = ([False] * num_res +\n+ [l for l, uk in zip(linear, in_unknowns[1:]) if uk])\n+ params = dict(branches=branches_unknown, linear=tuple(linear_unknown))\nname_stack = source_info_util.current_name_stack()[len(trace.name_stack):]\nsource = source_info_util.current().replace(name_stack=name_stack)\neqn = pe.new_eqn_recipe(\n[index_tracer] + res_tracers + ops_tracers, out_tracers, cond_p, params,\ncore.no_effects, source)\nfor t in out_tracers: t.recipe = eqn\n- return out_tracers\n+ return util.merge_lists(out_uks, out_consts, out_tracers)\n# When partially evaluating conditionals, each branch produces residuals\n# depending on the computation carried out by the branch, and a corresponding\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/lax.py",
"new_path": "jax/_src/lax/lax.py",
"diff": "@@ -2212,7 +2212,11 @@ def _convert_element_type_jvp_rule(tangent, operand , *, new_dtype, weak_type):\ndef _convert_elt_type_folding_rule(consts, eqn):\nc, = consts\nif type(c) in core.literalable_types and not np.shape(c):\n- return [np.array(c, eqn.params['new_dtype'])], None\n+ out = np.array(c, eqn.params['new_dtype'])\n+ if eqn.outvars[0].aval.weak_type:\n+ return [out.item()], None # return as Python scalar to preserve weak_type\n+ else:\n+ return [out], None\nelse:\nreturn [None], eqn\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -802,21 +802,23 @@ def _split_aval(unknown: bool, aval: AbstractValue) -> Tuple[AbstractValue, Abst\ndef partial_eval_jaxpr_nounits(\njaxpr: ClosedJaxpr, unknowns: Sequence[bool],\ninstantiate: Union[bool, Sequence[bool]],\n- ) -> Tuple[ClosedJaxpr, ClosedJaxpr, List[bool]]:\n+ ) -> Tuple[ClosedJaxpr, ClosedJaxpr, List[bool], List[AbstractValue]]:\n\"\"\"Unzip a jaxpr in two by data dependence into 'known' and 'unknown' parts.\nThat is, given a jaxpr and a sequence of booleans indicating which jaxpr\n- inputs (i.e. invars) are considered unknown, produce two jaxprs and a list of\n+ inputs (i.e. invars) are considered unknown, produce two jaxprs, a list of\nbooleans representing which of the original jaxpr's outputs are unknown (i.e.\n- have a data dependence on an unknown input). The two jaxprs result from\n- partitioning the original jaxpr's first-order primitive applications based on\n- whether all the inputs to the application are known (in which case the\n- application is represented in the 'known' jaxpr and its result is considered\n- known) or whether any inputs to the application are unknown (in which case the\n- application is represented in the 'unknown' jaxpr and its result is considered\n- unknown). Higher-order primitives are recursively unzipped in two.\n-\n- The instantiate argument can be used to ensure some outputs are lifted into\n+ have a data dependence on an unknown input), and a list of abstract values\n+ representing residuals (part of the first jaxpr's output and the second\n+ jaxpr's input). The two jaxprs result from partitioning the original jaxpr's\n+ first-order primitive applications based on whether all the inputs to the\n+ application are known (in which case the application is represented in the\n+ 'known' jaxpr and its result is considered known) or whether any inputs to the\n+ application are unknown (in which case the application is represented in the\n+ 'unknown' jaxpr and its result is considered unknown). Higher-order primitives\n+ are recursively unzipped in two.\n+\n+ The `instantiate` argument can be used to ensure some outputs are lifted into\nthe 'unknown' jaxpr.\nFor example, give an input jaxpr:\n@@ -871,24 +873,18 @@ def _partial_eval_jaxpr_nounits(jaxpr, in_unknowns, instantiate):\nin_pvals = [PartialVal.unknown(next(unknown_avals)) if uk\nelse PartialVal.known(next(known_vals_in)) for uk in in_unknowns]\nassert next(known_vals_in, None) is next(unknown_avals, None) is None\n- jaxpr_unknown, out_pvals, residuals = trace_to_jaxpr_nounits(\n+ jaxpr_unknown_, out_pvals, residuals = trace_to_jaxpr_nounits(\nf, in_pvals, instantiate=instantiate)\n+ jaxpr_unknown = convert_constvars_jaxpr(jaxpr_unknown_)\nout_unknowns = [not pval.is_known() for pval in out_pvals]\nres_avals = [core.raise_to_shaped(core.get_aval(r)) for r in residuals]\ncell.append((out_unknowns, jaxpr_unknown, res_avals))\nknown_vals_out = [pval.get_known() for pval in out_pvals if pval.is_known()]\nreturn [*known_vals_out, *residuals]\n- in_avals = [a for a, uk in zip(jaxpr.in_avals, in_unknowns) if not uk]\n- jaxpr_known, _, consts_known = trace_to_jaxpr_dynamic(lu.wrap_init(fun), in_avals)\n+ known_avals = [a for a, uk in zip(jaxpr.in_avals, in_unknowns) if not uk]\n+ jaxpr_known, _, consts_known = trace_to_jaxpr_dynamic(lu.wrap_init(fun), known_avals)\n(out_unknowns, jaxpr_unknown, res_avals), = cell\n- num_res = len(res_avals)\n-\n- # move jaxpr_unknown's residual inputs from constvars to the end of invars\n- assert [v.aval for v in jaxpr_unknown.constvars] == res_avals\n- jaxpr_unknown = convert_constvars_jaxpr(jaxpr_unknown)\n- jaxpr_unknown.invars = (jaxpr_unknown.invars[num_res:] +\n- jaxpr_unknown.invars[:num_res])\n# check jaxpr_known and jaxpr_unknown in isolation\nif config.jax_enable_checks:\n@@ -903,14 +899,14 @@ def _partial_eval_jaxpr_nounits(jaxpr, in_unknowns, instantiate):\nres_avals)\n# check jaxpr_unknown has input type corresponding to unknown inputs plus res\nassert ([v.aval for v in jaxpr_unknown.invars] ==\n- [a for a, uk in zip(jaxpr.in_avals, in_unknowns) if uk] + res_avals)\n+ res_avals + [a for a, uk in zip(jaxpr.in_avals, in_unknowns) if uk])\n# check jaxpr_unknown has output type corresponding to unknown outputs\nassert ([v.aval for v in jaxpr_unknown.outvars] ==\n[a for a, uk in zip(jaxpr.out_avals, out_unknowns) if uk])\nclosed_jaxpr_known = ClosedJaxpr(jaxpr_known, consts_known)\nclosed_jaxpr_unknown = ClosedJaxpr(jaxpr_unknown, ())\n- return closed_jaxpr_known, closed_jaxpr_unknown, out_unknowns\n+ return closed_jaxpr_known, closed_jaxpr_unknown, out_unknowns, res_avals\nremat_call_p: Primitive = core.CallPrimitive('remat_call')\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] prevent cond partial eval from introducing units |
260,335 | 24.04.2022 21:04:06 | 25,200 | fde63050126fd2b0d773ef0c0af8ab3ffe833a6b | refine const folding | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/lax.py",
"new_path": "jax/_src/lax/lax.py",
"diff": "@@ -2210,14 +2210,24 @@ def _convert_element_type_jvp_rule(tangent, operand , *, new_dtype, weak_type):\nweak_type=weak_type)\ndef _convert_elt_type_folding_rule(consts, eqn):\n+ # We constant-fold convert_element_types applied to constants if those\n+ # constants are Python builtin numeric types or numpy.ndarrays (so as not\n+ # to perform any device operations when constant-folding) and if the output\n+ # type can be faithfully represented by a Python builtin numeric type or\n+ # numpy.ndarray. If those conditions are met, we output a numpy.ndarray\n+ # constant if the output type is not weak, and if the output type is weak then\n+ # we output a Python builtin numeric type.\n+ # TODO(mattjj): allow constant-folding CPU-backed JAX arrays\nc, = consts\n- if type(c) in core.literalable_types and not np.shape(c):\n+ o, = eqn.outvars\n+ if (type(c) in {np.ndarray, *dtypes.python_scalar_dtypes} and\n+ isinstance(o.aval, core.UnshapedArray) and not np.shape(c)):\nout = np.array(c, eqn.params['new_dtype'])\n- if eqn.outvars[0].aval.weak_type:\n- return [out.item()], None # return as Python scalar to preserve weak_type\n- else:\n+ if not o.aval.weak_type:\n+ return [out], None\n+ out = out.item()\n+ if core.get_aval(out).dtype is o.aval.dtype:\nreturn [out], None\n- else:\nreturn [None], eqn\ndef _convert_elt_type_fwd_rule(eqn):\n"
}
] | Python | Apache License 2.0 | google/jax | refine const folding |
260,335 | 23.04.2022 15:32:30 | 25,200 | 9359cc3e53e9fe160d9391d36922c41a279681e9 | [remove-units] remove units from while partial eval | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/control_flow.py",
"new_path": "jax/_src/lax/control_flow.py",
"diff": "@@ -470,30 +470,29 @@ def _while_loop_jvp(primals, tangents, cond_nconsts, cond_jaxpr, body_nconsts,\ndef _while_partial_eval(trace: pe.JaxprTrace, *tracers: pe.Tracer, cond_nconsts: int,\ncond_jaxpr: pe.ClosedJaxpr, body_nconsts: int,\nbody_jaxpr: pe.ClosedJaxpr) -> Sequence[pe.Tracer]:\n- \"\"\"An implementation of partial evaluation for while.\n- As long as some carry (and hence output) are known and the output\n- of `cond_jaxpr` is known, we use a portion of the loop body to compute the known\n- outputs of the `while_loop`. For the unknown outputs we generate Jaxpr to run\n- the whole while, including recomputing the known parts.\n-\n- This means that we don't actually save any computation by partial\n- evaluation if there are unknown outputs.\n-\n- What this achieves is that we can give a proper error for reverse\n- differentiation of `while`, because in that use of partial evaluation the\n- primal inputs are considered \"known\", and only the tangent computation is\n- unknown (see issue #2129).\n- \"\"\"\n+ # As long as some carry (and hence output) are known and the output of\n+ # `cond_jaxpr` is known, we use a portion of the loop body to compute the\n+ # known outputs of the `while_loop`. For the unknown outputs we generate a\n+ # jaxpr to run the whole while, including recomputing the known parts,\n+ # basically like building in checkpointing/rematieralization. This means that\n+ # we don't actually save any computation by partial evaluation if there are\n+ # unknown outputs.\n+ #\n+ # What this achieves is twofold: jax.linearize works, and we can give a proper\n+ # error for reverse differentiation of `while`.\n+\nunknowns = [not t.pval.is_known() for t in tracers]\nparams = dict(cond_nconsts=cond_nconsts, cond_jaxpr=cond_jaxpr,\nbody_nconsts=body_nconsts, body_jaxpr=body_jaxpr)\n- cond_consts_uk, body_consts_uk, carry_init_uk = split_list(unknowns, [cond_nconsts, body_nconsts])\n- # Fixpoint computation of unknown carry. Each iteration promotes\n- # at least one carry to unknown. We need one last iteration to prepare the jaxpr.\n+ cond_consts_uk, body_consts_uk, carry_init_uk = \\\n+ split_list(unknowns, [cond_nconsts, body_nconsts])\n+\n+ # Fixpoint computation of unknown carry. Each iteration promotes at least one\n+ # carry to unknown. We need one last iteration to prepare the jaxpr.\ncarry_uk = carry_init_uk\nfor _ in range(1 + len(carry_uk)):\n- body_jaxpr_known, _, carry_out_uk = pe.partial_eval_jaxpr( # type: ignore\n+ body_jaxpr_known, _, carry_out_uk, body_res_avals = pe.partial_eval_jaxpr_nounits( # type: ignore\nbody_jaxpr, body_consts_uk + carry_uk, instantiate=carry_uk)\nif carry_out_uk == carry_uk:\nbreak\n@@ -502,7 +501,7 @@ def _while_partial_eval(trace: pe.JaxprTrace, *tracers: pe.Tracer, cond_nconsts:\nelse:\nassert False, \"Fixpoint not reached\"\n- cond_jaxpr_known, _, cond_uk = pe.partial_eval_jaxpr( # type: ignore\n+ cond_jaxpr_known, _, cond_uk, _ = pe.partial_eval_jaxpr_nounits( # type: ignore\ncond_jaxpr, cond_consts_uk + carry_uk, instantiate=False)\nif cond_uk[0] or all([not uk for uk in unknowns]) or all(unknowns):\n@@ -510,33 +509,24 @@ def _while_partial_eval(trace: pe.JaxprTrace, *tracers: pe.Tracer, cond_nconsts:\n# just do the default processing.\nreturn trace.default_process_primitive(while_p, tracers, params)\n- # Run the known part of the while. Prepare the inputs, as constants (if known), or\n- # as core.unit.\n- in_consts = [ core.unit if uk else t.pval.get_known()\n- for uk, t in zip(cond_consts_uk + body_consts_uk + carry_uk,\n- tracers)]\n- # There should be no residuals for the cond_jaxpr_known\n- assert 1 == len(cond_jaxpr_known.out_avals)\n- # We ignore the residuals from the body_jaxpr_known, so the type of inputs matches\n- # the type of outputs; residuals are at the end\n- if len(body_jaxpr_known.out_avals) > len(body_jaxpr.out_avals):\n- # TODO(necula): this is not quite enough; we should drop the residual computations also\n- body_jaxpr_known.jaxpr.outvars = body_jaxpr_known.jaxpr.outvars[:len(body_jaxpr.out_avals)]\n+ # Run the known part of the while.\n+ in_consts = [t.pval.get_known() for uk, t in\n+ zip(cond_consts_uk + body_consts_uk + carry_uk, tracers)\n+ if not uk]\n+ cond_nconsts_known = len(cond_consts_uk) - sum(cond_consts_uk)\n+ body_nconsts_known = len(body_consts_uk) - sum(body_consts_uk)\n+ num_known_outs = len(carry_uk) - sum(carry_uk)\n+ # TODO(mattjj): use pe.dce_jaxpr to drop res computations and not just outputs\n+ body_jaxpr_known.jaxpr.outvars = body_jaxpr_known.jaxpr.outvars[:num_known_outs]\nout_known = while_p.bind(\n- *in_consts,\n- cond_nconsts=cond_nconsts,\n- cond_jaxpr=cond_jaxpr_known,\n- body_nconsts=body_nconsts,\n- body_jaxpr=body_jaxpr_known)\n+ *in_consts, cond_nconsts=cond_nconsts_known, cond_jaxpr=cond_jaxpr_known,\n+ body_nconsts=body_nconsts_known, body_jaxpr=body_jaxpr_known)\n+ del body_jaxpr_known\n# Run the whole while_loop to get all the outputs, then merge with known ones\n- out_all: Sequence[pe.Tracer] = trace.default_process_primitive(while_p, tracers, params)\n- out_tracers: Sequence[pe.Tracer] = [\n- out_unknown if uk\n- else pe.JaxprTracer(trace, pe.PartialVal.known(known), out_unknown.recipe)\n- for uk, out_unknown, known in zip(carry_uk, out_all, out_known)]\n-\n- return out_tracers\n+ out_tracers_ = trace.default_process_primitive(while_p, tracers, params)\n+ out_tracers = [t for t, uk in zip(out_tracers_, carry_uk) if uk]\n+ return util.merge_lists(carry_uk, out_known, out_tracers)\ndef _while_transpose_error(*_, **kwargs):\nraise ValueError(\"Reverse-mode differentiation does not work for \"\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_control_flow_test.py",
"new_path": "tests/lax_control_flow_test.py",
"diff": "@@ -1930,6 +1930,35 @@ class LaxControlFlowTest(jtu.JaxTestCase):\njtu.check_grads(loop, (x,), order=2, modes=[\"fwd\"])\n+ @parameterized.named_parameters(\n+ {\"testcase_name\": \"_jit_loop={}_jit_body={}_jit_cond={}\".format(\n+ jit_loop, jit_body, jit_cond),\n+ \"jit_loop\": jit_loop, \"jit_body\": jit_body, \"jit_cond\": jit_cond}\n+ for jit_loop in [False, True]\n+ for jit_body in [False, True]\n+ for jit_cond in [False, True])\n+ def testWhileLinearize(self, jit_loop=True, jit_body=False, jit_cond=True):\n+ cond = lambda x: x[0, 2] <= 8\n+ body = lambda x: x * x\n+\n+ if jit_cond:\n+ cond = jax.jit(cond)\n+ if jit_body:\n+ body = jax.jit(body)\n+\n+ loop = partial(lax.while_loop, cond, body)\n+ if jit_loop:\n+ loop = jax.jit(loop)\n+\n+ loop_ref = partial(while_loop_reference, cond, body)\n+\n+ x = jnp.arange(9.).reshape((3, 3))\n+ y, f_lin = jax.linearize(loop, x)\n+ ydot = f_lin(x)\n+ y_expected, ydot_expected = jax.jvp(loop_ref, (x,), (x,))\n+ self.assertAllClose(y, y_expected, check_dtypes=False)\n+ self.assertAllClose(ydot, ydot_expected, check_dtypes=False)\n+\ndef testWhileJVPViaForiLoop(self):\nf = lambda x: lax.fori_loop(0, 3, lambda i, x: x * 2, x)\nself.assertAllClose(f(2.), 16., check_dtypes=False)\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] remove units from while partial eval |
260,440 | 25.04.2022 17:44:56 | -3,600 | 0483483f143df64c3089ee816fa68234504059a8 | compile_or_get_cached() is now more type-checker friendly
Prior to this change compile_or_get_cached() could end up calling
.as_hlo_text() on an ir.Module. That error is opaque to the type checker unless
it has access to the MLIR Python bindings. | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/dispatch.py",
"new_path": "jax/_src/dispatch.py",
"diff": "@@ -692,8 +692,13 @@ def compile_or_get_cached(backend, computation, compile_options):\nreturn compiled\nif FLAGS.jax_dump_ir_to:\n- ir_str = (computation if isinstance(computation, str)\n- else computation.as_hlo_text())\n+ if isinstance(computation, xc.XlaComputation):\n+ ir_str = computation.as_hlo_text()\n+ elif isinstance(computation, ir.Module):\n+ ir_str = mlir.module_to_string(computation)\n+ else:\n+ assert isinstance(computation, str)\n+ ir_str = computation\n_dump_ir_to_file(module_name, ir_str)\nreturn backend_compile(backend, computation, compile_options)\n"
}
] | Python | Apache License 2.0 | google/jax | compile_or_get_cached() is now more type-checker friendly
Prior to this change compile_or_get_cached() could end up calling
.as_hlo_text() on an ir.Module. That error is opaque to the type checker unless
it has access to the MLIR Python bindings. |
260,447 | 25.04.2022 18:44:44 | 25,200 | 84d84abd1c5d87ae75a17d2fdb0df68b4b26eb87 | [sparse] Change the outer call to ir.RankedTensorType to make it call .get(). | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/sparse/bcoo.py",
"new_path": "jax/experimental/sparse/bcoo.py",
"diff": "@@ -758,7 +758,7 @@ def _bcoo_dot_general_cuda_lowering(\nif rhs_ndim == 1:\n# Transforms a single-element array to a scalar.\nreturn [mhlo.ReshapeOp(\n- ir.RankedTensorType(\n+ ir.RankedTensorType.get(\n[], ir.RankedTensorType(dot_product.type).element_type),\ndot_product).result]\nelse:\n"
}
] | Python | Apache License 2.0 | google/jax | [sparse] Change the outer call to ir.RankedTensorType to make it call .get().
PiperOrigin-RevId: 444426777 |
260,510 | 25.04.2022 19:38:03 | 25,200 | 098f2126aeb415a7d9d22818dcc2f22d85d50953 | Add CustomCall MLIR lowering for HCB `outside_call` primitive | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/host_callback.py",
"new_path": "jax/experimental/host_callback.py",
"diff": "@@ -514,14 +514,18 @@ from jax import lax\nfrom jax.experimental import pjit\nfrom jax.interpreters import ad, xla, batching, masking, pxla\nfrom jax.interpreters import partial_eval as pe\n+from jax.interpreters import mlir\nfrom jax._src import dispatch\nfrom jax._src import pretty_printer as pp\nfrom jax._src import source_info_util\nfrom jax._src import util\n+from jax._src import lib as jaxlib\nfrom jax._src.lib import pytree\nfrom jax._src.lib import xla_bridge as xb\nfrom jax._src.lib import xla_client\nfrom jax._src.lib import xla_extension\n+from jax._src.lib.mlir import ir\n+from jax._src.lib.mlir.dialects import mhlo\nimport numpy as np\n@@ -1006,6 +1010,10 @@ def _outside_call_translation_rule(ctx, avals_in, avals_out,\nneed_callback_results_on_device = (not identity and\nlen(non_empty_flat_results_aval) > 0)\nuse_outfeed = _use_outfeed(ctx.platform)\n+ # TODO(sharadmv): Delete non-outfeed path when jaxlib minimum version is\n+ # bumped past 0.3.8.\n+ assert use_outfeed or jaxlib.version < (0, 3, 8), (\n+ 'Should be using MLIR path for `CustomCall` lowering')\nsend_infeed = use_outfeed and need_callback_results_on_device\ngenerated_infeed = False # Keep track if we emitted an infeed op\nif use_outfeed:\n@@ -1128,6 +1136,98 @@ def _outside_call_translation_rule(ctx, avals_in, avals_out,\nxla.register_translation(outside_call_p, _outside_call_translation_rule)\n+def _outside_call_lowering(\n+ ctx: mlir.LoweringRuleContext, *args, has_token: bool, identity: bool,\n+ flat_results_aval=(), **params):\n+ \"\"\"MLIR Lowering for `CustomCall`-based HCB.\"\"\"\n+ platform = ctx.module_context.platform\n+ use_outfeed = _use_outfeed(platform)\n+ if use_outfeed:\n+ # Fall back to XLA path if we are using the outfeed\n+ # TODO(sharadmv): update to use MLIR for this path as well and delete\n+ # XLA lowering\n+ return mlir.xla_fallback_lowering(outside_call_p)(ctx, *args,\n+ has_token=has_token, identity=identity,\n+ flat_results_aval=flat_results_aval, **params)\n+ backend = xb.get_backend(platform)\n+ # We expect the current tokens at the end, inserted by _rewrite_jaxpr.\n+ assert has_token\n+ current_token = args[-2]\n+ current_itoken = args[-1]\n+ assert current_token.type == mhlo.TokenType.get(), \"The last two arguments must be tokens\"\n+ assert current_itoken.type == mhlo.TokenType.get(), \"The last two arguments must be tokens\"\n+\n+ args_to_outfeed = args[:-2]\n+ # TODO(necula): this is a weak attempt to get the device. This works\n+ # inside pmap, but does not work when we just execute on a single device,\n+ # because in such executions we always get replica_id == 0.\n+ replica_id = mhlo.ReplicaIdOp()\n+ callback_operands = [current_token, replica_id, *args_to_outfeed]\n+ callback_operand_avals = [\n+ core.abstract_token, core.ShapedArray((), np.uint32), *ctx.avals_in[:-2]]\n+ if identity:\n+ callback_flat_results_aval = [core.abstract_token]\n+ else:\n+ callback_flat_results_aval = [core.abstract_token, *flat_results_aval]\n+\n+ def wrapped_callback(*args):\n+ token, replica_id, *arrays = args\n+ result_arrays = _outside_call_run_callback(\n+ arrays,\n+ xb.local_devices()[replica_id],\n+ send_infeed=False,\n+ # The same parameters as outside_call_p\n+ identity=identity,\n+ flat_results_aval=flat_results_aval,\n+ **params)\n+ if identity:\n+ # For identity, we do not pass the any results back to the device\n+ result_arrays = ()\n+ return (token,) + result_arrays\n+\n+ result_shapes = [\n+ xla.aval_to_xla_shapes(res_aval)[0]\n+ for res_aval in callback_flat_results_aval\n+ ]\n+ callback_operand_shapes = [\n+ xla.aval_to_xla_shapes(op_aval)[0]\n+ for op_aval in callback_operand_avals\n+ ]\n+ callback_descriptor, keep_alive = backend.get_emit_python_callback_descriptor(\n+ wrapped_callback,\n+ callback_operand_shapes,\n+ result_shapes)\n+ _callback_handler_data.keep_alives.append(keep_alive)\n+ descriptor_operand = mlir.ir_constant(callback_descriptor, canonicalize_types=False)\n+ callback_operands = [descriptor_operand, *callback_operands]\n+ result_types = util.flatten(\n+ [mlir.aval_to_ir_types(aval) for aval in callback_flat_results_aval])\n+ result_type = ir.TupleType.get_tuple(result_types)\n+ result = mhlo.CustomCallOp([result_type], callback_operands,\n+ call_target_name=ir.StringAttr.get(\"xla_python_cpu_callback\"),\n+ has_side_effect=ir.BoolAttr.get(True),\n+ api_version=mlir.i32_attr(2),\n+ called_computations=ir.ArrayAttr.get([]),\n+ backend_config=ir.StringAttr.get(\"\"),\n+ operand_layouts=None,\n+ result_layouts=None)\n+ results = [\n+ mhlo.GetTupleElementOp(result, mlir.i32_attr(i)).result\n+ for i in range(len(result_types))\n+ ]\n+ next_token, *results = results\n+ # We must put the two tokens at the end\n+ if identity:\n+ results = list(args_to_outfeed)\n+ next_itoken = current_itoken\n+\n+ assert identity or len(results) == len(flat_results_aval), (\n+ f\"got {len(results)} but expected {len(flat_results_aval)}. \"\n+ f\"identity = {identity}\")\n+ return results + [next_token, next_itoken]\n+\n+if jaxlib.version >= (0, 3, 8):\n+ mlir.register_lowering(outside_call_p, _outside_call_lowering, platform=\"cpu\")\ndef _outside_call_run_callback(\narrays, device, *,\n"
}
] | Python | Apache License 2.0 | google/jax | Add CustomCall MLIR lowering for HCB `outside_call` primitive
PiperOrigin-RevId: 444436860 |
260,430 | 23.04.2022 01:26:02 | -28,800 | ecab8e00e87a22df794528bc08f6f5ed72ad0f1a | try to improve docs for scipy.linalg with unused parameters | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/scipy/linalg.py",
"new_path": "jax/_src/scipy/linalg.py",
"diff": "@@ -28,6 +28,11 @@ from jax._src.numpy import lax_numpy as jnp\nfrom jax._src.numpy import linalg as np_linalg\n_T = lambda x: jnp.swapaxes(x, -1, -2)\n+_no_chkfinite_doc = textwrap.dedent(\"\"\"\n+Does not support the Scipy argument ``check_finite=True``,\n+because compiled JAX code cannot perform checks of array values at runtime.\n+\"\"\")\n+_no_overwrite_and_chkfinite_doc = _no_chkfinite_doc + \"\\nDoes not support the Scipy argument ``overwrite_*=True``.\"\n@partial(jit, static_argnames=('lower',))\ndef _cholesky(a, lower):\n@@ -35,12 +40,14 @@ def _cholesky(a, lower):\nl = lax_linalg.cholesky(a if lower else jnp.conj(_T(a)), symmetrize_input=False)\nreturn l if lower else jnp.conj(_T(l))\n-@_wraps(scipy.linalg.cholesky)\n+@_wraps(scipy.linalg.cholesky,\n+ lax_description=_no_overwrite_and_chkfinite_doc, skip_params=('overwrite_a', 'check_finite'))\ndef cholesky(a, lower=False, overwrite_a=False, check_finite=True):\ndel overwrite_a, check_finite\nreturn _cholesky(a, lower)\n-@_wraps(scipy.linalg.cho_factor)\n+@_wraps(scipy.linalg.cho_factor,\n+ lax_description=_no_overwrite_and_chkfinite_doc, skip_params=('overwrite_a', 'check_finite'))\ndef cho_factor(a, lower=False, overwrite_a=False, check_finite=True):\nreturn (cholesky(a, lower=lower), lower)\n@@ -54,7 +61,8 @@ def _cho_solve(c, b, lower):\ntranspose_a=lower, conjugate_a=lower)\nreturn b\n-@_wraps(scipy.linalg.cho_solve, update_doc=False)\n+@_wraps(scipy.linalg.cho_solve, update_doc=False,\n+ lax_description=_no_overwrite_and_chkfinite_doc, skip_params=('overwrite_b', 'check_finite'))\ndef cho_solve(c_and_lower, b, overwrite_b=False, check_finite=True):\ndel overwrite_b, check_finite\nc, lower = c_and_lower\n@@ -66,13 +74,15 @@ def _svd(a, *, full_matrices, compute_uv):\na, = _promote_dtypes_inexact(jnp.asarray(a))\nreturn lax_linalg.svd(a, full_matrices, compute_uv)\n-@_wraps(scipy.linalg.svd)\n+@_wraps(scipy.linalg.svd,\n+ lax_description=_no_overwrite_and_chkfinite_doc, skip_params=('overwrite_a', 'check_finite', 'lapack_driver'))\ndef svd(a, full_matrices=True, compute_uv=True, overwrite_a=False,\ncheck_finite=True, lapack_driver='gesdd'):\ndel overwrite_a, check_finite, lapack_driver\nreturn _svd(a, full_matrices=full_matrices, compute_uv=compute_uv)\n-@_wraps(scipy.linalg.det)\n+@_wraps(scipy.linalg.det,\n+ lax_description=_no_overwrite_and_chkfinite_doc, skip_params=('overwrite_a', 'check_finite'))\ndef det(a, overwrite_a=False, check_finite=True):\ndel overwrite_a, check_finite\nreturn np_linalg.det(a)\n@@ -96,7 +106,8 @@ def _eigh(a, b, lower, eigvals_only, eigvals, type):\nelse:\nreturn w, v\n-@_wraps(scipy.linalg.eigh)\n+@_wraps(scipy.linalg.eigh,\n+ lax_description=_no_overwrite_and_chkfinite_doc, skip_params=('overwrite_a', 'overwrite_b', 'check_finite'))\ndef eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False,\noverwrite_b=False, turbo=True, eigvals=None, type=1,\ncheck_finite=True):\n@@ -116,13 +127,15 @@ def schur(a, output='real'):\n\"Expected 'output' to be either 'real' or 'complex', got output={}.\".format(output))\nreturn _schur(a, output)\n-@_wraps(scipy.linalg.inv)\n+@_wraps(scipy.linalg.inv,\n+ lax_description=_no_overwrite_and_chkfinite_doc, skip_params=('overwrite_a', 'check_finite'))\ndef inv(a, overwrite_a=False, check_finite=True):\ndel overwrite_a, check_finite\nreturn np_linalg.inv(a)\n-@_wraps(scipy.linalg.lu_factor)\n+@_wraps(scipy.linalg.lu_factor,\n+ lax_description=_no_overwrite_and_chkfinite_doc, skip_params=('overwrite_a', 'check_finite'))\n@partial(jit, static_argnames=('overwrite_a', 'check_finite'))\ndef lu_factor(a, overwrite_a=False, check_finite=True):\ndel overwrite_a, check_finite\n@@ -131,7 +144,8 @@ def lu_factor(a, overwrite_a=False, check_finite=True):\nreturn lu, pivots\n-@_wraps(scipy.linalg.lu_solve)\n+@_wraps(scipy.linalg.lu_solve,\n+ lax_description=_no_overwrite_and_chkfinite_doc, skip_params=('overwrite_b', 'check_finite'))\n@partial(jit, static_argnames=('trans', 'overwrite_a', 'check_finite'))\ndef lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):\ndel overwrite_b, check_finite\n@@ -156,7 +170,8 @@ def _lu(a, permute_l):\nelse:\nreturn p, l, u\n-@_wraps(scipy.linalg.lu, update_doc=False)\n+@_wraps(scipy.linalg.lu, update_doc=False,\n+ lax_description=_no_overwrite_and_chkfinite_doc, skip_params=('overwrite_a', 'check_finite'))\n@partial(jit, static_argnames=('permute_l', 'overwrite_a', 'check_finite'))\ndef lu(a, permute_l=False, overwrite_a=False, check_finite=True):\ndel overwrite_a, check_finite\n@@ -179,7 +194,8 @@ def _qr(a, mode, pivoting):\nreturn r\nreturn q, r\n-@_wraps(scipy.linalg.qr)\n+@_wraps(scipy.linalg.qr,\n+ lax_description=_no_overwrite_and_chkfinite_doc, skip_params=('overwrite_a', 'check_finite'))\ndef qr(a, overwrite_a=False, lwork=None, mode=\"full\", pivoting=False,\ncheck_finite=True):\ndel overwrite_a, lwork, check_finite\n@@ -210,7 +226,8 @@ def _solve(a, b, sym_pos, lower):\nreturn vmap(custom_solve, b.ndim - 1, max(a.ndim, b.ndim) - 1)(b)\n-@_wraps(scipy.linalg.solve)\n+@_wraps(scipy.linalg.solve,\n+ lax_description=_no_overwrite_and_chkfinite_doc, skip_params=('overwrite_a', 'overwrite_b', 'debug', 'check_finite'))\ndef solve(a, b, sym_pos=False, lower=False, overwrite_a=False, overwrite_b=False,\ndebug=False, check_finite=True):\ndel overwrite_a, overwrite_b, debug, check_finite\n@@ -242,7 +259,8 @@ def _solve_triangular(a, b, trans, lower, unit_diagonal):\nelse:\nreturn out\n-@_wraps(scipy.linalg.solve_triangular)\n+@_wraps(scipy.linalg.solve_triangular,\n+ lax_description=_no_overwrite_and_chkfinite_doc, skip_params=('overwrite_b', 'debug', 'check_finite'))\ndef solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False,\noverwrite_b=False, debug=None, check_finite=True):\ndel overwrite_b, debug, check_finite\n@@ -657,12 +675,7 @@ def sqrtm(A, blocksize=1):\nraise NotImplementedError(\"Blocked version is not implemented yet.\")\nreturn _sqrtm(A)\n-_no_asarray_chkfinite_doc = textwrap.dedent(\"\"\"\n-Does not currently support the Scipy argument ``jax.numpy.asarray_chkfinite``,\n-because `jax.numpy.asarray_chkfinite` does not exist at the moment.\n-\"\"\")\n-\n-@_wraps(scipy.linalg.rsf2csf, lax_description=_no_asarray_chkfinite_doc)\n+@_wraps(scipy.linalg.rsf2csf, lax_description=_no_chkfinite_doc)\n@partial(jit, static_argnames=('check_finite',))\ndef rsf2csf(T, Z, check_finite=True):\nT = jnp.asarray(T)\n"
}
] | Python | Apache License 2.0 | google/jax | try to improve docs for scipy.linalg with unused parameters |
260,335 | 22.04.2022 22:23:35 | 25,200 | 4680b86ff7f468429a0820b4f8c7f64ffd1a1cad | [remove-units] prevent scan partial eval from introducing units | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/control_flow.py",
"new_path": "jax/_src/lax/control_flow.py",
"diff": "@@ -1681,119 +1681,143 @@ def _prune_zeros(ts):\ndef _scan_partial_eval(trace, *tracers, reverse, length, num_consts, num_carry,\njaxpr, linear, unroll):\nnum_ys = len(jaxpr.out_avals) - num_carry\n-\n- unknowns = [t.pval[0] is not None for t in tracers]\n+ unknowns = [not t.pval.is_known() for t in tracers]\nconst_uk, init_uk, xs_uk = split_list(unknowns, [num_consts, num_carry])\n- # Fixpoint computation of which carry are unknown (not a constant): either\n- # unknown from init, or the carry out is unknown. Each iteration promotes\n- # at least one carry to unknown. We need at most len(carry) iterations,\n- # but we need one last iteration to prepare the jaxpr based on the final\n- # carry_uk.\n+ # Fixpoint computation of which carry elements are unknown. Each iteration\n+ # promotes at least one carry to unknown. We need at most len(carry)\n+ # iterations, but we need one last iteration to prepare the jaxpr based on the\n+ # final carry_uk.\ncarry_uk = init_uk\nfor _ in range(1 + len(carry_uk)):\nunknowns = const_uk + carry_uk + xs_uk\n- jaxpr_1, jaxpr_2, out_uk = pe.partial_eval_jaxpr(\n+ jaxpr_known, jaxpr_unknown, out_uk, res_avals = pe.partial_eval_jaxpr_nounits(\njaxpr, unknowns, instantiate=carry_uk + [False] * num_ys)\n- carry_uk_out = out_uk[:num_carry]\n+ carry_uk_out, ys_uk = split_list(out_uk, [num_carry])\nif carry_uk_out == carry_uk:\nbreak\nelse:\ncarry_uk = _map(operator.or_, carry_uk, carry_uk_out)\nelse:\nassert False, \"Fixpoint not reached\"\n- num_res = len(jaxpr_1.out_avals) - len(jaxpr_2.out_avals)\n-\n- # The residuals are treated as extensive outputs of jaxpr_1 (and extensive\n- # inputs to jaxpr_2), but residuals that are loop-invariant can be hoisted.\n- # TODO(mattjj): hoist other loop-invariant values here too (instantiate=False)\n- invariant_pvals = [pe.PartialVal.known(core.unit if uk else t.pval[1])\n- for uk, t in zip(unknowns[:num_consts], tracers[:num_consts])]\n- other_pvals = [pe.PartialVal.unknown(a) for a in jaxpr_1.in_avals[num_consts:]]\n- in_pvals_1 = invariant_pvals + other_pvals\n+ num_res = len(res_avals)\n+ del res_avals, carry_uk_out\n+\n+ # Instantiate those inputs which must be treated as unknown from the fixpoint.\n+ tracers = [trace.instantiate_const(t) if uk else t\n+ for t, uk in zip(tracers, unknowns)]\n+\n+ # The residual inputs and outputs of the jaxprs produced haven't yet been\n+ # adapted to the scan calling convention; in particular, jaxpr_known has its\n+ # residual outputs all at the end, meaning they're extensive outputs (which is\n+ # fully general but may be wasteful for residuals which are loop-invariant)\n+ # while jaxpr_unknown has its corresponding residual inputs at the front (just\n+ # as a convention with partial_eval_jaxpr_nounits), making them constant\n+ # inputs. To make them consistent, we move the residual inputs on\n+ # jaxpr_unknown to the end, even though we may move some back in the sequel.\n+ jaxpr_unknown = pe.move_binders_to_back(\n+ jaxpr_unknown, [True] * num_res + [False] * sum(unknowns))\n+\n+ # At this point, all residuals are treated as extensive outputs of jaxpr_known\n+ # (and extensive inputs to jaxpr_unknown). But residuals that are loop-\n+ # invariant can be hoisted out of the scan, rather than letting them get\n+ # broadcast (as in e.g. scanning multiplication by a constant matrix; we don't\n+ # want to broadcast the matrix!). So, outside the loop we perform a partial\n+ # evaluation with known 'const' inputs (but all other inputs unknown).\n+ const_pvals = [pe.PartialVal.known(t.pval.get_known())\n+ for t in tracers[:num_consts] if t.pval.is_known()]\n+ other_pvals = [pe.PartialVal.unknown(aval)\n+ for aval in jaxpr_known.in_avals[len(const_pvals):]]\nwith source_info_util.reset_name_stack():\n- jaxpr_1_opt, out_pvals_1, consts_1 = pe.trace_to_jaxpr(\n- lu.wrap_init(core.jaxpr_as_fun(jaxpr_1)), in_pvals_1,\n- instantiate=[True] * (num_carry + num_ys) + [False] * num_res)\n- jaxpr_1_opt = pe.ClosedJaxpr(pe.convert_constvars_jaxpr(jaxpr_1_opt), ())\n- num_consts_1 = num_consts + len(consts_1)\n- # any now-known residuals are intensive, so we want to revise jaxpr_2 to take\n- # those inputs as constants rather than as extensive inputs\n- _, _, res_pvals = split_list(out_pvals_1, [num_carry, num_ys])\n- intensive_residuals = [const for pv, const in res_pvals if pv is None]\n- move = [False] * len(jaxpr_1.in_avals) + [pv is None for pv, _ in res_pvals]\n- jaxpr_2_opt = pe.move_binders_to_front(jaxpr_2, move)\n- num_consts_2 = num_consts + len(intensive_residuals)\n+ jaxpr_known_, invar_pvals_out, jaxpr_known_consts = pe.trace_to_jaxpr_nounits(\n+ lu.wrap_init(core.jaxpr_as_fun(jaxpr_known)), const_pvals + other_pvals,\n+ instantiate=[True] * (len(out_uk) - sum(out_uk)) + [False] * num_res)\n+ jaxpr_known = pe.ClosedJaxpr(pe.convert_constvars_jaxpr(jaxpr_known_), ())\n+ # The above trace_to_jaxpr_nounits call computed loop-invariant residuals\n+ # (known values in invar_pvals_out) and also computed loop-invariant values\n+ # needed by the new jaxpr_known (in jaxpr_known_consts, which replace the\n+ # previous consts). We need to collect the computed inteisive residuals, and\n+ # move corresponding intensive residual binders in jaxpr_unknown to the front.\n+ res_pvals = invar_pvals_out[len(invar_pvals_out) - num_res:]\n+ intensive_res = [pval.get_known() for pval in res_pvals if pval.is_known()]\n+ jaxpr_unknown = pe.move_binders_to_front(\n+ jaxpr_unknown,\n+ [False] * sum(unknowns) + [pval.is_known() for pval in res_pvals])\n+ del const_pvals, other_pvals, invar_pvals_out, jaxpr_known_, res_pvals\n+ # We use `jaxpr_known_consts` when we call scan_p.bind with jaxpr_known, and\n+ # we use `intensive_res` when we build the jaxpr eqn with jaxpr_unknown.\n# As another optimization, for any extensive inputs that are just forwarded to\n- # extensive outputs, to avoid a copy (looping over dynamic-update-slice) we'd\n- # rather just forward the input tracer. That means pruning some extensive\n- # outputs from the jaxpr here, and updating out_flat below.\n- extensive_invars = jaxpr_1_opt.jaxpr.invars[num_consts_1 + num_carry:]\n- extensive_outvars = jaxpr_1_opt.jaxpr.outvars[num_carry:]\n- extensive_avals = [core.unmapped_aval(length, core.no_axis_name, 0,\n- core.raise_to_shaped(v.aval))\n- for v in extensive_outvars]\n- fwd_extensive = [num_consts + num_carry + extensive_invars.index(v)\n- if v in extensive_invars else None for v in extensive_outvars]\n- jaxpr_1_opt.jaxpr.outvars = (\n- jaxpr_1_opt.jaxpr.outvars[:num_carry] +\n- [v for i, v in zip(fwd_extensive, extensive_outvars) if i is None])\n-\n- in_consts = (list(consts_1) + [core.unit] * num_consts +\n- [core.unit if uk else t.pval[1]\n- for uk, t in zip(unknowns[num_consts:], tracers[num_consts:])])\n- linear_1 = ([False] * len(consts_1) + [True] * num_consts +\n- [lin or uk for uk, lin\n- in zip(unknowns[num_consts:], linear[num_consts:])])\n- out_flat = scan_p.bind(\n- *in_consts, reverse=reverse, length=length, jaxpr=jaxpr_1_opt,\n- num_consts=num_consts_1, num_carry=num_carry, linear=tuple(linear_1),\n- unroll=unroll)\n-\n- # Propagate the forwarded extensive outputs using fwd_extensive. Any\n- # numpy.ndarray inputs should be converted to JAX DeviceArrays.\n- out_carry, out_extensive = split_list(out_flat, [num_carry])\n- out_extensive_iter = iter(out_extensive)\n- out_extensive = [next(out_extensive_iter) if i is None\n- else _maybe_device_put(tracers[i].pval[1]) if tracers[i].is_known()\n- else tracers[i] for i in fwd_extensive]\n- assert all(core.typematch(a, core.get_aval(out))\n- for a, out in zip(extensive_avals, out_extensive))\n- out_flat = out_carry + out_extensive\n-\n- out_carry, ys, res_and_units = split_list(out_flat, [num_carry, num_ys])\n- extensive_residuals = [r for r, (pv, _) in zip(res_and_units, res_pvals) if pv is not None]\n-\n- new_tracers = [trace.instantiate_const(t) if uk else trace.new_instantiated_literal(core.unit)\n- for uk, t in zip(unknowns, tracers)]\n- carry_avals, y_avals = split_list(jaxpr.out_avals, [num_carry])\n- ys_avals = _map(partial(_prepend_dim_to_aval, length), y_avals)\n- out_avals = carry_avals + ys_avals\n- out_pvs = [aval if uk else None for aval, uk in zip(out_avals, out_uk)]\n-\n- out_consts = out_carry + ys\n- int_res_tracers = _map(trace.new_instantiated_const, intensive_residuals)\n- ext_res_tracers = _map(trace.new_instantiated_const, extensive_residuals)\n- out_tracers = [pe.JaxprTracer(trace, pe.PartialVal((pv, const)), None)\n- for pv, const in zip(out_pvs, out_consts)]\n+ # extensive outputs, to avoid a copy (which would be looping over\n+ # dynamic-update-slice) we'd rather forward the input tracer/value. That means\n+ # pruning some outputs from jaxpr_known here, and updating `out_flat` below.\n+ fwds_known = pe._jaxpr_forwarding(jaxpr_known.jaxpr)\n+ # Prune fwds_known to include only extensive input to extensive output.\n+ fwds_known = [in_idx if out_idx >= num_carry - sum(carry_uk) and\n+ in_idx is not None and\n+ in_idx >= len(jaxpr_known_consts) + num_carry - sum(carry_uk)\n+ else None for out_idx, in_idx in enumerate(fwds_known)]\n+ # DCE any (extensive) output we can instead get by forwarding an input.\n+ jaxpr_known_, kept_inputs = pe.dce_jaxpr(\n+ jaxpr_known.jaxpr, [i is None for i in fwds_known])\n+ jaxpr_known = core.ClosedJaxpr(jaxpr_known_, ())\n+ del jaxpr_known_\n+ # We must use `kept_inputs` below when forming the inputs to jaxpr_known, and\n+ # we must use `fwds_known` when forming its output.\n+\n+ # Run the known part of the scan.\n+ known_inputs = (list(jaxpr_known_consts) +\n+ [t.pval.get_known() for t in tracers[num_consts:]\n+ if t.pval.is_known()])\n+ known_inputs_prune = [c for c, kept in zip(known_inputs, kept_inputs) if kept]\n+ kept_consts, kept_carry, _ = split_list(kept_inputs, [len(jaxpr_known_consts),\n+ num_carry-sum(carry_uk)])\n+ linear_known = [False] * len(known_inputs_prune) # conservative!\n+ out_known = scan_p.bind(\n+ *known_inputs_prune, reverse=reverse, length=length, jaxpr=jaxpr_known,\n+ num_consts=sum(kept_consts), num_carry=sum(kept_carry),\n+ linear=tuple(linear_known), unroll=unroll)\n+ # Complete the known output by filling in forwarded values using fwds_known.\n+ out_known_iter = iter(out_known)\n+ out_known = [next(out_known_iter) if f is None else _maybe_put(known_inputs[f])\n+ for f in fwds_known]\n+ assert next(out_known_iter, None) is None\n+ del kept_inputs, known_inputs, known_inputs_prune, out_known_iter\n+\n+ # Split known outputs from residuals.\n+ out_known, extensive_res = split_list(out_known, [len(out_uk) - sum(out_uk)])\n+ assert len(intensive_res) + len(extensive_res) == num_res\n+\n+ # Create input tracers for jaxpr_unknown bind.\n+ unknown_inputs = [t for t in tracers if not t.pval.is_known()]\n+ intensive_res = _map(trace.new_instantiated_const, intensive_res)\n+ extensive_res = _map(trace.new_instantiated_const, extensive_res)\n+ # Create output tracers for jaxpr_unknown bind, adapting extensive shapes.\n+ carry_avals, y_avals = split_list(jaxpr_unknown.out_avals, [sum(carry_uk)])\n+ ys_avals = [core.unmapped_aval(length, core.no_axis_name, 0, y_aval)\n+ for y_aval in y_avals]\n+ out_tracers = [pe.JaxprTracer(trace, pe.PartialVal.unknown(a), None)\n+ for a in itertools.chain(carry_avals, ys_avals)]\n+ del carry_avals, y_avals\n+ # Create equation.\n+ linear_unknown = tuple([False] * len(intensive_res) +\n+ [l for l, uk in zip(linear, unknowns) if uk] +\n+ [False] * len(extensive_res))\nname_stack = source_info_util.current_name_stack()[len(trace.name_stack):]\nsource = source_info_util.current().replace(name_stack=name_stack)\n- linear_2 = ([False] * len(int_res_tracers) +\n- [lin or not uk for uk, lin in zip(unknowns, linear)] +\n- [False] * len(ext_res_tracers))\n- eqn = pe.new_eqn_recipe(int_res_tracers + new_tracers + ext_res_tracers,\n+ eqn = pe.new_eqn_recipe([*intensive_res, *unknown_inputs, *extensive_res],\nout_tracers, scan_p,\n- dict(reverse=reverse, length=length, jaxpr=jaxpr_2_opt,\n- num_consts=num_consts_2,\n- num_carry=num_carry, linear=tuple(linear_2),\n- unroll=unroll),\n- jaxpr_2_opt.effects,\n- source)\n+ dict(reverse=reverse, length=length, unroll=unroll,\n+ jaxpr=jaxpr_unknown, linear=linear_unknown,\n+ num_consts=len(intensive_res) + sum(const_uk),\n+ num_carry=sum(carry_uk)),\n+ jaxpr_unknown.effects, source)\nfor t in out_tracers: t.recipe = eqn\n- return out_tracers\n-def _maybe_device_put(x):\n+ # Merge known and unknown outputs into final result.\n+ return util.merge_lists(out_uk, out_known, out_tracers)\n+\n+def _maybe_put(x):\nif isinstance(x, np.ndarray):\nreturn jax.device_put(x, jax.devices('cpu')[0])\nelse:\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "# 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+from __future__ import annotations\nfrom collections import namedtuple\nimport contextlib\n@@ -78,11 +79,11 @@ class PartialVal(tuple):\nreturn tuple.__new__(cls, xs)\n@classmethod\n- def known(cls, const: core.Value) -> 'PartialVal':\n+ def known(cls, const: core.Value) -> PartialVal:\nreturn PartialVal((None, const))\n@classmethod\n- def unknown(cls, aval: AbstractValue) -> 'PartialVal':\n+ def unknown(cls, aval: AbstractValue) -> PartialVal:\nreturn PartialVal((aval, core.unit))\ndef is_known(self) -> bool:\n@@ -112,29 +113,29 @@ class JaxprTrace(Trace):\nsuper().__init__(*args)\nself.name_stack = name_stack\n- def pure(self, val) -> 'JaxprTracer':\n+ def pure(self, val) -> JaxprTracer:\nreturn self.new_const(val)\n- def lift(self, val) -> 'JaxprTracer':\n+ def lift(self, val) -> JaxprTracer:\nreturn self.new_const(val)\n- def sublift(self, val) -> 'JaxprTracer':\n+ def sublift(self, val) -> JaxprTracer:\nreturn JaxprTracer(self, val.pval, FreeVar(val))\n- def new_const(self, val) -> 'JaxprTracer':\n+ def new_const(self, val) -> JaxprTracer:\nif isinstance(val, Tracer) and val._trace.level == self.level:\nraise Exception\nreturn JaxprTracer(self, PartialVal.known(val), unit)\n- def new_instantiated_literal(self, val) -> 'JaxprTracer':\n+ def new_instantiated_literal(self, val) -> JaxprTracer:\naval = get_aval(val)\nreturn JaxprTracer(self, PartialVal.unknown(aval),\nLiteral(val, raise_to_shaped(aval)))\n- def new_instantiated_const(self, val) -> 'JaxprTracer':\n+ def new_instantiated_const(self, val) -> JaxprTracer:\nreturn JaxprTracer(self, PartialVal.unknown(get_aval(val)), ConstVar(val))\n- def new_arg(self, pval: PartialVal) -> 'JaxprTracer':\n+ def new_arg(self, pval: PartialVal) -> JaxprTracer:\nconst = pval.get_known()\n# XXX: Think twice before changing this constant argument pruning!\n# This has really important consequences for partial_eval_jaxpr.\n@@ -155,7 +156,7 @@ class JaxprTrace(Trace):\nelse:\nreturn self.new_instantiated_const(const)\n- def instantiate_const_abstracted(self, tracer) -> 'JaxprTracer':\n+ def instantiate_const_abstracted(self, tracer) -> JaxprTracer:\nconst = tracer.pval.get_known()\nif const is None:\nreturn tracer\n@@ -170,8 +171,9 @@ class JaxprTrace(Trace):\nreturn self.default_process_primitive(primitive, tracers, params)\ndef default_process_primitive(self, primitive, tracers, params):\n- \"\"\"By default, if all the input tracers are known, then execute the primitive\n- and all the outputs are known. Otherwise, all the outputs are unknown.\"\"\"\n+ # By default, if all the input tracers are known, then bind the primitive\n+ # and consider all outputs known. Otherwise, stage the application into the\n+ # jaxpr and consider all outputs unknown.\nconsts = [t.pval.get_known() for t in tracers]\nif all(c is not None for c in consts):\nreturn primitive.bind(*consts, **params)\n@@ -556,7 +558,7 @@ class JaxprTracer(Tracer):\nreturn self.pval.get_aval()\n@property\n- def parents(self) -> Sequence['JaxprTracer']:\n+ def parents(self) -> Sequence[JaxprTracer]:\nif isinstance(self.recipe, JaxprEqnRecipe):\nreturn self.recipe.invars\nelse:\n@@ -661,7 +663,7 @@ LambdaBinding = namedtuple('LambdaBinding', [])\nclass JaxprEqnRecipe(NamedTuple):\neqn_id: object\ninvars: Sequence[JaxprTracer]\n- outvars: 'Sequence[ref[JaxprTracer]]'\n+ outvars: Sequence[ref[JaxprTracer]]\nprimitive: Primitive\nparams: Dict[str, Any]\neffects: core.Effects\n@@ -674,14 +676,6 @@ def new_eqn_recipe(invars: Sequence[JaxprTracer],\neffects: core.Effects,\nsource_info: source_info_util.SourceInfo\n) -> JaxprEqnRecipe:\n- \"\"\"Constructs a new JaxEqnRecipe.\n-\n- Params:\n- invars: the tracers for the primitive inputs.\n- outvars: the tracers for the primitive outputs.\n- primitive: the primitive.\n- params: the primitive params\n- \"\"\"\n# TODO(necula): move these checks to core.check_jaxpr, and call in more places\nif primitive.call_primitive or primitive.map_primitive:\nassert \"call_jaxpr\" in params\n@@ -901,8 +895,10 @@ def _partial_eval_jaxpr_nounits(jaxpr, in_unknowns, instantiate):\nassert ([v.aval for v in jaxpr_unknown.invars] ==\nres_avals + [a for a, uk in zip(jaxpr.in_avals, in_unknowns) if uk])\n# check jaxpr_unknown has output type corresponding to unknown outputs\n- assert ([v.aval for v in jaxpr_unknown.outvars] ==\n- [a for a, uk in zip(jaxpr.out_avals, out_unknowns) if uk])\n+ # TODO(mattjj): enable weak type checking here\n+ assert ([v.aval.strip_weak_type() for v in jaxpr_unknown.outvars] ==\n+ [a.strip_weak_type() for a, uk in zip(jaxpr.out_avals, out_unknowns)\n+ if uk])\nclosed_jaxpr_known = ClosedJaxpr(jaxpr_known, consts_known)\nclosed_jaxpr_unknown = ClosedJaxpr(jaxpr_unknown, ())\n@@ -1169,6 +1165,21 @@ partial_eval_jaxpr_custom_rules[remat_call_p] = \\\nlambda _, __, ___, ____, p1, p2: (p1, dict(p2, differentiated=True)))\n+def _jaxpr_forwarding(jaxpr: Jaxpr) -> List[Optional[int]]:\n+ # Compute which inputs are just forwarded to outputs.\n+ fwds: Dict[Var, Var] = dict(zip(jaxpr.invars, jaxpr.invars))\n+ for eqn in jaxpr.eqns:\n+ if eqn.primitive in forwarding_rules:\n+ eqn = eqn.replace(invars=[fwds.get(v, v) for v in eqn.invars]) # type: ignore\n+ fwd_vars, _ = forwarding_rules[eqn.primitive](eqn)\n+ for v_orig, v_new in zip(eqn.outvars, fwd_vars):\n+ if v_new is not None:\n+ fwds[v_orig] = v_new\n+ idxs: Dict[Var, int] = {v: i for i, v in enumerate(jaxpr.invars)}\n+ return [None if type(v) is Literal else idxs.get(fwds.get(v)) # type: ignore\n+ for v in jaxpr.outvars]\n+\n+\n# TODO(mattjj): unify with dce code below\ndef dce_jaxpr(jaxpr: Jaxpr, used_outputs: List[bool]\n) -> Tuple[Jaxpr, List[bool]]:\n@@ -1275,8 +1286,9 @@ def _reconstruct_pval(pval1: PartialVal, const2: core.Value):\nreturn PartialVal.known(const2)\n-def move_binders_to_front(closed_jaxpr: ClosedJaxpr, to_move: Sequence[bool]) -> ClosedJaxpr:\n- \"\"\"Reorder the `invars` to move to front the ones for which `to_move` is True.\"\"\"\n+def move_binders_to_front(closed_jaxpr: ClosedJaxpr, to_move: Sequence[bool]\n+ ) -> ClosedJaxpr:\n+ \"\"\"Reorder `invars` by moving those indicated in `to_move` to the front.\"\"\"\nassert len(closed_jaxpr.in_avals) == len(to_move)\nnew_invars = _move_to_front(closed_jaxpr.jaxpr.invars, to_move)\nnew_jaxpr = Jaxpr(closed_jaxpr.jaxpr.constvars, new_invars,\n@@ -1289,6 +1301,10 @@ def _move_to_front(lst: Sequence, to_move: Sequence[bool]) -> Sequence:\nreturn ([elt for elt, move in zip(lst, to_move) if move] +\n[elt for elt, move in zip(lst, to_move) if not move])\n+def move_binders_to_back(closed_jaxpr: ClosedJaxpr, to_move: Sequence[bool]\n+ ) -> ClosedJaxpr:\n+ \"\"\"Reorder `invars` by moving those indicated in `to_move` to the back.\"\"\"\n+ return move_binders_to_front(closed_jaxpr, map(op.not_, to_move))\nclass DynamicJaxprTracer(core.Tracer):\n__slots__ = ['aval']\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] prevent scan partial eval from introducing units |
260,510 | 26.04.2022 12:19:15 | 25,200 | 5d68280e58ae82af36fd18718e27d46f07b719c7 | Add an `emit_python_callback` helper function | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/host_callback.py",
"new_path": "jax/experimental/host_callback.py",
"diff": "@@ -524,7 +524,6 @@ from jax._src.lib import pytree\nfrom jax._src.lib import xla_bridge as xb\nfrom jax._src.lib import xla_client\nfrom jax._src.lib import xla_extension\n-from jax._src.lib.mlir import ir\nfrom jax._src.lib.mlir.dialects import mhlo\nimport numpy as np\n@@ -1149,7 +1148,6 @@ def _outside_call_lowering(\nreturn mlir.xla_fallback_lowering(outside_call_p)(ctx, *args,\nhas_token=has_token, identity=identity,\nflat_results_aval=flat_results_aval, **params)\n- backend = xb.get_backend(platform)\n# We expect the current tokens at the end, inserted by _rewrite_jaxpr.\nassert has_token\ncurrent_token = args[-2]\n@@ -1185,36 +1183,10 @@ def _outside_call_lowering(\nresult_arrays = ()\nreturn (token,) + result_arrays\n- result_shapes = [\n- xla.aval_to_xla_shapes(res_aval)[0]\n- for res_aval in callback_flat_results_aval\n- ]\n- callback_operand_shapes = [\n- xla.aval_to_xla_shapes(op_aval)[0]\n- for op_aval in callback_operand_avals\n- ]\n- callback_descriptor, keep_alive = backend.get_emit_python_callback_descriptor(\n- wrapped_callback,\n- callback_operand_shapes,\n- result_shapes)\n+ results, keep_alive = mlir.emit_python_callback(platform, wrapped_callback,\n+ callback_operands, callback_operand_avals, callback_flat_results_aval, # type: ignore[arg-type]\n+ has_side_effect=True)\n_callback_handler_data.keep_alives.append(keep_alive)\n- descriptor_operand = mlir.ir_constant(callback_descriptor, canonicalize_types=False)\n- callback_operands = [descriptor_operand, *callback_operands]\n- result_types = util.flatten(\n- [mlir.aval_to_ir_types(aval) for aval in callback_flat_results_aval])\n- result_type = ir.TupleType.get_tuple(result_types)\n- result = mhlo.CustomCallOp([result_type], callback_operands,\n- call_target_name=ir.StringAttr.get(\"xla_python_cpu_callback\"),\n- has_side_effect=ir.BoolAttr.get(True),\n- api_version=mlir.i32_attr(2),\n- called_computations=ir.ArrayAttr.get([]),\n- backend_config=ir.StringAttr.get(\"\"),\n- operand_layouts=None,\n- result_layouts=None)\n- results = [\n- mhlo.GetTupleElementOp(result, mlir.i32_attr(i)).result\n- for i in range(len(result_types))\n- ]\nnext_token, *results = results\n# We must put the two tokens at the end\nif identity:\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/mlir.py",
"new_path": "jax/interpreters/mlir.py",
"diff": "@@ -39,6 +39,7 @@ from jax._src.lib.mlir import ir\nfrom jax._src.lib.mlir.dialects import chlo\nfrom jax._src.lib.mlir.dialects import mhlo\nfrom jax._src.lib.mlir.dialects import func as func_dialect\n+from jax._src.lib import xla_bridge as xb\nfrom jax._src.lib import xla_client as xc\nfrom jax._src import source_info_util\nimport jax._src.util as util\n@@ -1207,6 +1208,43 @@ def xla_fallback_lowering(prim: core.Primitive):\nregister_lowering(ad.custom_lin_p, ad._raise_custom_vjp_error_on_jvp)\n+def emit_python_callback(platform, callback,\n+ operands: List[ir.Value],\n+ operand_avals: List[core.AbstractValue],\n+ result_avals: List[core.AbstractValue],\n+ has_side_effect: bool) -> Tuple[List[ir.Value], Any]:\n+ \"\"\"Creates an MHLO `CustomCallOp` that calls back to the provided function.\"\"\"\n+ if platform != \"cpu\":\n+ raise ValueError('`EmitPythonCallback` not supported in non-CPU backends.')\n+ backend = xb.get_backend(platform)\n+ result_shapes = util.flatten(\n+ [xla.aval_to_xla_shapes(result_aval) for result_aval in result_avals])\n+ operand_shapes = util.flatten(\n+ [xla.aval_to_xla_shapes(op_aval) for op_aval in operand_avals])\n+ callback_descriptor, keepalive = backend.get_emit_python_callback_descriptor(\n+ callback, operand_shapes, result_shapes)\n+ descriptor_operand = ir_constant(\n+ callback_descriptor, canonicalize_types=False)\n+ callback_operands = [descriptor_operand, *operands]\n+ result_types = util.flatten(\n+ [aval_to_ir_types(aval) for aval in result_avals])\n+ result_type = ir.TupleType.get_tuple(result_types)\n+ result = mhlo.CustomCallOp(\n+ [result_type],\n+ callback_operands,\n+ call_target_name=ir.StringAttr.get(\"xla_python_cpu_callback\"),\n+ has_side_effect=ir.BoolAttr.get(has_side_effect),\n+ api_version=i32_attr(2),\n+ called_computations=ir.ArrayAttr.get([]),\n+ backend_config=ir.StringAttr.get(\"\"),\n+ operand_layouts=None,\n+ result_layouts=None)\n+ results = [\n+ mhlo.GetTupleElementOp(result, i32_attr(i)).result\n+ for i in range(len(result_types))\n+ ]\n+ return results, keepalive\n+\n# Lax ops missing MLIR lowerings.\n# # TODO(b/203775215): these are missing from the cHLO dialect. Either add\n# # them or port them to Python.\n"
}
] | Python | Apache License 2.0 | google/jax | Add an `emit_python_callback` helper function
PiperOrigin-RevId: 444633097 |
260,335 | 26.04.2022 12:31:08 | 25,200 | e7acb82b145dc2d5397cda85565c2d4e6a32648c | [remove-units] remove units from api_util.py | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/ad_util.py",
"new_path": "jax/_src/ad_util.py",
"diff": "from typing import Any, Callable, Dict, Type\nfrom jax import core\n-from jax.core import (lattice_join, Primitive, Unit, unit, AbstractUnit,\n- valid_jaxtype, raise_to_shaped, get_aval)\n+from jax.core import (lattice_join, Primitive, valid_jaxtype, raise_to_shaped,\n+ get_aval)\nfrom jax.tree_util import register_pytree_node\nfrom jax._src.util import safe_map\n@@ -28,7 +28,7 @@ Array = Any\nmap = safe_map\njaxval_adders: Dict[type, Callable] = {}\n-jaxval_adders[Unit] = lambda _, __: unit\n+jaxval_adders[core.Unit] = lambda _, __: core.unit\ndef add_jaxvals(x, y):\nif core.get_aval(x) is core.abstract_unit is core.get_aval(y):\n@@ -53,7 +53,7 @@ def zeros_like_aval(aval):\nreturn aval_zeros_likers[type(aval)](aval)\naval_zeros_likers: Dict[Type[core.AbstractValue], Array] = {}\n-aval_zeros_likers[AbstractUnit] = lambda _: unit\n+aval_zeros_likers[core.AbstractUnit] = lambda _: core.unit\ndef zeros_like_jaxval(val):\nreturn zeros_like_p.bind(val)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/api_util.py",
"new_path": "jax/_src/api_util.py",
"diff": "@@ -26,7 +26,6 @@ from jax._src.tree_util import (\nfrom jax._src.tree_util import _replace_nones\nfrom jax import linear_util as lu\nfrom jax._src.util import safe_map, WrapKwArgs, Hashable, Unhashable\n-from jax.core import unit\nfrom jax._src import traceback_util\ntraceback_util.register_exclusion(__file__)\n@@ -136,19 +135,19 @@ class _HashableWithStrictTypeEquality:\ndef argnums_partial(f, dyn_argnums, args, require_static_args_hashable=True):\ndyn_argnums = _ensure_index_tuple(dyn_argnums)\n- fixed_args = [unit] * len(args)\n+ if require_static_args_hashable:\n+ fixed_args = []\nfor i, arg in enumerate(args):\nif i in dyn_argnums: continue\n- if require_static_args_hashable:\nif not is_hashable(arg):\nraise ValueError(\n\"Non-hashable static arguments are not supported, as this can lead \"\nf\"to unexpected cache-misses. Static argument (index {i}) of type \"\nf\"{type(arg)} for function {f.__name__} is non-hashable.\")\n- fixed_args[i] = _HashableWithStrictTypeEquality(arg)\n+ fixed_args.append(_HashableWithStrictTypeEquality(arg))\nelse:\n- fixed_args[i] = Unhashable(arg)\n-\n+ fixed_args = [Unhashable(arg) for i, arg in enumerate(args)\n+ if i not in dyn_argnums]\ndyn_args = tuple(args[i] for i in dyn_argnums)\nreturn _argnums_partial(f, dyn_argnums, tuple(fixed_args)), dyn_args\n@@ -160,10 +159,9 @@ def argnums_partial_except(f: lu.WrappedFun, static_argnums: Tuple[int, ...],\ndyn_argnums = tuple(i for i in range(len(args)) if i not in static_argnums)\ndyn_args = tuple(args[i] for i in dyn_argnums)\n- fixed_args = [unit] * len(args) # type: ignore\n+ fixed_args = []\nfor i in static_argnums:\n- # TODO(shoyer): set allow_invalid=True permanently after enabling\n- # static_argnames.\n+ # TODO(shoyer): set allow_invalid=True permanently after static_argnames.\nif allow_invalid and i >= len(args):\ncontinue\nstatic_arg = args[i]\n@@ -175,16 +173,19 @@ def argnums_partial_except(f: lu.WrappedFun, static_argnums: Tuple[int, ...],\nf\"to unexpected cache-misses. Static argument (index {i}) of type \"\nf\"{type(static_arg)} for function {f.__name__} is non-hashable.\")\nelse:\n- fixed_args[i] = _HashableWithStrictTypeEquality(static_arg) # type: ignore\n+ fixed_args.append(_HashableWithStrictTypeEquality(static_arg)) # type: ignore\nreturn _argnums_partial(f, dyn_argnums, tuple(fixed_args)), dyn_args\n-\n@lu.transformation\ndef _argnums_partial(dyn_argnums, fixed_args, *dyn_args, **kwargs):\n- args = [None if arg is unit else arg.val for arg in fixed_args]\n+ sentinel = object()\n+ args = [sentinel] * (len(fixed_args) + len(dyn_args))\nfor i, arg in zip(dyn_argnums, dyn_args):\nargs[i] = arg\n+ fixed_args_ = iter(fixed_args)\n+ args = [next(fixed_args_).val if x is sentinel else x for x in args]\n+ assert next(fixed_args_, sentinel) is sentinel\nans = yield args, kwargs\nyield ans\n@@ -197,9 +198,7 @@ def argnames_partial_except(f: lu.WrappedFun, static_argnames: Tuple[str, ...],\nfixed_kwargs: Dict[str, Any] = {}\nfor k, arg in kwargs.items():\n- if k in dyn_kwargs:\n- fixed_kwargs[k] = unit\n- else:\n+ if k not in dyn_kwargs:\ntry:\nhash(arg)\nexcept TypeError:\n@@ -212,12 +211,9 @@ def argnames_partial_except(f: lu.WrappedFun, static_argnames: Tuple[str, ...],\nreturn _argnames_partial(f, WrapKwArgs(fixed_kwargs)), dyn_kwargs\n-\n@lu.transformation\ndef _argnames_partial(fixed_kwargs: WrapKwArgs, *args, **dyn_kwargs):\n- kwargs = {k: None if arg is unit else arg.val\n- for k, arg in fixed_kwargs.val.items()}\n- kwargs.update(dyn_kwargs)\n+ kwargs = dict({k: v.val for k, v in fixed_kwargs.val.items()}, **dyn_kwargs)\nans = yield args, kwargs\nyield ans\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -39,10 +39,10 @@ from jax._src.util import (unzip2, safe_zip, safe_map, toposort, split_list,\nmerge_lists, partition_list, OrderedSet,\nas_hashable_function, weakref_lru_cache)\nfrom jax.core import (Trace, Tracer, Jaxpr, Literal, get_aval, AbstractValue,\n- unit, unitvar, abstract_unit, ClosedJaxpr, new_jaxpr_eqn,\n- ConcreteArray, raise_to_shaped, Var, DropVar, Atom,\n- JaxprEqn, Primitive, ShapedArray, DShapedArray,\n- AbstractBInt, mapped_aval, unmapped_aval)\n+ ClosedJaxpr, new_jaxpr_eqn, ConcreteArray,\n+ raise_to_shaped, Var, DropVar, Atom, JaxprEqn, Primitive,\n+ ShapedArray, DShapedArray, AbstractBInt, mapped_aval,\n+ unmapped_aval)\nfrom jax._src import source_info_util\nfrom jax.config import config\n@@ -125,7 +125,7 @@ class JaxprTrace(Trace):\ndef new_const(self, val) -> JaxprTracer:\nif isinstance(val, Tracer) and val._trace.level == self.level:\nraise Exception\n- return JaxprTracer(self, PartialVal.known(val), unit)\n+ return JaxprTracer(self, PartialVal.known(val), core.unit)\ndef new_instantiated_literal(self, val) -> JaxprTracer:\naval = get_aval(val)\n@@ -721,7 +721,7 @@ def tracers_to_jaxpr(\ndef getvar(t: JaxprTracer) -> Atom:\nvar = t_to_var.get(id(t))\nif var is None:\n- aval = t.pval.get_aval() if not t.pval.is_known() else abstract_unit\n+ aval = t.pval.get_aval() if not t.pval.is_known() else core.abstract_unit\nvar = t_to_var[id(t)] = newvar(aval)\nreturn var\nsorted_tracers = toposort(out_tracers)\n@@ -754,8 +754,8 @@ def tracers_to_jaxpr(\nconsts[v] = recipe.val\nelif isinstance(recipe, Literal):\nt_to_var[id(t)] = recipe\n- elif recipe is unit:\n- t_to_var[id(t)] = unitvar\n+ elif recipe is core.unit:\n+ t_to_var[id(t)] = core.unitvar\nelse:\nraise TypeError(recipe)\n@@ -790,7 +790,7 @@ def convert_envvars_to_constvars(jaxpr: Jaxpr, num_env_vars: int) -> Jaxpr:\ndef _split_aval(unknown: bool, aval: AbstractValue) -> Tuple[AbstractValue, AbstractValue]:\n- return (abstract_unit, aval) if unknown else (aval, abstract_unit)\n+ return (core.abstract_unit, aval) if unknown else (aval, core.abstract_unit)\ndef partial_eval_jaxpr_nounits(\n@@ -952,7 +952,7 @@ def _remat_partial_eval(trace, _, f, tracers, params):\nout_consts = core.eval_jaxpr(jaxpr_known, (), *in_consts)\nout_consts_ = iter(out_consts)\n# reconstruct known outs, inserting units\n- outs1 = [pval.get_known() if x.aval is abstract_unit else next(out_consts_)\n+ outs1 = [pval.get_known() if x.aval is core.abstract_unit else next(out_consts_)\nfor uk, pval, x in zip(out_unknowns, eval_out_pvals, jaxpr.outvars)\nif not uk]\n# form known outputs and collect residual tracers\n@@ -1054,7 +1054,7 @@ def _partial_eval_jaxpr_custom(\nreturn x\nknown_eqns, staged_eqns = [], []\n- write(False, True, unitvar)\n+ write(False, True, core.unitvar)\nmap(write, in_unknowns, [True] * len(in_unknowns), jaxpr.invars)\nfor eqn in jaxpr.eqns:\nunks_in, inst_in = unzip2(map(read, eqn.invars))\n@@ -1081,7 +1081,7 @@ def _partial_eval_jaxpr_custom(\nins_known, _ = partition_list(in_unknowns, jaxpr.invars)\nouts_known_, _ = partition_list(out_unknowns, jaxpr.outvars)\n- outs_known = [x for x in outs_known_ if x.aval is not abstract_unit]\n+ outs_known = [x for x in outs_known_ if x.aval is not core.abstract_unit]\nknown_effects = core.join_effects(*(eqn.effects for eqn in known_eqns))\njaxpr_known = Jaxpr((), ins_known, [*outs_known, *residuals], known_eqns,\nknown_effects)\n@@ -1254,7 +1254,7 @@ def _dce_open_jaxpr(jaxpr: Jaxpr, outputs: Tuple[bool, ...], drop_outputs=False)\nif drop_outputs:\nnew_outvars = [var for var, output in zip(jaxpr.outvars, outputs) if output]\nelse:\n- new_outvars = [var if output else unitvar\n+ new_outvars = [var if output else core.unitvar\nfor var, output in zip(jaxpr.outvars, outputs)]\nneeded_vars = {v for v in new_outvars if type(v) is not Literal}\n@@ -2139,7 +2139,7 @@ def _eval_jaxpr_padded(\ndef write(v, val) -> None:\nenv[v] = val\n- write(unitvar, unit)\n+ write(core.unitvar, core.unit)\nmap(write, jaxpr.constvars, consts)\nmap(write, jaxpr.invars, args)\nfor eqn in jaxpr.eqns:\n@@ -2219,7 +2219,8 @@ def _partial_eval_jaxpr(jaxpr, unknowns, instantiate):\n# For jaxpr_known we pass core.unit for the unknown inputs, and known\n# PartialVal for the known inputs.\n- in_avals = [abstract_unit if uk else a for a, uk in zip(jaxpr.in_avals, unknowns)]\n+ in_avals = [core.abstract_unit if uk else a\n+ for a, uk in zip(jaxpr.in_avals, unknowns)]\njaxpr_1, out_avals, consts_1 = trace_to_jaxpr_dynamic(lu.wrap_init(fun), in_avals)\n(out_pvs_2, jaxpr_2, num_res), = cell\nassert len(jaxpr_2.constvars) == num_res\n@@ -2232,7 +2233,7 @@ def _partial_eval_jaxpr(jaxpr, unknowns, instantiate):\njaxpr_2.invars = jaxpr_2.invars[num_res:] + jaxpr_2.invars[:num_res]\nfor var, unknown in zip(jaxpr_2.invars[:len(unknowns)], unknowns):\nif not unknown:\n- var.aval = abstract_unit\n+ var.aval = core.abstract_unit\nuk_out = [pv is not None for pv in out_pvs_2]\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] remove units from api_util.py |
260,335 | 26.04.2022 13:01:01 | 25,200 | 9fd53bc6f74796af6383d371d0eb0f98f98986d2 | [remove-units] prevent ad.py from introducing units | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/api.py",
"new_path": "jax/_src/api.py",
"diff": "@@ -2320,8 +2320,11 @@ def _lift_linearized(jaxpr, primal_avals, io_tree, out_pvals, consts, *py_args):\n\"the original primal values: \"\nf\"got {tangent_aval} for primal aval {primal_aval}\")\ntangents_out = eval_jaxpr(jaxpr, consts, *tangents)\n- return tuple(map(lambda out_pv, tan_out: out_pv.merge_with_known(tan_out),\n- out_pvals, tangents_out))\n+ tangents_out_ = iter(tangents_out)\n+ full_out = [pval.get_known() if pval.is_known() else next(tangents_out_)\n+ for pval in out_pvals]\n+ assert next(tangents_out_, None) is None\n+ return full_out\nreturn apply_flat_fun(fun, io_tree, *py_args)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/ad.py",
"new_path": "jax/interpreters/ad.py",
"diff": "@@ -79,6 +79,9 @@ def jvp_subtrace(main, primals, tangents):\ntrace = JVPTrace(main, core.cur_sublevel())\nfor x in list(primals) + list(tangents):\nif isinstance(x, Tracer):\n+ if x._trace.level >= trace.level:\n+ raise core.escaped_tracer_error(\n+ x, f\"Tracer from a higher level: {x} in trace {trace}\")\nassert x._trace.level < trace.level\nin_tracers = [JVPTracer(trace, x, t) if type(t) is not Zero else x\nfor x, t in zip(primals, tangents)]\n@@ -113,12 +116,10 @@ def linearize(traceable, *primals, **kwargs):\nfor p in primals))\n_, in_tree = tree_flatten(((primals, primals), {}))\njvpfun_flat, out_tree = flatten_fun(jvpfun, in_tree)\n- jaxpr, out_pvals, consts = pe.trace_to_jaxpr(jvpfun_flat, in_pvals)\n+ jaxpr, out_pvals, consts = pe.trace_to_jaxpr_nounits(jvpfun_flat, in_pvals)\nout_primals_pvals, out_tangents_pvals = tree_unflatten(out_tree(), out_pvals)\nassert all(out_primal_pval.is_known() for out_primal_pval in out_primals_pvals)\n- _, out_primals_consts = unzip2(out_primals_pvals)\n- jaxpr.invars = jaxpr.invars[len(primals):]\n- jaxpr.outvars = jaxpr.outvars[len(out_primals_pvals):]\n+ out_primals_consts = [pval.get_known() for pval in out_primals_pvals]\nif not has_aux:\nreturn out_primals_consts, out_tangents_pvals, jaxpr, consts\nelse:\n@@ -131,7 +132,7 @@ def vjp(traceable, primals, has_aux=False, reduce_axes=()):\nout_primals, pvals, jaxpr, consts, aux = linearize(traceable, *primals, has_aux=True)\ndef unbound_vjp(pvals, jaxpr, consts, *cts):\n- cts = tuple(map(ignore_consts, cts, pvals))\n+ cts = tuple(ct for ct, pval in zip(cts, pvals) if not pval.is_known())\ndummy_args = [UndefinedPrimal(v.aval) for v in jaxpr.invars]\narg_cts = backward_pass(jaxpr, reduce_axes, True, consts, dummy_args, cts)\nreturn map(instantiate_zeros, arg_cts)\n@@ -144,15 +145,6 @@ def vjp(traceable, primals, has_aux=False, reduce_axes=()):\nelse:\nreturn out_primals, vjp_, aux\n-def ignore_consts(ct, pval):\n- aval, const = pval\n- if isinstance(aval, core.AbstractValue):\n- return ct\n- elif aval is None:\n- return core.unit\n- else:\n- raise TypeError(aval)\n-\ndef unpair_pval(pval):\naval, const = pval\nconst_1, const_2 = const\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -39,10 +39,10 @@ from jax._src.util import (unzip2, safe_zip, safe_map, toposort, split_list,\nmerge_lists, partition_list, OrderedSet,\nas_hashable_function, weakref_lru_cache)\nfrom jax.core import (Trace, Tracer, Jaxpr, Literal, get_aval, AbstractValue,\n- unit, unitvar, abstract_unit, ClosedJaxpr, new_jaxpr_eqn,\n- ConcreteArray, raise_to_shaped, Var, DropVar, Atom,\n- JaxprEqn, Primitive, ShapedArray, DShapedArray,\n- AbstractBInt, mapped_aval, unmapped_aval)\n+ ClosedJaxpr, new_jaxpr_eqn, ConcreteArray,\n+ raise_to_shaped, Var, DropVar, Atom, JaxprEqn, Primitive,\n+ ShapedArray, DShapedArray, AbstractBInt, mapped_aval,\n+ unmapped_aval)\nfrom jax._src import source_info_util\nfrom jax.config import config\n@@ -101,11 +101,6 @@ class PartialVal(tuple):\nelse:\nreturn self[0]\n- def merge_with_known(self, val: core.Value) -> core.Value:\n- \"\"\"Either the stored known value, or the given 'val'.\"\"\"\n- known = self.get_known()\n- return known if known is not None else val\n-\nclass JaxprTrace(Trace):\n@@ -125,7 +120,7 @@ class JaxprTrace(Trace):\ndef new_const(self, val) -> JaxprTracer:\nif isinstance(val, Tracer) and val._trace.level == self.level:\nraise Exception\n- return JaxprTracer(self, PartialVal.known(val), unit)\n+ return JaxprTracer(self, PartialVal.known(val), core.unit)\ndef new_instantiated_literal(self, val) -> JaxprTracer:\naval = get_aval(val)\n@@ -545,7 +540,7 @@ class JaxprTracer(Tracer):\npv, const = pval\nif isinstance(const, Tracer) and const._trace.level >= trace.level:\nraise core.escaped_tracer_error(\n- const, \"Tracer from a higher level: {} in trace {}\".format(const, trace))\n+ const, f\"Tracer from a higher level: {const} in trace {trace}\")\nself._trace = trace\nself.pval = pval\nself.recipe = recipe\n@@ -721,7 +716,7 @@ def tracers_to_jaxpr(\ndef getvar(t: JaxprTracer) -> Atom:\nvar = t_to_var.get(id(t))\nif var is None:\n- aval = t.pval.get_aval() if not t.pval.is_known() else abstract_unit\n+ aval = t.pval.get_aval() if not t.pval.is_known() else core.abstract_unit\nvar = t_to_var[id(t)] = newvar(aval)\nreturn var\nsorted_tracers = toposort(out_tracers)\n@@ -754,8 +749,8 @@ def tracers_to_jaxpr(\nconsts[v] = recipe.val\nelif isinstance(recipe, Literal):\nt_to_var[id(t)] = recipe\n- elif recipe is unit:\n- t_to_var[id(t)] = unitvar\n+ elif recipe is core.unit:\n+ t_to_var[id(t)] = core.unitvar\nelse:\nraise TypeError(recipe)\n@@ -790,7 +785,7 @@ def convert_envvars_to_constvars(jaxpr: Jaxpr, num_env_vars: int) -> Jaxpr:\ndef _split_aval(unknown: bool, aval: AbstractValue) -> Tuple[AbstractValue, AbstractValue]:\n- return (abstract_unit, aval) if unknown else (aval, abstract_unit)\n+ return (core.abstract_unit, aval) if unknown else (aval, core.abstract_unit)\ndef partial_eval_jaxpr_nounits(\n@@ -952,7 +947,7 @@ def _remat_partial_eval(trace, _, f, tracers, params):\nout_consts = core.eval_jaxpr(jaxpr_known, (), *in_consts)\nout_consts_ = iter(out_consts)\n# reconstruct known outs, inserting units\n- outs1 = [pval.get_known() if x.aval is abstract_unit else next(out_consts_)\n+ outs1 = [pval.get_known() if x.aval is core.abstract_unit else next(out_consts_)\nfor uk, pval, x in zip(out_unknowns, eval_out_pvals, jaxpr.outvars)\nif not uk]\n# form known outputs and collect residual tracers\n@@ -1054,7 +1049,7 @@ def _partial_eval_jaxpr_custom(\nreturn x\nknown_eqns, staged_eqns = [], []\n- write(False, True, unitvar)\n+ write(False, True, core.unitvar)\nmap(write, in_unknowns, [True] * len(in_unknowns), jaxpr.invars)\nfor eqn in jaxpr.eqns:\nunks_in, inst_in = unzip2(map(read, eqn.invars))\n@@ -1081,7 +1076,7 @@ def _partial_eval_jaxpr_custom(\nins_known, _ = partition_list(in_unknowns, jaxpr.invars)\nouts_known_, _ = partition_list(out_unknowns, jaxpr.outvars)\n- outs_known = [x for x in outs_known_ if x.aval is not abstract_unit]\n+ outs_known = [x for x in outs_known_ if x.aval is not core.abstract_unit]\nknown_effects = core.join_effects(*(eqn.effects for eqn in known_eqns))\njaxpr_known = Jaxpr((), ins_known, [*outs_known, *residuals], known_eqns,\nknown_effects)\n@@ -1254,7 +1249,7 @@ def _dce_open_jaxpr(jaxpr: Jaxpr, outputs: Tuple[bool, ...], drop_outputs=False)\nif drop_outputs:\nnew_outvars = [var for var, output in zip(jaxpr.outvars, outputs) if output]\nelse:\n- new_outvars = [var if output else unitvar\n+ new_outvars = [var if output else core.unitvar\nfor var, output in zip(jaxpr.outvars, outputs)]\nneeded_vars = {v for v in new_outvars if type(v) is not Literal}\n@@ -2139,7 +2134,7 @@ def _eval_jaxpr_padded(\ndef write(v, val) -> None:\nenv[v] = val\n- write(unitvar, unit)\n+ write(core.unitvar, core.unit)\nmap(write, jaxpr.constvars, consts)\nmap(write, jaxpr.invars, args)\nfor eqn in jaxpr.eqns:\n@@ -2219,7 +2214,8 @@ def _partial_eval_jaxpr(jaxpr, unknowns, instantiate):\n# For jaxpr_known we pass core.unit for the unknown inputs, and known\n# PartialVal for the known inputs.\n- in_avals = [abstract_unit if uk else a for a, uk in zip(jaxpr.in_avals, unknowns)]\n+ in_avals = [core.abstract_unit if uk else a\n+ for a, uk in zip(jaxpr.in_avals, unknowns)]\njaxpr_1, out_avals, consts_1 = trace_to_jaxpr_dynamic(lu.wrap_init(fun), in_avals)\n(out_pvs_2, jaxpr_2, num_res), = cell\nassert len(jaxpr_2.constvars) == num_res\n@@ -2232,7 +2228,7 @@ def _partial_eval_jaxpr(jaxpr, unknowns, instantiate):\njaxpr_2.invars = jaxpr_2.invars[num_res:] + jaxpr_2.invars[:num_res]\nfor var, unknown in zip(jaxpr_2.invars[:len(unknowns)], unknowns):\nif not unknown:\n- var.aval = abstract_unit\n+ var.aval = core.abstract_unit\nuk_out = [pv is not None for pv in out_pvs_2]\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] prevent ad.py from introducing units |
260,335 | 26.04.2022 13:38:53 | 25,200 | 291899b34f037cb9953e0241a58f43cdabf11e83 | fix jax2tf test | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/jax2tf/tests/jax2tf_test.py",
"new_path": "jax/experimental/jax2tf/tests/jax2tf_test.py",
"diff": "@@ -401,7 +401,7 @@ class Jax2TfTest(tf_test_util.JaxToTfTestCase):\nreturn 2 * x + y\ndef g(x): # x: i32\n- return jnp.sum(2. * f(3 * x, 4. * x.astype(\"float32\")))\n+ return jnp.sum(2. * f(3 * x, 4. * jnp.array(x, jnp.dtype(\"float32\"))))\ngrad_g = jax.grad(g, allow_int=True)\nx = 2\n"
}
] | Python | Apache License 2.0 | google/jax | fix jax2tf test |
260,447 | 26.04.2022 13:58:27 | 25,200 | bcfa290c26e7ae0d237965e22c4d12564998ce63 | [sparse] Add BCOO attribute `_indices_sorted`. | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/sparse/bcoo.py",
"new_path": "jax/experimental/sparse/bcoo.py",
"diff": "@@ -116,7 +116,7 @@ class BCOOProperties(NamedTuple):\nclass BCOOInfo(NamedTuple):\nshape: Shape\n-\n+ indices_sorted: bool = False\ndef _validate_bcoo(data: jnp.ndarray, indices: jnp.ndarray, shape: Sequence[int]) -> BCOOProperties:\nprops = _validate_bcoo_indices(indices, shape)\n@@ -263,7 +263,7 @@ def bcoo_fromdense(mat, *, nse=None, n_batch=0, n_dense=0, index_dtype=jnp.int32\nnse = core.concrete_or_error(operator.index, nse, _TRACED_NSE_ERROR)\nreturn BCOO(_bcoo_fromdense(mat, nse=nse, n_batch=n_batch, n_dense=n_dense,\nindex_dtype=index_dtype),\n- shape=mat.shape)\n+ shape=mat.shape, indices_sorted=True)\ndef _bcoo_fromdense(mat, *, nse, n_batch=0, n_dense=0, index_dtype=jnp.int32):\n\"\"\"Create BCOO-format sparse matrix from a dense matrix.\n@@ -800,9 +800,9 @@ def _bcoo_dot_general_gpu_lowering(\nctx, lhs_data, lhs_indices, rhs,\ndimension_numbers=dimension_numbers, lhs_spinfo=lhs_spinfo)\n- (lhs_contract, rhs_contract), (lhs_batch, rhs_batch) = dimension_numbers\n+ (lhs_contract, _), (lhs_batch, rhs_batch) = dimension_numbers\nlhs_data_aval, lhs_indices_aval, rhs_aval, = ctx.avals_in\n- n_batch, n_sparse, n_dense, nse = _validate_bcoo(\n+ n_batch, n_sparse, n_dense, _ = _validate_bcoo(\nlhs_data_aval, lhs_indices_aval, lhs_spinfo.shape)\ndtype = lhs_data_aval.dtype\n@@ -821,16 +821,14 @@ def _bcoo_dot_general_gpu_lowering(\nctx, lhs_data, lhs_indices, rhs,\ndimension_numbers=dimension_numbers, lhs_spinfo=lhs_spinfo)\nelse:\n- # Sorts lhs by row indices.\n- sub_ctx = mlir.LoweringRuleContext(module_context=ctx.module_context,\n- primitive=None,\n- avals_in=ctx.avals_in[:2],\n- avals_out=ctx.avals_in[:2],\n- tokens_in=ctx.tokens_in,\n- tokens_out=ctx.tokens_out)\n-\n- (lhs_data,), (lhs_indices,) = _bcoo_sort_indices_mhlo(\n- sub_ctx, lhs_data, lhs_indices, spinfo=lhs_spinfo)\n+ if not lhs_spinfo.indices_sorted:\n+ warnings.warn(\"bcoo_dot_general GPU lowering requires matrices with \"\n+ \"sorted indices. To sort the rows in your matrix, use e.g. \"\n+ \"mat = mat.sort_indices(). Falling back to the default \"\n+ \"implementation.\", CuSparseEfficiencyWarning)\n+ return _bcoo_dot_general_default_lowering(\n+ ctx, lhs_data, lhs_indices, rhs,\n+ dimension_numbers=dimension_numbers, lhs_spinfo=lhs_spinfo)\nreturn _bcoo_dot_general_cuda_lowering(\nctx, lhs_data, lhs_indices, rhs,\n@@ -1202,7 +1200,7 @@ def bcoo_sort_indices(mat):\nmat_out : BCOO array with sorted indices.\n\"\"\"\ndata, indices = bcoo_sort_indices_p.bind(*mat._bufs, spinfo=mat._info)\n- return BCOO((data, indices), shape=mat.shape)\n+ return BCOO((data, indices), shape=mat.shape, indices_sorted=True)\n@bcoo_sort_indices_p.def_impl\ndef _bcoo_sort_indices_impl(data, indices, *, spinfo):\n@@ -1305,7 +1303,7 @@ def bcoo_sum_duplicates(mat, nse=None):\nmat_out : BCOO array with sorted indices and no duplicate indices.\n\"\"\"\ndata, indices = _bcoo_sum_duplicates(mat.data, mat.indices, spinfo=mat._info, nse=nse)\n- return BCOO((data, indices), shape=mat.shape)\n+ return BCOO((data, indices), shape=mat.shape, indices_sorted=True)\ndef _bcoo_sum_duplicates(data, indices, *, spinfo, nse):\nif nse is not None:\n@@ -1355,6 +1353,7 @@ def _bcoo_sum_duplicates_unbatched(indices, *, shape):\nfill_value = jnp.expand_dims(jnp.array(shape[:props.n_sparse], dtype=indices.dtype), (0,))\nout_of_bounds = (indices >= fill_value).any(-1, keepdims=True)\nindices = jnp.where(out_of_bounds, fill_value, indices)\n+ # TODO: check if `_indices_sorted` is True.\nindices_unique, inv_idx, nse = _unique(\nindices, axis=0, return_inverse=True, return_true_size=True,\nsize=props.nse, fill_value=fill_value)\n@@ -1765,13 +1764,15 @@ class BCOO(JAXSparse):\nn_batch = property(lambda self: self.indices.ndim - 2)\nn_sparse = property(lambda self: self.indices.shape[-1])\nn_dense = property(lambda self: self.data.ndim - 1 - self.n_batch)\n- _info = property(lambda self: BCOOInfo(self.shape))\n+ _info = property(lambda self: BCOOInfo(self.shape, self._indices_sorted))\n_bufs = property(lambda self: (self.data, self.indices))\n+ _indices_sorted: bool\n- def __init__(self, args, *, shape):\n+ def __init__(self, args, *, shape, indices_sorted=False):\n# JAX transforms will sometimes instantiate pytrees with null values, so we\n# must catch that in the initialization of inputs.\nself.data, self.indices = _safe_asarray(args)\n+ self._indices_sorted = indices_sorted\nsuper().__init__(args, shape=shape)\n@classmethod\n@@ -1785,10 +1786,13 @@ class BCOO(JAXSparse):\n\"\"\"Create a BCOO array from a :mod:`scipy.sparse` array.\"\"\"\nif n_dense != 0 or n_batch != 0:\nraise NotImplementedError(\"BCOO.fromscipy with nonzero n_dense/n_batch\")\n+\nmat = mat.tocoo()\ndata = jnp.asarray(mat.data)\n- indices = jnp.column_stack((mat.row, mat.col)).astype(index_dtype or jnp.int32)\n- return cls((data, indices), shape=mat.shape)\n+ indices = jnp.column_stack((mat.row, mat.col)).astype(\n+ index_dtype or jnp.int32)\n+ # TODO: determines sorted indices for scipy conversion.\n+ return cls((data, indices), shape=mat.shape, indices_sorted=False)\n@classmethod\ndef _empty(cls, shape, *, dtype=None, index_dtype='int32', n_dense=0, n_batch=0, nse=0):\n@@ -1800,7 +1804,7 @@ class BCOO(JAXSparse):\nbatch_shape, sparse_shape, dense_shape = split_list(shape, [n_batch, n_sparse])\ndata = jnp.zeros((*batch_shape, nse, *dense_shape), dtype)\nindices = jnp.full((*batch_shape, nse, n_sparse), jnp.array(sparse_shape), index_dtype)\n- return cls((data, indices), shape=shape)\n+ return cls((data, indices), shape=shape, indices_sorted=True)\ndef _unbatch(self):\n\"\"\"Return an unbatched representation of the BCOO matrix.\"\"\"\n@@ -1849,7 +1853,16 @@ class BCOO(JAXSparse):\naxes = np.arange(self.ndim)[::-1] if axes is None else axes\nmat_T = bcoo_transpose(self, permutation=axes)\nshape_T = tuple(self.shape[i] for i in axes)\n- return BCOO((mat_T.data, mat_T.indices), shape=shape_T)\n+ sparse_perm = [p - self.n_batch\n+ for p in axes[self.n_batch: self.n_batch + self.n_sparse]]\n+ if tuple(sparse_perm) == tuple(range(self.n_sparse)):\n+ is_sorted = self._indices_sorted\n+ else:\n+ # TODO: address the corner cases that the transposed indices are sorted.\n+ # possibly use permutation?\n+ is_sorted = False\n+ return BCOO((mat_T.data, mat_T.indices), shape=shape_T,\n+ indices_sorted=is_sorted)\ndef tree_flatten(self):\nreturn (self.data, self.indices), self._info._asdict()\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/sparse_test.py",
"new_path": "tests/sparse_test.py",
"diff": "@@ -742,6 +742,17 @@ class BCOOTest(jtu.JaxTestCase):\nself.assertEqual(j1.shape, data.shape + M.shape)\nself.assertEqual(hess.shape, data.shape + 2 * M.shape)\n+ def test_bcoo_fromdense_indices_sorted(self):\n+ rng = self.rng()\n+ rng_sparse = rand_sparse(rng)\n+ mat = sparse.BCOO.fromdense(rng_sparse((5, 6), np.float32))\n+ perm = rng.permutation(mat.nse)\n+ mat_unsorted = sparse.BCOO((mat.data[perm], mat.indices[perm]),\n+ shape=mat.shape)\n+ mat_resorted = mat_unsorted.sort_indices()\n+ self.assertArraysEqual(mat.indices, mat_resorted.indices)\n+ self.assertArraysEqual(mat.data, mat_resorted.data)\n+\n@parameterized.named_parameters(jtu.cases_from_list(\n{\"testcase_name\": \"_{}_nbatch={}_ndense={}\".format(\njtu.format_shape_dtype_string(shape, dtype), n_batch, n_dense),\n@@ -901,6 +912,22 @@ class BCOOTest(jtu.JaxTestCase):\n# TODO(jakevdp) also test against dense version?\nself.assertAllClose(jf_sparse, jr_sparse, rtol=tol)\n+ def test_bcoo_transpose_indices_sorted(self):\n+ rng = self.rng()\n+ rng_sparse = rand_sparse(rng)\n+ n_batch, n_dense = 2, 2\n+ shape = (2, 3, 4, 5, 6, 7, 8)\n+ mat = sparse.BCOO.fromdense(rng_sparse(shape, np.float32),\n+ n_dense=n_dense, n_batch=n_batch)\n+\n+ permutations = (1, 0, 2, 3, 4, 6, 5)\n+ mat_T_indices_sorted = mat.transpose(axes=permutations)\n+ self.assertTrue(mat_T_indices_sorted._indices_sorted)\n+\n+ permutations = (0, 1, 3, 2, 4, 5, 6)\n+ mat_T_indices_unsorted = mat.transpose(axes=permutations)\n+ self.assertFalse(mat_T_indices_unsorted._indices_sorted)\n+\n@parameterized.named_parameters(jtu.cases_from_list(\n{\"testcase_name\": \"_{}_nbatch={}_ndense={}\".format(\njtu.format_shape_dtype_string(shape, dtype), n_batch, n_dense),\n@@ -953,6 +980,7 @@ class BCOOTest(jtu.JaxTestCase):\n# TODO(jakevdp): In rare cases, this fails python_should_be_executing check. Why?\n# self._CompileAndCheck(f_sparse, args_maker)\n+ @unittest.skipIf(not GPU_LOWERING_ENABLED, \"test requires cusparse/hipsparse\")\n@unittest.skipIf(jtu.device_under_test() != \"gpu\", \"test requires GPU\")\n@parameterized.named_parameters(jtu.cases_from_list(\n{\"testcase_name\":\n@@ -974,6 +1002,7 @@ class BCOOTest(jtu.JaxTestCase):\n[(5, 3), (5, 2), [0], [0]],\n]\nfor dtype in jtu.dtypes.floating + jtu.dtypes.complex))\n+ @jtu.skip_on_devices(\"rocm\") # will be fixed in ROCm-5.1\ndef test_bcoo_dot_general_cusparse(\nself, lhs_shape, rhs_shape, dtype, lhs_contracting, rhs_contracting):\nrng = jtu.rand_small(self.rng())\n@@ -982,84 +1011,77 @@ class BCOOTest(jtu.JaxTestCase):\nlhs = rng_sparse(lhs_shape, dtype)\nrhs = rng(rhs_shape, dtype)\nnse = int(sparse_bcoo._bcoo_nse(lhs, n_batch=0, n_dense=0))\n- data, indices = sparse_bcoo._bcoo_fromdense(lhs, nse=nse, index_dtype=jnp.int32)\n- return data, indices, lhs, rhs\n+ lhs_bcoo = sparse_bcoo.bcoo_fromdense(lhs, nse=nse, index_dtype=jnp.int32)\n+ return lhs_bcoo, lhs, rhs\n+\ndimension_numbers = ((lhs_contracting, rhs_contracting), ([], []))\n- def f_dense(data, indices, lhs, rhs):\n+ def f_dense(lhs_bcoo, lhs, rhs):\nreturn lax.dot_general(lhs, rhs, dimension_numbers=dimension_numbers)\n- def f_sparse(data, indices, lhs, rhs):\n- return sparse_bcoo._bcoo_dot_general(data, indices, rhs,\n- dimension_numbers=dimension_numbers,\n- lhs_spinfo=BCOOInfo(lhs.shape))\n+ def f_sparse(lhs_bcoo, lhs, rhs):\n+ return sparse_bcoo.bcoo_dot_general(lhs_bcoo, rhs,\n+ dimension_numbers=dimension_numbers)\nself._CompileAndCheck(f_sparse, args_maker)\nself._CheckAgainstNumpy(f_dense, f_sparse, args_maker)\n+ @unittest.skipIf(not GPU_LOWERING_ENABLED, \"test requires cusparse/hipsparse\")\n@unittest.skipIf(jtu.device_under_test() != \"gpu\", \"test requires GPU\")\n+ @jtu.skip_on_devices(\"rocm\") # TODO(rocm): see SWDEV-328107\ndef test_bcoo_dot_general_oob_and_unsorted_indices_cusparse(self):\n\"\"\"Tests bcoo dot general with out-of-bound and unsorted indices.\"\"\"\nrhs = jnp.ones((5, 3), dtype=jnp.float32)\n# It creates out-of-bound indices when nse > nnz.\n- lhs_2d_dense = jnp.array([[1, 0, 2, 3, 0], [0, 0, 0, 4, 0]],\n+ lhs_mat_dense = jnp.array([[1, 0, 2, 3, 0], [0, 0, 0, 4, 0]],\ndtype=jnp.float32)\n- lhs_2d_sparse, lhs_sparse_2d_indicdes = sparse_bcoo._bcoo_fromdense(\n- lhs_2d_dense, nse=7)\n-\n- def create_unsorted_indices(data, indices):\n- data_to_shuffle = jnp.hstack((jnp.expand_dims(data, axis=1), indices))\n- key = jax.random.PRNGKey(1701)\n- data_after_shuffle = jax.random.permutation(key, data_to_shuffle)\n- return (data_after_shuffle[:, 0],\n- data_after_shuffle[:, 1:].astype(dtype=jnp.int32))\n-\n- # Random permutate the indices to make them unsorted.\n- lhs_2d_sparse, lhs_sparse_2d_indicdes = create_unsorted_indices(\n- lhs_2d_sparse, lhs_sparse_2d_indicdes)\n+ lhs_mat_bcoo = sparse.BCOO.fromdense(lhs_mat_dense, nse=7)\n+ rng = self.rng()\n+ perm = rng.permutation(lhs_mat_bcoo.nse)\n+ lhs_mat_bcoo_unsorted = sparse.BCOO(\n+ (lhs_mat_bcoo.data[perm], lhs_mat_bcoo.indices[perm]),\n+ shape=lhs_mat_dense.shape)\ndimension_numbers_2d = (([1], [0]), ([], []))\n+ sp_matmat = jit(partial(sparse_bcoo.bcoo_dot_general,\n+ dimension_numbers=dimension_numbers_2d))\n- def args_maker_2d():\n- return lhs_2d_sparse, lhs_sparse_2d_indicdes, lhs_2d_dense, rhs\n+ matmat_expected = lax.dot_general(lhs_mat_dense, rhs,\n+ dimension_numbers=dimension_numbers_2d)\n+ if config.jax_bcoo_cusparse_lowering:\n+ with self.assertWarnsRegex(\n+ sparse.CuSparseEfficiencyWarning,\n+ \"bcoo_dot_general GPU lowering requires matrices with sorted indices*\"):\n+ matmat_unsorted_fallback = sp_matmat(lhs_mat_bcoo_unsorted, rhs)\n- def f_dense_2d(data, indices, lhs, rhs):\n- return lax.dot_general(lhs, rhs, dimension_numbers=dimension_numbers_2d)\n-\n- def f_sparse_2d(data, indices, lhs, rhs):\n- return sparse_bcoo._bcoo_dot_general(data, indices, rhs,\n- dimension_numbers=dimension_numbers_2d,\n- lhs_spinfo=BCOOInfo(lhs.shape))\nwith self.subTest(msg=\"2D\"):\n- self._CompileAndCheck(f_sparse_2d, args_maker_2d)\n- self._CheckAgainstNumpy(f_dense_2d, f_sparse_2d, args_maker_2d)\n-\n- lhs_1d_dense = jnp.array([0, 1, 0, 2, 0], dtype=jnp.float32)\n- lhs_1d_sparse, lhs_sparse_1d_indicdes = sparse_bcoo._bcoo_fromdense(\n- lhs_1d_dense, nse=5)\n+ self.assertArraysEqual(matmat_expected, matmat_unsorted_fallback)\n- # Random permutate the indices to make them unsorted.\n- lhs_1d_sparse, lhs_sparse_1d_indicdes = create_unsorted_indices(\n- lhs_1d_sparse, lhs_sparse_1d_indicdes)\n+ lhs_vec_dense = jnp.array([0, 1, 0, 2, 0], dtype=jnp.float32)\n+ lhs_vec_bcoo = sparse.BCOO.fromdense(lhs_vec_dense, nse=5)\n+ rng = self.rng()\n+ perm = rng.permutation(lhs_vec_bcoo.nse)\n+ lhs_vec_bcoo_unsorted = sparse.BCOO(\n+ (lhs_vec_bcoo.data[perm], lhs_vec_bcoo.indices[perm]),\n+ shape=lhs_vec_dense.shape, indices_sorted=False)\ndimension_numbers_1d = (([0], [0]), ([], []))\n+ sp_vecmat = jit(partial(sparse_bcoo.bcoo_dot_general,\n+ dimension_numbers=dimension_numbers_1d))\n- def args_maker_1d():\n- return lhs_1d_sparse, lhs_sparse_1d_indicdes, lhs_1d_dense, rhs\n-\n- def f_dense_1d(data, indices, lhs, rhs):\n- return lax.dot_general(lhs, rhs, dimension_numbers=dimension_numbers_1d)\n+ vecmat_expected = lax.dot_general(lhs_vec_dense, rhs,\n+ dimension_numbers=dimension_numbers_1d)\n- def f_sparse_1d(data, indices, lhs, rhs):\n- return sparse_bcoo._bcoo_dot_general(data, indices, rhs,\n- dimension_numbers=dimension_numbers_1d,\n- lhs_spinfo=BCOOInfo(lhs.shape))\n+ if config.jax_bcoo_cusparse_lowering:\n+ with self.assertWarnsRegex(\n+ sparse.CuSparseEfficiencyWarning,\n+ \"bcoo_dot_general GPU lowering requires matrices with sorted indices*\"):\n+ vecmat_unsorted_fallback = sp_vecmat(lhs_vec_bcoo_unsorted, rhs)\nwith self.subTest(msg=\"1D\"):\n- self._CompileAndCheck(f_sparse_1d, args_maker_1d)\n- self._CheckAgainstNumpy(f_dense_1d, f_sparse_1d, args_maker_1d)\n+ self.assertArraysEqual(vecmat_expected, vecmat_unsorted_fallback)\n@parameterized.named_parameters(jtu.cases_from_list(\n{\"testcase_name\": props.testcase_name(), \"props\": props}\n@@ -1663,6 +1685,7 @@ class BCOOTest(jtu.JaxTestCase):\nassert mat_sorted_jit.data.shape == data_shape_out\nself.assertArraysEqual(mat.todense(), mat_sorted_jit.todense())\n+\ndef test_bcoo_sum_duplicates_inferred_nse(self):\nx = sparse.BCOO.fromdense(jnp.diag(jnp.arange(4)))\nself.assertEqual(x.nse, 3)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/sparsify_test.py",
"new_path": "tests/sparsify_test.py",
"diff": "@@ -26,6 +26,7 @@ import jax._src.test_util as jtu\nfrom jax.experimental.sparse import BCOO, sparsify, todense, SparseTracer\nfrom jax.experimental.sparse.transform import (\narrays_to_spvalues, spvalues_to_arrays, sparsify_raw, SparsifyValue, SparsifyEnv)\n+from jax.experimental.sparse.util import CuSparseEfficiencyWarning\nconfig.parse_flags_with_absl()\n@@ -125,9 +126,11 @@ class SparsifyTest(jtu.JaxTestCase):\ndef func(x, v):\nreturn -jnp.sin(jnp.pi * x).T @ (v + 1)\n- result_dense = func(M_dense, v)\n+ with jtu.ignore_warning(\n+ category=CuSparseEfficiencyWarning,\n+ message=\"bcoo_dot_general GPU lowering requires matrices with sorted indices*\"):\nresult_sparse = func(M_sparse, v)\n-\n+ result_dense = func(M_dense, v)\nself.assertAllClose(result_sparse, result_dense)\ndef testSparsifyWithConsts(self):\n@@ -149,13 +152,21 @@ class SparsifyTest(jtu.JaxTestCase):\nY = jnp.ones(4)\nYsp = BCOO.fromdense(Y)\n+ func = self.sparsify(operator.matmul)\n+\n# dot_general\n- result_sparse = self.sparsify(operator.matmul)(Xsp, Y)\n+ with jtu.ignore_warning(\n+ category=CuSparseEfficiencyWarning,\n+ message=\"bcoo_dot_general GPU lowering requires matrices with sorted indices*\"):\n+ result_sparse = func(Xsp, Y)\nresult_dense = operator.matmul(X, Y)\nself.assertAllClose(result_sparse, result_dense)\n# rdot_general\n- result_sparse = self.sparsify(operator.matmul)(Y, Xsp)\n+ with jtu.ignore_warning(\n+ category=CuSparseEfficiencyWarning,\n+ message=\"bcoo_dot_general GPU lowering requires matrices with sorted indices*\"):\n+ result_sparse = func(Y, Xsp)\nresult_dense = operator.matmul(Y, X)\nself.assertAllClose(result_sparse, result_dense)\n@@ -353,6 +364,9 @@ class SparsifyTest(jtu.JaxTestCase):\nM_bcoo = BCOO.fromdense(M)\nresult_dense = func(M, x)\n+ with jtu.ignore_warning(\n+ category=CuSparseEfficiencyWarning,\n+ message=\"bcoo_dot_general GPU lowering requires matrices with sorted indices*\"):\nresult_sparse = self.sparsify(func)(M_bcoo, x)\nself.assertArraysAllClose(result_dense, result_sparse)\n"
}
] | Python | Apache License 2.0 | google/jax | [sparse] Add BCOO attribute `_indices_sorted`.
PiperOrigin-RevId: 444659603 |
260,335 | 26.04.2022 16:29:23 | 25,200 | 823ad552d687335b1f0af436f631260ee1826599 | Copybara import of the project:
by Matthew Johnson
[remove-units] prevent scan partial eval from introducing units | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/control_flow.py",
"new_path": "jax/_src/lax/control_flow.py",
"diff": "@@ -1681,143 +1681,119 @@ def _prune_zeros(ts):\ndef _scan_partial_eval(trace, *tracers, reverse, length, num_consts, num_carry,\njaxpr, linear, unroll):\nnum_ys = len(jaxpr.out_avals) - num_carry\n- unknowns = [not t.pval.is_known() for t in tracers]\n+\n+ unknowns = [t.pval[0] is not None for t in tracers]\nconst_uk, init_uk, xs_uk = split_list(unknowns, [num_consts, num_carry])\n- # Fixpoint computation of which carry elements are unknown. Each iteration\n- # promotes at least one carry to unknown. We need at most len(carry)\n- # iterations, but we need one last iteration to prepare the jaxpr based on the\n- # final carry_uk.\n+ # Fixpoint computation of which carry are unknown (not a constant): either\n+ # unknown from init, or the carry out is unknown. Each iteration promotes\n+ # at least one carry to unknown. We need at most len(carry) iterations,\n+ # but we need one last iteration to prepare the jaxpr based on the final\n+ # carry_uk.\ncarry_uk = init_uk\nfor _ in range(1 + len(carry_uk)):\nunknowns = const_uk + carry_uk + xs_uk\n- jaxpr_known, jaxpr_unknown, out_uk, res_avals = pe.partial_eval_jaxpr_nounits(\n+ jaxpr_1, jaxpr_2, out_uk = pe.partial_eval_jaxpr(\njaxpr, unknowns, instantiate=carry_uk + [False] * num_ys)\n- carry_uk_out, ys_uk = split_list(out_uk, [num_carry])\n+ carry_uk_out = out_uk[:num_carry]\nif carry_uk_out == carry_uk:\nbreak\nelse:\ncarry_uk = _map(operator.or_, carry_uk, carry_uk_out)\nelse:\nassert False, \"Fixpoint not reached\"\n- num_res = len(res_avals)\n- del res_avals, carry_uk_out\n-\n- # Instantiate those inputs which must be treated as unknown from the fixpoint.\n- tracers = [trace.instantiate_const(t) if uk else t\n- for t, uk in zip(tracers, unknowns)]\n-\n- # The residual inputs and outputs of the jaxprs produced haven't yet been\n- # adapted to the scan calling convention; in particular, jaxpr_known has its\n- # residual outputs all at the end, meaning they're extensive outputs (which is\n- # fully general but may be wasteful for residuals which are loop-invariant)\n- # while jaxpr_unknown has its corresponding residual inputs at the front (just\n- # as a convention with partial_eval_jaxpr_nounits), making them constant\n- # inputs. To make them consistent, we move the residual inputs on\n- # jaxpr_unknown to the end, even though we may move some back in the sequel.\n- jaxpr_unknown = pe.move_binders_to_back(\n- jaxpr_unknown, [True] * num_res + [False] * sum(unknowns))\n-\n- # At this point, all residuals are treated as extensive outputs of jaxpr_known\n- # (and extensive inputs to jaxpr_unknown). But residuals that are loop-\n- # invariant can be hoisted out of the scan, rather than letting them get\n- # broadcast (as in e.g. scanning multiplication by a constant matrix; we don't\n- # want to broadcast the matrix!). So, outside the loop we perform a partial\n- # evaluation with known 'const' inputs (but all other inputs unknown).\n- const_pvals = [pe.PartialVal.known(t.pval.get_known())\n- for t in tracers[:num_consts] if t.pval.is_known()]\n- other_pvals = [pe.PartialVal.unknown(aval)\n- for aval in jaxpr_known.in_avals[len(const_pvals):]]\n+ num_res = len(jaxpr_1.out_avals) - len(jaxpr_2.out_avals)\n+\n+ # The residuals are treated as extensive outputs of jaxpr_1 (and extensive\n+ # inputs to jaxpr_2), but residuals that are loop-invariant can be hoisted.\n+ # TODO(mattjj): hoist other loop-invariant values here too (instantiate=False)\n+ invariant_pvals = [pe.PartialVal.known(core.unit if uk else t.pval[1])\n+ for uk, t in zip(unknowns[:num_consts], tracers[:num_consts])]\n+ other_pvals = [pe.PartialVal.unknown(a) for a in jaxpr_1.in_avals[num_consts:]]\n+ in_pvals_1 = invariant_pvals + other_pvals\nwith source_info_util.reset_name_stack():\n- jaxpr_known_, invar_pvals_out, jaxpr_known_consts = pe.trace_to_jaxpr_nounits(\n- lu.wrap_init(core.jaxpr_as_fun(jaxpr_known)), const_pvals + other_pvals,\n- instantiate=[True] * (len(out_uk) - sum(out_uk)) + [False] * num_res)\n- jaxpr_known = pe.ClosedJaxpr(pe.convert_constvars_jaxpr(jaxpr_known_), ())\n- # The above trace_to_jaxpr_nounits call computed loop-invariant residuals\n- # (known values in invar_pvals_out) and also computed loop-invariant values\n- # needed by the new jaxpr_known (in jaxpr_known_consts, which replace the\n- # previous consts). We need to collect the computed inteisive residuals, and\n- # move corresponding intensive residual binders in jaxpr_unknown to the front.\n- res_pvals = invar_pvals_out[len(invar_pvals_out) - num_res:]\n- intensive_res = [pval.get_known() for pval in res_pvals if pval.is_known()]\n- jaxpr_unknown = pe.move_binders_to_front(\n- jaxpr_unknown,\n- [False] * sum(unknowns) + [pval.is_known() for pval in res_pvals])\n- del const_pvals, other_pvals, invar_pvals_out, jaxpr_known_, res_pvals\n- # We use `jaxpr_known_consts` when we call scan_p.bind with jaxpr_known, and\n- # we use `intensive_res` when we build the jaxpr eqn with jaxpr_unknown.\n+ jaxpr_1_opt, out_pvals_1, consts_1 = pe.trace_to_jaxpr(\n+ lu.wrap_init(core.jaxpr_as_fun(jaxpr_1)), in_pvals_1,\n+ instantiate=[True] * (num_carry + num_ys) + [False] * num_res)\n+ jaxpr_1_opt = pe.ClosedJaxpr(pe.convert_constvars_jaxpr(jaxpr_1_opt), ())\n+ num_consts_1 = num_consts + len(consts_1)\n+ # any now-known residuals are intensive, so we want to revise jaxpr_2 to take\n+ # those inputs as constants rather than as extensive inputs\n+ _, _, res_pvals = split_list(out_pvals_1, [num_carry, num_ys])\n+ intensive_residuals = [const for pv, const in res_pvals if pv is None]\n+ move = [False] * len(jaxpr_1.in_avals) + [pv is None for pv, _ in res_pvals]\n+ jaxpr_2_opt = pe.move_binders_to_front(jaxpr_2, move)\n+ num_consts_2 = num_consts + len(intensive_residuals)\n# As another optimization, for any extensive inputs that are just forwarded to\n- # extensive outputs, to avoid a copy (which would be looping over\n- # dynamic-update-slice) we'd rather forward the input tracer/value. That means\n- # pruning some outputs from jaxpr_known here, and updating `out_flat` below.\n- fwds_known = pe._jaxpr_forwarding(jaxpr_known.jaxpr)\n- # Prune fwds_known to include only extensive input to extensive output.\n- fwds_known = [in_idx if out_idx >= num_carry - sum(carry_uk) and\n- in_idx is not None and\n- in_idx >= len(jaxpr_known_consts) + num_carry - sum(carry_uk)\n- else None for out_idx, in_idx in enumerate(fwds_known)]\n- # DCE any (extensive) output we can instead get by forwarding an input.\n- jaxpr_known_, kept_inputs = pe.dce_jaxpr(\n- jaxpr_known.jaxpr, [i is None for i in fwds_known])\n- jaxpr_known = core.ClosedJaxpr(jaxpr_known_, ())\n- del jaxpr_known_\n- # We must use `kept_inputs` below when forming the inputs to jaxpr_known, and\n- # we must use `fwds_known` when forming its output.\n-\n- # Run the known part of the scan.\n- known_inputs = (list(jaxpr_known_consts) +\n- [t.pval.get_known() for t in tracers[num_consts:]\n- if t.pval.is_known()])\n- known_inputs_prune = [c for c, kept in zip(known_inputs, kept_inputs) if kept]\n- kept_consts, kept_carry, _ = split_list(kept_inputs, [len(jaxpr_known_consts),\n- num_carry-sum(carry_uk)])\n- linear_known = [False] * len(known_inputs_prune) # conservative!\n- out_known = scan_p.bind(\n- *known_inputs_prune, reverse=reverse, length=length, jaxpr=jaxpr_known,\n- num_consts=sum(kept_consts), num_carry=sum(kept_carry),\n- linear=tuple(linear_known), unroll=unroll)\n- # Complete the known output by filling in forwarded values using fwds_known.\n- out_known_iter = iter(out_known)\n- out_known = [next(out_known_iter) if f is None else _maybe_put(known_inputs[f])\n- for f in fwds_known]\n- assert next(out_known_iter, None) is None\n- del kept_inputs, known_inputs, known_inputs_prune, out_known_iter\n-\n- # Split known outputs from residuals.\n- out_known, extensive_res = split_list(out_known, [len(out_uk) - sum(out_uk)])\n- assert len(intensive_res) + len(extensive_res) == num_res\n-\n- # Create input tracers for jaxpr_unknown bind.\n- unknown_inputs = [t for t in tracers if not t.pval.is_known()]\n- intensive_res = _map(trace.new_instantiated_const, intensive_res)\n- extensive_res = _map(trace.new_instantiated_const, extensive_res)\n- # Create output tracers for jaxpr_unknown bind, adapting extensive shapes.\n- carry_avals, y_avals = split_list(jaxpr_unknown.out_avals, [sum(carry_uk)])\n- ys_avals = [core.unmapped_aval(length, core.no_axis_name, 0, y_aval)\n- for y_aval in y_avals]\n- out_tracers = [pe.JaxprTracer(trace, pe.PartialVal.unknown(a), None)\n- for a in itertools.chain(carry_avals, ys_avals)]\n- del carry_avals, y_avals\n- # Create equation.\n- linear_unknown = tuple([False] * len(intensive_res) +\n- [l for l, uk in zip(linear, unknowns) if uk] +\n- [False] * len(extensive_res))\n+ # extensive outputs, to avoid a copy (looping over dynamic-update-slice) we'd\n+ # rather just forward the input tracer. That means pruning some extensive\n+ # outputs from the jaxpr here, and updating out_flat below.\n+ extensive_invars = jaxpr_1_opt.jaxpr.invars[num_consts_1 + num_carry:]\n+ extensive_outvars = jaxpr_1_opt.jaxpr.outvars[num_carry:]\n+ extensive_avals = [core.unmapped_aval(length, core.no_axis_name, 0,\n+ core.raise_to_shaped(v.aval))\n+ for v in extensive_outvars]\n+ fwd_extensive = [num_consts + num_carry + extensive_invars.index(v)\n+ if v in extensive_invars else None for v in extensive_outvars]\n+ jaxpr_1_opt.jaxpr.outvars = (\n+ jaxpr_1_opt.jaxpr.outvars[:num_carry] +\n+ [v for i, v in zip(fwd_extensive, extensive_outvars) if i is None])\n+\n+ in_consts = (list(consts_1) + [core.unit] * num_consts +\n+ [core.unit if uk else t.pval[1]\n+ for uk, t in zip(unknowns[num_consts:], tracers[num_consts:])])\n+ linear_1 = ([False] * len(consts_1) + [True] * num_consts +\n+ [lin or uk for uk, lin\n+ in zip(unknowns[num_consts:], linear[num_consts:])])\n+ out_flat = scan_p.bind(\n+ *in_consts, reverse=reverse, length=length, jaxpr=jaxpr_1_opt,\n+ num_consts=num_consts_1, num_carry=num_carry, linear=tuple(linear_1),\n+ unroll=unroll)\n+\n+ # Propagate the forwarded extensive outputs using fwd_extensive. Any\n+ # numpy.ndarray inputs should be converted to JAX DeviceArrays.\n+ out_carry, out_extensive = split_list(out_flat, [num_carry])\n+ out_extensive_iter = iter(out_extensive)\n+ out_extensive = [next(out_extensive_iter) if i is None\n+ else _maybe_device_put(tracers[i].pval[1]) if tracers[i].is_known()\n+ else tracers[i] for i in fwd_extensive]\n+ assert all(core.typematch(a, core.get_aval(out))\n+ for a, out in zip(extensive_avals, out_extensive))\n+ out_flat = out_carry + out_extensive\n+\n+ out_carry, ys, res_and_units = split_list(out_flat, [num_carry, num_ys])\n+ extensive_residuals = [r for r, (pv, _) in zip(res_and_units, res_pvals) if pv is not None]\n+\n+ new_tracers = [trace.instantiate_const(t) if uk else trace.new_instantiated_literal(core.unit)\n+ for uk, t in zip(unknowns, tracers)]\n+ carry_avals, y_avals = split_list(jaxpr.out_avals, [num_carry])\n+ ys_avals = _map(partial(_prepend_dim_to_aval, length), y_avals)\n+ out_avals = carry_avals + ys_avals\n+ out_pvs = [aval if uk else None for aval, uk in zip(out_avals, out_uk)]\n+\n+ out_consts = out_carry + ys\n+ int_res_tracers = _map(trace.new_instantiated_const, intensive_residuals)\n+ ext_res_tracers = _map(trace.new_instantiated_const, extensive_residuals)\n+ out_tracers = [pe.JaxprTracer(trace, pe.PartialVal((pv, const)), None)\n+ for pv, const in zip(out_pvs, out_consts)]\nname_stack = source_info_util.current_name_stack()[len(trace.name_stack):]\nsource = source_info_util.current().replace(name_stack=name_stack)\n- eqn = pe.new_eqn_recipe([*intensive_res, *unknown_inputs, *extensive_res],\n+ linear_2 = ([False] * len(int_res_tracers) +\n+ [lin or not uk for uk, lin in zip(unknowns, linear)] +\n+ [False] * len(ext_res_tracers))\n+ eqn = pe.new_eqn_recipe(int_res_tracers + new_tracers + ext_res_tracers,\nout_tracers, scan_p,\n- dict(reverse=reverse, length=length, unroll=unroll,\n- jaxpr=jaxpr_unknown, linear=linear_unknown,\n- num_consts=len(intensive_res) + sum(const_uk),\n- num_carry=sum(carry_uk)),\n- jaxpr_unknown.effects, source)\n+ dict(reverse=reverse, length=length, jaxpr=jaxpr_2_opt,\n+ num_consts=num_consts_2,\n+ num_carry=num_carry, linear=tuple(linear_2),\n+ unroll=unroll),\n+ jaxpr_2_opt.effects,\n+ source)\nfor t in out_tracers: t.recipe = eqn\n+ return out_tracers\n- # Merge known and unknown outputs into final result.\n- return util.merge_lists(out_uk, out_known, out_tracers)\n-\n-def _maybe_put(x):\n+def _maybe_device_put(x):\nif isinstance(x, np.ndarray):\nreturn jax.device_put(x, jax.devices('cpu')[0])\nelse:\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "# 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-from __future__ import annotations\nfrom collections import namedtuple\nimport contextlib\n@@ -79,11 +78,11 @@ class PartialVal(tuple):\nreturn tuple.__new__(cls, xs)\n@classmethod\n- def known(cls, const: core.Value) -> PartialVal:\n+ def known(cls, const: core.Value) -> 'PartialVal':\nreturn PartialVal((None, const))\n@classmethod\n- def unknown(cls, aval: AbstractValue) -> PartialVal:\n+ def unknown(cls, aval: AbstractValue) -> 'PartialVal':\nreturn PartialVal((aval, core.unit))\ndef is_known(self) -> bool:\n@@ -108,29 +107,29 @@ class JaxprTrace(Trace):\nsuper().__init__(*args)\nself.name_stack = name_stack\n- def pure(self, val) -> JaxprTracer:\n+ def pure(self, val) -> 'JaxprTracer':\nreturn self.new_const(val)\n- def lift(self, val) -> JaxprTracer:\n+ def lift(self, val) -> 'JaxprTracer':\nreturn self.new_const(val)\n- def sublift(self, val) -> JaxprTracer:\n+ def sublift(self, val) -> 'JaxprTracer':\nreturn JaxprTracer(self, val.pval, FreeVar(val))\n- def new_const(self, val) -> JaxprTracer:\n+ def new_const(self, val) -> 'JaxprTracer':\nif isinstance(val, Tracer) and val._trace.level == self.level:\nraise Exception\nreturn JaxprTracer(self, PartialVal.known(val), core.unit)\n- def new_instantiated_literal(self, val) -> JaxprTracer:\n+ def new_instantiated_literal(self, val) -> 'JaxprTracer':\naval = get_aval(val)\nreturn JaxprTracer(self, PartialVal.unknown(aval),\nLiteral(val, raise_to_shaped(aval)))\n- def new_instantiated_const(self, val) -> JaxprTracer:\n+ def new_instantiated_const(self, val) -> 'JaxprTracer':\nreturn JaxprTracer(self, PartialVal.unknown(get_aval(val)), ConstVar(val))\n- def new_arg(self, pval: PartialVal) -> JaxprTracer:\n+ def new_arg(self, pval: PartialVal) -> 'JaxprTracer':\nconst = pval.get_known()\n# XXX: Think twice before changing this constant argument pruning!\n# This has really important consequences for partial_eval_jaxpr.\n@@ -151,7 +150,7 @@ class JaxprTrace(Trace):\nelse:\nreturn self.new_instantiated_const(const)\n- def instantiate_const_abstracted(self, tracer) -> JaxprTracer:\n+ def instantiate_const_abstracted(self, tracer) -> 'JaxprTracer':\nconst = tracer.pval.get_known()\nif const is None:\nreturn tracer\n@@ -166,9 +165,8 @@ class JaxprTrace(Trace):\nreturn self.default_process_primitive(primitive, tracers, params)\ndef default_process_primitive(self, primitive, tracers, params):\n- # By default, if all the input tracers are known, then bind the primitive\n- # and consider all outputs known. Otherwise, stage the application into the\n- # jaxpr and consider all outputs unknown.\n+ \"\"\"By default, if all the input tracers are known, then execute the primitive\n+ and all the outputs are known. Otherwise, all the outputs are unknown.\"\"\"\nconsts = [t.pval.get_known() for t in tracers]\nif all(c is not None for c in consts):\nreturn primitive.bind(*consts, **params)\n@@ -553,7 +551,7 @@ class JaxprTracer(Tracer):\nreturn self.pval.get_aval()\n@property\n- def parents(self) -> Sequence[JaxprTracer]:\n+ def parents(self) -> Sequence['JaxprTracer']:\nif isinstance(self.recipe, JaxprEqnRecipe):\nreturn self.recipe.invars\nelse:\n@@ -658,7 +656,7 @@ LambdaBinding = namedtuple('LambdaBinding', [])\nclass JaxprEqnRecipe(NamedTuple):\neqn_id: object\ninvars: Sequence[JaxprTracer]\n- outvars: Sequence[ref[JaxprTracer]]\n+ outvars: 'Sequence[ref[JaxprTracer]]'\nprimitive: Primitive\nparams: Dict[str, Any]\neffects: core.Effects\n@@ -671,6 +669,14 @@ def new_eqn_recipe(invars: Sequence[JaxprTracer],\neffects: core.Effects,\nsource_info: source_info_util.SourceInfo\n) -> JaxprEqnRecipe:\n+ \"\"\"Constructs a new JaxEqnRecipe.\n+\n+ Params:\n+ invars: the tracers for the primitive inputs.\n+ outvars: the tracers for the primitive outputs.\n+ primitive: the primitive.\n+ params: the primitive params\n+ \"\"\"\n# TODO(necula): move these checks to core.check_jaxpr, and call in more places\nif primitive.call_primitive or primitive.map_primitive:\nassert \"call_jaxpr\" in params\n@@ -890,10 +896,8 @@ def _partial_eval_jaxpr_nounits(jaxpr, in_unknowns, instantiate):\nassert ([v.aval for v in jaxpr_unknown.invars] ==\nres_avals + [a for a, uk in zip(jaxpr.in_avals, in_unknowns) if uk])\n# check jaxpr_unknown has output type corresponding to unknown outputs\n- # TODO(mattjj): enable weak type checking here\n- assert ([v.aval.strip_weak_type() for v in jaxpr_unknown.outvars] ==\n- [a.strip_weak_type() for a, uk in zip(jaxpr.out_avals, out_unknowns)\n- if uk])\n+ assert ([v.aval for v in jaxpr_unknown.outvars] ==\n+ [a for a, uk in zip(jaxpr.out_avals, out_unknowns) if uk])\nclosed_jaxpr_known = ClosedJaxpr(jaxpr_known, consts_known)\nclosed_jaxpr_unknown = ClosedJaxpr(jaxpr_unknown, ())\n@@ -1160,21 +1164,6 @@ partial_eval_jaxpr_custom_rules[remat_call_p] = \\\nlambda _, __, ___, ____, p1, p2: (p1, dict(p2, differentiated=True)))\n-def _jaxpr_forwarding(jaxpr: Jaxpr) -> List[Optional[int]]:\n- # Compute which inputs are just forwarded to outputs.\n- fwds: Dict[Var, Var] = dict(zip(jaxpr.invars, jaxpr.invars))\n- for eqn in jaxpr.eqns:\n- if eqn.primitive in forwarding_rules:\n- eqn = eqn.replace(invars=[fwds.get(v, v) for v in eqn.invars]) # type: ignore\n- fwd_vars, _ = forwarding_rules[eqn.primitive](eqn)\n- for v_orig, v_new in zip(eqn.outvars, fwd_vars):\n- if v_new is not None:\n- fwds[v_orig] = v_new\n- idxs: Dict[Var, int] = {v: i for i, v in enumerate(jaxpr.invars)}\n- return [None if type(v) is Literal else idxs.get(fwds.get(v)) # type: ignore\n- for v in jaxpr.outvars]\n-\n-\n# TODO(mattjj): unify with dce code below\ndef dce_jaxpr(jaxpr: Jaxpr, used_outputs: List[bool]\n) -> Tuple[Jaxpr, List[bool]]:\n@@ -1281,9 +1270,8 @@ def _reconstruct_pval(pval1: PartialVal, const2: core.Value):\nreturn PartialVal.known(const2)\n-def move_binders_to_front(closed_jaxpr: ClosedJaxpr, to_move: Sequence[bool]\n- ) -> ClosedJaxpr:\n- \"\"\"Reorder `invars` by moving those indicated in `to_move` to the front.\"\"\"\n+def move_binders_to_front(closed_jaxpr: ClosedJaxpr, to_move: Sequence[bool]) -> ClosedJaxpr:\n+ \"\"\"Reorder the `invars` to move to front the ones for which `to_move` is True.\"\"\"\nassert len(closed_jaxpr.in_avals) == len(to_move)\nnew_invars = _move_to_front(closed_jaxpr.jaxpr.invars, to_move)\nnew_jaxpr = Jaxpr(closed_jaxpr.jaxpr.constvars, new_invars,\n@@ -1296,10 +1284,6 @@ def _move_to_front(lst: Sequence, to_move: Sequence[bool]) -> Sequence:\nreturn ([elt for elt, move in zip(lst, to_move) if move] +\n[elt for elt, move in zip(lst, to_move) if not move])\n-def move_binders_to_back(closed_jaxpr: ClosedJaxpr, to_move: Sequence[bool]\n- ) -> ClosedJaxpr:\n- \"\"\"Reorder `invars` by moving those indicated in `to_move` to the back.\"\"\"\n- return move_binders_to_front(closed_jaxpr, map(op.not_, to_move))\nclass DynamicJaxprTracer(core.Tracer):\n__slots__ = ['aval']\n"
}
] | Python | Apache License 2.0 | google/jax | Copybara import of the project:
--
4680b86ff7f468429a0820b4f8c7f64ffd1a1cad by Matthew Johnson <mattjj@google.com>:
[remove-units] prevent scan partial eval from introducing units
PiperOrigin-RevId: 444698613 |
260,335 | 26.04.2022 20:34:14 | 25,200 | ebbad07ce7e2918729c720060b9558b7a7a6a780 | [remove-units] roll forward fix dce bug | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/control_flow.py",
"new_path": "jax/_src/lax/control_flow.py",
"diff": "@@ -1681,119 +1681,141 @@ def _prune_zeros(ts):\ndef _scan_partial_eval(trace, *tracers, reverse, length, num_consts, num_carry,\njaxpr, linear, unroll):\nnum_ys = len(jaxpr.out_avals) - num_carry\n-\n- unknowns = [t.pval[0] is not None for t in tracers]\n+ unknowns = [not t.pval.is_known() for t in tracers]\nconst_uk, init_uk, xs_uk = split_list(unknowns, [num_consts, num_carry])\n- # Fixpoint computation of which carry are unknown (not a constant): either\n- # unknown from init, or the carry out is unknown. Each iteration promotes\n- # at least one carry to unknown. We need at most len(carry) iterations,\n- # but we need one last iteration to prepare the jaxpr based on the final\n- # carry_uk.\n+ # Fixpoint computation of which carry elements are unknown. Each iteration\n+ # promotes at least one carry to unknown. We need at most len(carry)\n+ # iterations, but we need one last iteration to prepare the jaxpr based on the\n+ # final carry_uk.\ncarry_uk = init_uk\nfor _ in range(1 + len(carry_uk)):\nunknowns = const_uk + carry_uk + xs_uk\n- jaxpr_1, jaxpr_2, out_uk = pe.partial_eval_jaxpr(\n+ jaxpr_known, jaxpr_unknown, out_uk, res_avals = pe.partial_eval_jaxpr_nounits(\njaxpr, unknowns, instantiate=carry_uk + [False] * num_ys)\n- carry_uk_out = out_uk[:num_carry]\n+ carry_uk_out, ys_uk = split_list(out_uk, [num_carry])\nif carry_uk_out == carry_uk:\nbreak\nelse:\ncarry_uk = _map(operator.or_, carry_uk, carry_uk_out)\nelse:\nassert False, \"Fixpoint not reached\"\n- num_res = len(jaxpr_1.out_avals) - len(jaxpr_2.out_avals)\n-\n- # The residuals are treated as extensive outputs of jaxpr_1 (and extensive\n- # inputs to jaxpr_2), but residuals that are loop-invariant can be hoisted.\n- # TODO(mattjj): hoist other loop-invariant values here too (instantiate=False)\n- invariant_pvals = [pe.PartialVal.known(core.unit if uk else t.pval[1])\n- for uk, t in zip(unknowns[:num_consts], tracers[:num_consts])]\n- other_pvals = [pe.PartialVal.unknown(a) for a in jaxpr_1.in_avals[num_consts:]]\n- in_pvals_1 = invariant_pvals + other_pvals\n+ num_res = len(res_avals)\n+ del res_avals, carry_uk_out\n+\n+ # Instantiate those inputs which must be treated as unknown from the fixpoint.\n+ tracers = [trace.instantiate_const(t) if uk else t\n+ for t, uk in zip(tracers, unknowns)]\n+\n+ # The residual inputs and outputs of the jaxprs produced haven't yet been\n+ # adapted to the scan calling convention; in particular, jaxpr_known has its\n+ # residual outputs all at the end, meaning they're extensive outputs (which is\n+ # fully general but may be wasteful for residuals which are loop-invariant)\n+ # while jaxpr_unknown has its corresponding residual inputs at the front (just\n+ # as a convention with partial_eval_jaxpr_nounits), making them constant\n+ # inputs. To make them consistent, we move the residual inputs on\n+ # jaxpr_unknown to the end, even though we may move some back in the sequel.\n+ jaxpr_unknown = pe.move_binders_to_back(\n+ jaxpr_unknown, [True] * num_res + [False] * sum(unknowns))\n+\n+ # At this point, all residuals are treated as extensive outputs of jaxpr_known\n+ # (and extensive inputs to jaxpr_unknown). But residuals that are loop-\n+ # invariant can be hoisted out of the scan, rather than letting them get\n+ # broadcast (as in e.g. scanning multiplication by a constant matrix; we don't\n+ # want to broadcast the matrix!). So, outside the loop we perform a partial\n+ # evaluation with known 'const' inputs (but all other inputs unknown).\n+ const_pvals = [pe.PartialVal.known(t.pval.get_known())\n+ for t in tracers[:num_consts] if t.pval.is_known()]\n+ other_pvals = [pe.PartialVal.unknown(aval)\n+ for aval in jaxpr_known.in_avals[len(const_pvals):]]\nwith source_info_util.reset_name_stack():\n- jaxpr_1_opt, out_pvals_1, consts_1 = pe.trace_to_jaxpr(\n- lu.wrap_init(core.jaxpr_as_fun(jaxpr_1)), in_pvals_1,\n- instantiate=[True] * (num_carry + num_ys) + [False] * num_res)\n- jaxpr_1_opt = pe.ClosedJaxpr(pe.convert_constvars_jaxpr(jaxpr_1_opt), ())\n- num_consts_1 = num_consts + len(consts_1)\n- # any now-known residuals are intensive, so we want to revise jaxpr_2 to take\n- # those inputs as constants rather than as extensive inputs\n- _, _, res_pvals = split_list(out_pvals_1, [num_carry, num_ys])\n- intensive_residuals = [const for pv, const in res_pvals if pv is None]\n- move = [False] * len(jaxpr_1.in_avals) + [pv is None for pv, _ in res_pvals]\n- jaxpr_2_opt = pe.move_binders_to_front(jaxpr_2, move)\n- num_consts_2 = num_consts + len(intensive_residuals)\n+ jaxpr_known_, invar_pvals_out, jaxpr_known_consts = pe.trace_to_jaxpr_nounits(\n+ lu.wrap_init(core.jaxpr_as_fun(jaxpr_known)), const_pvals + other_pvals,\n+ instantiate=[True] * (len(out_uk) - sum(out_uk)) + [False] * num_res)\n+ jaxpr_known = pe.ClosedJaxpr(pe.convert_constvars_jaxpr(jaxpr_known_), ())\n+ # The above trace_to_jaxpr_nounits call computed loop-invariant residuals\n+ # (known values in invar_pvals_out) and also computed loop-invariant values\n+ # needed by the new jaxpr_known (in jaxpr_known_consts, which replace the\n+ # previous consts). We need to collect the computed inteisive residuals, and\n+ # move corresponding intensive residual binders in jaxpr_unknown to the front.\n+ res_pvals = invar_pvals_out[len(invar_pvals_out) - num_res:]\n+ intensive_res = [pval.get_known() for pval in res_pvals if pval.is_known()]\n+ jaxpr_unknown = pe.move_binders_to_front(\n+ jaxpr_unknown,\n+ [False] * sum(unknowns) + [pval.is_known() for pval in res_pvals])\n+ del const_pvals, other_pvals, invar_pvals_out, jaxpr_known_, res_pvals\n+ # We use `jaxpr_known_consts` when we call scan_p.bind with jaxpr_known, and\n+ # we use `intensive_res` when we build the jaxpr eqn with jaxpr_unknown.\n# As another optimization, for any extensive inputs that are just forwarded to\n- # extensive outputs, to avoid a copy (looping over dynamic-update-slice) we'd\n- # rather just forward the input tracer. That means pruning some extensive\n- # outputs from the jaxpr here, and updating out_flat below.\n- extensive_invars = jaxpr_1_opt.jaxpr.invars[num_consts_1 + num_carry:]\n- extensive_outvars = jaxpr_1_opt.jaxpr.outvars[num_carry:]\n- extensive_avals = [core.unmapped_aval(length, core.no_axis_name, 0,\n- core.raise_to_shaped(v.aval))\n- for v in extensive_outvars]\n- fwd_extensive = [num_consts + num_carry + extensive_invars.index(v)\n- if v in extensive_invars else None for v in extensive_outvars]\n- jaxpr_1_opt.jaxpr.outvars = (\n- jaxpr_1_opt.jaxpr.outvars[:num_carry] +\n- [v for i, v in zip(fwd_extensive, extensive_outvars) if i is None])\n-\n- in_consts = (list(consts_1) + [core.unit] * num_consts +\n- [core.unit if uk else t.pval[1]\n- for uk, t in zip(unknowns[num_consts:], tracers[num_consts:])])\n- linear_1 = ([False] * len(consts_1) + [True] * num_consts +\n- [lin or uk for uk, lin\n- in zip(unknowns[num_consts:], linear[num_consts:])])\n- out_flat = scan_p.bind(\n- *in_consts, reverse=reverse, length=length, jaxpr=jaxpr_1_opt,\n- num_consts=num_consts_1, num_carry=num_carry, linear=tuple(linear_1),\n- unroll=unroll)\n-\n- # Propagate the forwarded extensive outputs using fwd_extensive. Any\n- # numpy.ndarray inputs should be converted to JAX DeviceArrays.\n- out_carry, out_extensive = split_list(out_flat, [num_carry])\n- out_extensive_iter = iter(out_extensive)\n- out_extensive = [next(out_extensive_iter) if i is None\n- else _maybe_device_put(tracers[i].pval[1]) if tracers[i].is_known()\n- else tracers[i] for i in fwd_extensive]\n- assert all(core.typematch(a, core.get_aval(out))\n- for a, out in zip(extensive_avals, out_extensive))\n- out_flat = out_carry + out_extensive\n-\n- out_carry, ys, res_and_units = split_list(out_flat, [num_carry, num_ys])\n- extensive_residuals = [r for r, (pv, _) in zip(res_and_units, res_pvals) if pv is not None]\n-\n- new_tracers = [trace.instantiate_const(t) if uk else trace.new_instantiated_literal(core.unit)\n- for uk, t in zip(unknowns, tracers)]\n- carry_avals, y_avals = split_list(jaxpr.out_avals, [num_carry])\n- ys_avals = _map(partial(_prepend_dim_to_aval, length), y_avals)\n- out_avals = carry_avals + ys_avals\n- out_pvs = [aval if uk else None for aval, uk in zip(out_avals, out_uk)]\n-\n- out_consts = out_carry + ys\n- int_res_tracers = _map(trace.new_instantiated_const, intensive_residuals)\n- ext_res_tracers = _map(trace.new_instantiated_const, extensive_residuals)\n- out_tracers = [pe.JaxprTracer(trace, pe.PartialVal((pv, const)), None)\n- for pv, const in zip(out_pvs, out_consts)]\n+ # extensive outputs, to avoid a copy (which would be looping over\n+ # dynamic-update-slice) we'd rather forward the input tracer/value. That means\n+ # pruning some outputs from jaxpr_known here, and updating `out_flat` below.\n+ fwds_known = pe._jaxpr_forwarding(jaxpr_known.jaxpr)\n+ # Prune fwds_known to include only extensive input to extensive output.\n+ fwds_known = [in_idx if out_idx >= num_carry - sum(carry_uk) and\n+ in_idx is not None and\n+ in_idx >= len(jaxpr_known_consts) + num_carry - sum(carry_uk)\n+ else None for out_idx, in_idx in enumerate(fwds_known)]\n+ # Drop any extensive output we can instead get by forwarding an input.\n+ # TODO(mattjj): use pe.dce_jaxpr here, though need a fixpoint\n+ jaxpr_known_, () = jaxpr_known.jaxpr, jaxpr_known.consts\n+ jaxpr_known_.outvars = [x for x, i in zip(jaxpr_known_.outvars, fwds_known)\n+ if i is None]\n+ jaxpr_known = core.ClosedJaxpr(jaxpr_known_, ())\n+ del jaxpr_known_\n+ # We use `fwds_known` below when forming the output of scanning jaxpr_known.\n+\n+ # Run the known part of the scan.\n+ known_inputs = (list(jaxpr_known_consts) +\n+ [t.pval.get_known() for t in tracers[num_consts:]\n+ if t.pval.is_known()])\n+ linear_known = [False] * len(known_inputs) # conservative!\n+ out_known = scan_p.bind(\n+ *known_inputs, reverse=reverse, length=length, jaxpr=jaxpr_known,\n+ num_consts=len(jaxpr_known_consts), num_carry=num_carry - sum(carry_uk),\n+ linear=tuple(linear_known), unroll=unroll)\n+ # Complete the known output by filling in forwarded values using fwds_known.\n+ out_known_iter = iter(out_known)\n+ out_known = [next(out_known_iter) if f is None else _maybe_put(known_inputs[f])\n+ for f in fwds_known]\n+ assert next(out_known_iter, None) is None\n+ del known_inputs, out_known_iter, linear_known\n+\n+ # Split known outputs from residuals.\n+ out_known, extensive_res = split_list(out_known, [len(out_uk) - sum(out_uk)])\n+ assert len(intensive_res) + len(extensive_res) == num_res\n+\n+ # Create input tracers for jaxpr_unknown bind.\n+ unknown_inputs = [t for t in tracers if not t.pval.is_known()]\n+ intensive_res = _map(trace.new_instantiated_const, intensive_res)\n+ extensive_res = _map(trace.new_instantiated_const, extensive_res)\n+ # Create output tracers for jaxpr_unknown bind, adapting extensive shapes.\n+ carry_avals, y_avals = split_list(jaxpr_unknown.out_avals, [sum(carry_uk)])\n+ ys_avals = [core.unmapped_aval(length, core.no_axis_name, 0, y_aval)\n+ for y_aval in y_avals]\n+ out_tracers = [pe.JaxprTracer(trace, pe.PartialVal.unknown(a), None)\n+ for a in itertools.chain(carry_avals, ys_avals)]\n+ del carry_avals, y_avals\n+ # Create equation.\n+ linear_unknown = tuple([False] * len(intensive_res) +\n+ [l for l, uk in zip(linear, unknowns) if uk] +\n+ [False] * len(extensive_res))\nname_stack = source_info_util.current_name_stack()[len(trace.name_stack):]\nsource = source_info_util.current().replace(name_stack=name_stack)\n- linear_2 = ([False] * len(int_res_tracers) +\n- [lin or not uk for uk, lin in zip(unknowns, linear)] +\n- [False] * len(ext_res_tracers))\n- eqn = pe.new_eqn_recipe(int_res_tracers + new_tracers + ext_res_tracers,\n+ eqn = pe.new_eqn_recipe([*intensive_res, *unknown_inputs, *extensive_res],\nout_tracers, scan_p,\n- dict(reverse=reverse, length=length, jaxpr=jaxpr_2_opt,\n- num_consts=num_consts_2,\n- num_carry=num_carry, linear=tuple(linear_2),\n- unroll=unroll),\n- jaxpr_2_opt.effects,\n- source)\n+ dict(reverse=reverse, length=length, unroll=unroll,\n+ jaxpr=jaxpr_unknown, linear=linear_unknown,\n+ num_consts=len(intensive_res) + sum(const_uk),\n+ num_carry=sum(carry_uk)),\n+ jaxpr_unknown.effects, source)\nfor t in out_tracers: t.recipe = eqn\n- return out_tracers\n-def _maybe_device_put(x):\n+ # Merge known and unknown outputs into final result.\n+ return util.merge_lists(out_uk, out_known, out_tracers)\n+\n+def _maybe_put(x):\nif isinstance(x, np.ndarray):\nreturn jax.device_put(x, jax.devices('cpu')[0])\nelse:\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "# 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+from __future__ import annotations\nfrom collections import namedtuple\nimport contextlib\n@@ -78,11 +79,11 @@ class PartialVal(tuple):\nreturn tuple.__new__(cls, xs)\n@classmethod\n- def known(cls, const: core.Value) -> 'PartialVal':\n+ def known(cls, const: core.Value) -> PartialVal:\nreturn PartialVal((None, const))\n@classmethod\n- def unknown(cls, aval: AbstractValue) -> 'PartialVal':\n+ def unknown(cls, aval: AbstractValue) -> PartialVal:\nreturn PartialVal((aval, core.unit))\ndef is_known(self) -> bool:\n@@ -107,29 +108,29 @@ class JaxprTrace(Trace):\nsuper().__init__(*args)\nself.name_stack = name_stack\n- def pure(self, val) -> 'JaxprTracer':\n+ def pure(self, val) -> JaxprTracer:\nreturn self.new_const(val)\n- def lift(self, val) -> 'JaxprTracer':\n+ def lift(self, val) -> JaxprTracer:\nreturn self.new_const(val)\n- def sublift(self, val) -> 'JaxprTracer':\n+ def sublift(self, val) -> JaxprTracer:\nreturn JaxprTracer(self, val.pval, FreeVar(val))\n- def new_const(self, val) -> 'JaxprTracer':\n+ def new_const(self, val) -> JaxprTracer:\nif isinstance(val, Tracer) and val._trace.level == self.level:\nraise Exception\nreturn JaxprTracer(self, PartialVal.known(val), core.unit)\n- def new_instantiated_literal(self, val) -> 'JaxprTracer':\n+ def new_instantiated_literal(self, val) -> JaxprTracer:\naval = get_aval(val)\nreturn JaxprTracer(self, PartialVal.unknown(aval),\nLiteral(val, raise_to_shaped(aval)))\n- def new_instantiated_const(self, val) -> 'JaxprTracer':\n+ def new_instantiated_const(self, val) -> JaxprTracer:\nreturn JaxprTracer(self, PartialVal.unknown(get_aval(val)), ConstVar(val))\n- def new_arg(self, pval: PartialVal) -> 'JaxprTracer':\n+ def new_arg(self, pval: PartialVal) -> JaxprTracer:\nconst = pval.get_known()\n# XXX: Think twice before changing this constant argument pruning!\n# This has really important consequences for partial_eval_jaxpr.\n@@ -150,7 +151,7 @@ class JaxprTrace(Trace):\nelse:\nreturn self.new_instantiated_const(const)\n- def instantiate_const_abstracted(self, tracer) -> 'JaxprTracer':\n+ def instantiate_const_abstracted(self, tracer) -> JaxprTracer:\nconst = tracer.pval.get_known()\nif const is None:\nreturn tracer\n@@ -165,8 +166,9 @@ class JaxprTrace(Trace):\nreturn self.default_process_primitive(primitive, tracers, params)\ndef default_process_primitive(self, primitive, tracers, params):\n- \"\"\"By default, if all the input tracers are known, then execute the primitive\n- and all the outputs are known. Otherwise, all the outputs are unknown.\"\"\"\n+ # By default, if all the input tracers are known, then bind the primitive\n+ # and consider all outputs known. Otherwise, stage the application into the\n+ # jaxpr and consider all outputs unknown.\nconsts = [t.pval.get_known() for t in tracers]\nif all(c is not None for c in consts):\nreturn primitive.bind(*consts, **params)\n@@ -551,7 +553,7 @@ class JaxprTracer(Tracer):\nreturn self.pval.get_aval()\n@property\n- def parents(self) -> Sequence['JaxprTracer']:\n+ def parents(self) -> Sequence[JaxprTracer]:\nif isinstance(self.recipe, JaxprEqnRecipe):\nreturn self.recipe.invars\nelse:\n@@ -656,7 +658,7 @@ LambdaBinding = namedtuple('LambdaBinding', [])\nclass JaxprEqnRecipe(NamedTuple):\neqn_id: object\ninvars: Sequence[JaxprTracer]\n- outvars: 'Sequence[ref[JaxprTracer]]'\n+ outvars: Sequence[ref[JaxprTracer]]\nprimitive: Primitive\nparams: Dict[str, Any]\neffects: core.Effects\n@@ -896,8 +898,10 @@ def _partial_eval_jaxpr_nounits(jaxpr, in_unknowns, instantiate):\nassert ([v.aval for v in jaxpr_unknown.invars] ==\nres_avals + [a for a, uk in zip(jaxpr.in_avals, in_unknowns) if uk])\n# check jaxpr_unknown has output type corresponding to unknown outputs\n- assert ([v.aval for v in jaxpr_unknown.outvars] ==\n- [a for a, uk in zip(jaxpr.out_avals, out_unknowns) if uk])\n+ # TODO(mattjj): enable weak type checking here\n+ assert ([v.aval.strip_weak_type() for v in jaxpr_unknown.outvars] ==\n+ [a.strip_weak_type() for a, uk in zip(jaxpr.out_avals, out_unknowns)\n+ if uk])\nclosed_jaxpr_known = ClosedJaxpr(jaxpr_known, consts_known)\nclosed_jaxpr_unknown = ClosedJaxpr(jaxpr_unknown, ())\n@@ -1164,6 +1168,21 @@ partial_eval_jaxpr_custom_rules[remat_call_p] = \\\nlambda _, __, ___, ____, p1, p2: (p1, dict(p2, differentiated=True)))\n+def _jaxpr_forwarding(jaxpr: Jaxpr) -> List[Optional[int]]:\n+ # Compute which inputs are just forwarded to outputs.\n+ fwds: Dict[Var, Var] = dict(zip(jaxpr.invars, jaxpr.invars))\n+ for eqn in jaxpr.eqns:\n+ if eqn.primitive in forwarding_rules:\n+ eqn = eqn.replace(invars=[fwds.get(v, v) for v in eqn.invars]) # type: ignore\n+ fwd_vars, _ = forwarding_rules[eqn.primitive](eqn)\n+ for v_orig, v_new in zip(eqn.outvars, fwd_vars):\n+ if v_new is not None:\n+ fwds[v_orig] = v_new\n+ idxs: Dict[Var, int] = {v: i for i, v in enumerate(jaxpr.invars)}\n+ return [None if type(v) is Literal else idxs.get(fwds.get(v)) # type: ignore\n+ for v in jaxpr.outvars]\n+\n+\n# TODO(mattjj): unify with dce code below\ndef dce_jaxpr(jaxpr: Jaxpr, used_outputs: List[bool]\n) -> Tuple[Jaxpr, List[bool]]:\n@@ -1270,8 +1289,9 @@ def _reconstruct_pval(pval1: PartialVal, const2: core.Value):\nreturn PartialVal.known(const2)\n-def move_binders_to_front(closed_jaxpr: ClosedJaxpr, to_move: Sequence[bool]) -> ClosedJaxpr:\n- \"\"\"Reorder the `invars` to move to front the ones for which `to_move` is True.\"\"\"\n+def move_binders_to_front(closed_jaxpr: ClosedJaxpr, to_move: Sequence[bool]\n+ ) -> ClosedJaxpr:\n+ \"\"\"Reorder `invars` by moving those indicated in `to_move` to the front.\"\"\"\nassert len(closed_jaxpr.in_avals) == len(to_move)\nnew_invars = _move_to_front(closed_jaxpr.jaxpr.invars, to_move)\nnew_jaxpr = Jaxpr(closed_jaxpr.jaxpr.constvars, new_invars,\n@@ -1284,6 +1304,10 @@ def _move_to_front(lst: Sequence, to_move: Sequence[bool]) -> Sequence:\nreturn ([elt for elt, move in zip(lst, to_move) if move] +\n[elt for elt, move in zip(lst, to_move) if not move])\n+def move_binders_to_back(closed_jaxpr: ClosedJaxpr, to_move: Sequence[bool]\n+ ) -> ClosedJaxpr:\n+ \"\"\"Reorder `invars` by moving those indicated in `to_move` to the back.\"\"\"\n+ return move_binders_to_front(closed_jaxpr, map(op.not_, to_move))\nclass DynamicJaxprTracer(core.Tracer):\n__slots__ = ['aval']\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] roll forward #10448, fix dce bug |
260,335 | 26.04.2022 21:33:15 | 25,200 | bd00926b63641a0ad9448bb6215d87ef66bca6fa | don't bind scan on jaxpr_known if no outputs | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/control_flow.py",
"new_path": "jax/_src/lax/control_flow.py",
"diff": "@@ -1766,21 +1766,25 @@ def _scan_partial_eval(trace, *tracers, reverse, length, num_consts, num_carry,\ndel jaxpr_known_\n# We use `fwds_known` below when forming the output of scanning jaxpr_known.\n- # Run the known part of the scan.\n+ # Run the known part of the scan (if it has any outputs or effects).\nknown_inputs = (list(jaxpr_known_consts) +\n[t.pval.get_known() for t in tracers[num_consts:]\nif t.pval.is_known()])\n+ if not jaxpr_known.out_avals and not jaxpr_known.effects:\n+ out_known = []\n+ else:\nlinear_known = [False] * len(known_inputs) # conservative!\nout_known = scan_p.bind(\n*known_inputs, reverse=reverse, length=length, jaxpr=jaxpr_known,\nnum_consts=len(jaxpr_known_consts), num_carry=num_carry - sum(carry_uk),\nlinear=tuple(linear_known), unroll=unroll)\n+ del linear_known\n# Complete the known output by filling in forwarded values using fwds_known.\nout_known_iter = iter(out_known)\n- out_known = [next(out_known_iter) if f is None else _maybe_put(known_inputs[f])\n- for f in fwds_known]\n+ out_known = [next(out_known_iter) if f is None\n+ else _maybe_put(known_inputs[f]) for f in fwds_known]\nassert next(out_known_iter, None) is None\n- del known_inputs, out_known_iter, linear_known\n+ del known_inputs, out_known_iter\n# Split known outputs from residuals.\nout_known, extensive_res = split_list(out_known, [len(out_uk) - sum(out_uk)])\n"
}
] | Python | Apache License 2.0 | google/jax | don't bind scan on jaxpr_known if no outputs |
260,335 | 26.04.2022 23:25:47 | 25,200 | ccfa6731f5e51e9c0d7b137e911efc5be074fc71 | Weaken some newly-added assertions, which are catching some weak type
inconsistencies. Hopefully temporary. | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -891,9 +891,10 @@ def _partial_eval_jaxpr_nounits(jaxpr, in_unknowns, instantiate):\nassert ([v.aval for v in jaxpr_known.invars] ==\n[a for a, uk in zip(jaxpr.in_avals, in_unknowns) if not uk])\n# check jaxpr_known has out type corresponding to known outs of jaxpr plus res\n- assert ([v.aval for v in jaxpr_known.outvars] ==\n- [a for a, uk in zip(jaxpr.out_avals, out_unknowns) if not uk] +\n- res_avals)\n+ # TODO(mattjj): enable weak type checking here\n+ assert ([v.aval.strip_weak_type() for v in jaxpr_known.outvars] ==\n+ [a.strip_weak_type() for a, uk in zip(jaxpr.out_avals, out_unknowns)\n+ if not uk] + [a.strip_weak_type() for a in res_avals])\n# check jaxpr_unknown has input type corresponding to unknown inputs plus res\nassert ([v.aval for v in jaxpr_unknown.invars] ==\nres_avals + [a for a, uk in zip(jaxpr.in_avals, in_unknowns) if uk])\n"
}
] | Python | Apache License 2.0 | google/jax | Weaken some newly-added assertions, which are catching some weak type
inconsistencies. Hopefully temporary.
PiperOrigin-RevId: 444770310 |
260,335 | 27.04.2022 19:58:33 | 25,200 | 7a5a6880f6d1cd56bf9bdcb3b89b194316a42d61 | [remove-units] prevent pjit partial eval from dealing with units | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/pjit.py",
"new_path": "jax/experimental/pjit.py",
"diff": "@@ -49,7 +49,8 @@ from jax._src.tree_util import prefix_errors\nfrom jax._src import util\nfrom jax._src.util import (\nHashableFunction, safe_map, safe_zip, wrap_name, wraps,\n- distributed_debug_log, split_list, cache, tuple_insert, weakref_lru_cache)\n+ distributed_debug_log, split_list, cache, tuple_insert, weakref_lru_cache,\n+ merge_lists)\nclass _FromGdaSingleton:\npass\n@@ -803,21 +804,15 @@ def _pjit_partial_eval(trace, *in_tracers,\nknown_ins = tuple(pv.is_known() for pv in in_pvals)\nunknown_ins = tuple(not k for k in known_ins)\n- raw_known_jaxpr, raw_unknown_jaxpr, unknown_outs = pe.partial_eval_jaxpr(\n+ known_jaxpr, unknown_jaxpr, unknown_outs, res_avals = pe.partial_eval_jaxpr_nounits(\njaxpr, unknown_ins, instantiate=False)\nunknown_outs = tuple(unknown_outs)\nknown_outs = tuple(not uk for uk in unknown_outs)\n- num_residuals = len(raw_known_jaxpr.jaxpr.outvars) - len(unknown_outs)\n+ num_residuals = len(res_avals)\ndef keep_where(l, should_keep):\nreturn tuple(x for x, keep in zip(l, should_keep) if keep)\n- # Prepare the known jaxpr\n- # TODO(apaszke): map_jaxpr will break caching!\n- known_jaxpr = raw_known_jaxpr.map_jaxpr(lambda jaxpr: pe._drop_vars(\n- jaxpr,\n- drop_ins=unknown_ins,\n- drop_outs=unknown_outs + (False,) * num_residuals))\n# Compute the known outputs\nknown_params = dict(\njaxpr=known_jaxpr,\n@@ -850,18 +845,18 @@ def _pjit_partial_eval(trace, *in_tracers,\n*(pv.get_known() for pv in in_pvals if pv.is_known()),\n**known_params)\nif num_residuals:\n- known_out_vals, residual_vals = split_list(all_known_outs, [-num_residuals])\n+ known_out_vals, residual_vals = \\\n+ split_list(all_known_outs, [len(all_known_outs) - num_residuals])\nelse:\nknown_out_vals, residual_vals = all_known_outs, ()\n- known_tracers_out = [trace.new_const(known_out) for known_out in known_out_vals]\nresidual_tracers = [trace.new_instantiated_const(residual) for residual in residual_vals]\n- # Prepare the unknown jaxpr\n- # TODO(apaszke): map_jaxpr will break caching!\n- unknown_jaxpr = raw_unknown_jaxpr.map_jaxpr(lambda jaxpr: pe._drop_vars(\n- jaxpr,\n- drop_ins=known_ins + (False,) * num_residuals,\n- drop_outs=known_outs))\n+ # The convention of partial_eval_jaxpr_nounits is to place residual binders\n+ # at the front of the jaxpr produced, so we move them to the back since both\n+ # the jaxpr equation built below and the pjit transpose rule assume a\n+ # residual-inputs-last convention.\n+ unknown_jaxpr = pe.move_binders_to_back(\n+ unknown_jaxpr, [True] * num_residuals + [False] * sum(unknown_ins))\n# Prepare unknown tracers\nunknown_params = dict(\njaxpr=unknown_jaxpr,\n@@ -888,7 +883,7 @@ def _pjit_partial_eval(trace, *in_tracers,\nunknown_jaxpr.effects,\nsource_info_util.current())\nfor t in unknown_tracers_out: t.recipe = eqn\n- return pe._zip_knowns(known_tracers_out, unknown_tracers_out, unknown_outs)\n+ return merge_lists(unknown_outs, known_out_vals, unknown_tracers_out)\npe.custom_partial_eval_rules[pjit_p] = _pjit_partial_eval\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] prevent pjit partial eval from dealing with units |
260,335 | 15.11.2021 22:36:39 | 28,800 | 4608d36340af6f7bdfd21a445d2fea8b3659bd47 | add scan dce rule | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/control_flow.py",
"new_path": "jax/_src/lax/control_flow.py",
"diff": "@@ -24,7 +24,7 @@ import inspect\nimport itertools\nimport operator\nimport os\n-from typing import Any, Callable, Optional, Sequence, Tuple, TypeVar\n+from typing import Any, Callable, Optional, Sequence, Tuple, TypeVar, List\nimport numpy as np\n@@ -1980,6 +1980,32 @@ def _scan_padding_rule(in_avals, out_avals, *args, jaxpr, **params):\npadded_jaxpr = core.ClosedJaxpr(*pe.pad_jaxpr(jaxpr.jaxpr, jaxpr.consts))\nreturn scan_p.bind(*args, jaxpr=padded_jaxpr, **params)\n+def _scan_dce_rule(used_outputs: List[bool], eqn: core.JaxprEqn\n+ ) -> Tuple[List[bool], core.JaxprEqn]:\n+ num_consts, num_carry = eqn.params['num_consts'], eqn.params['num_carry']\n+ used_carry_out, used_extensive_out = split_list(used_outputs, [num_carry])\n+ for i in range(1 + num_carry):\n+ jaxpr, used_inputs = pe.dce_jaxpr(eqn.params['jaxpr'].jaxpr,\n+ used_carry_out + used_extensive_out)\n+ used_consts, used_carry_in, used_extensive_in = \\\n+ split_list(used_inputs, [num_consts, num_carry])\n+ if used_carry_in == used_carry_out:\n+ break\n+ else:\n+ used_carry_out = _map(operator.or_, used_carry_out, used_carry_in)\n+ else:\n+ assert False, \"Fixpoint not reached\"\n+\n+ new_linear = [l for l, u in zip(eqn.params['linear'], used_inputs) if u]\n+ new_params = dict(eqn.params, num_consts=sum(used_consts),\n+ num_carry=sum(used_carry_in), linear=tuple(new_linear),\n+ jaxpr=core.ClosedJaxpr(jaxpr, eqn.params['jaxpr'].consts))\n+ new_eqn = pe.new_jaxpr_eqn([v for v, used in zip(eqn.invars, used_inputs) if used],\n+ [v for v, used in zip(eqn.outvars, used_outputs) if used],\n+ eqn.primitive, new_params, eqn.effects,\n+ eqn.source_info)\n+ return used_inputs, new_eqn\n+\ndef _scan_typecheck(bind_time, *avals, reverse, length, num_consts, num_carry,\njaxpr, linear, unroll):\ntc = partial(_typecheck_param, 'scan')\n@@ -2049,7 +2075,7 @@ core.custom_typechecks[scan_p] = partial(_scan_typecheck, False)\npe.partial_eval_jaxpr_custom_rules[scan_p] = \\\npartial(pe.partial_eval_jaxpr_custom_rule_not_implemented, 'scan')\npe.padding_rules[scan_p] = _scan_padding_rule\n-\n+pe.dce_rules[scan_p] = _scan_dce_rule\n@api_boundary\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -1185,7 +1185,6 @@ def _jaxpr_forwarding(jaxpr: Jaxpr) -> List[Optional[int]]:\nfor v in jaxpr.outvars]\n-# TODO(mattjj): unify with dce code below\ndef dce_jaxpr(jaxpr: Jaxpr, used_outputs: Sequence[bool]\n) -> Tuple[Jaxpr, List[bool]]:\nreturn _dce_jaxpr(jaxpr, tuple(used_outputs))\n@@ -1193,7 +1192,6 @@ def dce_jaxpr(jaxpr: Jaxpr, used_outputs: Sequence[bool]\n@weakref_lru_cache\ndef _dce_jaxpr(jaxpr: Jaxpr, used_outputs: Tuple[bool, ...]\n) -> Tuple[Jaxpr, List[bool]]:\n- if jaxpr.constvars: raise NotImplementedError # TODO(mattjj)\nenv: Dict[Var, bool] = {}\ndef read(v: Var) -> bool:\n@@ -1224,7 +1222,7 @@ def _dce_jaxpr(jaxpr: Jaxpr, used_outputs: Tuple[bool, ...]\nmap(write, eqn.invars, used_ins)\nused_inputs = map(read, jaxpr.invars)\n- new_jaxpr = Jaxpr((),\n+ new_jaxpr = Jaxpr(jaxpr.constvars,\n[v for v, b in zip(jaxpr.invars, used_inputs) if b],\n[v for v, b in zip(jaxpr.outvars, used_outputs) if b],\nnew_eqns[::-1], jaxpr.effects)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/api_test.py",
"new_path": "tests/api_test.py",
"diff": "@@ -50,6 +50,7 @@ from jax.interpreters import ad\nfrom jax.interpreters import mlir\nfrom jax.interpreters import xla\nfrom jax.interpreters import pxla\n+from jax.interpreters import partial_eval as pe\nfrom jax.interpreters.pxla import PartitionSpec as P\nfrom jax._src import device_array\nimport jax._src.lib\n@@ -4492,6 +4493,76 @@ class JaxprTest(jtu.JaxTestCase):\nself.assertIn('in (*,)', str(jaxpr))\nself.assertNotIn('in (a,)', str(jaxpr))\n+ def test_dce_jaxpr_scan(self):\n+ @api.remat\n+ def scanned_f(c, x):\n+ out = jnp.tanh(c * x)\n+ return out, out\n+\n+ def f(xs):\n+ return lax.scan(scanned_f, 1., xs)\n+\n+ jaxpr = api.make_jaxpr(lambda xs: api.linearize(f, xs)[1])(jnp.arange(10.)).jaxpr\n+ jaxpr, _ = pe.dce_jaxpr(jaxpr, [True] * len(jaxpr.outvars))\n+\n+ self.assertLen(jaxpr.eqns, 1)\n+ self.assertLen(jaxpr.eqns[-1].params['jaxpr'].jaxpr.eqns, 2)\n+\n+ def test_dce_jaxpr_scan_nontrivial_fixedpoint(self):\n+ def f(lst):\n+ def body(c, _):\n+ return [c[0]] + [c1 + c2 for c1, c2 in zip(c[:-1], c[1:])], None\n+ out, _ = jax.lax.scan(body, lst, None, length=len(lst))\n+ return out\n+ jaxpr = api.make_jaxpr(f)([1, 2, 3, 4]).jaxpr\n+ self.assertLen(jaxpr.eqns, 1)\n+ self.assertLen(jaxpr.eqns[0].params['jaxpr'].jaxpr.eqns, 3)\n+\n+ # If we use all but the last element, only one eqn is pruned.\n+ jaxpr_pruned, used_inputs = pe.dce_jaxpr(jaxpr, [True, True, True, False])\n+ self.assertLen(jaxpr_pruned.eqns, 1)\n+ self.assertLen(jaxpr_pruned.eqns[0].params['jaxpr'].jaxpr.eqns, 2)\n+ # And all but the first input is used.\n+ self.assertEqual(used_inputs, [True, True, True, False])\n+\n+ # If we use all but the last two elements, two eqns can be pruned.\n+ jaxpr_pruned, used_inputs = pe.dce_jaxpr(jaxpr, [True, True, False, False])\n+ self.assertLen(jaxpr_pruned.eqns, 1)\n+ self.assertLen(jaxpr_pruned.eqns[0].params['jaxpr'].jaxpr.eqns, 1)\n+ # And the last two inputs are not used.\n+ self.assertEqual(used_inputs, [True, True, False, False])\n+\n+ # If we only use the last element, no eqns can be pruned.\n+ jaxpr_pruned, used_inputs = pe.dce_jaxpr(jaxpr, [False, False, False, True])\n+ self.assertLen(jaxpr_pruned.eqns, 1)\n+ self.assertLen(jaxpr_pruned.eqns[0].params['jaxpr'].jaxpr.eqns, 3)\n+ # And all inputs are used.\n+ self.assertEqual(used_inputs, [True, True, True, True])\n+\n+ def test_dce_jaxpr_scan_const_in_jvp(self):\n+ @api.custom_jvp\n+ def f(x):\n+ return x * np.arange(3.)\n+ @f.defjvp\n+ def f_jvp(primals, tangents):\n+ (x,), (xdot,) = primals, tangents\n+ return f(x), xdot * np.arange(3.)\n+\n+ def g(x):\n+ def body(c, _):\n+ return f(c), None\n+ y, _ = jax.lax.scan(body, x, None, length=1)\n+ return y\n+\n+ jvp_jaxpr = api.make_jaxpr(lambda x, xdot: api.jvp(g, (x,), (xdot,)))(\n+ np.arange(3.), np.arange(3.)).jaxpr\n+\n+ jaxpr_pruned, used_inputs = pe.dce_jaxpr(jvp_jaxpr, [True, True])\n+ self.assertTrue(all(used_inputs))\n+\n+ jaxpr_pruned, used_inputs = pe.dce_jaxpr(jvp_jaxpr, [True, False])\n+ self.assertEqual(used_inputs, [True, False])\n+\nclass CustomJVPTest(jtu.JaxTestCase):\n"
}
] | Python | Apache License 2.0 | google/jax | add scan dce rule |
260,598 | 28.04.2022 14:22:17 | 0 | 5d742fc0c3313798ba01b45bc13f973ef950e2e7 | Compatible with RngBitGeneratorOp builder modifications | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/lax.py",
"new_path": "jax/_src/lax/lax.py",
"diff": "@@ -4087,6 +4087,19 @@ def _rng_bit_generator_weak_type_rule(key, *, shape, dtype, algorithm):\ndel shape, dtype, algorithm\nreturn (key.weak_type, False)\n+RandomAlgorithm = xops.RandomAlgorithm\n+RandomAlgorithm.__str__ = lambda algorithm: algorithm.name # type: ignore[assignment]\n+\n+def rng_algorithm(algorithm: RandomAlgorithm):\n+ if algorithm == RandomAlgorithm.RNG_THREE_FRY:\n+ return mhlo.RngAlgorithmAttr.get(\"THREE_FRY\")\n+ elif algorithm == RandomAlgorithm.RNG_PHILOX:\n+ return mhlo.RngAlgorithmAttr.get(\"PHILOX\")\n+ elif algorithm == RandomAlgorithm.RNG_DEFAULT:\n+ return mhlo.RngAlgorithmAttr.get(\"DEFAULT\")\n+ else:\n+ assert False\n+\ndef _rng_bit_generator_lowering(\nctx, key, *, shape, dtype, algorithm):\nkey_type = ir.RankedTensorType(key.type)\n@@ -4113,11 +4126,15 @@ def _rng_bit_generator_lowering(\nkey = mhlo.BitcastConvertOp(\nir.RankedTensorType.get([2], u64_type),\nmhlo.ReshapeOp(ir.RankedTensorType.get([2, 2], u32_type), key)).result\n+\n+ algorithm_attr = rng_algorithm(algorithm) if jax._src.lib.mlir_api_version >= 13 \\\n+ else mlir.i32_attr(algorithm)\nout_key, out_vals = mhlo.RngBitGeneratorOp(\nkey.type,\nir.RankedTensorType.get(shape, rbg_etype),\n- mlir.i32_attr(algorithm),\n- key).results\n+ algorithm_attr, key).results\n+\n+\nif key_etype == u32_type:\nout_key = mhlo.ReshapeOp(\nir.RankedTensorType.get([4], u32_type),\n@@ -4145,8 +4162,6 @@ rng_bit_generator_p.def_abstract_eval(\nmlir.register_lowering(rng_bit_generator_p,\n_rng_bit_generator_lowering)\n-RandomAlgorithm = xops.RandomAlgorithm\n-RandomAlgorithm.__str__ = lambda algorithm: algorithm.name # type: ignore[assignment]\ndef _array_copy(arr):\nreturn copy_p.bind(arr)\n"
}
] | Python | Apache License 2.0 | google/jax | Compatible with RngBitGeneratorOp builder modifications |
260,335 | 28.04.2022 12:44:19 | 25,200 | 891539144343af2a63906653996d6fde72bd4f7b | fix redundant (harmless) axis env extension in pmap partial eval | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -265,7 +265,6 @@ class JaxprTrace(Trace):\nout_axes_thunk=const_out_axes_thunk)\n# Run the map, getting known out vals and aux data used for staged-out map.\n- with core.extend_axis_env(params['axis_name'], params['axis_size'], None):\nout = primitive.bind(f, *in_consts, **const_params)\nout_knowns, out_avals_mapped, jaxpr, env = aux()\n# Split apart known outputs from the original call and residuals.\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/pmap_test.py",
"new_path": "tests/pmap_test.py",
"diff": "@@ -1926,6 +1926,14 @@ class PythonPmapTest(jtu.JaxTestCase):\nself.assertEqual(x.size, 8 * 267736 * 1024)\nself.assertEqual(type(x.size), int)\n+ def test_axis_env_length(self):\n+ f = lambda x: jax.pmap(g)(jnp.array([x]))[0]\n+ def g(x):\n+ assert len(jax.core.thread_local_state.trace_state.axis_env) == 1\n+ return x\n+ jax.grad(f)(3.) # doesn't fail\n+\n+\nclass CppPmapTest(PythonPmapTest):\n@property\n"
}
] | Python | Apache License 2.0 | google/jax | fix redundant (harmless) axis env extension in pmap partial eval |
260,335 | 27.04.2022 22:04:34 | 25,200 | ca112da8b9103334df85419fd42015154d77509e | [remove-units] avoid making xmap partial eval deal with units | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/maps.py",
"new_path": "jax/experimental/maps.py",
"diff": "@@ -48,9 +48,10 @@ from jax.interpreters import batching\nfrom jax.interpreters import ad\nfrom jax._src.lib import xla_bridge as xb\nfrom jax._src.lib import xla_client as xc\n-from jax._src.util import (safe_map, safe_zip, HashableFunction,\n- as_hashable_function, unzip2, distributed_debug_log,\n- tuple_insert, moveaxis, split_list, wrap_name)\n+from jax._src.util import (safe_map, safe_zip, HashableFunction, unzip2,\n+ as_hashable_function, distributed_debug_log,\n+ tuple_insert, moveaxis, split_list, wrap_name,\n+ merge_lists, partition_list)\nfrom jax import lax\nsource_info_util.register_exclusion(__file__)\n@@ -1126,122 +1127,85 @@ def restore_units(is_unit, vals):\ndef _jaxpr_trace_process_xmap(self, primitive, f: lu.WrappedFun, tracers, params):\n- from jax.interpreters.partial_eval import (\n- PartialVal, JaxprTracer, _drop_vars, _dce_open_jaxpr,\n- convert_constvars_jaxpr, new_eqn_recipe)\nassert primitive is xmap_p\nin_axes = params['in_axes']\ndonated_invars = params['donated_invars']\nglobal_axis_sizes = params['global_axis_sizes']\n+ out_axes_thunk = params['out_axes_thunk']\n- in_pvals = [t.pval for t in tracers]\n- in_pvals = [pval if pval.is_known()\n- else PartialVal.unknown(_delete_aval_axes(pval[0], axes, global_axis_sizes))\n- for pval, axes in zip(in_pvals, in_axes)]\n-\n- const_axes_s = lu.Store()\n- def app(f, *args):\n- args_no_units, in_units = filter_units(args)\n- f, out_units = hide_units(f, tuple(in_units))\n+ # Adjust input tracers' pvals for mapped axes, and unpack.\n+ in_pvals = [t.pval if t.pval.is_known() else\n+ pe.PartialVal.unknown(\n+ _delete_aval_axes(t.pval.get_aval(), axes, global_axis_sizes))\n+ for t, axes in zip(tracers, in_axes)]\n+ in_knowns, in_avals, in_consts = pe.partition_pvals(in_pvals)\n+\n+ # Wrap f to perform partial evaluation, and plumb out aux data.\n+ f = pe.trace_to_subjaxpr_nounits(f, self.main, False)\n+ f, aux = pe.partial_eval_wrapper_nounits(f, tuple(in_knowns), tuple(in_avals))\n+ # Also grab the local named shapes of the output (known and res).\nf, out_named_shapes = out_local_named_shapes(f, frozenset(global_axis_sizes))\n- out_axes_thunk = params['out_axes_thunk']\n+\n+ # Adjust params for knowns (donated_invars, in_axes, out_axes_thunk).\n@as_hashable_function(closure=out_axes_thunk)\ndef new_out_axes_thunk():\n- out_axes = out_axes_thunk()\n- axes_units, const_units = split_list(out_units(), [len(out_axes)])\n- assert not any(const_units)\n- num_consts = len(const_units)\n- out_axes_no_units = [a for a, u in zip(out_axes, axes_units) if not u]\n- const_axes: Sequence[AxisNamePos]\n- if num_consts == 0:\n- const_axes = ()\n- else:\n- const_axes = [\n- AxisNamePos(zip(sort_named_shape, range(len(sort_named_shape))),\n- user_repr=f'<internal: {sort_named_shape}>')\n- for named_shape in out_named_shapes()[-num_consts:]\n- # We sort here to make the iteration order deterministic\n- for sort_named_shape in [sorted(named_shape, key=str)]\n- ]\n- if not const_axes_s: # NOTE: This can be called multiple times\n- const_axes_s.store(const_axes)\n- assert const_axes_s.val == const_axes\n- return (*out_axes_no_units, *const_axes)\n- pe_params = dict(\n- params,\n- in_axes=tuple(a for a, u in zip(in_axes, in_units) if not u),\n- donated_invars=tuple(a for a, u in zip(donated_invars, in_units) if not u),\n+ out_knowns, _, _, _ = aux()\n+ _, out_axes = partition_list(out_knowns, out_axes_thunk())\n+ return (*out_axes, *res_axes())\n+ def res_axes():\n+ _, _, jaxpr, _ = aux()\n+ num_res = len(jaxpr.constvars)\n+ res_named_shapes = out_named_shapes()[-num_res:] if num_res else []\n+ sorted_named_shapes = [sorted(ns, key=str) for ns in res_named_shapes]\n+ return [AxisNamePos(zip(named_shape, range(len(named_shape))),\n+ user_repr=f'<internal: {named_shape}>')\n+ for named_shape in sorted_named_shapes]\n+ known_params = dict(\n+ params, in_axes=tuple(a for a, k in zip(in_axes, in_knowns) if k),\n+ donated_invars=tuple(d for d, k in zip(donated_invars, in_knowns) if k),\nout_axes_thunk=new_out_axes_thunk)\n- outs_no_units = primitive.bind(f, *args_no_units, **pe_params)\n- new_out_axes_thunk() # Make sure it is called at least once to compute const_axes\n- return restore_units(out_units(), outs_no_units)\n-\n- jaxpr, out_pvals, consts, env_tracers = self.partial_eval(\n- f, in_pvals, app, instantiate=False)\n- out_axes = params['out_axes_thunk']()\n- const_axes = const_axes_s.val\n+ # Run the known part.\n+ outs = primitive.bind(f, *in_consts, **known_params)\n+ out_knowns, out_avals, jaxpr, env = aux()\n+ known_outvals, res = split_list(outs, [len(outs) - len(jaxpr.constvars)])\n+ with core.extend_axis_env_nd(global_axis_sizes.items()):\n+ jaxpr = pe.convert_constvars_jaxpr(jaxpr)\n+\n+ # Set up new params.\n+ out_axes = [a for a, k in zip(out_axes_thunk(), out_knowns) if not k]\n+ unknown_params = dict(\n+ params, call_jaxpr=jaxpr, out_axes=tuple(out_axes), spmd_out_axes=None,\n+ donated_invars=(*(False for _ in res),\n+ *(d for d, t in zip(donated_invars, tracers)\n+ if not t.pval.is_known())),\n+ in_axes=(*res_axes(), *(None for _ in env),\n+ *(a for a, t in zip(in_axes, tracers) if not t.pval.is_known())))\n+ del unknown_params['out_axes_thunk']\n+ del unknown_params['spmd_out_axes_thunk']\n+ # Create input tracers for unknown part.\n+ res_tracers = map(self.new_instantiated_const, res)\n+ env_tracers = map(self.full_raise, env)\n+ unknown_arg_tracers = [t for t in tracers if not t.pval.is_known()]\n+ # Create output tracers for unknown part, adjusting avals.\naxis_resource_count = _get_axis_resource_count(\nparams['axis_resources'], params['resource_env'],\nparams['in_positional_semantics'])\nlocal_axis_sizes = {\n- axis: axis_resource_count[axis].to_local(params['out_positional_semantics'], global_size)\n- for axis, global_size in global_axis_sizes.items()\n- }\n- out_pvals = [pval if pval.is_known() else\n- PartialVal.unknown(_insert_aval_axes(pval[0], axes, local_axis_sizes))\n- for pval, axes in zip(out_pvals, out_axes)]\n-\n- with core.extend_axis_env_nd(global_axis_sizes.items()):\n- # Skip known invars and outvars, and lift constants as regular invars\n- in_knowns = tuple(t.pval.is_known() for t in it.chain(env_tracers, tracers))\n- out_unknowns = tuple(not pval.is_known() for pval in out_pvals)\n- jaxpr = _drop_vars(jaxpr, in_knowns, (False,) * len(jaxpr.outvars))\n- jaxpr = _dce_open_jaxpr(jaxpr, out_unknowns, drop_outputs=True)\n- jaxpr = convert_constvars_jaxpr(jaxpr)\n-\n- # Known tracers get propagated as if they were constants\n- known_tracers_out = [self.new_const(pval.get_known()) for pval in out_pvals\n- if pval.is_known()]\n-\n- # I'm not 100% if that's correct, but it is an assumption that\n- # JaxprTrace.process_call already makes.\n- if any(t.pval.is_known() for t in env_tracers):\n- raise AssertionError(\"Please open a bug report!\")\n- # Unknown tracers need to have the jaxpr set up as their recipe\n- unknown_tracers_in = (*env_tracers, *(t for t in tracers if not t.pval.is_known()))\n- unknown_tracers_out = [JaxprTracer(self, pval, None) for pval in out_pvals\n- if not pval.is_known()]\n- const_tracers = map(self.new_instantiated_const, consts)\n-\n- # Set up new params\n- new_in_axes = (*const_axes,\n- *(None for _ in env_tracers),\n- *(axis for axis, t in zip(in_axes, tracers)\n- if not t.pval.is_known()))\n- new_out_axes = tuple(axis for axis, pval in zip(out_axes, out_pvals)\n- if not pval.is_known())\n-\n- assert params['spmd_in_axes'] is None and params['spmd_out_axes_thunk'] is None\n- new_params = dict(\n- params,\n- call_jaxpr=jaxpr,\n- donated_invars=(*(False for _ in const_tracers),\n- *(d for d, t in zip(donated_invars, tracers) if not t.pval.is_known())),\n- in_axes=new_in_axes,\n- out_axes=new_out_axes,\n- spmd_out_axes=None)\n- del new_params['out_axes_thunk']\n- del new_params['spmd_out_axes_thunk']\n-\n- eqn = new_eqn_recipe((*const_tracers, *unknown_tracers_in),\n- unknown_tracers_out,\n- primitive, new_params, jaxpr.effects, source_info_util.current())\n+ ax: axis_resource_count[ax].to_local(\n+ params['out_positional_semantics'], global_size)\n+ for ax, global_size in global_axis_sizes.items()}\n+ out_pvals = [pe.PartialVal.unknown(_insert_aval_axes(a, ax, local_axis_sizes))\n+ for a, ax in zip(out_avals, out_axes)]\n+ unknown_tracers_out = [pe.JaxprTracer(self, pval, None) for pval in out_pvals]\n+ # Build eqn to be staged out and attach it to unknown output tracers.\n+ eqn = pe.new_eqn_recipe((*res_tracers, *env_tracers, *unknown_arg_tracers),\n+ unknown_tracers_out, primitive, unknown_params,\n+ jaxpr.effects, source_info_util.current())\nfor t in unknown_tracers_out: t.recipe = eqn\n- return pe._zip_knowns(known_tracers_out, unknown_tracers_out, out_unknowns)\n+ return merge_lists(out_knowns, unknown_tracers_out, known_outvals)\npe.JaxprTrace.process_xmap = _jaxpr_trace_process_xmap\n-\ndef _batch_trace_update_spmd_axes(\nspmd_in_axes, spmd_out_axes_thunk,\naxis_name, dims, dims_out_thunk):\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -377,19 +377,6 @@ class JaxprTrace(Trace):\ndef _current_truncated_name_stack(self):\nreturn source_info_util.current_name_stack()[len(self.name_stack):]\n- def partial_eval(self, f: lu.WrappedFun, pvals: Sequence[PartialVal],\n- app: Callable[[lu.WrappedFun, Tuple[core.Value, ...]], Tuple[core.Value]],\n- instantiate: bool):\n- \"\"\"Partially evaluate f on a sequence of PartialVals.\"\"\"\n- in_avals, in_consts = unzip2(pvals)\n- f = trace_to_subjaxpr(f, self.main, instantiate)\n- f, aux = partial_eval_wrapper(f, tuple(in_avals))\n- out_flat, (out_avals, jaxpr, env) = app(f, *in_consts), aux()\n- out_consts, consts = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\n- out_pvs = map(PartialVal, zip(out_avals, out_consts))\n- env_tracers = map(self.full_raise, env)\n- return jaxpr, out_pvs, consts, env_tracers\n-\ndef process_custom_jvp_call(self, prim, fun, jvp, tracers):\ntracers = map(self.instantiate_const_abstracted, tracers)\nin_avals, in_consts = unzip2(t.pval for t in tracers) # in_consts are units\n@@ -751,7 +738,7 @@ def tracers_to_jaxpr(\nt, \"Tracer not among input tracers {}\".format(t))\nassert in_tracers, \"Lambda binding with no args\"\nelif isinstance(recipe, FreeVar):\n- env[cast(Var, getvar(t))] = recipe.val\n+ env[getvar(t)] = recipe.val # type: ignore\nelif isinstance(recipe, ConstVar):\nv = t_to_var[id(t)] = getconstvar(recipe.val)\nconsts[v] = recipe.val\n@@ -2217,31 +2204,3 @@ def _partial_eval_jaxpr(jaxpr, unknowns, instantiate):\nin_avals_2 = [*in_avals_2, *res_avals]\nreturn ClosedJaxpr(jaxpr_1, consts_1), ClosedJaxpr(jaxpr_2, ()), uk_out\n-\n-@weakref_lru_cache\n-def _drop_vars(jaxpr: Jaxpr, drop_ins: Tuple[bool, ...], drop_outs: Tuple[bool, ...]):\n- return Jaxpr(jaxpr.constvars,\n- [v for v, d in zip(jaxpr.invars, drop_ins) if not d],\n- [v for v, d in zip(jaxpr.outvars, drop_outs) if not d],\n- jaxpr.eqns, jaxpr.effects)\n-\n-@weakref_lru_cache\n-def _dce_open_jaxpr(jaxpr: Jaxpr, outputs: Tuple[bool, ...], drop_outputs=False) -> Jaxpr:\n- # This dead-code elimination is pretty rudimentary, and in particular doesn't\n- # nontrivially DCE through scan, call, or other higher-order primitives.\n- # TODO(mattjj): better DCE (i.e. use above dce_jaxpr)\n- if drop_outputs:\n- new_outvars = [var for var, output in zip(jaxpr.outvars, outputs) if output]\n- else:\n- new_outvars = [var if output else core.unitvar\n- for var, output in zip(jaxpr.outvars, outputs)]\n-\n- needed_vars = {v for v in new_outvars if type(v) is not Literal}\n- new_eqns = []\n- for eqn in jaxpr.eqns[::-1]:\n- if set(eqn.outvars) & needed_vars:\n- new_eqns.append(eqn)\n- needed_vars.update(v for v in eqn.invars if type(v) is not Literal)\n- new_eqns = new_eqns[::-1]\n- return Jaxpr(jaxpr.constvars, jaxpr.invars, new_outvars, new_eqns,\n- jaxpr.effects)\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] avoid making xmap partial eval deal with units |
260,447 | 28.04.2022 14:41:29 | 25,200 | 4d41111a8706fead18cdbd07080577ffe05e995d | [linalg] Update svd test on reconstructed operands and unitary singular vectors. | [
{
"change_type": "MODIFY",
"old_path": "tests/linalg_test.py",
"new_path": "tests/linalg_test.py",
"diff": "@@ -544,16 +544,27 @@ class NumpyLinalgTest(jtu.JaxTestCase):\nfor hermitian in ([False, True] if m == n else [False])))\n@jtu.skip_on_devices(\"rocm\") # will be fixed in ROCm-5.1\ndef testSVD(self, b, m, n, dtype, full_matrices, compute_uv, hermitian):\n+ # TODO: enable after linking lax.svd to lax.linalg.svd\nif (jnp.issubdtype(dtype, np.complexfloating) and\njtu.device_under_test() == \"tpu\"):\nraise unittest.SkipTest(\"No complex SVD implementation\")\nrng = jtu.rand_default(self.rng())\nargs_maker = lambda: [rng(b + (m, n), dtype)]\n- # Norm, adjusted for dimension and type.\n- def norm(x):\n- norm = np.linalg.norm(x, axis=(-2, -1))\n- return norm / (max(1, m, n) * jnp.finfo(dtype).eps)\n+ def compute_max_backward_error(operand, reconstructed_operand):\n+ error_norm = np.linalg.norm(operand - reconstructed_operand,\n+ axis=(-2, -1))\n+ backward_error = (error_norm /\n+ np.linalg.norm(operand, axis=(-2, -1)))\n+ max_backward_error = np.amax(backward_error)\n+ return max_backward_error\n+\n+ if dtype in [np.float32, np.complex64]:\n+ reconstruction_tol = 6e-3\n+ unitariness_tol = 5e-3\n+ elif dtype in [np.float64, np.complex128]:\n+ reconstruction_tol = 1e-8\n+ unitariness_tol = 1e-8\na, = args_maker()\nif hermitian:\n@@ -562,36 +573,55 @@ class NumpyLinalgTest(jtu.JaxTestCase):\nhermitian=hermitian)\nif compute_uv:\n# Check the reconstructed matrices\n+ if m and n:\nif full_matrices:\nk = min(m, n)\nif m < n:\n- self.assertTrue(np.all(\n- norm(a - np.matmul(out[1][..., None, :] * out[0], out[2][..., :k, :])) < 50))\n+ max_backward_error = compute_max_backward_error(\n+ a, np.matmul(out[1][..., None, :] * out[0], out[2][..., :k, :]))\n+ self.assertLess(max_backward_error, reconstruction_tol)\nelse:\n- self.assertTrue(np.all(\n- norm(a - np.matmul(out[1][..., None, :] * out[0][..., :, :k], out[2])) < 350))\n+ max_backward_error = compute_max_backward_error(\n+ a, np.matmul(out[1][..., None, :] * out[0][..., :, :k], out[2]))\n+ self.assertLess(max_backward_error, reconstruction_tol)\nelse:\n- self.assertTrue(np.all(\n- norm(a - np.matmul(out[1][..., None, :] * out[0], out[2])) < 350))\n+ max_backward_error = compute_max_backward_error(\n+ a, np.matmul(out[1][..., None, :] * out[0], out[2]))\n+ print(max_backward_error)\n+ self.assertLess(max_backward_error, reconstruction_tol)\n# Check the unitary properties of the singular vector matrices.\n- self.assertTrue(np.all(norm(np.eye(out[0].shape[-1]) - np.matmul(np.conj(T(out[0])), out[0])) < 15))\n+ unitary_mat = np.real(np.matmul(np.conj(T(out[0])), out[0]))\n+ eye_slice = np.eye(out[0].shape[-1], dtype=unitary_mat.dtype)\n+ self.assertAllClose(np.broadcast_to(eye_slice, b + eye_slice.shape),\n+ unitary_mat, rtol=unitariness_tol,\n+ atol=unitariness_tol)\nif m >= n:\n- self.assertTrue(np.all(norm(np.eye(out[2].shape[-1]) - np.matmul(np.conj(T(out[2])), out[2])) < 10))\n+ unitary_mat = np.real(np.matmul(np.conj(T(out[2])), out[2]))\n+ eye_slice = np.eye(out[2].shape[-1], dtype=unitary_mat.dtype)\n+ self.assertAllClose(np.broadcast_to(eye_slice, b + eye_slice.shape),\n+ unitary_mat, rtol=unitariness_tol,\n+ atol=unitariness_tol)\nelse:\n- self.assertTrue(np.all(norm(np.eye(out[2].shape[-2]) - np.matmul(out[2], np.conj(T(out[2])))) < 20))\n-\n+ unitary_mat = np.real(np.matmul(out[2], np.conj(T(out[2]))))\n+ eye_slice = np.eye(out[2].shape[-2], dtype=unitary_mat.dtype)\n+ self.assertAllClose(np.broadcast_to(eye_slice, b + eye_slice.shape),\n+ unitary_mat, rtol=unitariness_tol,\n+ atol=unitariness_tol)\nelse:\n- self.assertTrue(np.allclose(np.linalg.svd(a, compute_uv=False), np.asarray(out), atol=1e-4, rtol=1e-4))\n+ self.assertTrue(np.allclose(np.linalg.svd(a, compute_uv=False),\n+ np.asarray(out), atol=1e-4, rtol=1e-4))\n- self._CompileAndCheck(partial(jnp.linalg.svd, full_matrices=full_matrices, compute_uv=compute_uv),\n+ self._CompileAndCheck(partial(jnp.linalg.svd, full_matrices=full_matrices,\n+ compute_uv=compute_uv),\nargs_maker)\nif not compute_uv:\nsvd = partial(jnp.linalg.svd, full_matrices=full_matrices,\ncompute_uv=compute_uv)\n# TODO(phawkins): these tolerances seem very loose.\nif dtype == np.complex128:\n- jtu.check_jvp(svd, partial(jvp, svd), (a,), rtol=1e-4, atol=1e-4, eps=1e-8)\n+ jtu.check_jvp(svd, partial(jvp, svd), (a,), rtol=1e-4, atol=1e-4,\n+ eps=1e-8)\nelse:\njtu.check_jvp(svd, partial(jvp, svd), (a,), rtol=5e-2, atol=2e-1)\n@@ -728,6 +758,7 @@ class NumpyLinalgTest(jtu.JaxTestCase):\nfor dtype in float_types + complex_types))\n@jtu.skip_on_devices(\"gpu\") # TODO(#2203): numerical errors\ndef testCond(self, shape, pnorm, dtype):\n+ # TODO: enable after linking lax.svd to lax.linalg.svd\nif (jnp.issubdtype(dtype, np.complexfloating) and\njtu.device_under_test() == \"tpu\"):\nraise unittest.SkipTest(\"No complex SVD implementation\")\n@@ -838,6 +869,7 @@ class NumpyLinalgTest(jtu.JaxTestCase):\nfor dtype in float_types + complex_types))\n@jtu.skip_on_devices(\"rocm\") # will be fixed in ROCm-5.1\ndef testPinv(self, shape, dtype):\n+ # TODO: enable after linking lax.svd to lax.linalg.svd\nif (jnp.issubdtype(dtype, np.complexfloating) and\njtu.device_under_test() == \"tpu\"):\nraise unittest.SkipTest(\"No complex SVD implementation\")\n@@ -892,6 +924,7 @@ class NumpyLinalgTest(jtu.JaxTestCase):\nfor dtype in float_types + complex_types))\n@jtu.skip_on_devices(\"rocm\") # will be fixed in ROCm-5.1\ndef testMatrixRank(self, shape, dtype):\n+ # TODO: enable after linking lax.svd to lax.linalg.svd\nif (jnp.issubdtype(dtype, np.complexfloating) and\njtu.device_under_test() == \"tpu\"):\nraise unittest.SkipTest(\"No complex SVD implementation\")\n"
}
] | Python | Apache License 2.0 | google/jax | [linalg] Update svd test on reconstructed operands and unitary singular vectors.
PiperOrigin-RevId: 445252682 |
260,447 | 28.04.2022 14:46:08 | 25,200 | cdd11670959b930e01d23199fadb32b183f03ca5 | [signal] Update signal detrend test. | [
{
"change_type": "MODIFY",
"old_path": "tests/scipy_signal_test.py",
"new_path": "tests/scipy_signal_test.py",
"diff": "@@ -122,11 +122,34 @@ class LaxBackedScipySignalTests(jtu.JaxTestCase):\nfor bp in [0, [0, 2]]))\n@jtu.skip_on_devices(\"rocm\") # will be fixed in rocm-5.1\ndef testDetrend(self, shape, dtype, axis, type, bp):\n- rng = jtu.rand_default(self.rng())\n- args_maker = lambda: [rng(shape, dtype)]\n- osp_fun = partial(osp_signal.detrend, axis=axis, type=type, bp=bp)\n- jsp_fun = partial(jsp_signal.detrend, axis=axis, type=type, bp=bp)\n+ signal = np.random.normal(loc=2, size=shape)\n+\n+ if type == 'constant':\n+ trend = np.ones_like(signal)\n+ elif type == 'linear':\n+ trend = np.linspace(-np.pi, np.pi, shape[0])\n+ if len(shape) == 1:\n+ trend = np.broadcast_to(trend, shape)\n+ elif len(shape) == 2:\n+ trend = np.broadcast_to(trend[:, None], shape)\n+ elif len(shape) == 3:\n+ trend = np.broadcast_to(trend[:, None, None], shape)\n+\n+ args_maker = lambda: [signal, trend]\n+\n+ def osp_fun(signal, trend):\n+ return osp_signal.detrend(\n+ signal + trend, axis=axis, type=type, bp=bp) - trend\n+\n+ def jsp_fun(signal, noise):\n+ return jsp_signal.detrend(\n+ signal + noise, axis=axis, type=type, bp=bp) - trend\n+\n+ if jtu.device_under_test() == 'tpu':\n+ tol = {np.float32: 7e-3, np.float64: 1e-12}\n+ else:\ntol = {np.float32: 1e-5, np.float64: 1e-12}\n+\nself._CheckAgainstNumpy(osp_fun, jsp_fun, args_maker, tol=tol)\nself._CompileAndCheck(jsp_fun, args_maker, rtol=tol, atol=tol)\n"
}
] | Python | Apache License 2.0 | google/jax | [signal] Update signal detrend test.
PiperOrigin-RevId: 445253797 |
260,335 | 28.04.2022 22:51:41 | 25,200 | 477dfa6e469bb0aa463b5bdbc04bd9f17a903dde | [remove-units] don't use abstract_unit for dropvar avals | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -554,7 +554,7 @@ class JaxprTracer(Tracer):\n@property\ndef parents(self) -> Sequence[JaxprTracer]:\nif isinstance(self.recipe, JaxprEqnRecipe):\n- return self.recipe.invars\n+ return self.recipe.in_tracers\nelse:\nreturn []\n@@ -655,34 +655,27 @@ FreeVar = namedtuple('FreeVar', ['val'])\nConstVar = namedtuple('ConstVar', ['val'])\nLambdaBinding = namedtuple('LambdaBinding', [])\nclass JaxprEqnRecipe(NamedTuple):\n- eqn_id: object\n- invars: Sequence[JaxprTracer]\n- outvars: Sequence[ref[JaxprTracer]]\n+ eqn_id: Any\n+ in_tracers: Sequence[JaxprTracer]\n+ out_tracer_refs: Sequence[ref[JaxprTracer]]\n+ out_avals: Sequence[core.AbstractValue]\nprimitive: Primitive\nparams: Dict[str, Any]\neffects: core.Effects\nsource_info: source_info_util.SourceInfo\n-def new_eqn_recipe(invars: Sequence[JaxprTracer],\n- outvars: Sequence[JaxprTracer],\n+def new_eqn_recipe(in_tracers: Sequence[JaxprTracer],\n+ out_tracers: Sequence[JaxprTracer],\nprimitive: Primitive,\nparams: Dict[str, Any],\neffects: core.Effects,\nsource_info: source_info_util.SourceInfo\n) -> JaxprEqnRecipe:\n- \"\"\"Constructs a new JaxEqnRecipe.\n-\n- Params:\n- invars: the tracers for the primitive inputs.\n- outvars: the tracers for the primitive outputs.\n- primitive: the primitive.\n- params: the primitive params\n- \"\"\"\n# TODO(necula): move these checks to core.check_jaxpr, and call in more places\nif primitive.call_primitive or primitive.map_primitive:\nassert \"call_jaxpr\" in params\n# assert len(invars) == len(params[\"call_jaxpr\"].invars) # TODO constvars?\n- assert len(outvars) == len(params[\"call_jaxpr\"].outvars)\n+ assert len(out_tracers) == len(params[\"call_jaxpr\"].outvars)\nassert (\"donated_invars\" not in params or\nlen(params[\"donated_invars\"]) == len(params[\"call_jaxpr\"].invars))\nif primitive.map_primitive:\n@@ -690,18 +683,19 @@ def new_eqn_recipe(invars: Sequence[JaxprTracer],\nlen(params[\"in_axes\"]) == len(params[\"call_jaxpr\"].invars))\nassert (\"donated_invars\" in params and\nlen(params[\"donated_invars\"]) == len(params[\"call_jaxpr\"].invars))\n- return JaxprEqnRecipe(object(), tuple(invars), map(ref, outvars), primitive,\n- params, effects, source_info)\n+ out_avals = [core.raise_to_shaped(t.aval) for t in out_tracers]\n+ return JaxprEqnRecipe(object(), tuple(in_tracers), map(ref, out_tracers),\n+ out_avals, primitive, params, effects, source_info)\ndef recipe_to_eqn(getvar: Callable[[JaxprTracer], Atom],\nrecipe: JaxprEqnRecipe) -> core.JaxprEqn:\n- _, in_tracers, out_tracer_refs, primitive, params, effects, source_info = recipe\n- out_tracers = [t_ref() for t_ref in out_tracer_refs]\n+ (_, in_tracers, out_tracer_refs, out_avals, prim, params, eff, src) = recipe\ninvars = [getvar(t) for t in in_tracers]\n- outvars = [DropVar(core.abstract_unit) if t is None\n- else cast(Var, getvar(t)) for t in out_tracers]\n- return new_jaxpr_eqn(invars, outvars, primitive, params, effects, source_info)\n+ out_tracers = [t_ref() for t_ref in out_tracer_refs]\n+ outvars = [DropVar(a) if t is None else getvar(t) # type: ignore\n+ for a, t in zip(out_avals, out_tracers)]\n+ return new_jaxpr_eqn(invars, outvars, prim, params, eff, src)\ndef tracers_to_jaxpr(\nin_tracers: Sequence[JaxprTracer],\n@@ -750,7 +744,7 @@ def tracers_to_jaxpr(\nt, \"Tracer not among input tracers {}\".format(t))\nassert in_tracers, \"Lambda binding with no args\"\nelif isinstance(recipe, FreeVar):\n- env[cast(Var, getvar(t))] = recipe.val\n+ env[getvar(t)] = recipe.val # type: ignore\nelif isinstance(recipe, ConstVar):\nv = t_to_var[id(t)] = getconstvar(recipe.val)\nconsts[v] = recipe.val\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/core_test.py",
"new_path": "tests/core_test.py",
"diff": "@@ -343,6 +343,19 @@ class CoreTest(jtu.JaxTestCase):\nnp.array([1], dtype=np.int32))),\n'ConcreteArray([1], dtype=int32)')\n+ def test_dropvar_avals(self):\n+ def f(x):\n+ def body(c, _):\n+ return c, None\n+ (x1, x2), _ = jax.lax.scan(body, (x, x), None, length=1)\n+ return [x2]\n+\n+ aval = core.ShapedArray((), jnp.dtype('int32'))\n+ pval = pe.PartialVal.unknown(aval)\n+ jaxpr, _, _ = pe.trace_to_jaxpr_nounits(lu.wrap_init(f), [pval], False)\n+ dropvar, b = jaxpr.eqns[0].outvars\n+ self.assertEqual(dropvar.aval, aval)\n+\nclass JaxprTypeChecks(jtu.JaxTestCase):\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] don't use abstract_unit for dropvar avals |
260,335 | 29.04.2022 10:56:03 | 25,200 | ec8252fce265e638bd7f9ba9542414a54f0d5b86 | broken remat test! | [
{
"change_type": "MODIFY",
"old_path": "tests/api_test.py",
"new_path": "tests/api_test.py",
"diff": "@@ -4344,6 +4344,15 @@ class RematTest(jtu.JaxTestCase):\nf_vjp(1.)[0].block_until_ready()\nself.assertEqual(count[0], 1) # fwd execute_trivial, backward_pass on bwd\n+ def test_remat_of_scan(self):\n+ to_scan = lambda c, _: (jnp.sin(c), jnp.sin(c))\n+ f = lambda x: lax.scan(to_scan, x, None, length=3)\n+ jtu.check_grads(jax.remat(f), (3.,), order=2, modes=['rev'])\n+\n+ jaxpr = api.make_jaxpr(api.linearize(jax.remat(f), 4.)[1])(1.)\n+ self.assertIn(' sin ', str(jaxpr))\n+ self.assertIn(' cos ', str(jaxpr))\n+\nclass JaxprTest(jtu.JaxTestCase):\n"
}
] | Python | Apache License 2.0 | google/jax | broken remat test! |
260,335 | 29.04.2022 11:01:32 | 25,200 | 36b0506b4d23b109fac40cd8b82440b66c473c2d | fix scan dce rule | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/control_flow.py",
"new_path": "jax/_src/lax/control_flow.py",
"diff": "@@ -1807,6 +1807,7 @@ def _scan_partial_eval(trace, *tracers, reverse, length, num_consts, num_carry,\n[False] * len(extensive_res))\nname_stack = source_info_util.current_name_stack()[len(trace.name_stack):]\nsource = source_info_util.current().replace(name_stack=name_stack)\n+ assert len(out_tracers) == len(jaxpr_unknown.out_avals)\neqn = pe.new_eqn_recipe([*intensive_res, *unknown_inputs, *extensive_res],\nout_tracers, scan_p,\ndict(reverse=reverse, length=length, unroll=unroll,\n@@ -1985,8 +1986,8 @@ def _scan_dce_rule(used_outputs: List[bool], eqn: core.JaxprEqn\nnum_consts, num_carry = eqn.params['num_consts'], eqn.params['num_carry']\nused_carry_out, used_extensive_out = split_list(used_outputs, [num_carry])\nfor i in range(1 + num_carry):\n- jaxpr, used_inputs = pe.dce_jaxpr(eqn.params['jaxpr'].jaxpr,\n- used_carry_out + used_extensive_out)\n+ used_outputs = used_carry_out + used_extensive_out\n+ jaxpr, used_inputs = pe.dce_jaxpr(eqn.params['jaxpr'].jaxpr, used_outputs)\nused_consts, used_carry_in, used_extensive_in = \\\nsplit_list(used_inputs, [num_consts, num_carry])\nif used_carry_in == used_carry_out:\n@@ -2000,10 +2001,13 @@ def _scan_dce_rule(used_outputs: List[bool], eqn: core.JaxprEqn\nnew_params = dict(eqn.params, num_consts=sum(used_consts),\nnum_carry=sum(used_carry_in), linear=tuple(new_linear),\njaxpr=core.ClosedJaxpr(jaxpr, eqn.params['jaxpr'].consts))\n- new_eqn = pe.new_jaxpr_eqn([v for v, used in zip(eqn.invars, used_inputs) if used],\n- [v for v, used in zip(eqn.outvars, used_outputs) if used],\n+ new_eqn = pe.new_jaxpr_eqn([v for v, used in zip(eqn.invars, used_inputs)\n+ if used],\n+ [v for v, used in zip(eqn.outvars, used_outputs)\n+ if used],\neqn.primitive, new_params, eqn.effects,\neqn.source_info)\n+ assert len(new_eqn.outvars) == len(new_params['jaxpr'].out_avals)\nreturn used_inputs, new_eqn\ndef _scan_typecheck(bind_time, *avals, reverse, length, num_consts, num_carry,\n"
}
] | Python | Apache License 2.0 | google/jax | fix scan dce rule
Co-authored-by: Roy Frostig <frostig@google.com> |
260,453 | 29.04.2022 14:20:50 | 14,400 | b276c31b75f25bcfbbc75f85f80489bd4a507906 | Added random.orthogonal. | [
{
"change_type": "MODIFY",
"old_path": "CHANGELOG.md",
"new_path": "CHANGELOG.md",
"diff": "@@ -44,6 +44,7 @@ PLEASE REMEMBER TO CHANGE THE '..main' WITH AN ACTUAL TAG in GITHUB LINK.\nis not of an integer type, matching the behavior of\n{func}`numpy.diag`. Previously non-integer `k` was silently\ncast to integers.\n+ * Added {func}`jax.random.orthogonal`.\n* Deprecations\n* Many functions and objects available in {mod}`jax.test_util` are now deprecated and will raise a\nwarning on import. This includes `cases_from_list`, `check_close`, `check_eq`, `device_under_test`,\n"
},
{
"change_type": "MODIFY",
"old_path": "docs/jax.random.rst",
"new_path": "docs/jax.random.rst",
"diff": "@@ -33,6 +33,7 @@ List of Available Functions\nmaxwell\nmultivariate_normal\nnormal\n+ orthogonal\npareto\npermutation\npoisson\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/_src/random.py",
"new_path": "jax/_src/random.py",
"diff": "from functools import partial\nfrom typing import Any, Optional, Sequence, Union\n+from operator import index\nimport warnings\nimport numpy as np\n@@ -1595,3 +1596,30 @@ def threefry_2x32(keypair, count):\nwarnings.warn('jax.random.threefry_2x32 has moved to jax.prng.threefry_2x32 '\n'and will be removed from `random` module.', FutureWarning)\nreturn prng.threefry_2x32(keypair, count)\n+\n+def orthogonal(\n+ key: KeyArray,\n+ n: int,\n+ shape: Sequence[int] = (),\n+ dtype: DTypeLikeFloat = dtypes.float_\n+) -> jnp.ndarray:\n+ \"\"\"Sample uniformly from the orthogonal group O(n).\n+\n+ If the dtype is complex, sample uniformly from the unitary group U(n).\n+\n+ Args:\n+ key: a PRNG key used as the random key.\n+ n: an integer indicating the resulting dimension.\n+ shape: optional, the batch dimensions of the result. Default ().\n+ dtype: optional, a float dtype for the returned values (default float64 if\n+ jax_enable_x64 is true, otherwise float32).\n+\n+ Returns:\n+ A random array of shape `(*shape, n, n)` and specified dtype.\n+ \"\"\"\n+ _check_shape(\"orthogonal\", shape)\n+ n = core.concrete_or_error(index, n, \"The error occurred in jax.random.orthogonal()\")\n+ z = normal(key, (*shape, n, n), dtype)\n+ q, r = jnp.linalg.qr(z)\n+ d = jnp.diagonal(r, 0, -2, -1)\n+ return q * jnp.expand_dims(d / abs(d), -2)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/random.py",
"new_path": "jax/random.py",
"diff": "@@ -143,6 +143,7 @@ from jax._src.random import (\nmaxwell as maxwell,\nmultivariate_normal as multivariate_normal,\nnormal as normal,\n+ orthogonal as orthogonal,\npareto as pareto,\npermutation as permutation,\npoisson as poisson,\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/random_test.py",
"new_path": "tests/random_test.py",
"diff": "@@ -1032,6 +1032,26 @@ class LaxRandomTest(jtu.JaxTestCase):\nfor samples in [uncompiled_samples, compiled_samples]:\nself._CheckKolmogorovSmirnovCDF(samples, scipy.stats.logistic().cdf)\n+ @parameterized.named_parameters(jtu.cases_from_list(\n+ {\"testcase_name\": \"_n={}_shape={}\"\\\n+ .format(n, jtu.format_shape_dtype_string(shape, dtype)),\n+ \"n\": n,\n+ \"shape\": shape,\n+ \"dtype\": dtype}\n+ for n in range(1, 5)\n+ for shape in [(), (5,), (10, 5)]\n+ for dtype in jtu.dtypes.floating + jtu.dtypes.complex))\n+ def testOrthogonal(self, n, shape, dtype):\n+ key = self.seed_prng(0)\n+ q = random.orthogonal(key, n, shape, dtype)\n+ self.assertEqual(q.shape, (*shape, n, n))\n+ self.assertEqual(q.dtype, dtype)\n+ with jax.numpy_rank_promotion('allow'):\n+ self.assertAllClose(\n+ jnp.einsum('...ij,...jk->...ik', q, jnp.conj(q).swapaxes(-2, -1)),\n+ jnp.broadcast_to(jnp.eye(n, dtype=dtype), (*shape, n, n))\n+ )\n+\n@parameterized.named_parameters(jtu.cases_from_list(\n{\"testcase_name\": \"_b={}_dtype={}\".format(b, np.dtype(dtype).name),\n\"b\": b, \"dtype\": dtype}\n"
}
] | Python | Apache License 2.0 | google/jax | Added random.orthogonal. |
260,335 | 29.04.2022 14:54:07 | 25,200 | 5a3d2e3eeae20d0aca2d24019eb5628fe8d4969d | [remove-units] remove partial_eval_jaxpr (no callers!) | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -2146,52 +2146,3 @@ def partial_eval_wrapper(pvs: Sequence[Optional[AbstractValue]], *consts):\nout_pvs, out_consts = unzip2(out_pvals)\nout = tuple(out_consts) + tuple(consts)\nyield out, (out_pvs, jaxpr, env)\n-\n-def partial_eval_jaxpr(jaxpr: ClosedJaxpr, unknowns: Sequence[bool],\n- instantiate: Union[bool, Sequence[bool]],\n- ) -> Tuple[ClosedJaxpr, ClosedJaxpr, Sequence[bool]]:\n- instantiate = tuple(instantiate) if isinstance(instantiate, list) else instantiate\n- return _partial_eval_jaxpr(jaxpr, tuple(unknowns), instantiate)\n-\n-@weakref_lru_cache\n-def _partial_eval_jaxpr(jaxpr, unknowns, instantiate):\n- f = lu.wrap_init(core.jaxpr_as_fun(jaxpr))\n-\n- cell = []\n- def fun(*vals):\n- pvals = [PartialVal.unknown(aval) if uk else PartialVal.known(val)\n- for aval, val, uk in zip(jaxpr.in_avals, vals, unknowns)]\n- jaxpr_2, out_pvals_2, consts_2 = trace_to_jaxpr(f, pvals, instantiate=instantiate)\n- out_pvs_2, out_consts_2 = unzip2(out_pvals_2)\n- cell.append((out_pvs_2, jaxpr_2, len(consts_2)))\n- return out_consts_2 + consts_2\n-\n- # For jaxpr_known we pass core.unit for the unknown inputs, and known\n- # PartialVal for the known inputs.\n- in_avals = [core.abstract_unit if uk else a\n- for a, uk in zip(jaxpr.in_avals, unknowns)]\n- jaxpr_1, out_avals, consts_1 = trace_to_jaxpr_dynamic(lu.wrap_init(fun), in_avals)\n- (out_pvs_2, jaxpr_2, num_res), = cell\n- assert len(jaxpr_2.constvars) == num_res\n-\n- # jaxpr :: a -> b\n- # jaxpr_1 :: a1 -> [b1, res]\n- # jaxpr_2 :: res | a2 -> b2\n- # jaxpr_2 :: [a2, res] -> b2\n- jaxpr_2 = convert_constvars_jaxpr(jaxpr_2)\n- jaxpr_2.invars = jaxpr_2.invars[num_res:] + jaxpr_2.invars[:num_res]\n- for var, unknown in zip(jaxpr_2.invars[:len(unknowns)], unknowns):\n- if not unknown:\n- var.aval = core.abstract_unit\n-\n- uk_out = [pv is not None for pv in out_pvs_2]\n-\n- in_avals_1, in_avals_2 = unzip2(map(_split_aval, unknowns, jaxpr.in_avals))\n- out_avals_1, out_avals_2 = unzip2(map(_split_aval, uk_out, jaxpr.out_avals))\n- # out_avals_1 and in_avals_2 need the residuals added\n- res_avals = out_avals[len(jaxpr.out_avals):]\n- assert len(res_avals) == num_res\n- out_avals_1 = [*out_avals_1, *res_avals]\n- in_avals_2 = [*in_avals_2, *res_avals]\n-\n- return ClosedJaxpr(jaxpr_1, consts_1), ClosedJaxpr(jaxpr_2, ()), uk_out\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] remove partial_eval_jaxpr (no callers!) |
260,335 | 29.04.2022 15:37:27 | 25,200 | 85dcad397adaa4d1bc8f912447c529778dab28b7 | [remove-units] remove units from custom_jvp/vjp | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -376,42 +376,45 @@ class JaxprTrace(Trace):\ndef _current_truncated_name_stack(self):\nreturn source_info_util.current_name_stack()[len(self.name_stack):]\n- def process_custom_jvp_call(self, prim, fun, jvp, tracers):\n+ def process_custom_jvp_call(self, prim, f, jvp, tracers):\n+ # TODO(mattjj): after old remat is deleted, make this method trivial:\n+ # https://github.com/google/jax/pull/9137/files#diff-440d9df723b313bb263bc7704103cad1dcc886ff6553aa78c30188b0b323b686R319-R323\n+ # Because we instantiate all tracers, in_knowns is all False.\ntracers = map(self.instantiate_const_abstracted, tracers)\n- in_avals, in_consts = unzip2(t.pval for t in tracers) # in_consts are units\n- fun = trace_to_subjaxpr(fun, self.main, True)\n- fun, aux = partial_eval_wrapper(fun, tuple(in_avals))\n- out_flat = prim.bind(fun, jvp, *in_consts)\n- out_avals, jaxpr, env = aux()\n- out_consts, consts = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\n- out_pvals = map(PartialVal, zip(out_avals, out_consts)) # out_consts are units\n+ in_knowns, in_avals, () = partition_pvals([t.pval for t in tracers])\n+ f = trace_to_subjaxpr_nounits(f, self.main, True)\n+ f, aux = partial_eval_wrapper_nounits(f, tuple(in_knowns), tuple(in_avals))\n+ out_flat = prim.bind(f, jvp)\n+ out_knowns, out_avals, jaxpr, env = aux()\n+ out_consts, res = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\n+ res_tracers = map(self.new_instantiated_const, res)\nenv_tracers = map(self.full_raise, env)\n- out_tracers = [JaxprTracer(self, pval, None) for pval in out_pvals]\n- const_tracers = map(self.new_instantiated_const, consts)\n- in_tracers = (*const_tracers, *env_tracers, *tracers)\n+ out_tracers = [JaxprTracer(self, PartialVal.unknown(a), None)\n+ for a in out_avals]\nclosed_jaxpr = core.ClosedJaxpr(convert_constvars_jaxpr(jaxpr), ())\n@_memoize\ndef jvp_jaxpr_thunk():\n- jvp_ = trace_to_subjaxpr(jvp, self.main, True)\n- jvp_, aux = partial_eval_wrapper(jvp_, tuple(in_avals) * 2)\n+ jvp_ = trace_to_subjaxpr_nounits(jvp, self.main, True)\n+ jvp_, aux = partial_eval_wrapper_nounits(\n+ jvp_, tuple(in_knowns) * 2, tuple(in_avals) * 2)\nwith core.new_sublevel():\n- out_flat = jvp_.call_wrapped(*(in_consts * 2)) # in_consts are units\n- out_avals, jaxpr, env = aux()\n- _, consts = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\n+ out_flat = jvp_.call_wrapped()\n+ out_knowns, out_avals, jaxpr, env = aux()\n+ _, res = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\nconverted_jaxpr = convert_envvars_to_constvars(jaxpr, len(env))\n- return converted_jaxpr, (*consts, *env)\n+ return converted_jaxpr, (*res, *env)\nname_stack = self._current_truncated_name_stack()\nsource = source_info_util.current().replace(name_stack=name_stack)\n- eqn = new_eqn_recipe(in_tracers, out_tracers, prim.initial_style,\n+ eqn = new_eqn_recipe((*res_tracers, *env_tracers, *tracers),\n+ out_tracers, prim.initial_style,\ndict(fun_jaxpr=closed_jaxpr,\njvp_jaxpr_thunk=jvp_jaxpr_thunk,\n- num_consts=len(consts) + len(env)),\n- jaxpr.effects,\n- source)\n+ num_consts=len(res)+len(env)),\n+ jaxpr.effects, source)\nfor t in out_tracers: t.recipe = eqn\n- return out_tracers\n+ return merge_lists(out_knowns, out_tracers, out_consts)\ndef post_process_custom_jvp_call(self, out_tracers, _):\n# This path should only be reachable if we expose a partial eval API\n@@ -437,43 +440,45 @@ class JaxprTrace(Trace):\nfor t in out_tracers: t.recipe = eqn\nreturn out_tracers\n- def process_custom_vjp_call(self, prim, fun, fwd, bwd, tracers, out_trees):\n+ def process_custom_vjp_call(self, prim, f, fwd, bwd, tracers, out_trees):\n+ # TODO(mattjj): after old remat is deleted, make this method trivial.\n+ # Because we instantiate all tracers, in_knowns is all False.\ntracers = map(self.instantiate_const_abstracted, tracers)\n- in_avals, in_consts = unzip2(t.pval for t in tracers) # in_consts are units\n- fun = trace_to_subjaxpr(fun, self.main, True)\n- fun, aux = partial_eval_wrapper(fun, tuple(in_avals))\n- out_flat = prim.bind(fun, fwd, bwd, *in_consts, out_trees=out_trees)\n- out_avals, jaxpr, env = aux()\n- out_consts, consts = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\n- out_pvals = map(PartialVal, zip(out_avals, out_consts)) # out_consts are units\n+ in_knowns, in_avals, () = partition_pvals([t.pval for t in tracers])\n+ f = trace_to_subjaxpr_nounits(f, self.main, True)\n+ f, aux = partial_eval_wrapper_nounits(f, tuple(in_knowns), tuple(in_avals))\n+ out_flat = prim.bind(f, fwd, bwd, out_trees=out_trees)\n+ out_knowns, out_avals, jaxpr, env = aux()\n+ out_consts, res = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\n+ res_tracers = map(self.new_instantiated_const, res)\nenv_tracers = map(self.full_raise, env)\n- out_tracers = [JaxprTracer(self, pval, None) for pval in out_pvals]\n- const_tracers = map(self.new_instantiated_const, consts)\n- in_tracers = (*const_tracers, *env_tracers, *tracers)\n+ out_tracers = [JaxprTracer(self, PartialVal.unknown(a), None)\n+ for a in out_avals]\nclosed_jaxpr = core.ClosedJaxpr(convert_constvars_jaxpr(jaxpr), ())\n@_memoize\ndef fwd_jaxpr_thunk():\n- fwd_ = trace_to_subjaxpr(fwd, self.main, True)\n- fwd_, aux = partial_eval_wrapper(fwd_, tuple(in_avals))\n+ fwd_ = trace_to_subjaxpr_nounits(fwd, self.main, True)\n+ fwd_, aux = partial_eval_wrapper_nounits(\n+ fwd_, tuple(in_knowns), tuple(in_avals))\nwith core.new_sublevel():\n- out_flat = fwd_.call_wrapped(*in_consts) # in_consts are units\n- out_avals, jaxpr, env = aux()\n- _, consts = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\n+ out_flat = fwd_.call_wrapped()\n+ out_knowns, out_avals, jaxpr, env = aux()\n+ _, res = split_list(out_flat, [len(out_flat)-len(jaxpr.constvars)])\nconverted_jaxpr = convert_envvars_to_constvars(jaxpr, len(env))\n- return converted_jaxpr, (*consts, *env)\n+ return converted_jaxpr, (*res, *env)\nname_stack = self._current_truncated_name_stack()\nsource = source_info_util.current().replace(name_stack=name_stack)\n- eqn = new_eqn_recipe(in_tracers, out_tracers, prim.initial_style,\n+ eqn = new_eqn_recipe((*res_tracers, *env_tracers, *tracers),\n+ out_tracers, prim.initial_style,\ndict(fun_jaxpr=closed_jaxpr,\nfwd_jaxpr_thunk=fwd_jaxpr_thunk,\n- num_consts=len(consts) + len(env),\n+ num_consts=len(res) + len(env),\nbwd=bwd, out_trees=out_trees),\n- jaxpr.effects,\n- source)\n+ jaxpr.effects, source)\nfor t in out_tracers: t.recipe = eqn\n- return out_tracers\n+ return merge_lists(out_knowns, out_tracers, out_consts)\ndef post_process_custom_vjp_call(self, out_tracers, _):\n# This path should only be reachable if we expose a partial eval API\n@@ -2138,11 +2143,3 @@ def trace_to_subjaxpr(main: core.MainTrace, instantiate: Union[bool, Sequence[bo\nout_pvals = [t.pval for t in out_tracers]\ndel trace, in_tracers, out_tracers\nyield jaxpr, (out_pvals, consts, env)\n-\n-@lu.transformation_with_aux\n-def partial_eval_wrapper(pvs: Sequence[Optional[AbstractValue]], *consts):\n- py_args = map(PartialVal, zip(pvs, consts))\n- jaxpr, (out_pvals, consts, env) = yield (py_args,), {}\n- out_pvs, out_consts = unzip2(out_pvals)\n- out = tuple(out_consts) + tuple(consts)\n- yield out, (out_pvs, jaxpr, env)\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] remove units from custom_jvp/vjp |
260,335 | 29.04.2022 16:16:08 | 25,200 | 58a2f47af9f4fa0c943c3e4ae5c1db9930ca9817 | [remove-units] avoid units in new remat
The new remat implementation called a unit-generating function in its transpose
rule. But there's no need for that! | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/ad_checkpoint.py",
"new_path": "jax/_src/ad_checkpoint.py",
"diff": "@@ -353,11 +353,15 @@ def remat_transpose(reduce_axes, out_cts, *in_primals, jaxpr, **params):\nin_pvals = [pe.PartialVal.unknown(x.aval) if ad.is_undefined_primal(x) else\npe.PartialVal.known(x) for x in in_primals]\nprimal_fun = lu.wrap_init(partial(core.eval_jaxpr, jaxpr, ()))\n- tangent_jaxpr, _, consts = pe.trace_to_jaxpr(primal_fun, in_pvals, False)\n- dummy_args = [ad.UndefinedPrimal(v.aval) for v in tangent_jaxpr.invars]\n- in_cts_ = ad.backward_pass(tangent_jaxpr, reduce_axes, False, consts, dummy_args,\n+ t_jaxpr, _, consts = pe.trace_to_jaxpr_nounits(primal_fun, in_pvals, False)\n+ dummy_args = [ad.UndefinedPrimal(v.aval) for v in t_jaxpr.invars]\n+ in_cts = ad.backward_pass(t_jaxpr, reduce_axes, False, consts, dummy_args,\nout_cts)\n- in_cts, cell.treedef = tree_flatten(in_cts_)\n+ in_cts_ = iter(in_cts)\n+ in_cts = [next(in_cts_) if ad.is_undefined_primal(x)\n+ else ad_util.Zero(x.aval) for x in in_primals]\n+ assert next(in_cts_, None) is None\n+ in_cts, cell.treedef = tree_flatten(in_cts)\nreturn in_cts\nargs, treedef = tree_flatten((in_primals, out_cts))\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] avoid units in new remat
The new remat implementation called a unit-generating function in its transpose
rule. But there's no need for that! |
260,335 | 29.04.2022 15:50:25 | 25,200 | 0bf3241e93acf734afc0ba0875f83ba505984057 | [remove-units] remove now-dead flax helper function | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -1856,14 +1856,6 @@ def trace_to_jaxpr_final(fun: lu.WrappedFun,\ndel fun, main\nreturn jaxpr, out_avals, consts\n-def partial_eval_to_jaxpr_dynamic(fun: lu.WrappedFun, in_pvals: Sequence[PartialVal]):\n- # This function provides a partial evaluation behavior used by Flax. We can't\n- # use trace_to_jaxpr directly because of an interaction with the curent\n- # custom_derivatives.py, which we work around by adding the EvalTrace.\n- # TODO(mattjj): alias to trace_to_jaxpr after revising custom_derivatives.py\n- with core.new_main(core.EvalTrace, dynamic=True) as _: # type: ignore\n- return trace_to_jaxpr(fun, in_pvals)\n-\nAbstractedAxisName = Hashable\nAbstractedAxesSpec = Union[Dict[int, AbstractedAxisName], Tuple[AbstractedAxisName, ...]]\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] remove now-dead flax helper function |
260,335 | 29.04.2022 16:28:08 | 25,200 | f970f5885764d6f9d594f0af7e43eadefcc17d54 | [remove-units] avoid unit-generating function in lax.reduce | [
{
"change_type": "MODIFY",
"old_path": "jax/_src/lax/lax.py",
"new_path": "jax/_src/lax/lax.py",
"diff": "@@ -938,7 +938,6 @@ def reduce(operands: Any,\n@cache()\ndef _reduction_jaxpr(computation, aval):\n- pval = pe.PartialVal.unknown(aval)\n@lu.wrap_init\ndef comp(x, y):\nresult = computation(x, y)\n@@ -948,8 +947,12 @@ def _reduction_jaxpr(computation, aval):\nf\"Reduction functions should only return an array.\\n\"\nf\"Full return value: {result}\")\nreturn (result,)\n- jaxpr, _, consts = pe.trace_to_jaxpr(comp, (pval, pval), instantiate=False)\n- return jaxpr, consts\n+ jaxpr, _, consts = pe.trace_to_jaxpr_dynamic(comp, (aval, aval))\n+ if any(isinstance(c, core.Tracer) for c in consts):\n+ raise NotImplementedError(\n+ \"Reduction computations can't close over Tracers. Please open an issue \"\n+ \"at https://github.com/google/jax.\")\n+ return jaxpr, tuple(consts)\n@cache()\ndef _variadic_reduction_jaxpr(computation, flat_avals, aval_tree):\n@@ -958,6 +961,10 @@ def _variadic_reduction_jaxpr(computation, flat_avals, aval_tree):\ncomp = lu.wrap_init(computation)\nflat_comp, out_tree = api_util.flatten_fun_nokwargs(comp, in_tree)\njaxpr, _, consts = pe.trace_to_jaxpr_dynamic(flat_comp, tuple(flat_in_avals))\n+ if any(isinstance(c, core.Tracer) for c in consts):\n+ raise NotImplementedError(\n+ \"Reduction computations can't close over Tracers. Please open an issue \"\n+ \"at https://github.com/google/jax.\")\nreturn jaxpr, tuple(consts), out_tree()\ndef _get_monoid_reducer(monoid_op: Callable,\n"
}
] | Python | Apache License 2.0 | google/jax | [remove-units] avoid unit-generating function in lax.reduce |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.