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,335 | 17.12.2018 22:21:59 | 28,800 | d8388e2d80379051063aef61b9ff06752d9f31ac | complete support for two-operand einsum | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1120,13 +1120,16 @@ def einsum(*operands):\nrhs, rhs_names = sum_repeats(rhs, rhs_names, rhs_counts,\nresult_names + lhs_names)\n- # contract lhs against rhs\ncontracted_names = contracted_names & (set(lhs_names) | set(rhs_names))\nbatch_names = set(lhs_names) & set(rhs_names) - contracted_names\n- lhs_cont, rhs_cont = unzip2((lhs_names.index(name), rhs_names.index(name))\n- for name in contracted_names)\n- lhs_batch, rhs_batch = unzip2((lhs_names.find(name), rhs_names.find(name))\n- for name in batch_names)\n+ lhs_batch, rhs_batch = unzip2((lhs_names.find(n), rhs_names.find(n))\n+ for n in batch_names)\n+ if contracted_names:\n+ # contract usint lax.dot_general\n+ lhs_cont, rhs_cont = unzip2((lhs_names.index(n), rhs_names.index(n))\n+ for n in contracted_names)\n+\n+ # lax.dot_general batch dims have to precede non-batch dims\nbatch_dims = tuple(range(len(batch_names)))\nif lhs_batch != rhs_batch or set(lhs_batch) != set(batch_dims):\nlhs = moveaxis(lhs, lhs_batch, batch_dims)\n@@ -1136,13 +1139,34 @@ def einsum(*operands):\nbatch_dims = tuple(lhs_batch)\nbatch_names = ''.join(lhs_names[i] for i in batch_dims)\n- # TODO need to flatten lhs_cont / rhs_cont if more than 1d\n+ # lax.dot_general only allows one contracting dimension, move it to last\n+ ncont = len(contracted_names)\n+ if ncont > 1:\n+ cdims = tuple(range(lhs.ndim - ncont, lhs.ndim))\n+ lhs = moveaxis(lhs, lhs_cont, cdims).reshape(lhs.shape[:-ncont] + (-1,))\n+ rhs = moveaxis(rhs, rhs_cont, cdims).reshape(rhs.shape[:-ncont] + (-1,))\n+ lhs_cont = rhs_cont = [lhs.ndim - 1]\n+\ndimension_numbers = [(lhs_cont, rhs_cont), (batch_dims, batch_dims)]\noperand = lax.dot_general(lhs, rhs, dimension_numbers)\ndeleted_names = batch_names + ''.join(contracted_names)\nnames = (batch_names\n+ lhs_names.translate(None, deleted_names)\n+ rhs_names.translate(None, deleted_names))\n+ else:\n+ # no contraction, just a tensor product\n+ if lhs_batch != rhs_batch:\n+ rhs = moveaxis(rhs, rhs_batch, lhs_batch)\n+ batch_names = ''.join(lhs_names[i] for i in lhs_batch)\n+\n+ names = batch_names + lhs_names + rhs_names\n+ lhs_shape = iter(lhs.shape)\n+ lhs_shape = [next(lhs_shape) if n in batch_names + lhs_names else 1\n+ for n in names]\n+ rhs_shape = iter(rhs.shape)\n+ rhs_shape = [next(rhs_shape) if n in batch_names + rhs_names else 1\n+ for n in names]\n+ operand = lax.reshape(lhs, lhs_shape) * lax.reshape(rhs, rhs_shape)\nelse:\nraise NotImplementedError\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_einsum_test.py",
"new_path": "tests/lax_numpy_einsum_test.py",
"diff": "@@ -37,6 +37,20 @@ def check(s, *ops):\nclass EinsumTest(jtu.JaxTestCase):\n+ def test_three_operands_1(self):\n+ x = rng().randn(3)\n+ y = rng().randn(4)\n+ z = rng().randn(5)\n+ s = 'i,j,k->ijk'\n+ check(s, x, y, z)\n+\n+ def test_three_operands_2(self):\n+ x = rng().randn(3)\n+ y = rng().randn(4)\n+ z = rng().randn(5)\n+ s = 'i,j,k->ijk'\n+ check(s, x, y, z)\n+\ndef test_two_operands_1(self):\nx = rng().randn(3, 4)\ny = rng().randn(4)\n@@ -55,6 +69,12 @@ class EinsumTest(jtu.JaxTestCase):\ns = 'iji,i->j'\ncheck(s, x, y)\n+ def test_two_operands_4(self):\n+ x = rng().randn(3, 4)\n+ y = rng().randn(3, 4)\n+ s = 'ij,ij->'\n+ check(s, x, y)\n+\ndef test_one_operand_1(self):\nx = rng().randn(3, 4, 5)\ns = 'ijk->j'\n"
}
] | Python | Apache License 2.0 | google/jax | complete support for two-operand einsum |
260,335 | 18.12.2018 09:06:01 | 28,800 | 6261ef729a5cd4b9ad3a9bcfca94a7140cb16d60 | more einsum improvements (complete?) | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1060,6 +1060,7 @@ def tensordot(a, b, axes=2):\ndef einsum(*operands):\noperands, contractions = opt_einsum.contract_path(\n*operands, einsum_call=True, use_blas=True)\n+ operands = list(_promote_dtypes(*operands))\nsum = lambda x, axes: lax.reduce(x, onp.array(0, x.dtype), lax.add, axes)\ndef sum_uniques(operand, names, uniques):\n@@ -1139,16 +1140,7 @@ def einsum(*operands):\nbatch_dims = tuple(lhs_batch)\nbatch_names = ''.join(lhs_names[i] for i in batch_dims)\n- # lax.dot_general only allows one contracting dimension, move it to last\n- ncont = len(contracted_names)\n- if ncont > 1:\n- cdims = tuple(range(lhs.ndim - ncont, lhs.ndim))\n- lhs = moveaxis(lhs, lhs_cont, cdims).reshape(lhs.shape[:-ncont] + (-1,))\n- rhs = moveaxis(rhs, rhs_cont, cdims).reshape(rhs.shape[:-ncont] + (-1,))\n- lhs_cont = rhs_cont = [lhs.ndim - 1]\n-\n- dimension_numbers = [(lhs_cont, rhs_cont), (batch_dims, batch_dims)]\n- operand = lax.dot_general(lhs, rhs, dimension_numbers)\n+ operand = _dot_general(lhs, rhs, lhs_cont, rhs_cont, len(batch_dims))\ndeleted_names = batch_names + ''.join(contracted_names)\nnames = (batch_names\n+ lhs_names.translate(None, deleted_names)\n@@ -1183,6 +1175,47 @@ def einsum(*operands):\nreturn operands[0]\n+def _dot_general(lhs, rhs, lhs_cont, rhs_cont, nbatch):\n+ # lax.dot_general has some tight constraints on dimension_numbers that this\n+ # wrapper loosens via transposes and reshapes\n+ assert len(lhs_cont) == len(rhs_cont) > 0\n+ ncont = len(lhs_cont)\n+ lhs_ntensor = lhs.ndim - nbatch - ncont\n+ rhs_ntensor = rhs.ndim - nbatch - ncont\n+ batch_dims = tuple(range(nbatch))\n+\n+ if ncont == 1 and 0 <= lhs_ntensor <= 1 and 0 <= rhs_ntensor <= 1:\n+ dimension_numbers = [(lhs_cont, rhs_cont), (batch_dims, batch_dims)]\n+ return lax.dot_general(lhs, rhs, dimension_numbers)\n+ else:\n+ # move contracting dimensions to the end. lax.dot_general only allows one\n+ # contracting dimension, so if there's more than one we collapse them.\n+ if ncont > 1:\n+ lhs_cdims = tuple(range(lhs.ndim - ncont, lhs.ndim))\n+ lhs = moveaxis(lhs, lhs_cont, lhs_cdims).reshape(lhs.shape[:-ncont] + (-1,))\n+\n+ rhs_cdims = tuple(range(rhs.ndim - ncont, rhs.ndim))\n+ rhs = moveaxis(rhs, rhs_cont, rhs_cdims).reshape(rhs.shape[:-ncont] + (-1,))\n+ else:\n+ lhs = moveaxis(lhs, lhs_cont[0], -1)\n+ rhs = moveaxis(rhs, rhs_cont[0], -1)\n+\n+ # lax.dot_general only allows zero or one tensor product dims per operand,\n+ # so if there's more than one we collapse them.\n+ result_shape = lhs.shape[:nbatch] + lhs.shape[nbatch:-1] + rhs.shape[nbatch:-1]\n+\n+ if lhs_ntensor > 1:\n+ lhs = lhs.reshape(lhs.shape[:nbatch] + (-1,) + lhs.shape[-1:])\n+\n+ if rhs_ntensor > 1:\n+ rhs = rhs.reshape(rhs.shape[:nbatch] + (-1,) + rhs.shape[-1:])\n+\n+ lhs_cont, rhs_cont = [lhs.ndim - 1], [rhs.ndim - 1]\n+ dimension_numbers = [(lhs_cont, rhs_cont), (batch_dims, batch_dims)]\n+ result = lax.dot_general(lhs, rhs, dimension_numbers)\n+ return lax.reshape(result, result_shape)\n+\n+\n### Misc\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_einsum_test.py",
"new_path": "tests/lax_numpy_einsum_test.py",
"diff": "@@ -75,6 +75,12 @@ class EinsumTest(jtu.JaxTestCase):\ns = 'ij,ij->'\ncheck(s, x, y)\n+ def test_two_operands_5(self):\n+ x = rng().randn(10, 2, 3)\n+ y = rng().randn(3, 4)\n+ s = 'nij,jk->nik'\n+ check(s, x, y)\n+\ndef test_one_operand_1(self):\nx = rng().randn(3, 4, 5)\ns = 'ijk->j'\n"
}
] | Python | Apache License 2.0 | google/jax | more einsum improvements (complete?) |
260,335 | 18.12.2018 09:12:49 | 28,800 | 061d033c2bd82b53c448f4e0d81ccfd4d98e268b | add jit around einsum | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -24,6 +24,7 @@ import opt_einsum\nimport collections\nimport itertools\n+from jax import jit\nfrom .. import core\nfrom ..abstract_arrays import UnshapedArray, ShapedArray, ConcreteArray\nfrom ..interpreters.xla import DeviceArray\n@@ -1058,8 +1059,15 @@ def tensordot(a, b, axes=2):\ndef einsum(*operands):\n+ # using einsum_call=True here is an internal api for opt_einsum\noperands, contractions = opt_einsum.contract_path(\n*operands, einsum_call=True, use_blas=True)\n+ contractions = tuple(data[:3] for data in contractions)\n+ return _einsum(operands, contractions)\n+\n+\n+@partial(jit, static_argnums=(1,))\n+def _einsum(operands, contractions):\noperands = list(_promote_dtypes(*operands))\nsum = lambda x, axes: lax.reduce(x, onp.array(0, x.dtype), lax.add, axes)\n@@ -1083,7 +1091,7 @@ def einsum(*operands):\nnames = names.replace(name, '', count - 1)\nreturn operand, names\n- for operand_indices, contracted_names, einstr, _, _ in contractions:\n+ for operand_indices, contracted_names, einstr in contractions:\ninput_str, result_names = einstr.split('->')\ninput_names = input_str.split(',')\n@@ -1176,6 +1184,7 @@ def einsum(*operands):\ndef _dot_general(lhs, rhs, lhs_cont, rhs_cont, nbatch):\n+ \"\"\"Helper for einsum contractions.\"\"\"\n# lax.dot_general has some tight constraints on dimension_numbers that this\n# wrapper loosens via transposes and reshapes\nassert len(lhs_cont) == len(rhs_cont) > 0\n"
}
] | Python | Apache License 2.0 | google/jax | add jit around einsum |
260,335 | 18.12.2018 11:33:44 | 28,800 | d7745dd9af8039f558f63b1eeef8044b88ed2055 | actually fix py3 str translate | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -16,13 +16,14 @@ from __future__ import absolute_import\nfrom __future__ import division\nfrom __future__ import print_function\n-from six.moves import builtins\n+import collections\n+import itertools\n+import string\n-import six\nimport numpy as onp\nimport opt_einsum\n-import collections\n-import itertools\n+import six\n+from six.moves import builtins\nfrom jax import jit\nfrom .. import core\n@@ -32,15 +33,12 @@ from .. import lax\nfrom ..util import memoize, partial, get_module_functions, unzip2, prod as _prod\nfrom ..lib import xla_bridge\n-# To provide the same module-level names as Numpy, we need to redefine builtins\n-# and also use some common names (like 'shape' and 'dtype') at the top-level.\n-# pylint: disable=redefined-builtin,redefined-outer-name\n-\n-# There might be a pylint bug with tuple unpacking.\n-# pylint: disable=unbalanced-tuple-unpacking\n-\n-# We get docstrings from the underlying numpy functions.\n-# pylint: disable=missing-docstring\n+if six.PY3:\n+ def removechars(s, chars):\n+ return s.translate(str.maketrans(dict.fromkeys(chars)))\n+else:\n+ def removechars(s, chars):\n+ return s.translate(None, ''.join(chars))\n# We replace some builtin names to follow Numpy's API, so we capture here.\n@@ -1075,7 +1073,7 @@ def _einsum(operands, contractions):\nif uniques:\naxes = [names.index(name) for name in uniques]\noperand = sum(operand, axes)\n- names = names.translate(None, ''.join(uniques))\n+ names = removechars(names, uniques)\nreturn operand, names\ndef sum_repeats(operand, names, counts, keep_names):\n@@ -1150,9 +1148,8 @@ def _einsum(operands, contractions):\noperand = _dot_general(lhs, rhs, lhs_cont, rhs_cont, len(batch_dims))\ndeleted_names = batch_names + ''.join(contracted_names)\n- names = (batch_names\n- + lhs_names.translate(None, deleted_names)\n- + rhs_names.translate(None, deleted_names))\n+ names = (batch_names + removechars(lhs_names, deleted_names)\n+ + removechars(rhs_names, deleted_names))\nelse:\n# no contraction, just a tensor product\nif lhs_batch != rhs_batch:\n"
}
] | Python | Apache License 2.0 | google/jax | actually fix py3 str translate |
260,335 | 17.12.2018 17:20:52 | 28,800 | 0a9ee106b382326ccf8373707f8577ba8a2afec9 | implement triangular solve lhs jvp (w/ | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/ad.py",
"new_path": "jax/interpreters/ad.py",
"diff": "@@ -328,7 +328,7 @@ defbilinear = partial(defbilinear_broadcasting, lambda g, x: g)\ndef bilinear_transpose(lhs_rule, rhs_rule, cotangent, x, y, **kwargs):\n- assert x is None or y is None\n+ assert (x is None) ^ (y is None)\nif x is None:\nout = zero if cotangent is zero else lhs_rule(cotangent, y, **kwargs)\nreturn out, None\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/lax_linalg.py",
"new_path": "jax/lax_linalg.py",
"diff": "@@ -109,6 +109,16 @@ def triangular_solve_shape_rule(a, b, left_side=False, **unused_kwargs):\nraise TypeError(msg.format(a.shape, b.shape))\nreturn b.shape\n+def triangular_solve_jvp_rule_a(\n+ g_a, ans, a, b, left_side, lower, transpose_a, conjugate_a):\n+ g_a = lax.neg(g_a)\n+ tmp = triangular_solve(a, g_a, left_side, lower, transpose_a, conjugate_a)\n+ dot = lax.dot if g_a.ndim == 2 else lax.batch_matmul\n+ if left_side:\n+ return dot(tmp, ans)\n+ else:\n+ return dot(ans, tmp)\n+\ndef triangular_solve_transpose_rule(\ncotangent, a, b, left_side, lower, transpose_a, conjugate_a):\nassert a is not None and b is None\n@@ -119,9 +129,9 @@ def triangular_solve_transpose_rule(\ntriangular_solve_p = standard_primitive(\ntriangular_solve_shape_rule, triangular_solve_dtype_rule,\n'triangular_solve')\n-ad.defjvp(triangular_solve_p,\n- None,\n- lambda g_b, a, b, **kwargs: triangular_solve(a, g_b, **kwargs))\n+ad.defjvp2(triangular_solve_p,\n+ triangular_solve_jvp_rule_a,\n+ lambda g_b, _, a, b, **kws: triangular_solve(a, g_b, **kws))\nad.primitive_transposes[triangular_solve_p] = triangular_solve_transpose_rule\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/scipy/linalg.py",
"new_path": "jax/scipy/linalg.py",
"diff": "@@ -81,6 +81,8 @@ def solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False,\nelse:\nraise ValueError(\"Invalid 'trans' value {}\".format(trans))\n+ a = np.tril(a) if lower else np.triu(a)\n+\n# lax_linalg.triangular_solve only supports matrix 'b's at the moment.\nb_is_vector = np.ndim(a) == np.ndim(b) + 1\nif b_is_vector:\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/test_util.py",
"new_path": "jax/test_util.py",
"diff": "@@ -141,6 +141,22 @@ def check_vjp(f, f_vjp, args, atol=ATOL, rtol=RTOL, eps=EPS):\ncheck_close(ip, ip_expected, atol=atol, rtol=rtol)\n+def check_grads(f, args, order, atol=None, rtol=None, eps=None):\n+ if order > 1:\n+ def f_vjp(*args):\n+ out_primal_py, vjp_py = api.vjp(f, *args)\n+ return vjp_py(out_primal_py)\n+\n+ check_grads(f_vjp, args, order - 1, atol=atol, rtol=rtol, eps=eps)\n+ else:\n+ default_tol = 1e-6 if FLAGS.jax_enable_x64 else 1e-2\n+ atol = atol or default_tol\n+ rtol = rtol or default_tol\n+ eps = eps or default_tol\n+ check_jvp(f, partial(api.jvp, f), args, atol, rtol, eps)\n+ check_vjp(f, partial(api.vjp, f), args, atol, rtol, eps)\n+\n+\ndef skip_on_devices(*disabled_devices):\n\"\"\"A decorator for test methods to skip the test on certain devices.\"\"\"\ndef skip(test_method):\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_test.py",
"new_path": "tests/lax_test.py",
"diff": "@@ -33,6 +33,7 @@ from jax import core\nfrom jax import lax\nfrom jax import test_util as jtu\nfrom jax import lax_reference\n+from jax.test_util import check_grads\nfrom jax.interpreters import xla\nfrom jax.lib import xla_bridge\n@@ -1484,22 +1485,6 @@ LAX_GRAD_OPS = [\n]\n-def check_grads(f, args, order, atol=None, rtol=None, eps=None):\n- if order > 1:\n- def f_vjp(*args):\n- out_primal_py, vjp_py = api.vjp(f, *args)\n- return vjp_py(out_primal_py)\n-\n- check_grads(f_vjp, args, order - 1, atol=atol, rtol=rtol, eps=eps)\n- else:\n- default_tol = 1e-6 if FLAGS.jax_enable_x64 else 1e-2\n- atol = atol or default_tol\n- rtol = rtol or default_tol\n- eps = eps or default_tol\n- jtu.check_jvp(f, partial(api.jvp, f), args, atol, rtol, eps)\n- jtu.check_vjp(f, partial(api.vjp, f), args, atol, rtol, eps)\n-\n-\ndef check_grads_bilinear(f, args, order, atol=None, rtol=None):\n# Can use large eps to make up for numerical inaccuracies since the op is\n# bilinear (relying on the fact that we only check one arg at a time)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/linalg_test.py",
"new_path": "tests/linalg_test.py",
"diff": "@@ -180,6 +180,31 @@ class ScipyLinalgTest(jtu.JaxTestCase):\nself.assertAllClose(onp_ans, ans, check_dtypes=True)\n+ @parameterized.named_parameters(jtu.cases_from_list(\n+ {\"testcase_name\":\n+ \"_lhs={}_rhs={}_lower={}_transposea={}\".format(\n+ jtu.format_shape_dtype_string(lhs_shape, dtype),\n+ jtu.format_shape_dtype_string(rhs_shape, dtype),\n+ lower, transpose_a),\n+ \"lower\": lower, \"transpose_a\": transpose_a,\n+ \"lhs_shape\": lhs_shape, \"rhs_shape\": rhs_shape, \"dtype\": dtype,\n+ \"rng\": rng}\n+ for lower, transpose_a in itertools.product([False, True], repeat=2)\n+ for lhs_shape, rhs_shape in [\n+ ((4, 4), (4,)),\n+ ((4, 4), (4, 3)),\n+ ((2, 8, 8), (2, 8, 10)),\n+ ]\n+ for dtype in float_types()\n+ for rng in [jtu.rand_default()]))\n+ def testSolveTriangularBlockedGrad(self, lower, transpose_a, lhs_shape,\n+ rhs_shape, dtype, rng):\n+ A = np.tril(rng(lhs_shape, dtype) + 10 * onp.eye(lhs_shape[-1], dtype=dtype))\n+ A = A if lower else T(A)\n+ B = rng(rhs_shape, dtype)\n+ f = partial(scipy.linalg.solve_triangular, lower=lower,\n+ trans=1 if transpose_a else 0)\n+ jtu.check_grads(f, (A, B), 2)\nif __name__ == \"__main__\":\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | implement triangular solve lhs jvp (w/ @froystig) |
260,335 | 19.12.2018 07:59:00 | 28,800 | 997c9c5a50febab1dfd7203cf711a3371993c319 | fix einsum tensor product logic (fixes
The error was that `lhs_names` and `rhs_names` included `batch_names` as
prefixes, but the reshaping logic was written as if they did not include
batch_names (and so batch_names had to be prepended). | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1155,14 +1155,16 @@ def _einsum(operands, contractions):\nif lhs_batch != rhs_batch:\nrhs = moveaxis(rhs, rhs_batch, lhs_batch)\nbatch_names = ''.join(lhs_names[i] for i in lhs_batch)\n+ nbatch = len(batch_names)\n- names = batch_names + lhs_names + rhs_names\n+ assert len(lhs_names) == lhs.ndim and len(rhs_names) == rhs.ndim\n+ assert lhs_names.startswith(batch_names) and rhs_names.startswith(batch_names)\n+\n+ names = batch_names + lhs_names[nbatch:] + rhs_names[nbatch:]\nlhs_shape = iter(lhs.shape)\n- lhs_shape = [next(lhs_shape) if n in batch_names + lhs_names else 1\n- for n in names]\n+ lhs_shape = [next(lhs_shape) if n in lhs_names else 1 for n in names]\nrhs_shape = iter(rhs.shape)\n- rhs_shape = [next(rhs_shape) if n in batch_names + rhs_names else 1\n- for n in names]\n+ rhs_shape = [next(rhs_shape) if n in rhs_names else 1 for n in names]\noperand = lax.reshape(lhs, lhs_shape) * lax.reshape(rhs, rhs_shape)\nelse:\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_einsum_test.py",
"new_path": "tests/lax_numpy_einsum_test.py",
"diff": "@@ -81,6 +81,13 @@ class EinsumTest(jtu.JaxTestCase):\ns = 'nij,jk->nik'\ncheck(s, x, y)\n+ def test_two_operands_6(self):\n+ # based on https://github.com/google/jax/issues/37#issuecomment-448572187\n+ x = rng().randn(2, 1)\n+ y = rng().randn(2, 3, 4)\n+ s = 'sa,shb->shab'\n+ check(s, x, y)\n+\ndef test_one_operand_1(self):\nx = rng().randn(3, 4, 5)\ns = 'ijk->j'\n"
}
] | Python | Apache License 2.0 | google/jax | fix einsum tensor product logic (fixes #37)
The error was that `lhs_names` and `rhs_names` included `batch_names` as
prefixes, but the reshaping logic was written as if they did not include
batch_names (and so batch_names had to be prepended). |
260,474 | 19.12.2018 10:59:13 | 18,000 | 87922fdf13b76990b4929be1b6e50e7d74250884 | Generalized make_jaxpr to handle python containers | [
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -227,14 +227,17 @@ def lift_jaxpr(jaxpr, consts, io_tree, pvals, py_args):\nreturn unflatten_fun(fun, io_tree, *py_args)\ndef make_jaxpr(f):\n- # TODO(frostig): handle container trees etc.\ndef pv_like(x):\n- aval = ShapedArray(onp.shape(x), onp.result_type(x))\n+ aval = xla.abstractify(x)\nreturn pe.PartialVal((aval, core.unit))\n+ fun = lu.wrap_init(f)\n@_wraps(f)\n- def jaxpr_maker(*args):\n- jaxpr, _, _, _ = trace_to_jaxpr(f, map(pv_like, args))\n+ def jaxpr_maker(*args, **kwargs):\n+ jax_args, in_trees = unzip2(map(tree_to_jaxtuples, args))\n+ flat_fun, out_tree = flatten_fun(fun, in_trees)\n+ pvals = map(pv_like, jax_args)\n+ jaxpr, _, _ = pe.trace_to_jaxpr(flat_fun, pvals, **kwargs)\nreturn jaxpr\njaxpr_maker.__name__ = \"make_jaxpr({})\".format(jaxpr_maker.__name__)\n"
}
] | Python | Apache License 2.0 | google/jax | Generalized make_jaxpr to handle python containers |
260,335 | 19.12.2018 08:42:29 | 28,800 | b781e4509ab4e617f5673ae45f47ff5697017f88 | update jaxlib references to 0.1.3 | [
{
"change_type": "MODIFY",
"old_path": "README.md",
"new_path": "README.md",
"diff": "@@ -144,7 +144,7 @@ PYTHON_VERSION=py2 # alternatives: py2, py3\nCUDA_VERSION=cuda92 # alternatives: cuda90, cuda92, cuda100\nPLATFORM=linux_x86_64 # alternatives: linux_x86_64\nBASE_URL='https://storage.googleapis.com/jax-wheels'\n-pip install --upgrade $BASE_URL/$CUDA_VERSION/jaxlib-0.1.2-$PYTHON_VERSION-none-$PLATFORM.whl\n+pip install --upgrade $BASE_URL/$CUDA_VERSION/jaxlib-0.1.3-$PYTHON_VERSION-none-$PLATFORM.whl\npip install --upgrade jax # install jax\n```\n"
},
{
"change_type": "MODIFY",
"old_path": "notebooks/gufuncs.ipynb",
"new_path": "notebooks/gufuncs.ipynb",
"diff": "},\n\"cell_type\": \"code\",\n\"source\": [\n- \"!pip install --upgrade -q https://storage.googleapis.com/jax-wheels/cuda92/jaxlib-0.1.2-py3-none-linux_x86_64.whl\\n\",\n+ \"!pip install --upgrade -q https://storage.googleapis.com/jax-wheels/cuda92/jaxlib-0.1.3-py3-none-linux_x86_64.whl\\n\",\n\"!pip install --upgrade -q jax\"\n],\n\"execution_count\": 0,\n"
},
{
"change_type": "MODIFY",
"old_path": "notebooks/neural_network_and_data_loading.ipynb",
"new_path": "notebooks/neural_network_and_data_loading.ipynb",
"diff": "},\n\"cell_type\": \"code\",\n\"source\": [\n- \"!pip install --upgrade https://storage.googleapis.com/jax-wheels/cuda92/jaxlib-0.1.2-py3-none-linux_x86_64.whl\\n\",\n+ \"!pip install --upgrade https://storage.googleapis.com/jax-wheels/cuda92/jaxlib-0.1.3-py3-none-linux_x86_64.whl\\n\",\n\"!pip install --upgrade jax\"\n],\n\"execution_count\": 0,\n"
},
{
"change_type": "MODIFY",
"old_path": "notebooks/quickstart.ipynb",
"new_path": "notebooks/quickstart.ipynb",
"diff": "},\n\"cell_type\": \"code\",\n\"source\": [\n- \"!pip install --upgrade https://storage.googleapis.com/jax-wheels/cuda92/jaxlib-0.1.2-py3-none-linux_x86_64.whl\\n\",\n+ \"!pip install --upgrade https://storage.googleapis.com/jax-wheels/cuda92/jaxlib-0.1.3-py3-none-linux_x86_64.whl\\n\",\n\"!pip install --upgrade jax\"\n],\n\"execution_count\": 0,\n"
}
] | Python | Apache License 2.0 | google/jax | update jaxlib references to 0.1.3 |
260,335 | 19.12.2018 09:07:04 | 28,800 | 6a9952a939dec83c977508c596093ae4db17308a | jax.numpy.arange should fall back to onp.arange
fixes | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -834,29 +834,16 @@ def eye(N, M=None, k=None, dtype=onp.dtype(\"float64\")):\n@_wraps(onp.arange)\ndef arange(*args, **kwargs):\n- nargs = len(args)\n- start, step = 0, 1\n+ # attempt to generate a lazy IotaConstant, otherwise fall back to raw numpy\ndtype = kwargs.pop(\"dtype\", None)\n- if kwargs:\n- raise TypeError(\"arange only accepts 'dtype' kwarg, got {}\".format(kwargs))\n- if nargs == 0:\n+ if not args:\nraise TypeError(\"Required argument 'start' (pos 1) not found\") # same as numpy error\n- elif nargs == 1:\n+ elif len(args) == 1 and not kwargs:\nstop, = args\ndtype = dtype or _dtype(stop)\n+ if onp.issubdtype(dtype, onp.integer):\nreturn lax.iota(dtype, stop) # avoids materializing\n- elif nargs == 2:\n- start, stop = args\n- dtype = dtype or onp.result_type(start, stop)\n- elif nargs == 3:\n- start, stop, step = args\n- dtype = dtype or onp.result_type(start, stop, step)\n- elif nargs == 4:\n- start, stop, step, dtype = args\n- dtype = dtype or onp.result_type(start, stop, step)\n-\n- size = (stop - start - 1) // step + 1\n- return start + step * lax.iota(dtype, size)\n+ return onp.arange(*args, **kwargs)\n@_wraps(onp.repeat)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_test.py",
"new_path": "tests/lax_numpy_test.py",
"diff": "@@ -845,6 +845,13 @@ class LaxBackedNumpyTests(jtu.JaxTestCase):\nans = onp.mean(x)\nself.assertAllClose(ans, onp.array([1./3, 1./3, 1./3]), check_dtypes=False)\n+ # TODO(mattjj): more exhaustive arange tests\n+ def testArangeOnFloats(self):\n+ # from https://github.com/google/jax/issues/145\n+ expected = onp.arange(0.0, 1.0, 0.1)\n+ ans = lnp.arange(0.0, 1.0, 0.1)\n+ self.assertAllClose(expected, ans, check_dtypes=True)\n+\nif __name__ == \"__main__\":\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | jax.numpy.arange should fall back to onp.arange
fixes #145 |
260,335 | 19.12.2018 09:21:30 | 28,800 | dc1d0c260a4df15bd857faf00e72f4cfbab26b61 | always fall back to onp.arange for now | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -835,14 +835,15 @@ def eye(N, M=None, k=None, dtype=onp.dtype(\"float64\")):\n@_wraps(onp.arange)\ndef arange(*args, **kwargs):\n# attempt to generate a lazy IotaConstant, otherwise fall back to raw numpy\n- dtype = kwargs.pop(\"dtype\", None)\n- if not args:\n- raise TypeError(\"Required argument 'start' (pos 1) not found\") # same as numpy error\n- elif len(args) == 1 and not kwargs:\n- stop, = args\n- dtype = dtype or _dtype(stop)\n- if onp.issubdtype(dtype, onp.integer):\n- return lax.iota(dtype, stop) # avoids materializing\n+ # TODO(mattjj): add tests for this function, then re-enable\n+ # dtype = kwargs.pop(\"dtype\", None)\n+ # if not args:\n+ # raise TypeError(\"Required argument 'start' (pos 1) not found\") # same as numpy error\n+ # elif len(args) == 1 and not kwargs:\n+ # stop, = args\n+ # dtype = dtype or _dtype(stop)\n+ # if onp.issubdtype(dtype, onp.integer):\n+ # return lax.iota(dtype, stop) # avoids materializing\nreturn onp.arange(*args, **kwargs)\n"
}
] | Python | Apache License 2.0 | google/jax | always fall back to onp.arange for now |
260,335 | 19.12.2018 09:40:40 | 28,800 | 43e77acca5e7621fba68c4a5c5dba2494e58b9ff | fix select transpose rule | [
{
"change_type": "MODIFY",
"old_path": "jax/lax.py",
"new_path": "jax/lax.py",
"diff": "@@ -1602,6 +1602,11 @@ def select_dtype_rule(pred, on_true, on_false):\ndef select_transpose_rule(t, pred, on_true, on_false):\nassert pred is not None\n+ if t is ad_util.zero:\n+ return [None,\n+ ad_util.zero if on_true is None else None,\n+ ad_util.zero if on_false is None else None]\n+ else:\nzeros = full_like(t, 0)\nreturn [None,\nselect(pred, t, zeros) if on_true is None else None,\n"
}
] | Python | Apache License 2.0 | google/jax | fix select transpose rule |
260,335 | 19.12.2018 08:49:22 | 28,800 | 166f45bf2b3e4b88e8cd1babbb7c242680304f89 | add tests for cases tf.einsum doesn't handle
from
one currently fails | [
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_einsum_test.py",
"new_path": "tests/lax_numpy_einsum_test.py",
"diff": "@@ -38,136 +38,186 @@ def check(s, *ops):\nclass EinsumTest(jtu.JaxTestCase):\ndef test_three_operands_1(self):\n- x = rng().randn(3)\n- y = rng().randn(4)\n- z = rng().randn(5)\n+ r = rng()\n+ x = r.randn(3)\n+ y = r.randn(4)\n+ z = r.randn(5)\ns = 'i,j,k->ijk'\ncheck(s, x, y, z)\ndef test_three_operands_2(self):\n- x = rng().randn(3)\n- y = rng().randn(4)\n- z = rng().randn(5)\n+ r = rng()\n+ x = r.randn(3)\n+ y = r.randn(4)\n+ z = r.randn(5)\ns = 'i,j,k->ijk'\ncheck(s, x, y, z)\ndef test_two_operands_1(self):\n- x = rng().randn(3, 4)\n- y = rng().randn(4)\n+ r = rng()\n+ x = r.randn(3, 4)\n+ y = r.randn(4)\ns = 'ij,j->i'\ncheck(s, x, y)\ndef test_two_operands_2(self):\n- x = rng().randn(3, 4, 5)\n- y = rng().randn(4)\n+ r = rng()\n+ x = r.randn(3, 4, 5)\n+ y = r.randn(4)\ns = 'ijk,j->i'\ncheck(s, x, y)\ndef test_two_operands_3(self):\n- x = rng().randn(3, 4, 3)\n- y = rng().randn(3)\n+ r = rng()\n+ x = r.randn(3, 4, 3)\n+ y = r.randn(3)\ns = 'iji,i->j'\ncheck(s, x, y)\ndef test_two_operands_4(self):\n- x = rng().randn(3, 4)\n- y = rng().randn(3, 4)\n+ r = rng()\n+ x = r.randn(3, 4)\n+ y = r.randn(3, 4)\ns = 'ij,ij->'\ncheck(s, x, y)\ndef test_two_operands_5(self):\n- x = rng().randn(10, 2, 3)\n- y = rng().randn(3, 4)\n+ r = rng()\n+ x = r.randn(10, 2, 3)\n+ y = r.randn(3, 4)\ns = 'nij,jk->nik'\ncheck(s, x, y)\ndef test_two_operands_6(self):\n# based on https://github.com/google/jax/issues/37#issuecomment-448572187\n- x = rng().randn(2, 1)\n- y = rng().randn(2, 3, 4)\n+ r = rng()\n+ x = r.randn(2, 1)\n+ y = r.randn(2, 3, 4)\ns = 'sa,shb->shab'\ncheck(s, x, y)\ndef test_one_operand_1(self):\n- x = rng().randn(3, 4, 5)\n+ r = rng()\n+ x = r.randn(3, 4, 5)\ns = 'ijk->j'\ncheck(s, x)\ndef test_one_operand_2(self):\n- x = rng().randn(3, 4, 5)\n+ r = rng()\n+ x = r.randn(3, 4, 5)\ns = 'ijk->kij'\ncheck(s, x)\ndef test_one_operand_3(self):\n- x = rng().randn(3, 4, 5)\n+ r = rng()\n+ x = r.randn(3, 4, 5)\ns = 'ijk->ki'\ncheck(s, x)\ndef test_one_operand_4(self):\n- x = rng().randn(3, 4, 5)\n+ r = rng()\n+ x = r.randn(3, 4, 5)\ns = 'ijk->ki'\ncheck(s, x)\ndef test_one_operand_5(self):\n- x = rng().randn(2, 3, 4, 5)\n+ r = rng()\n+ x = r.randn(2, 3, 4, 5)\ns = '...ijk->...ki'\ncheck(s, x)\ndef test_one_operand_6(self):\n- x = rng().randn(3, 4, 5)\n+ r = rng()\n+ x = r.randn(3, 4, 5)\ns = '...ijk->ki'\ncheck(s, x)\ndef test_one_operand_7(self):\n- x = rng().randn(3, 3)\n+ r = rng()\n+ x = r.randn(3, 3)\ns = 'ii->'\ncheck(s, x)\ndef test_one_operand_8(self):\n- x = rng().randn(3, 3)\n+ r = rng()\n+ x = r.randn(3, 3)\ns = 'ij->'\ncheck(s, x)\ndef test_one_operand_9(self):\n- x = rng().randn(3, 3, 3)\n+ r = rng()\n+ x = r.randn(3, 3, 3)\ns = 'iii->'\ncheck(s, x)\ndef test_one_operand_10(self):\n- x = rng().randn(3, 3)\n+ r = rng()\n+ x = r.randn(3, 3)\ns = 'ii->i'\ncheck(s, x)\ndef test_one_operand_11(self):\n- x = rng().randn(3, 3, 4)\n+ r = rng()\n+ x = r.randn(3, 3, 4)\ns = 'iij->i'\ncheck(s, x)\ndef test_one_operand_12(self):\n- x = rng().randn(3, 3, 3)\n+ r = rng()\n+ x = r.randn(3, 3, 3)\ns = 'iii->i'\ncheck(s, x)\ndef test_one_operand_13(self):\n- x = rng().randn(3, 3, 5, 4, 4)\n+ r = rng()\n+ x = r.randn(3, 3, 5, 4, 4)\ns = 'iijkk->i'\ncheck(s, x)\ndef test_one_operand_14(self):\n- x = rng().randn(3, 3, 5, 4, 4)\n+ r = rng()\n+ x = r.randn(3, 3, 5, 4, 4)\ns = 'iijkk->ik'\ncheck(s, x)\ndef test_one_operand_15(self):\n- x = rng().randn(3, 3, 5, 4, 4)\n+ r = rng()\n+ x = r.randn(3, 3, 5, 4, 4)\ns = 'iijkl->il'\ncheck(s, x)\ndef test_one_operand_16(self):\n- x = rng().randn(3, 3)\n+ r = rng()\n+ x = r.randn(3, 3)\ns = 'ij->ij'\ncheck(s, x)\n+ # TODO(mattjj): patch this up!\n+ # def test_tf_unsupported_1(self):\n+ # # from https://www.tensorflow.org/api_docs/python/tf/einsum\n+ # r = rng()\n+ # x = r.randn(2, 3, 5, 1)\n+ # y = r.randn(3, 4, 5, 1)\n+ # s = 'ij...,jk...->ik...'\n+ # check(s, x, y)\n+\n+ def test_tf_unsupported_2(self):\n+ # from https://www.tensorflow.org/api_docs/python/tf/einsum\n+ r = rng()\n+ x = r.randn(2, 3, 3)\n+ y = r.randn(4)\n+ s = 'ijj,k->ik'\n+ check(s, x, y)\n+\n+ def test_tf_unsupported_3(self):\n+ # from https://www.tensorflow.org/api_docs/python/tf/einsum\n+ r = rng()\n+ x = r.randn(2, 3)\n+ y = r.randn(2, 3)\n+ z = r.randn(3, 4)\n+ s = 'ij,ij,jk->ik'\n+ check(s, x, y, z)\n+\nif __name__ == '__main__':\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | add tests for cases tf.einsum doesn't handle
from https://www.tensorflow.org/api_docs/python/tf/einsum
one currently fails |
260,335 | 19.12.2018 08:55:59 | 28,800 | 9a68bce567b13ebf0ccea4c9bdd44294c66850e2 | add comment marking a bug | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1082,7 +1082,7 @@ def _einsum(operands, contractions):\ninput_names = input_str.split(',')\n# switch on the number of operands to be processed in this loop iteration.\n- # every case here sets 'result' and 'names'.\n+ # every case here sets 'operand' and 'names'.\nif len(operand_indices) == 1:\noperand = operands.pop(operand_indices[0])\nnames, = input_names\n@@ -1120,7 +1120,7 @@ def _einsum(operands, contractions):\nlhs_batch, rhs_batch = unzip2((lhs_names.find(n), rhs_names.find(n))\nfor n in batch_names)\nif contracted_names:\n- # contract usint lax.dot_general\n+ # contract using lax.dot_general\nlhs_cont, rhs_cont = unzip2((lhs_names.index(n), rhs_names.index(n))\nfor n in contracted_names)\n@@ -1130,6 +1130,7 @@ def _einsum(operands, contractions):\nlhs = moveaxis(lhs, lhs_batch, batch_dims)\nrhs = moveaxis(rhs, rhs_batch, batch_dims)\nbatch_names = ''.join(batch_names)\n+ # TODO(mattjj): may need to update lhs_cont and rhs_cont here\nelse:\nbatch_dims = tuple(lhs_batch)\nbatch_names = ''.join(lhs_names[i] for i in batch_dims)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_einsum_test.py",
"new_path": "tests/lax_numpy_einsum_test.py",
"diff": "@@ -192,14 +192,13 @@ class EinsumTest(jtu.JaxTestCase):\ns = 'ij->ij'\ncheck(s, x)\n- # TODO(mattjj): patch this up!\n- # def test_tf_unsupported_1(self):\n- # # from https://www.tensorflow.org/api_docs/python/tf/einsum\n- # r = rng()\n- # x = r.randn(2, 3, 5, 1)\n- # y = r.randn(3, 4, 5, 1)\n- # s = 'ij...,jk...->ik...'\n- # check(s, x, y)\n+ def test_tf_unsupported_1(self):\n+ # from https://www.tensorflow.org/api_docs/python/tf/einsum\n+ r = rng()\n+ x = r.randn(2, 3, 5, 1)\n+ y = r.randn(3, 4, 5, 1)\n+ s = 'ij...,jk...->ik...'\n+ check(s, x, y)\ndef test_tf_unsupported_2(self):\n# from https://www.tensorflow.org/api_docs/python/tf/einsum\n"
}
] | Python | Apache License 2.0 | google/jax | add comment marking a bug |
260,335 | 19.12.2018 10:59:03 | 28,800 | 9c722db37304f293180119501c355d1d35431e16 | einsum: update id strings after moving batch dims | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1121,20 +1121,21 @@ def _einsum(operands, contractions):\nfor n in batch_names)\nif contracted_names:\n# contract using lax.dot_general\n- lhs_cont, rhs_cont = unzip2((lhs_names.index(n), rhs_names.index(n))\n- for n in contracted_names)\n# lax.dot_general batch dims have to precede non-batch dims\nbatch_dims = tuple(range(len(batch_names)))\nif lhs_batch != rhs_batch or set(lhs_batch) != set(batch_dims):\nlhs = moveaxis(lhs, lhs_batch, batch_dims)\n+ lhs_names = _movechars(lhs_names, lhs_batch, batch_dims)\nrhs = moveaxis(rhs, rhs_batch, batch_dims)\n+ rhs_names = _movechars(rhs_names, rhs_batch, batch_dims)\nbatch_names = ''.join(batch_names)\n- # TODO(mattjj): may need to update lhs_cont and rhs_cont here\nelse:\nbatch_dims = tuple(lhs_batch)\nbatch_names = ''.join(lhs_names[i] for i in batch_dims)\n+ lhs_cont, rhs_cont = unzip2((lhs_names.index(n), rhs_names.index(n))\n+ for n in contracted_names)\noperand = _dot_general(lhs, rhs, lhs_cont, rhs_cont, len(batch_dims))\ndeleted_names = batch_names + ''.join(contracted_names)\nnames = (batch_names + removechars(lhs_names, deleted_names)\n@@ -1212,6 +1213,15 @@ def _dot_general(lhs, rhs, lhs_cont, rhs_cont, nbatch):\nresult = lax.dot_general(lhs, rhs, dimension_numbers)\nreturn lax.reshape(result, result_shape)\n+\n+def _movechars(s, src, dst):\n+ \"\"\"Helper for einsum string munging, like moveaxis on identifier strings.\"\"\"\n+ chars = [c for i, c in enumerate(s) if i not in src]\n+ for i, j in sorted(zip(dst, src)):\n+ chars.insert(i, s[j])\n+ return ''.join(chars)\n+\n+\n@_wraps(onp.inner)\ndef inner(a, b):\nif ndim(a) == 0 or ndim(b) == 0:\n"
}
] | Python | Apache License 2.0 | google/jax | einsum: update id strings after moving batch dims |
260,474 | 19.12.2018 17:47:56 | 18,000 | e6b23dd2b7e78dd123b18392b774d7fc1e85dcb0 | Fixed triangular_solve_jvp_rule for transpose_a=True case | [
{
"change_type": "MODIFY",
"old_path": "jax/lax_linalg.py",
"new_path": "jax/lax_linalg.py",
"diff": "@@ -112,6 +112,7 @@ def triangular_solve_shape_rule(a, b, left_side=False, **unused_kwargs):\ndef triangular_solve_jvp_rule_a(\ng_a, ans, a, b, left_side, lower, transpose_a, conjugate_a):\ng_a = lax.neg(g_a)\n+ g_a = np.swapaxes(g_a, -1, -2) if transpose_a else g_a\ntmp = triangular_solve(a, g_a, left_side, lower, transpose_a, conjugate_a)\ndot = lax.dot if g_a.ndim == 2 else lax.batch_matmul\nif left_side:\n"
}
] | Python | Apache License 2.0 | google/jax | Fixed triangular_solve_jvp_rule for transpose_a=True case |
260,335 | 19.12.2018 16:15:43 | 28,800 | 6a138202ef1c32f935cb6ec66c33340d67266466 | fix several einsum bugs | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1119,10 +1119,8 @@ def _einsum(operands, contractions):\nbatch_names = set(lhs_names) & set(rhs_names) - contracted_names\nlhs_batch, rhs_batch = unzip2((lhs_names.find(n), rhs_names.find(n))\nfor n in batch_names)\n- if contracted_names:\n- # contract using lax.dot_general\n- # lax.dot_general batch dims have to precede non-batch dims\n+ # move batch dims to the front (required by lax.dot_general, and easier)\nbatch_dims = tuple(range(len(batch_names)))\nif lhs_batch != rhs_batch or set(lhs_batch) != set(batch_dims):\nlhs = moveaxis(lhs, lhs_batch, batch_dims)\n@@ -1134,6 +1132,8 @@ def _einsum(operands, contractions):\nbatch_dims = tuple(lhs_batch)\nbatch_names = ''.join(lhs_names[i] for i in batch_dims)\n+ if contracted_names:\n+ # contract using lax.dot_general\nlhs_cont, rhs_cont = unzip2((lhs_names.index(n), rhs_names.index(n))\nfor n in contracted_names)\noperand = _dot_general(lhs, rhs, lhs_cont, rhs_cont, len(batch_dims))\n@@ -1142,23 +1142,15 @@ def _einsum(operands, contractions):\n+ removechars(rhs_names, deleted_names))\nelse:\n# no contraction, just a tensor product\n- if lhs_batch != rhs_batch:\n- rhs = moveaxis(rhs, rhs_batch, lhs_batch)\n- batch_names = ''.join(lhs_names[i] for i in lhs_batch)\nnbatch = len(batch_names)\n-\n- assert len(lhs_names) == lhs.ndim and len(rhs_names) == rhs.ndim\n- assert lhs_names.startswith(batch_names) and rhs_names.startswith(batch_names)\n-\n+ assert lhs.shape[:nbatch] == rhs.shape[:nbatch]\nnames = batch_names + lhs_names[nbatch:] + rhs_names[nbatch:]\n- lhs_shape = iter(lhs.shape)\n- lhs_shape = [next(lhs_shape) if n in lhs_names else 1 for n in names]\n- rhs_shape = iter(rhs.shape)\n- rhs_shape = [next(rhs_shape) if n in rhs_names else 1 for n in names]\n+ lhs_shape = lhs.shape + (1,) * (rhs.ndim - nbatch)\n+ rhs_shape = rhs.shape[:nbatch] + (1,) * (lhs.ndim - nbatch) + rhs.shape[nbatch:]\noperand = lax.reshape(lhs, lhs_shape) * lax.reshape(rhs, rhs_shape)\nelse:\n- raise NotImplementedError\n+ raise NotImplementedError # if this is actually reachable, open an issue!\n# the resulting 'operand' with axis labels 'names' should be a permutation\n# of the desired result\n@@ -1190,10 +1182,12 @@ def _dot_general(lhs, rhs, lhs_cont, rhs_cont, nbatch):\n# contracting dimension, so if there's more than one we collapse them.\nif ncont > 1:\nlhs_cdims = tuple(range(lhs.ndim - ncont, lhs.ndim))\n- lhs = moveaxis(lhs, lhs_cont, lhs_cdims).reshape(lhs.shape[:-ncont] + (-1,))\n+ lhs = moveaxis(lhs, lhs_cont, lhs_cdims)\n+ lhs = lhs.reshape(lhs.shape[:-ncont] + (-1,))\nrhs_cdims = tuple(range(rhs.ndim - ncont, rhs.ndim))\n- rhs = moveaxis(rhs, rhs_cont, rhs_cdims).reshape(rhs.shape[:-ncont] + (-1,))\n+ rhs = moveaxis(rhs, rhs_cont, rhs_cdims)\n+ rhs = rhs.reshape(rhs.shape[:-ncont] + (-1,))\nelse:\nlhs = moveaxis(lhs, lhs_cont[0], -1)\nrhs = moveaxis(rhs, rhs_cont[0], -1)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_einsum_test.py",
"new_path": "tests/lax_numpy_einsum_test.py",
"diff": "@@ -263,9 +263,9 @@ class EinsumTest(jtu.JaxTestCase):\ninput_str = einstr\ninput_names = input_str.split(',')\n- # TODO(mattjj): handle '...' better here\nshapes = defaultdict(itertools.cycle([2, 3, 4]).next)\n- input_shapes = [tuple(shapes[c] for c in names) for names in input_names]\n+ input_shapes = [tuple(shapes[c] for c in names.replace('...', '01'))\n+ for names in input_names]\noperands = [r.randn(*shape) for shape in input_shapes]\ncheck(einstr, *operands)\n"
}
] | Python | Apache License 2.0 | google/jax | fix several einsum bugs |
260,335 | 19.12.2018 16:58:31 | 28,800 | 6bb9609fb8fd36490557dda3de4da486f3c4430a | disable test, py3 opt_einsum nondeterministic bug? | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1116,10 +1116,16 @@ def _einsum(operands, contractions):\nresult_names + lhs_names)\ncontracted_names = contracted_names & (set(lhs_names) | set(rhs_names))\n- batch_names = set(lhs_names) & set(rhs_names) - contracted_names\n+ batch_names = (set(lhs_names) & set(rhs_names)) - contracted_names\nlhs_batch, rhs_batch = unzip2((lhs_names.find(n), rhs_names.find(n))\nfor n in batch_names)\n+ # NOTE(mattjj): this can fail non-deterministically in python3, maybe\n+ # due to opt_einsum\n+ assert _all(name in lhs_names and name in rhs_names and\n+ lhs.shape[lhs_names.index(name)] == rhs.shape[rhs_names.index(name)]\n+ for name in contracted_names)\n+\n# move batch dims to the front (required by lax.dot_general, and easier)\nbatch_dims = tuple(range(len(batch_names)))\nif lhs_batch != rhs_batch or set(lhs_batch) != set(batch_dims):\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_einsum_test.py",
"new_path": "tests/lax_numpy_einsum_test.py",
"diff": "@@ -22,6 +22,7 @@ import itertools\nimport numpy as onp\nfrom absl.testing import absltest\nfrom absl.testing import parameterized\n+import six\nimport jax.numpy as np\nimport jax.test_util as jtu\n@@ -213,6 +214,10 @@ class EinsumTest(jtu.JaxTestCase):\ncheck(s, x, y)\ndef test_tf_unsupported_3(self):\n+ # TODO(mattjj): heisenbug! fails sometimes in python3. opt_einsum bug?\n+ if six.PY3:\n+ return absltest.unittest.skip(\"py3 failures\")\n+\n# from https://www.tensorflow.org/api_docs/python/tf/einsum\nr = rng()\nx = r.randn(2, 3)\n@@ -263,7 +268,8 @@ class EinsumTest(jtu.JaxTestCase):\ninput_str = einstr\ninput_names = input_str.split(',')\n- shapes = defaultdict(itertools.cycle([2, 3, 4]).next)\n+ dims = itertools.cycle([2, 3, 4])\n+ shapes = defaultdict(lambda: next(dims))\ninput_shapes = [tuple(shapes[c] for c in names.replace('...', '01'))\nfor names in input_names]\noperands = [r.randn(*shape) for shape in input_shapes]\n"
}
] | Python | Apache License 2.0 | google/jax | disable test, py3 opt_einsum nondeterministic bug? |
260,335 | 20.12.2018 10:09:34 | 28,800 | 8f1bc997ca0146f4f537ee6418d9b7fc3cee9983 | add value-and-grad fun (closes | [
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -58,16 +58,17 @@ def jit(fun, static_argnums=()):\nArgs:\nfun: Function to be jitted. Should be a pure function, as side-effects may\n- only be executed once. Its positional arguments and return value should\n- be arrays, scalars, or standard Python containers (tuple/list/dict)\n- thereof. Keyword arguments and positional arguments specified by\n- `static_argnums` can be anything at all. These are treated as static\n- (see below).\n+ only be executed once. Its positional arguments and return value should be\n+ arrays, scalars, or standard Python containers (tuple/list/dict) thereof.\n+ Keyword arguments and positional arguments specified by `static_argnums`\n+ can be anything at all. These are treated as static (see below).\nstatic_argnums: A tuple of ints. Specifies which arguments to treat as\nstatic (compile-time constant). Operations that only depend on static\narguments will be constant-folded. Calling the jitted function with\ndifferent values for these constants will trigger recompilation.\n- Returns: A wrapped version of `fun`, set up for just-in-time compilation.\n+\n+ Returns:\n+ A wrapped version of `fun`, set up for just-in-time compilation.\n\"\"\"\n@_wraps(fun)\ndef f_jitted(*args, **kwargs):\n@@ -83,6 +84,7 @@ def jit(fun, static_argnums=()):\nf_jitted.__name__ = \"jit({})\".format(f_jitted.__name__)\nreturn f_jitted\n+\ndef grad(fun, argnums=0):\n\"\"\"Creates a function which evaluates the gradient of `fun`.\n@@ -93,21 +95,51 @@ def grad(fun, argnums=0):\narrays with shape `(1,)` etc.)\nargnums: Integer or tuple of integers. Specifies which positional\nargument(s) to differentiate with respect to.\n- Returns: A function with the same arguments as `fun`, that evaluates the\n- gradient of `fun`. If `argnums` is an integer then the gradient has the\n- same shape and type as the positional argument indicated by that integer.\n- If argnums is a tuple of integers, the gradient is a tuple of values with\n- the same shapes and types as the corresponding arguments.\n+\n+ Returns:\n+ A function with the same arguments as `fun`, that evaluates the gradient of\n+ `fun`. If `argnums` is an integer then the gradient has the same shape and\n+ type as the positional argument indicated by that integer. If argnums is a\n+ tuple of integers, the gradient is a tuple of values with the same shapes\n+ and types as the corresponding arguments.\n\"\"\"\n+ value_and_grad_f = value_and_grad(fun, argnums)\n+\ndef grad_f(*args, **kwargs):\n+ ans, g = value_and_grad_f(*args, **kwargs)\n+ return g\n+\n+ return grad_f\n+\n+def value_and_grad(fun, argnums=0):\n+ \"\"\"Creates a function which evaluates both `fun` and the gradient of `fun`.\n+\n+ Args:\n+ fun: Function to be differentiated. Its arguments at positions specified by\n+ `argnums` should be arrays, scalars, or standard Python containers. It\n+ should return a scalar (which includes arrays with shape `()` but not\n+ arrays with shape `(1,)` etc.)\n+ argnums: Integer or tuple of integers. Specifies which positional\n+ argument(s) to differentiate with respect to.\n+\n+ Returns:\n+ A function with the same arguments as `fun` that evaluates both `fun` and\n+ the gradient of `fun` and returns them as a pair (a two-element tuple). If\n+ `argnums` is an integer then the gradient has the same shape and type as the\n+ positional argument indicated by that integer. If argnums is a tuple of\n+ integers, the gradient is a tuple of values with the same shapes and types\n+ as the corresponding arguments.\n+ \"\"\"\n+ def value_and_grad_f(*args, **kwargs):\nf = lu.wrap_init(fun, kwargs)\nf_partial, dyn_args = argnums_partial(f, argnums, args)\nans, vjp_py = vjp(f_partial, *dyn_args)\ncheck_scalar(ans)\ng = vjp_py(onp.ones((), onp.result_type(ans)))\n- return g[0] if isinstance(argnums, int) else g\n+ g = g[0] if isinstance(argnums, int) else g\n+ return (ans, g)\n- return grad_f\n+ return value_and_grad_f\n@curry\ndef jacfwd(fun, x):\n@@ -137,10 +169,12 @@ def vmap(fun, in_axes=0, out_axes=0):\nfun: Function to be mapped over additional axes.\nin_axes, out_axes: Specifies which axes to map over. These may be integers,\nNone, or (possibly nested) tuples of integers or None.\n- Returns: Batched/vectorized version of `fun` with arguments that correspond to\n- those of `fun`, but with extra array axes at positions indicated by\n- `in_axes`, and a return value that corresponds to that of `fun`, but with\n- extra array axes at positions indicated by `out_axes`.\n+\n+ Returns:\n+ Batched/vectorized version of `fun` with arguments that correspond to those\n+ of `fun`, but with extra array axes at positions indicated by `in_axes`, and\n+ a return value that corresponds to that of `fun`, but with extra array axes\n+ at positions indicated by `out_axes`.\nFor example, we can implement a matrix-matrix product using a vector dot\nproduct:\n@@ -150,7 +184,6 @@ def vmap(fun, in_axes=0, out_axes=0):\nmm = vmap(mv, (None, 1), 1) # ([a,b], [b,c]) -> [a,c]\n(`[a,b]` indicates an array with shape (a,b))\n-\n\"\"\"\ndef batched_fun(*args, **kwargs):\nif not isinstance(fun, lu.WrappedFun):\n"
}
] | Python | Apache License 2.0 | google/jax | add value-and-grad fun (closes #149) |
260,335 | 20.12.2018 10:17:42 | 28,800 | 565c95582dd0fe77c85f16bf6d537bb9393ef077 | add simple value_and_grad test | [
{
"change_type": "MODIFY",
"old_path": "tests/api_test.py",
"new_path": "tests/api_test.py",
"diff": "@@ -44,6 +44,15 @@ class APITest(jtu.JaxTestCase):\nassert grad(f, argnums=1)(1.0, 1.0, 1.0, flag=True) == 2.0\nassert grad(f, argnums=(2, 0))(1.0, 1.0, 1.0, flag=True) == (3.0, 1.0)\n+ def value_and_grad_argnums(self):\n+ def f(x, y, z, flag=False):\n+ assert flag\n+ return 1.0 * x + 2.0 * y + 3.0 * z\n+\n+ y = f(1.0, 1.0, 1.0, flag=True)\n+ assert value_and_grad(f)(1.0, 1.0, 1.0, flag=True) == (y, 1.0)\n+ assert value_and_grad(f, argnums=1)(1.0, 1.0, 1.0, flag=True) == (y, 2.0)\n+ assert value_and_grad(f, argnums=(2, 0))(1.0, 1.0, 1.0, flag=True) == (y, (3.0, 1.0))\ndef test_jit_static_args(self):\nside = []\n"
}
] | Python | Apache License 2.0 | google/jax | add simple value_and_grad test |
260,335 | 21.12.2018 08:11:36 | 28,800 | 43f2e2a70a1d6e976d312561179a851a93aa0532 | cover unimplemented add_jaxvals_p batching case | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/batching.py",
"new_path": "jax/interpreters/batching.py",
"diff": "@@ -229,40 +229,49 @@ def reducer_batcher(prim, batched_args, batch_dims, axes, **kwargs):\nreturn prim.bind(operand, axes=axes, **kwargs), bdim_out\ndef add_batched(batched_args, batch_dims):\n- xs, ys = batched_args\nbdx, bdy = batch_dims\nif bdx == bdy:\n+ xs, ys = batched_args\nreturn add_jaxvals_p.bind(xs, ys), bdx\nelse:\n- raise NotImplementedError # TODO(mattjj)\n+ xs, ys = map(bdim_at_front, batched_args, batch_dims)\n+ return add_jaxvals_p.bind(xs, ys), 0\nprimitive_batchers[add_jaxvals_p] = add_batched\n### util\n+# These utilities depend on primitives for things like broadcasting, reshaping,\n+# and transposition on arrays. To avoid a circular import from depending on\n+# lax.py, these functions use method dispatch on their arguments, which could be\n+# DeviceArrays, numpy.ndarrays, or traced versions of those. This strategy\n+# almost works, except for broadcast, for which raw numpy.ndarrays don't have a\n+# method. To handle that case, the `broadcast` function uses a try/except.\n+\ndef bdim_at_front(x, bdim, broadcast_size=1):\nif bdim is None:\n- return broadcast(x, broadcast_size) if onp.ndim(x) else x\n+ return broadcast(x, broadcast_size)\nelse:\nreturn move_dim_to_front(x, bdim)\ndef move_dim_to_front(x, dim):\n+ aval = get_aval(x)\n+ if type(aval) is AbstractTuple:\n+ return pack(map(partial(move_dim_to_front, dim=dim), x))\n+ elif isinstance(aval, ShapedArray):\nassert 0 <= dim < onp.ndim(x)\nif dim == 0:\nreturn x\nelse:\nperm = (dim,) + tuple(range(dim)) + tuple(range(dim + 1, onp.ndim(x)))\nreturn x.transpose(perm)\n-\n-def handle_scalar_broadcasting(nd, x, bdim):\n- if bdim is None or nd == onp.ndim(x):\n- return x\nelse:\n- return x.reshape(x.shape + (1,) * (nd - x.ndim))\n+ raise TypeError(type(x))\ndef dimsize(dim, x):\n- if type(x) is JaxTuple:\n+ aval = get_aval(x)\n+ if type(aval) is AbstractTuple:\nreturn reduce(set.union, map(partial(dimsize, dim), x))\nelif type(dim) is int:\nreturn {x.shape[dim]}\n@@ -298,8 +307,26 @@ def moveaxis(sz, dst, src, x):\nraise TypeError(type(aval))\ndef broadcast(x, sz):\n+ aval = get_aval(x)\n+ if type(aval) is AbstractTuple:\n+ return pack(map(partial(broadcast, sz=sz), x))\n+ elif isinstance(aval, ShapedArray):\n+ # for scalars, don't actually broadcast\n+ if not onp.ndim(x):\n+ return x\n+\n+ # See comment at the top of this section about this try/except.\ntry:\nreturn x.broadcast((sz,))\nexcept AttributeError:\nassert not isinstance(x, Tracer)\nreturn onp.broadcast_to(x, (sz,) + onp.shape(x))\n+ else:\n+ raise TypeError(type(x))\n+\n+def handle_scalar_broadcasting(nd, x, bdim):\n+ assert isinstance(get_aval(x), ShapedArray)\n+ if bdim is None or nd == onp.ndim(x):\n+ return x\n+ else:\n+ return x.reshape(x.shape + (1,) * (nd - x.ndim))\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/batching_test.py",
"new_path": "tests/batching_test.py",
"diff": "@@ -24,7 +24,7 @@ import jax.numpy as np\nfrom jax import test_util as jtu\nfrom jax.abstract_arrays import ShapedArray\nfrom jax import lax\n-from jax.api import jit, grad, jvp, vjp, trace_to_jaxpr, jacfwd, jacrev\n+from jax.api import jit, grad, jvp, vjp, trace_to_jaxpr, jacfwd, jacrev, hessian\nfrom jax.api import vmap\nfrom jax.core import unit\nfrom jax.interpreters import partial_eval as pe\n@@ -291,6 +291,21 @@ class BatchingTest(jtu.JaxTestCase):\nexpected = np.array([True, False])\nself.assertAllClose(ans, expected, check_dtypes=True)\n+ def testHessian(self):\n+ # test based on code from sindhwani@google\n+ def fun(x, t):\n+ return np.sum(np.power(np.maximum(x, 0.0), 2)) + t\n+\n+ x = onp.array([-1., -0.5, 0., 0.5, 1.0])\n+\n+ ans = hessian(lambda x: fun(x, 0.0))(x)\n+ expected = onp.array([[0., 0., 0., 0., 0.],\n+ [0., 0., 0., 0., 0.],\n+ [0., 0.,0.5, 0., 0.],\n+ [0., 0., 0., 2., 0.],\n+ [0., 0., 0., 0., 2.]])\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\nif __name__ == '__main__':\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | cover unimplemented add_jaxvals_p batching case |
260,335 | 23.12.2018 09:28:23 | 28,800 | d48e7ef43d933e9b56dff7bd026f5dd576930543 | add batching (vmap) rule for lax.dynamic_slice
fixes | [
{
"change_type": "MODIFY",
"old_path": "jax/lax.py",
"new_path": "jax/lax.py",
"diff": "@@ -1752,11 +1752,37 @@ def dynamic_slice_transpose_rule(t, operand, start_indices, slice_sizes,\nzeros = broadcast(_const(t, 0), operand_shape)\nreturn [dynamic_update_slice(zeros, t, start_indices), ad_util.zero]\n+def dynamic_slice_batching_rule(batched_args, batch_dims, slice_sizes,\n+ **unused_kwargs):\n+ operand, start_indices = batched_args\n+ op_bdim, idx_bdim = batch_dims\n+\n+ if idx_bdim is None:\n+ new_start_indices = concatenate(\n+ [start_indices[:op_bdim], _zeros(start_indices, shape=(1,)),\n+ start_indices[op_bdim:]], 0)\n+ new_slice_sizes = list(slice_sizes)\n+ new_slice_sizes.insert(op_bdim, operand.shape[op_bdim])\n+ out = dynamic_slice(operand, new_start_indices, new_slice_sizes)\n+ return out, op_bdim\n+ else:\n+ # TODO(mattjj): add support for Gather HLO, use it here\n+ start_indices = batching.bdim_at_front(start_indices, idx_bdim)\n+ if op_bdim is None:\n+ out = concatenate([dynamic_slice(operand, idx, slice_sizes)\n+ for idx in start_indices], 0)\n+ else:\n+ operand = batching.bdim_at_front(operand, op_bdim)\n+ out = concatenate([dynamic_slice(op, idx, slice_sizes)\n+ for op, idx in zip(operand, start_indices)], 0)\n+ return out, 0\n+\ndynamic_slice_p = standard_primitive(\ndynamic_slice_shape_rule, _input_dtype, 'dynamic_slice',\ndynamic_slice_translation_rule)\nad.defjvp(dynamic_slice_p, dynamic_slice_jvp_rule, None)\nad.primitive_transposes[dynamic_slice_p] = dynamic_slice_transpose_rule\n+batching.primitive_batchers[dynamic_slice_p] = dynamic_slice_batching_rule\ndef dynamic_update_slice_shape_rule(operand, update, start_indices,\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/batching_test.py",
"new_path": "tests/batching_test.py",
"diff": "@@ -306,6 +306,26 @@ class BatchingTest(jtu.JaxTestCase):\n[0., 0., 0., 0., 2.]])\nself.assertAllClose(ans, expected, check_dtypes=False)\n+ def testDynamicSlice(self):\n+ # test dynamic_slice via numpy indexing syntax\n+ x = onp.arange(30).reshape((10, 3))\n+\n+ ans = vmap(lambda x, i: x[i], in_axes=(0, None))(x, 1)\n+ expected = x[:, 1]\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+\n+ idx = onp.array([0, 1, 2, 1, 0] * 2)\n+ ans = vmap(lambda x, i: x[i], in_axes=(0, 0))(x, idx)\n+ expected = x[onp.arange(10), idx]\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+ x = onp.arange(3)\n+ idx = onp.array([0, 1, 2, 1, 0] * 2)\n+ ans = vmap(lambda x, i: x[i], in_axes=(None, 0))(x, idx)\n+ expected = x[idx]\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\nif __name__ == '__main__':\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | add batching (vmap) rule for lax.dynamic_slice
fixes #165 |
260,335 | 23.12.2018 11:02:00 | 28,800 | 6d6b5263fea9d2549becc6b411d78ca348cc361d | add non-advanced boolean indexing support
also don't sub-sample indexing tests (run them all)
fixes | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1438,7 +1438,7 @@ def _rewriting_take(arr, idx, axis=0):\n# Handle slice index (only static, otherwise an error is raised)\nelif isinstance(idx, slice):\n- if not _all(elt is None or isinstance(core.get_aval(elt), ConcreteArray)\n+ if not _all(elt is None or type(core.get_aval(elt)) is ConcreteArray\nfor elt in (idx.start, idx.stop, idx.step)):\nmsg = (\"Array slice indices must have static start/stop/step to be used \"\n\"with Numpy indexing syntax. Try lax.dynamic_slice instead.\")\n@@ -1448,6 +1448,27 @@ def _rewriting_take(arr, idx, axis=0):\nresult = lax.slice_in_dim(arr, start, limit, stride, axis=axis)\nreturn lax.rev(result, [axis]) if needs_rev else result\n+ # Handle non-advanced bool index (only static, otherwise an error is raised)\n+ elif (isinstance(abstract_idx, ShapedArray) and onp.issubdtype(abstract_idx.dtype, onp.bool_)\n+ or isinstance(idx, list) and _all(not _shape(e) and onp.issubdtype(_dtype(e), onp.bool_)\n+ for e in idx)):\n+ if isinstance(idx, list):\n+ idx = array(idx)\n+ abstract_idx = core.get_aval(idx)\n+\n+ if not type(abstract_idx) is ConcreteArray:\n+ msg = (\"Array boolean indices must be static (e.g. no dependence on an \"\n+ \"argument to a jit or vmap function).\")\n+ raise IndexError(msg)\n+ else:\n+ if idx.ndim > arr.ndim or idx.shape != arr.shape[:idx.ndim]:\n+ msg = \"Boolean index shape did not match indexed array shape prefix.\"\n+ raise IndexError(msg)\n+ else:\n+ reshaped_arr = arr.reshape((-1,) + arr.shape[idx.ndim:])\n+ int_idx, = onp.where(idx.ravel())\n+ return lax.index_take(reshaped_arr, (int_idx,), (0,))\n+\n# Handle non-advanced tuple indices by recursing once\nelif isinstance(idx, tuple) and _all(onp.ndim(elt) == 0 for elt in idx):\ncanonical_idx = _canonicalize_tuple_index(arr, idx)\n@@ -1487,10 +1508,11 @@ def _rewriting_take(arr, idx, axis=0):\n# https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html#combining-advanced-and-basic-indexing\nelif _is_advanced_int_indexer(idx):\ncanonical_idx = _canonicalize_tuple_index(arr, tuple(idx))\n- idx_noadvanced = [slice(None) if _is_int(e) else e for e in canonical_idx]\n+ idx_noadvanced = [slice(None) if _is_int_arraylike(e) else e\n+ for e in canonical_idx]\narr_sliced = _rewriting_take(arr, tuple(idx_noadvanced))\n- advanced_pairs = ((e, i) for i, e in enumerate(canonical_idx) if _is_int(e))\n+ advanced_pairs = ((e, i) for i, e in enumerate(canonical_idx) if _is_int_arraylike(e))\nidx_advanced, axes = zip(*advanced_pairs)\nidx_advanced = broadcast_arrays(*idx_advanced)\n@@ -1522,11 +1544,11 @@ def _is_advanced_int_indexer(idx):\n# https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html#advanced-indexing\nif isinstance(idx, (tuple, list)):\n# We assume this check comes *after* the check for non-advanced tuple index,\n- # and hence we already know at least one element is a sequence\n- return _all(e is None or e is Ellipsis or isinstance(e, slice) or _is_int(e)\n- for e in idx)\n+ # and hence we already know at least one element is a sequence if it's a tuple\n+ return _all(e is None or e is Ellipsis or isinstance(e, slice)\n+ or _is_int_arraylike(e) for e in idx)\nelse:\n- return _is_int(idx)\n+ return _is_int_arraylike(idx)\ndef _is_advanced_int_indexer_without_slices(idx):\n@@ -1539,11 +1561,11 @@ def _is_advanced_int_indexer_without_slices(idx):\nreturn True\n-def _is_int(x):\n+def _is_int_arraylike(x):\n\"\"\"Returns True if x is array-like with integer dtype, False otherwise.\"\"\"\nreturn (isinstance(x, int) and not isinstance(x, bool)\nor onp.issubdtype(getattr(x, \"dtype\", None), onp.integer)\n- or isinstance(x, (list, tuple)) and _all(_is_int(e) for e in x))\n+ or isinstance(x, (list, tuple)) and _all(_is_int_arraylike(e) for e in x))\ndef _canonicalize_tuple_index(arr, idx):\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_indexing_test.py",
"new_path": "tests/lax_numpy_indexing_test.py",
"diff": "@@ -62,9 +62,8 @@ def check_grads(f, args, order, atol=None, rtol=None, eps=None):\nclass IndexingTest(jtu.JaxTestCase):\n\"\"\"Tests for Numpy indexing translation rules.\"\"\"\n- @parameterized.named_parameters(jtu.cases_from_list({\n- \"testcase_name\":\n- \"{}_inshape={}_indexer={}\".format(\n+ @parameterized.named_parameters({\n+ \"testcase_name\": \"{}_inshape={}_indexer={}\".format(\nname, jtu.format_shape_dtype_string( shape, dtype), indexer),\n\"shape\": shape, \"dtype\": dtype, \"rng\": rng, \"indexer\": indexer\n} for name, index_specs in [\n@@ -154,14 +153,14 @@ class IndexingTest(jtu.JaxTestCase):\nIndexSpec(shape=(3, 4), indexer=()),\n]),\n] for shape, indexer in index_specs for dtype in all_dtypes\n- for rng in [jtu.rand_default()]))\n+ for rng in [jtu.rand_default()])\n@jtu.skip_on_devices(\"tpu\")\ndef testStaticIndexing(self, shape, dtype, rng, indexer):\nargs_maker = lambda: [rng(shape, dtype)]\nfun = lambda x: x[indexer]\nself._CompileAndCheck(fun, args_maker, check_dtypes=True)\n- @parameterized.named_parameters(jtu.cases_from_list({\n+ @parameterized.named_parameters({\n\"testcase_name\":\n\"{}_inshape={}_indexer={}\".format(name,\njtu.format_shape_dtype_string(\n@@ -233,7 +232,7 @@ class IndexingTest(jtu.JaxTestCase):\n# IndexSpec(shape=(3, 4), indexer=()),\n# ]),\n] for shape, indexer in index_specs for dtype in float_dtypes\n- for rng in [jtu.rand_default()]))\n+ for rng in [jtu.rand_default()])\n@jtu.skip_on_devices(\"tpu\")\ndef testStaticIndexingGrads(self, shape, dtype, rng, indexer):\ntol = 1e-2 if onp.finfo(dtype).bits == 32 else None\n@@ -257,7 +256,7 @@ class IndexingTest(jtu.JaxTestCase):\nelse:\nreturn idx, lambda x: x\n- @parameterized.named_parameters(jtu.cases_from_list(\n+ @parameterized.named_parameters(\n{\"testcase_name\": \"{}_inshape={}_indexer={}\"\n.format(name, jtu.format_shape_dtype_string(shape, dtype), indexer),\n\"shape\": shape, \"dtype\": dtype, \"rng\": rng, \"indexer\": indexer}\n@@ -280,7 +279,7 @@ class IndexingTest(jtu.JaxTestCase):\n]\nfor shape, indexer in index_specs\nfor dtype in all_dtypes\n- for rng in [jtu.rand_default()]))\n+ for rng in [jtu.rand_default()])\ndef testDynamicIndexingWithSlicesErrors(self, shape, dtype, rng, indexer):\nunpacked_indexer, pack_indexer = self._ReplaceSlicesWithTuples(indexer)\n@@ -292,7 +291,7 @@ class IndexingTest(jtu.JaxTestCase):\nargs_maker = lambda: [rng(shape, dtype), unpacked_indexer]\nself.assertRaises(IndexError, lambda: fun(*args_maker()))\n- @parameterized.named_parameters(jtu.cases_from_list(\n+ @parameterized.named_parameters(\n{\"testcase_name\": \"{}_inshape={}_indexer={}\"\n.format(name, jtu.format_shape_dtype_string(shape, dtype), indexer),\n\"shape\": shape, \"dtype\": dtype, \"rng\": rng, \"indexer\": indexer}\n@@ -312,7 +311,7 @@ class IndexingTest(jtu.JaxTestCase):\n]\nfor shape, indexer in index_specs\nfor dtype in all_dtypes\n- for rng in [jtu.rand_default()]))\n+ for rng in [jtu.rand_default()])\ndef testDynamicIndexingWithIntegers(self, shape, dtype, rng, indexer):\nunpacked_indexer, pack_indexer = self._ReplaceSlicesWithTuples(indexer)\n@@ -324,7 +323,7 @@ class IndexingTest(jtu.JaxTestCase):\nself._CompileAndCheck(fun, args_maker, check_dtypes=True)\n@skip\n- @parameterized.named_parameters(jtu.cases_from_list(\n+ @parameterized.named_parameters(\n{\"testcase_name\": \"{}_inshape={}_indexer={}\"\n.format(name, jtu.format_shape_dtype_string(shape, dtype), indexer),\n\"shape\": shape, \"dtype\": dtype, \"rng\": rng, \"indexer\": indexer}\n@@ -346,7 +345,7 @@ class IndexingTest(jtu.JaxTestCase):\n]\nfor shape, indexer in index_specs\nfor dtype in float_dtypes\n- for rng in [jtu.rand_default()]))\n+ for rng in [jtu.rand_default()])\ndef DISABLED_testDynamicIndexingWithIntegersGrads(self, shape, dtype, rng, indexer):\n# TODO(mattjj): re-enable (test works but for grad-of-compile, in flux)\ntol = 1e-2 if onp.finfo(dtype).bits == 32 else None\n@@ -360,7 +359,7 @@ class IndexingTest(jtu.JaxTestCase):\narr = rng(shape, dtype)\ncheck_grads(partial(fun, unpacked_indexer), (arr,), 2, tol, tol, tol)\n- @parameterized.named_parameters(jtu.cases_from_list(\n+ @parameterized.named_parameters(\n{\"testcase_name\": \"{}_inshape={}_indexer={}\"\n.format(name, jtu.format_shape_dtype_string(shape, dtype), indexer),\n\"shape\": shape, \"dtype\": dtype, \"rng\": rng, \"indexer\": indexer}\n@@ -412,13 +411,13 @@ class IndexingTest(jtu.JaxTestCase):\n]\nfor shape, indexer in index_specs\nfor dtype in all_dtypes\n- for rng in [jtu.rand_default()]))\n+ for rng in [jtu.rand_default()])\ndef testAdvancedIntegerIndexing(self, shape, dtype, rng, indexer):\nargs_maker = lambda: [rng(shape, dtype), indexer]\nfun = lambda x, idx: x[idx]\nself._CompileAndCheck(fun, args_maker, check_dtypes=True)\n- @parameterized.named_parameters(jtu.cases_from_list(\n+ @parameterized.named_parameters(\n{\"testcase_name\": \"{}_inshape={}_indexer={}\"\n.format(name, jtu.format_shape_dtype_string(shape, dtype), indexer),\n\"shape\": shape, \"dtype\": dtype, \"rng\": rng, \"indexer\": indexer}\n@@ -470,14 +469,14 @@ class IndexingTest(jtu.JaxTestCase):\n]\nfor shape, indexer in index_specs\nfor dtype in float_dtypes\n- for rng in [jtu.rand_default()]))\n+ for rng in [jtu.rand_default()])\ndef testAdvancedIntegerIndexingGrads(self, shape, dtype, rng, indexer):\ntol = 1e-2 if onp.finfo(dtype).bits == 32 else None\narg = rng(shape, dtype)\nfun = lambda x: x[indexer]**2\ncheck_grads(fun, (arg,), 2, tol, tol, tol)\n- @parameterized.named_parameters(jtu.cases_from_list(\n+ @parameterized.named_parameters(\n{\"testcase_name\": \"{}_inshape={}_indexer={}\"\n.format(name, jtu.format_shape_dtype_string(shape, dtype), indexer),\n\"shape\": shape, \"dtype\": dtype, \"rng\": rng, \"indexer\": indexer}\n@@ -533,7 +532,7 @@ class IndexingTest(jtu.JaxTestCase):\n]\nfor shape, indexer in index_specs\nfor dtype in all_dtypes\n- for rng in [jtu.rand_default()]))\n+ for rng in [jtu.rand_default()])\ndef testMixedAdvancedIntegerIndexing(self, shape, dtype, rng, indexer):\nindexer_with_dummies = [e if isinstance(e, onp.ndarray) else ()\nfor e in indexer]\n@@ -588,6 +587,49 @@ class IndexingTest(jtu.JaxTestCase):\nself.assertAllClose(a1, a2, check_dtypes=True)\n+ def testBooleanIndexingArray1D(self):\n+ idx = onp.array([True, True, False])\n+ x = api.device_put(onp.arange(3))\n+ ans = x[idx]\n+ expected = onp.arange(3)[idx]\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+ def testBooleanIndexingList1D(self):\n+ idx = [True, True, False]\n+ x = api.device_put(onp.arange(3))\n+ ans = x[idx]\n+ expected = onp.arange(3)[idx]\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+ def testBooleanIndexingArray2DBroadcast(self):\n+ idx = onp.array([True, True, False, True])\n+ x = onp.arange(8).reshape(4, 2)\n+ ans = api.device_put(x)[idx]\n+ expected = x[idx]\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+ def testBooleanIndexingList2DBroadcast(self):\n+ idx = [True, True, False, True]\n+ x = onp.arange(8).reshape(4, 2)\n+ ans = api.device_put(x)[idx]\n+ expected = x[idx]\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+ def testBooleanIndexingArray2D(self):\n+ idx = onp.array([[True, False],\n+ [False, True],\n+ [False, False],\n+ [True, True]])\n+ x = onp.arange(8).reshape(4, 2)\n+ ans = api.device_put(x)[idx]\n+ expected = x[idx]\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+ def testBooleanIndexingDynamicShapeError(self):\n+ x = onp.zeros(3)\n+ i = onp.array([True, True, False])\n+ self.assertRaises(IndexError, lambda: api.jit(lambda x, i: x[i])(x, i))\n+\nif __name__ == \"__main__\":\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | add non-advanced boolean indexing support
also don't sub-sample indexing tests (run them all)
fixes #166 |
260,335 | 23.12.2018 11:21:33 | 28,800 | b900339b879cba9737089abbd5fc061969ef5a60 | loosen scipy test tol to fix benign failure | [
{
"change_type": "MODIFY",
"old_path": "tests/scipy_stats_test.py",
"new_path": "tests/scipy_stats_test.py",
"diff": "@@ -50,7 +50,8 @@ class LaxBackedScipyStatsTests(jtu.JaxTestCase):\nx, a, b, loc, scale = map(rng, shapes, dtypes)\nreturn [x, onp.abs(a), onp.abs(b), loc, onp.abs(scale)]\n- self._CheckAgainstNumpy(scipy_fun, lax_fun, args_maker, check_dtypes=True)\n+ self._CheckAgainstNumpy(scipy_fun, lax_fun, args_maker, check_dtypes=True,\n+ tol=1e-4)\nself._CompileAndCheck(lax_fun, args_maker, check_dtypes=True)\n@genNamedParametersNArgs(3, jtu.rand_default())\n"
}
] | Python | Apache License 2.0 | google/jax | loosen scipy test tol to fix benign failure |
260,335 | 24.12.2018 10:30:23 | 28,800 | 59142a2494537aa68e6d192416f1d4baa3457556 | add error message if Dropout gets no rng key
closes (though there's more work to be done here) | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/stax.py",
"new_path": "jax/experimental/stax.py",
"diff": "@@ -217,6 +217,12 @@ def Dropout(rate, mode='train'):\ndef init_fun(input_shape):\nreturn input_shape, ()\ndef apply_fun(params, inputs, rng):\n+ if rng is None:\n+ msg = (\"Dropout layer requires apply_fun to be called with a PRNG key \"\n+ \"argument. That is, instead of `apply_fun(params, inputs)`, call \"\n+ \"it like `apply_fun(params, inputs, key)` where `key` is a \"\n+ \"jax.random.PRNGKey value.\")\n+ raise ValueError(msg)\nif mode == 'train':\nkeep = random.bernoulli(rng, rate, inputs.shape)\nreturn np.where(keep, inputs / rate, 0)\n"
}
] | Python | Apache License 2.0 | google/jax | add error message if Dropout gets no rng key
closes #170 (though there's more work to be done here) |
260,335 | 30.12.2018 16:51:32 | 28,800 | b4246163ac7c4a6480187d05b5a4c476434f1126 | add stax.FanInConcat (fixes | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/stax.py",
"new_path": "jax/experimental/stax.py",
"diff": "@@ -212,6 +212,18 @@ def FanInSum():\nFanInSum = FanInSum()\n+def FanInConcat(axis=-1):\n+ \"\"\"Layer construction function for a fan-in concatenation layer.\"\"\"\n+ def init_fun(input_shape):\n+ ax = axis % len(input_shape[0])\n+ concat_size = sum(shape[ax] for shape in input_shape)\n+ out_shape = input_shape[0][:ax] + (concat_size,) + input_shape[0][ax+1:]\n+ return out_shape, ()\n+ def apply_fun(params, inputs, rng=None):\n+ return np.concatenate(inputs, axis)\n+ return init_fun, apply_fun\n+\n+\ndef Dropout(rate, mode='train'):\n\"\"\"Layer construction function for a dropout layer with given rate.\"\"\"\ndef init_fun(input_shape):\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/stax_test.py",
"new_path": "tests/stax_test.py",
"diff": "@@ -30,9 +30,18 @@ from jax.config import config\nconfig.parse_flags_with_absl()\n+def random_inputs(rng, input_shape):\n+ if type(input_shape) is tuple:\n+ return rng.randn(*input_shape).astype(onp.float32)\n+ elif type(input_shape) is list:\n+ return [random_inputs(rng, shape) for shape in input_shape]\n+ else:\n+ raise TypeError(type(input_shape))\n+\n+\ndef _CheckShapeAgreement(test_case, init_fun, apply_fun, input_shape):\nresult_shape, params = init_fun(input_shape)\n- inputs = onp.random.RandomState(0).randn(*input_shape).astype(\"float32\")\n+ inputs = random_inputs(onp.random.RandomState(0), input_shape)\nrng_key = random.PRNGKey(0)\nresult = apply_fun(params, inputs, rng_key)\ntest_case.assertEqual(result.shape, result_shape)\n@@ -130,6 +139,26 @@ class StaxTest(jtu.JaxTestCase):\ninit_fun, apply_fun = stax.Dropout(0.9)\n_CheckShapeAgreement(self, init_fun, apply_fun, input_shape)\n+ @parameterized.named_parameters(jtu.cases_from_list(\n+ {\"testcase_name\": \"_input_shape={}\".format(input_shape),\n+ \"input_shape\": input_shape}\n+ for input_shape in [(3, 4), (2, 5, 6, 1)]))\n+ def testFanInSum(self, input_shape):\n+ init_fun, apply_fun = stax.FanInSum\n+ _CheckShapeAgreement(self, init_fun, apply_fun, [input_shape, input_shape])\n+\n+ @parameterized.named_parameters(jtu.cases_from_list(\n+ {\"testcase_name\": \"_inshapes={}_axis={}\".format(input_shapes, axis),\n+ \"input_shapes\": input_shapes, \"axis\": axis}\n+ for input_shapes, axis in [\n+ ([(2, 3), (2, 1)], 1),\n+ ([(2, 3), (2, 1)], -1),\n+ ([(1, 2, 4), (1, 1, 4)], 1),\n+ ]))\n+ def testFanInConcat(self, input_shapes, axis):\n+ init_fun, apply_fun = stax.FanInConcat(axis)\n+ _CheckShapeAgreement(self, init_fun, apply_fun, input_shapes)\n+\nif __name__ == \"__main__\":\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | add stax.FanInConcat (fixes #174) |
260,335 | 30.12.2018 17:49:11 | 28,800 | 9c49a9bfe690738d502a48e33d2f421c4694e6ab | add np.append and np.polyval | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1070,6 +1070,27 @@ def diag(v, k=0):\nraise ValueError(\"diag input must be 1d or 2d\")\n+@_wraps(onp.polyval)\n+def polyval(p, x):\n+ if isinstance(p, onp.poly1d):\n+ p = onp.asarray(p)\n+ if isinstance(x, onp.poly1d):\n+ y = 0\n+ else:\n+ y = zeros_like(x)\n+ for i in range(len(p)):\n+ y = y * x + p[i]\n+ return y\n+\n+\n+@_wraps(onp.append)\n+def append(arr, values, axis=None):\n+ if axis is None:\n+ return concatenate([ravel(arr), ravel(values)], 0)\n+ else:\n+ return concatenate([arr, values], axis=axis)\n+\n+\n### Tensor contraction operations\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_test.py",
"new_path": "tests/lax_numpy_test.py",
"diff": "@@ -119,6 +119,7 @@ JAX_COMPOUND_OP_RECORDS = [\nop_record(\"log1p\", 1, numeric_dtypes, all_shapes, jtu.rand_small_positive(), []),\nop_record(\"logaddexp\", 2, float_dtypes, all_shapes, jtu.rand_default(), [\"rev\"]),\nop_record(\"logaddexp2\", 2, float_dtypes, all_shapes, jtu.rand_default(), [\"rev\"]),\n+ op_record(\"polyval\", 2, numeric_dtypes, nonempty_array_shapes, jtu.rand_default(), []),\nop_record(\"ravel\", 1, default_dtypes, all_shapes, jtu.rand_default(), [\"rev\"]),\nop_record(\"remainder\", 2, default_dtypes, all_shapes, jtu.rand_nonzero(), []),\nop_record(\"sqrt\", 1, default_dtypes, all_shapes, jtu.rand_positive(), [\"rev\"]),\n@@ -451,6 +452,28 @@ class LaxBackedNumpyTests(jtu.JaxTestCase):\nself._CheckAgainstNumpy(onp_fun, lnp_fun, args_maker, check_dtypes=True)\nself._CompileAndCheck(lnp_fun, args_maker, check_dtypes=True)\n+ @parameterized.named_parameters(jtu.cases_from_list(\n+ {\"testcase_name\": \"_axis={}_baseshape=[{}]_dtypes=[{}]\".format(\n+ axis, \",\".join(str(d) for d in base_shape),\n+ \",\".join(onp.dtype(dtype).name for dtype in dtypes)),\n+ \"axis\": axis, \"base_shape\": base_shape, \"dtypes\": dtypes,\n+ \"rng\": jtu.rand_default()}\n+ for dtypes in CombosWithReplacement(default_dtypes, 2)\n+ for base_shape in [(4,), (3, 4), (2, 3, 4)]\n+ for axis in range(-len(base_shape)+1, len(base_shape))))\n+ def testAppend(self, axis, base_shape, dtypes, rng):\n+ wrapped_axis = axis % len(base_shape)\n+ shapes = [base_shape[:wrapped_axis] + (size,) + base_shape[wrapped_axis+1:]\n+ for size, _ in zip(itertools.cycle([3, 1, 4]), dtypes)]\n+ onp_fun = lambda arr, values: onp.append(arr, values, axis=axis)\n+ lnp_fun = lambda arr, values: lnp.append(arr, values, axis=axis)\n+\n+ def args_maker():\n+ return [rng(shape, dtype) for shape, dtype in zip(shapes, dtypes)]\n+\n+ self._CheckAgainstNumpy(onp_fun, lnp_fun, args_maker, check_dtypes=True)\n+ self._CompileAndCheck(lnp_fun, args_maker, check_dtypes=True)\n+\n@parameterized.named_parameters(jtu.cases_from_list(\n{\"testcase_name\": \"_shape=[{}]_axis={}_repeats={}\".format(\njtu.format_shape_dtype_string(shape, dtype), axis, repeats),\n"
}
] | Python | Apache License 2.0 | google/jax | add np.append and np.polyval |
260,335 | 30.12.2018 18:07:50 | 28,800 | 5d2fc7c05bc103b73e2c6fb52f59fdfc57b4e5a5 | only test np.polyval on nonscalar array shapes | [
{
"change_type": "MODIFY",
"old_path": "jax/test_util.py",
"new_path": "jax/test_util.py",
"diff": "@@ -458,7 +458,7 @@ class JaxTestCase(parameterized.TestCase):\ndef _CheckAgainstNumpy(self, lax_op, numpy_reference_op, args_maker,\ncheck_dtypes=False, tol=1e-5):\nargs = args_maker()\n- lax_ans = lax_op(*args)\nnumpy_ans = numpy_reference_op(*args)\n+ lax_ans = lax_op(*args)\nself.assertAllClose(lax_ans, numpy_ans, check_dtypes=check_dtypes,\natol=tol, rtol=tol)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_test.py",
"new_path": "tests/lax_numpy_test.py",
"diff": "@@ -35,7 +35,8 @@ from jax.config import config\nconfig.parse_flags_with_absl()\nFLAGS = config.FLAGS\n-nonempty_array_shapes = [(), (4,), (3, 4), (3, 1), (1, 4), (2, 1, 4), (2, 3, 4)]\n+nonempty_nonscalar_array_shapes = [(4,), (3, 4), (3, 1), (1, 4), (2, 1, 4), (2, 3, 4)]\n+nonempty_array_shapes = [()] + nonempty_nonscalar_array_shapes\nempty_array_shapes = [(0,), (0, 4), (3, 0),]\nscalar_shapes = [jtu.NUMPY_SCALAR_SHAPE]\n@@ -119,7 +120,7 @@ JAX_COMPOUND_OP_RECORDS = [\nop_record(\"log1p\", 1, numeric_dtypes, all_shapes, jtu.rand_small_positive(), []),\nop_record(\"logaddexp\", 2, float_dtypes, all_shapes, jtu.rand_default(), [\"rev\"]),\nop_record(\"logaddexp2\", 2, float_dtypes, all_shapes, jtu.rand_default(), [\"rev\"]),\n- op_record(\"polyval\", 2, numeric_dtypes, nonempty_array_shapes, jtu.rand_default(), []),\n+ op_record(\"polyval\", 2, numeric_dtypes, nonempty_nonscalar_array_shapes, jtu.rand_default(), []),\nop_record(\"ravel\", 1, default_dtypes, all_shapes, jtu.rand_default(), [\"rev\"]),\nop_record(\"remainder\", 2, default_dtypes, all_shapes, jtu.rand_nonzero(), []),\nop_record(\"sqrt\", 1, default_dtypes, all_shapes, jtu.rand_positive(), [\"rev\"]),\n"
}
] | Python | Apache License 2.0 | google/jax | only test np.polyval on nonscalar array shapes |
260,335 | 30.12.2018 21:42:55 | 28,800 | 072e6f78f1aebfa651574e47709d0f9f0e2e17a5 | replace PRNGKey class with uint32[2] array | [
{
"change_type": "MODIFY",
"old_path": "jax/random.py",
"new_path": "jax/random.py",
"diff": "@@ -29,22 +29,11 @@ from .api import jit\nfrom jax.lib import xla_bridge\nfrom jax import core\n-class PRNGKey(object):\n- \"\"\"A pseudo-random number generator (PRNG) key for use with lax.random.\"\"\"\n- __slots__ = [\"keypair\"]\n- def __init__(self, seed):\n- \"\"\"Create a new PRNG key.\n-\n- Args:\n- seed: a scalar integer value used to initialize the PRNG key.\n-\n- Returns:\n- A new PRNGKey object.\n- \"\"\"\n- convert = lambda key: lax.convert_element_type(key, onp.uint32)\n+def PRNGKey(seed):\nif onp.shape(seed):\nraise TypeError(\"PRNGKey seed must be a scalar.\")\n+ convert = lambda k: lax.reshape(lax.convert_element_type(k, onp.uint32), [1])\nif isinstance(seed, (int, onp.ndarray)):\n# Special handling of raw integer values, which may have be 64bit even\n# when jax_enable_x64=False and we don't want to drop the top 32 bits\n@@ -52,18 +41,13 @@ class PRNGKey(object):\nelse:\nk1 = convert(lax.shift_right_logical(seed, 32))\nk2 = convert(lax.bitwise_and(seed, 0xFFFFFFFF))\n- self.keypair = core.pack((k1, k2))\n-\n- @classmethod\n- def from_keypair(cls, keypair):\n- \"\"\"Internal method to create a PRNGKey instance from a raw key pair.\"\"\"\n- new = cls.__new__(cls)\n- new.keypair = core.pack(keypair)\n- return new\n-\n+ return lax.concatenate([k1, k2], 0)\n-tree_util.register_pytree_node(PRNGKey, lambda k: (k.keypair, None),\n- lambda _, xs: PRNGKey.from_keypair(xs))\n+def is_prng_key(key):\n+ try:\n+ return key.shape == (2,) and key.dtype == onp.uint32\n+ except AttributeError:\n+ return False\n### utilities\n@@ -169,14 +153,15 @@ def split(key, num=2):\nReturns:\nA tuple of length `num` of new PRNGKey instances.\n\"\"\"\n- counts = lax.tie_in(key.keypair, lax.iota(onp.uint32, num * 2))\n- bits = lax.reshape(threefry_2x32(key.keypair, counts), (num, 2))\n- keypairs = (lax.index_in_dim(bits, i, keepdims=False) for i in range(num))\n- return tuple(PRNGKey.from_keypair((kp[0], kp[1])) for kp in keypairs)\n+ counts = lax.tie_in(key, lax.iota(onp.uint32, num * 2))\n+ bits = lax.reshape(threefry_2x32(key, counts), (num, 2))\n+ return tuple(bits)\ndef _random_bits(key, bit_width, shape):\n\"\"\"Sample uniform random bits of given width and shape using PRNG key.\"\"\"\n+ if not is_prng_key(key):\n+ raise TypeError(\"_random_bits got invalid prng key.\")\nif bit_width not in (32, 64):\nraise TypeError(\"requires 32- or 64-bit field width.\")\nmax_count = (bit_width // 32) * onp.prod(shape)\n@@ -184,8 +169,8 @@ def _random_bits(key, bit_width, shape):\n# TODO(mattjj): just split the key here\nraise TypeError(\"requesting more random bits than a single call provides.\")\n- counts = lax.tie_in(key.keypair, lax.iota(onp.uint32, max_count))\n- bits = threefry_2x32(key.keypair, counts)\n+ counts = lax.tie_in(key, lax.iota(onp.uint32, max_count))\n+ bits = threefry_2x32(key, counts)\nif bit_width == 64:\nbits = [lax.convert_element_type(x, onp.uint64) for x in np.split(bits, 2)]\nbits = (bits[0] << onp.uint64(32)) | bits[1]\n"
}
] | Python | Apache License 2.0 | google/jax | replace PRNGKey class with uint32[2] array |
260,335 | 30.12.2018 22:26:22 | 28,800 | 4ed5df85e3b8145910f31b6d1010034bb1011a98 | add batching test for PRNGKeys and random sampling | [
{
"change_type": "MODIFY",
"old_path": "tests/batching_test.py",
"new_path": "tests/batching_test.py",
"diff": "@@ -24,6 +24,7 @@ import jax.numpy as np\nfrom jax import test_util as jtu\nfrom jax.abstract_arrays import ShapedArray\nfrom jax import lax\n+from jax import random\nfrom jax.api import jit, grad, jvp, vjp, trace_to_jaxpr, jacfwd, jacrev, hessian\nfrom jax.api import vmap\nfrom jax.core import unit\n@@ -326,6 +327,14 @@ class BatchingTest(jtu.JaxTestCase):\nexpected = x[idx]\nself.assertAllClose(ans, expected, check_dtypes=False)\n+ def testRandom(self):\n+ seeds = vmap(random.PRNGKey)(onp.arange(10))\n+ ans = vmap(partial(random.normal, shape=(3, 2)))(seeds)\n+ expected = onp.stack([random.normal(random.PRNGKey(seed), (3, 2))\n+ for seed in onp.arange(10)])\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+ assert len(onp.unique(ans)) == 10 * 3 * 2\n+\nif __name__ == '__main__':\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | add batching test for PRNGKeys and random sampling |
260,316 | 31.12.2018 16:08:23 | 18,000 | d85c0dbecbadf8d1aceb1f98e5497f5c130538fd | Added example of automatic differentiation variational inference | [
{
"change_type": "ADD",
"old_path": null,
"new_path": "examples/advi.py",
"diff": "+\"\"\"Automatic differentiation variational inference in Numpy and JAX.\n+\n+This demo fits a Gaussian approximation to an intractable, unnormalized\n+density, by differentiating through a Monte Carlo estimate of the\n+variational evidence lower bound (ELBO).\"\"\"\n+\n+from __future__ import absolute_import\n+from __future__ import print_function\n+\n+from functools import partial\n+import matplotlib.pyplot as plt\n+\n+from jax.api import jit, grad, vmap\n+from jax import random\n+from jax.experimental import minmax\n+import jax.numpy as np\n+import jax.scipy.stats.norm as norm\n+\n+\n+# ========= Functions to define the evidence lower bound. =========\n+\n+def diag_gaussian_sample(mean, log_std, rng):\n+ return mean + np.exp(log_std) * random.normal(rng, mean.shape)\n+\n+def diag_gaussian_logpdf(x, mean, log_std):\n+ return np.sum(vmap(norm.logpdf)(x, mean, np.exp(log_std)))\n+\n+def elbo((mean, log_std), logprob, rng):\n+ # Simple Monte Carlo estimate of the variational lower bound.\n+ sample = diag_gaussian_sample(mean, log_std, rng)\n+ return logprob(sample) - diag_gaussian_logpdf(sample, mean, log_std)\n+\n+\n+# ========= Helper functions for batching. =========\n+\n+def rng_map(f, rng, num_samples, *args, **kwargs):\n+ # Calls f with a batch of different seeds.\n+ # f must have signature f(*args, rng, **kwargs).\n+ rngs = np.array(random.split(rng, num_samples))\n+ return vmap(partial(f, *args, **kwargs))(rngs)\n+\n+def batch_elbo(params, logprob, num_samples, rng):\n+ return np.mean(rng_map(elbo, rng, num_samples, params, logprob))\n+\n+\n+# ========= Helper functions for plotting. =========\n+\n+def eval_zip(func, X, Y):\n+ params_vec = np.stack([X.ravel(), Y.ravel()]).T\n+ zs = vmap(func)(params_vec)\n+ return zs.reshape(X.shape)\n+eval_zip = jit(eval_zip, static_argnums=(0,))\n+\n+def plot_isocontours(ax, func, xlimits, ylimits, numticks=101, **kwargs):\n+ x = np.linspace(*xlimits, num=numticks)\n+ y = np.linspace(*ylimits, num=numticks)\n+ X, Y = np.meshgrid(x, y)\n+ Z = eval_zip(func, X, Y)\n+ ax.contour(X, Y, Z, **kwargs)\n+ ax.set_xlim(xlimits)\n+ ax.set_ylim(ylimits)\n+ ax.set_yticks([])\n+ ax.set_xticks([])\n+\n+\n+# ========= Define an intractable unnormalized density =========\n+\n+def funnel_log_density(params):\n+ mean, log_stddev = params[0], params[1]\n+ return norm.logpdf(mean, 0, np.exp(log_stddev)) + \\\n+ norm.logpdf(log_stddev, 0, 1.35)\n+\n+\n+if __name__ == \"__main__\":\n+ step_size = 0.1\n+ momentum = 0.9\n+ num_steps = 100\n+ num_samples = 20\n+\n+ def objective(params, rng):\n+ return -batch_elbo(params, funnel_log_density, num_samples, rng)\n+\n+ # Set up figure.\n+ fig = plt.figure(figsize=(8,8), facecolor='white')\n+ ax = fig.add_subplot(111, frameon=False)\n+ plt.ion()\n+ plt.show(block=False)\n+ xlimits = [-2, 2]\n+ ylimits = [-4, 2]\n+\n+ def callback(params, t, rng):\n+ print(\"Iteration {} lower bound {}\".format(t, objective(params, rng)))\n+\n+ plt.cla()\n+ target_dist = lambda x: np.exp(funnel_log_density(x))\n+ approx_dist = lambda x: np.exp(diag_gaussian_logpdf(x, *params))\n+ plot_isocontours(ax, target_dist, xlimits, ylimits, cmap='summer')\n+ plot_isocontours(ax, approx_dist, xlimits, ylimits, cmap='winter')\n+\n+ samples = rng_map(diag_gaussian_sample, rng, num_samples, *params)\n+ plt.plot(samples[:, 0], samples[:, 1], 'b.')\n+ plt.draw()\n+ plt.pause(1.0/60.0)\n+\n+\n+ # Set up optimizer.\n+ D = 2\n+ init_mean = np.zeros(D)\n+ init_std = np.zeros(D)\n+ init_params = (init_mean, init_std)\n+ opt_init, opt_update = minmax.momentum(step_size, mass=momentum)\n+ opt_state = opt_init(init_params)\n+\n+ @jit\n+ def update(i, opt_state, rng):\n+ params = minmax.get_params(opt_state)\n+ return opt_update(i, grad(objective)(params, rng), opt_state)\n+\n+\n+ # Main fitting loop.\n+ print(\"Optimizing variational parameters...\")\n+ rng = random.PRNGKey(0)\n+ for t in range(num_steps):\n+ opt_state = update(t, opt_state, rng)\n+ callback(minmax.get_params(opt_state), t, rng)\n+ old, rng = random.split(rng)\n"
}
] | Python | Apache License 2.0 | google/jax | Added example of automatic differentiation variational inference |
260,335 | 02.01.2019 12:52:39 | 28,800 | a627cc80e8de84e3bc0db550d27f9fa4b432c8a4 | make random.split return something vmap-compatible
(in particular, return an array rather than a tuple, c.f. | [
{
"change_type": "MODIFY",
"old_path": "jax/random.py",
"new_path": "jax/random.py",
"diff": "@@ -154,8 +154,7 @@ def split(key, num=2):\nA tuple of length `num` of new PRNGKey instances.\n\"\"\"\ncounts = lax.tie_in(key, lax.iota(onp.uint32, num * 2))\n- bits = lax.reshape(threefry_2x32(key, counts), (num, 2))\n- return tuple(bits)\n+ return lax.reshape(threefry_2x32(key, counts), (num, 2))\ndef _random_bits(key, bit_width, shape):\n"
}
] | Python | Apache License 2.0 | google/jax | make random.split return something vmap-compatible
(in particular, return an array rather than a tuple, c.f. #181) |
260,335 | 02.01.2019 17:46:46 | 28,800 | c4d32ca2cdcef0f1816bf1a5473184e853abdcfd | support x[[0, 2, 4], [0, 2, 4]] indexing, fix | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1510,7 +1510,7 @@ def _rewriting_take(arr, idx, axis=0):\n# Handle integer array indexing *without* ellipsis/slices/nones\n# https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html#integer-array-indexing\nif _is_advanced_int_indexer_without_slices(idx):\n- if isinstance(idx, list):\n+ if isinstance(idx, (tuple, list)):\nif _any(_shape(e) for e in idx):\n# At least one sequence element in the index list means broadcasting.\nidx = broadcast_arrays(*idx)\n@@ -1521,7 +1521,7 @@ def _rewriting_take(arr, idx, axis=0):\n# The indexer is just a single integer array.\nidx = [idx]\n- flat_idx = tuple(mod(ravel(x), arr.shape[i]) for i, x in enumerate(idx))\n+ flat_idx = tuple([mod(ravel(x), arr.shape[i]) for i, x in enumerate(idx)])\nout = lax.index_take(arr, flat_idx, tuple(range(len(idx))))\nreturn lax.reshape(out, idx[0].shape + _shape(arr)[len(idx):])\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_indexing_test.py",
"new_path": "tests/lax_numpy_indexing_test.py",
"diff": "@@ -398,6 +398,10 @@ class IndexingTest(jtu.JaxTestCase):\n[IndexSpec(shape=(3, 4, 5), indexer=[[0, 1]]),\nIndexSpec(shape=(3, 4, 5), indexer=[[[0], [-1]], [[2, 3, 0, 3]]]),\n]),\n+ (\"TupleOfListsOfPythonInts\",\n+ [IndexSpec(shape=(3, 4, 5), indexer=([0, 1])),\n+ IndexSpec(shape=(3, 4, 5), indexer=([[0], [-1]], [[2, 3, 0, 3]])),\n+ ]),\n(\"ListOfPythonIntsAndIntArrays\",\n[IndexSpec(shape=(3, 4, 5), indexer=[0, onp.array([0, 1])]),\nIndexSpec(shape=(3, 4, 5), indexer=[0, 1,\n@@ -630,6 +634,15 @@ class IndexingTest(jtu.JaxTestCase):\ni = onp.array([True, True, False])\nself.assertRaises(IndexError, lambda: api.jit(lambda x, i: x[i])(x, i))\n+ def testIssue187(self):\n+ x = lnp.ones((5, 5))\n+ x[[0, 2, 4], [0, 2, 4]] # doesn't crash\n+\n+ x = onp.arange(25).reshape((5, 5))\n+ ans = api.jit(lambda x: x[[0, 2, 4], [0, 2, 4]])(x)\n+ expected = x[[0, 2, 4], [0, 2, 4]]\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\nif __name__ == \"__main__\":\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | support x[[0, 2, 4], [0, 2, 4]] indexing, fix #187 |
260,335 | 05.01.2019 09:44:34 | 28,800 | 77f0fca7fa3ec21ef6a6986ae6427955ae303866 | fix np.polyval complex128 bug in x64=True mode
Also enable JAX_ENABLE_X64=True tests on Travis to avoid future such
issues. (Internal tests catch things like this, but we don't run those
automatically.) | [
{
"change_type": "MODIFY",
"old_path": ".travis.yml",
"new_path": ".travis.yml",
"diff": "@@ -7,7 +7,8 @@ python:\n- \"2.7\"\n- \"3.6\"\nenv:\n- - DEPS=\"pip nose six protobuf>=3.6.0 absl-py opt_einsum numpy scipy\"\n+ - JAX_ENABLE_X64=0 JAX_NUM_GENERATED_CASES=100\n+ - JAX_ENABLE_X64=1 JAX_NUM_GENERATED_CASES=100\nbefore_install:\n- if [[ \"$TRAVIS_PYTHON_VERSION\" == \"2.7\" ]]; then\nwget https://repo.continuum.io/miniconda/Miniconda2-latest-Linux-x86_64.sh -O miniconda.sh;\n@@ -19,8 +20,8 @@ before_install:\n- conda update --yes conda\n- conda config --add channels conda-forge\ninstall:\n- - conda install --yes python=$TRAVIS_PYTHON_VERSION $DEPS\n+ - conda install --yes python=$TRAVIS_PYTHON_VERSION pip nose six protobuf>=3.6.0 absl-py opt_einsum numpy scipy\n- pip install jaxlib\n- pip install -v .\nscript:\n- - JAX_NUM_GENERATED_CASES=100 nosetests tests examples\n+ - nosetests tests examples\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/lib/xla_bridge.py",
"new_path": "jax/lib/xla_bridge.py",
"diff": "@@ -34,7 +34,9 @@ from jaxlib import xla_client\nFLAGS = flags.FLAGS\n-flags.DEFINE_bool('jax_enable_x64', False, 'Enable 64-bit types to be used.')\n+flags.DEFINE_bool('jax_enable_x64',\n+ os.getenv('JAX_ENABLE_X64', False),\n+ 'Enable 64-bit types to be used.')\nflags.DEFINE_string('jax_dump_hlo_graph', None, 'Regexp of HLO graphs to dump.')\nflags.DEFINE_bool('jax_hlo_profile', False, 'Enables HLO profiling mode.')\nflags.DEFINE_string('jax_dump_hlo_unoptimized', None,\n@@ -216,6 +218,11 @@ _dtype_to_32bit_dtype = {\ndef canonicalize_dtype(dtype):\n\"\"\"Convert from a dtype to a canonical dtype based on FLAGS.jax_enable_x64.\"\"\"\ndtype = onp.dtype(dtype)\n+\n+ # special rule for complex128, which XLA doesn't support\n+ if dtype == onp.complex128:\n+ dtype = onp.dtype('complex64')\n+\nif FLAGS.jax_enable_x64:\nreturn str(dtype)\nelse:\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -149,8 +149,7 @@ def _promote_dtypes(*args):\nif len(args) < 2:\nreturn args\nelse:\n- from_dtypes = (_dtype(x) for x in args)\n- to_dtype = xla_bridge.canonicalize_dtype(result_type(*from_dtypes))\n+ to_dtype = xla_bridge.canonicalize_dtype(result_type(*args))\nreturn [lax.convert_element_type(x, to_dtype)\nif _dtype(x) != to_dtype else x for x in args]\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/test_util.py",
"new_path": "jax/test_util.py",
"diff": "@@ -408,8 +408,17 @@ class JaxTestCase(parameterized.TestCase):\nself.assertDtypesMatch(x, y)\ndef assertDtypesMatch(self, x, y):\n+ # special rule for complex128, which XLA doesn't support\n+ def c128_to_c64(dtype):\n+ if dtype == onp.complex128:\n+ return onp.complex64\n+ else:\n+ return dtype\n+\nif FLAGS.jax_enable_x64:\n- self.assertEqual(onp.asarray(x).dtype, onp.asarray(y).dtype)\n+ x_dtype = c128_to_c64(onp.asarray(x).dtype)\n+ y_dtype = c128_to_c64(onp.asarray(y).dtype)\n+ self.assertEqual(x_dtype, y_dtype)\ndef assertAllClose(self, x, y, check_dtypes, atol=None, rtol=None):\n\"\"\"Assert that x and y, either arrays or nested tuples/lists, are close.\"\"\"\n"
}
] | Python | Apache License 2.0 | google/jax | fix np.polyval complex128 bug in x64=True mode
Also enable JAX_ENABLE_X64=True tests on Travis to avoid future such
issues. (Internal tests catch things like this, but we don't run those
automatically.) |
260,335 | 05.01.2019 10:06:31 | 28,800 | ecaae6bdd001cab5e7e9ce7e395fd7536a7ad79f | add Softmax layer to stax (closes | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/stax.py",
"new_path": "jax/experimental/stax.py",
"diff": "@@ -146,6 +146,7 @@ def _elemwise_no_params(fun, **kwargs):\nreturn init_fun, apply_fun\nTanh = _elemwise_no_params(np.tanh)\nRelu = _elemwise_no_params(relu)\n+Exp = _elemwise_no_params(np.exp)\nLogSoftmax = _elemwise_no_params(logsoftmax, axis=-1)\nSoftplus = _elemwise_no_params(softplus)\n@@ -314,3 +315,8 @@ def shape_dependent(make_layer):\ndef apply_fun(params, inputs, rng=None):\nreturn make_layer(inputs.shape)[1](params, inputs, rng)\nreturn init_fun, apply_fun\n+\n+\n+# Simple compositions\n+\n+Softmax = serial(LogSoftmax, Exp)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/stax_test.py",
"new_path": "tests/stax_test.py",
"diff": "@@ -159,6 +159,17 @@ class StaxTest(jtu.JaxTestCase):\ninit_fun, apply_fun = stax.FanInConcat(axis)\n_CheckShapeAgreement(self, init_fun, apply_fun, input_shapes)\n+ def testIsuse182(self):\n+ init_fun, apply_fun = stax.Softmax\n+ input_shape = (10, 3)\n+ inputs = onp.arange(30.).astype(\"float32\").reshape(input_shape)\n+\n+ out_shape, params = init_fun(input_shape)\n+ out = apply_fun(params, inputs)\n+\n+ assert out_shape == out.shape\n+ assert onp.allclose(onp.sum(onp.asarray(out), -1), 1.)\n+\nif __name__ == \"__main__\":\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | add Softmax layer to stax (closes #182) |
260,335 | 05.01.2019 10:17:11 | 28,800 | 555bed74c6bbadd1df017836f1f97cc9bd155073 | revert lax_numpy dtype promotion logic | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -149,7 +149,8 @@ def _promote_dtypes(*args):\nif len(args) < 2:\nreturn args\nelse:\n- to_dtype = xla_bridge.canonicalize_dtype(result_type(*args))\n+ from_dtypes = (_dtype(x) for x in args)\n+ to_dtype = xla_bridge.canonicalize_dtype(result_type(*from_dtypes))\nreturn [lax.convert_element_type(x, to_dtype)\nif _dtype(x) != to_dtype else x for x in args]\n"
}
] | Python | Apache License 2.0 | google/jax | revert lax_numpy dtype promotion logic |
260,335 | 05.01.2019 10:22:55 | 28,800 | 3174b37b487b129b6cc6762a1d271de6f1c5b031 | implement softmax directly | [
{
"change_type": "MODIFY",
"old_path": "jax/experimental/stax.py",
"new_path": "jax/experimental/stax.py",
"diff": "@@ -47,6 +47,11 @@ def logsoftmax(x, axis=-1):\n\"\"\"Apply log softmax to an array of logits, log-normalizing along an axis.\"\"\"\nreturn x - logsumexp(x, axis, keepdims=True)\n+def softmax(x, axis=-1):\n+ \"\"\"Apply softmax to an array of logits, exponentiating and normalizing along an axis.\"\"\"\n+ unnormalized = np.exp(x - x.max(axis, keepdims=True))\n+ return unnormalized / unnormalized.sum(axis, keepdims=True)\n+\ndef fastvar(x, axis, keepdims):\n\"\"\"A fast but less numerically-stable variance calculation than np.var.\"\"\"\nreturn np.mean(x**2, axis, keepdims=keepdims) - np.mean(x, axis, keepdims=keepdims)**2\n@@ -148,6 +153,7 @@ Tanh = _elemwise_no_params(np.tanh)\nRelu = _elemwise_no_params(relu)\nExp = _elemwise_no_params(np.exp)\nLogSoftmax = _elemwise_no_params(logsoftmax, axis=-1)\n+Softmax = _elemwise_no_params(softmax, axis=-1)\nSoftplus = _elemwise_no_params(softplus)\n@@ -315,8 +321,3 @@ def shape_dependent(make_layer):\ndef apply_fun(params, inputs, rng=None):\nreturn make_layer(inputs.shape)[1](params, inputs, rng)\nreturn init_fun, apply_fun\n-\n-\n-# Simple compositions\n-\n-Softmax = serial(LogSoftmax, Exp)\n"
}
] | Python | Apache License 2.0 | google/jax | implement softmax directly |
260,316 | 06.01.2019 09:16:29 | 14,400 | cb7d3550ff4092652258b000a8a624f4884304a9 | Updated advi example to map over rngs. | [
{
"change_type": "MODIFY",
"old_path": "examples/advi.py",
"new_path": "examples/advi.py",
"diff": "@@ -19,86 +19,84 @@ import jax.scipy.stats.norm as norm\n# ========= Functions to define the evidence lower bound. =========\n-def diag_gaussian_sample(mean, log_std, rng):\n+def diag_gaussian_sample(rng, mean, log_std):\n+ # Take a single sample from a diagonal multivariate Gaussian.\nreturn mean + np.exp(log_std) * random.normal(rng, mean.shape)\ndef diag_gaussian_logpdf(x, mean, log_std):\n+ # Evaluate a single point on a diagonal multivariate Gaussian.\nreturn np.sum(vmap(norm.logpdf)(x, mean, np.exp(log_std)))\n-def elbo((mean, log_std), logprob, rng):\n- # Simple Monte Carlo estimate of the variational lower bound.\n- sample = diag_gaussian_sample(mean, log_std, rng)\n+def elbo(logprob, rng, (mean, log_std)):\n+ # Single-sample Monte Carlo estimate of the variational lower bound.\n+ sample = diag_gaussian_sample(rng, mean, log_std)\nreturn logprob(sample) - diag_gaussian_logpdf(sample, mean, log_std)\n+def batch_elbo(logprob, rng, params, num_samples):\n+ # Average over a batch of random samples.\n+ rngs = random.split(rng, num_samples)\n+ vectorized_elbo = vmap(partial(elbo, logprob), in_axes=(0, None))\n+ return np.mean(vectorized_elbo(rngs, params))\n-# ========= Helper functions for batching. =========\n-def rng_map(f, rng, num_samples, *args, **kwargs):\n- # Calls f with a batch of different seeds.\n- # f must have signature f(*args, rng, **kwargs).\n- rngs = np.array(random.split(rng, num_samples))\n- return vmap(partial(f, *args, **kwargs))(rngs)\n+# ========= Helper function for plotting. =========\n-def batch_elbo(params, logprob, num_samples, rng):\n- return np.mean(rng_map(elbo, rng, num_samples, params, logprob))\n-\n-\n-# ========= Helper functions for plotting. =========\n-\n-def eval_zip(func, X, Y):\n- params_vec = np.stack([X.ravel(), Y.ravel()]).T\n- zs = vmap(func)(params_vec)\n- return zs.reshape(X.shape)\n-eval_zip = jit(eval_zip, static_argnums=(0,))\n-\n-def plot_isocontours(ax, func, xlimits, ylimits, numticks=101, **kwargs):\n- x = np.linspace(*xlimits, num=numticks)\n- y = np.linspace(*ylimits, num=numticks)\n+@partial(jit, static_argnums=(0, 1, 2, 4))\n+def mesh_eval(func, x_limits, y_limits, params, num_ticks=101):\n+ # Evaluate func on a 2D grid defined by x_limits and y_limits.\n+ x = np.linspace(*x_limits, num=num_ticks)\n+ y = np.linspace(*y_limits, num=num_ticks)\nX, Y = np.meshgrid(x, y)\n- Z = eval_zip(func, X, Y)\n- ax.contour(X, Y, Z, **kwargs)\n- ax.set_xlim(xlimits)\n- ax.set_ylim(ylimits)\n- ax.set_yticks([])\n- ax.set_xticks([])\n+ xy_vec = np.stack([X.ravel(), Y.ravel()]).T\n+ zs = vmap(func, in_axes=(0, None))(xy_vec, params)\n+ return X, Y, zs.reshape(X.shape)\n# ========= Define an intractable unnormalized density =========\ndef funnel_log_density(params):\n- mean, log_stddev = params[0], params[1]\n- return norm.logpdf(mean, 0, np.exp(log_stddev)) + \\\n- norm.logpdf(log_stddev, 0, 1.35)\n+ return norm.logpdf(params[0], 0, np.exp(params[1])) + \\\n+ norm.logpdf(params[1], 0, 1.35)\nif __name__ == \"__main__\":\n- step_size = 0.1\n- momentum = 0.9\n- num_steps = 100\n- num_samples = 20\n+ num_samples = 40\n- def objective(params, rng):\n- return -batch_elbo(params, funnel_log_density, num_samples, rng)\n+ @jit\n+ def objective(params, t):\n+ rng = random.PRNGKey(t)\n+ return -batch_elbo(funnel_log_density, rng, params, num_samples)\n# Set up figure.\nfig = plt.figure(figsize=(8,8), facecolor='white')\nax = fig.add_subplot(111, frameon=False)\nplt.ion()\nplt.show(block=False)\n- xlimits = [-2, 2]\n- ylimits = [-4, 2]\n+ x_limits = [-2, 2]\n+ y_limits = [-4, 2]\n+ target_dist = lambda x, _: np.exp(funnel_log_density(x))\n+ approx_dist = lambda x, params: np.exp(diag_gaussian_logpdf(x, *params))\n- def callback(params, t, rng):\n- print(\"Iteration {} lower bound {}\".format(t, objective(params, rng)))\n+ def callback(params, t):\n+ print(\"Iteration {} lower bound {}\".format(t, objective(params, t)))\nplt.cla()\n- target_dist = lambda x: np.exp(funnel_log_density(x))\n- approx_dist = lambda x: np.exp(diag_gaussian_logpdf(x, *params))\n- plot_isocontours(ax, target_dist, xlimits, ylimits, cmap='summer')\n- plot_isocontours(ax, approx_dist, xlimits, ylimits, cmap='winter')\n+ X, Y, Z = mesh_eval(target_dist, x_limits, y_limits, 1)\n+ ax.contour(X, Y, Z, cmap='summer')\n+ X, Y, Z = mesh_eval(approx_dist, x_limits, y_limits, params)\n+ ax.contour(X, Y, Z, cmap='winter')\n+ ax.set_xlim(x_limits)\n+ ax.set_ylim(y_limits)\n+ ax.set_yticks([])\n+ ax.set_xticks([])\n+\n+ # Plot random samples from variational distribution.\n+ # Here we clone the rng used in computing the objective\n+ # so that we can show exactly the same samples.\n+ rngs = random.split(random.PRNGKey(t), num_samples)\n+ samples = vmap(diag_gaussian_sample, in_axes=(0, None, None))(rngs, *params)\n+ ax.plot(samples[:, 0], samples[:, 1], 'b.')\n- samples = rng_map(diag_gaussian_sample, rng, num_samples, *params)\n- plt.plot(samples[:, 0], samples[:, 1], 'b.')\nplt.draw()\nplt.pause(1.0/60.0)\n@@ -108,19 +106,19 @@ if __name__ == \"__main__\":\ninit_mean = np.zeros(D)\ninit_std = np.zeros(D)\ninit_params = (init_mean, init_std)\n- opt_init, opt_update = minmax.momentum(step_size, mass=momentum)\n+ opt_init, opt_update = minmax.momentum(step_size=0.1, mass=0.9)\nopt_state = opt_init(init_params)\n@jit\n- def update(i, opt_state, rng):\n+ def update(i, opt_state):\nparams = minmax.get_params(opt_state)\n- return opt_update(i, grad(objective)(params, rng), opt_state)\n+ gradient = grad(objective)(params, i)\n+ return opt_update(i, gradient, opt_state)\n- # Main fitting loop.\n+ # Main loop.\nprint(\"Optimizing variational parameters...\")\n- rng = random.PRNGKey(0)\n- for t in range(num_steps):\n- opt_state = update(t, opt_state, rng)\n- callback(minmax.get_params(opt_state), t, rng)\n- old, rng = random.split(rng)\n+ for t in range(100):\n+ opt_state = update(t, opt_state)\n+ params = minmax.get_params(opt_state)\n+ callback(params, t)\n"
}
] | Python | Apache License 2.0 | google/jax | Updated advi example to map over rngs. |
260,335 | 03.01.2019 16:14:30 | 28,800 | ad4322c5daea26fb685ec990746a0dc9252f21ee | playing around with flattening functions | [
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -31,7 +31,9 @@ import numpy as onp\nfrom . import core\nfrom . import linear_util as lu\nfrom .core import pack, eval_jaxpr\n-from .api_util import flatten_fun, unflatten_fun, tree_to_jaxtuples\n+from .api_util import (pytree_fun_to_jaxtupletree_fun, apply_jaxtree_fun,\n+ pytree_to_jaxtupletree, wraps)\n+from .flatten_util import ravel_fun, ravel_pytree\nfrom .tree_util import (process_pytree, node_types, build_tree, PyTreeDef, leaf,\ntree_map)\nfrom .util import unzip2, unzip3, curry, partial, safe_map, WrapHashably\n@@ -43,15 +45,6 @@ from .interpreters import batching\nmap = safe_map\n-def _wraps(wrapped):\n- def decorator(wrapper):\n- wrapper.__name__ = getattr(wrapped, \"__name__\", \"<unnamed function>\")\n- wrapper.__module__ = getattr(wrapped, \"__module__\", \"<unknown module>\")\n- if hasattr(wrapped, \"__doc__\"):\n- wrapper.__doc__ = getattr(wrapped, \"__doc__\")\n- return wrapper\n- return decorator\n-\ndef jit(fun, static_argnums=()):\n\"\"\"Sets up `fun` for just-in-time compilation with XLA.\n@@ -70,15 +63,15 @@ def jit(fun, static_argnums=()):\nReturns:\nA wrapped version of `fun`, set up for just-in-time compilation.\n\"\"\"\n- @_wraps(fun)\n+ @wraps(fun)\ndef f_jitted(*args, **kwargs):\nf = lu.wrap_init(fun, kwargs)\ndyn_argnums = [i for i in range(len(args)) if i not in static_argnums]\nf, dyn_args = argnums_partial(f, dyn_argnums, args)\n- args_flat, in_trees = unzip2(map(tree_to_jaxtuples, dyn_args))\n+ args_flat, in_trees = unzip2(map(pytree_to_jaxtupletree, dyn_args))\ncheck_args(args_flat)\n- flat_fun, out_tree = flatten_fun(f, in_trees)\n- out_flat = xla.xla_call(flat_fun, *args_flat)\n+ jaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(f, in_trees)\n+ out_flat = xla.xla_call(jaxtree_fun, *args_flat)\nreturn build_tree(out_tree(), out_flat)\nf_jitted.__name__ = \"jit({})\".format(f_jitted.__name__)\n@@ -93,8 +86,8 @@ def grad(fun, argnums=0):\n`argnums` should be arrays, scalars, or standard Python containers. It\nshould return a scalar (which includes arrays with shape `()` but not\narrays with shape `(1,)` etc.)\n- argnums: Integer or tuple of integers. Specifies which positional\n- argument(s) to differentiate with respect to.\n+ argnums: Optional, integer or tuple of integers. Specifies which positional\n+ argument(s) to differentiate with respect to (default 0).\nReturns:\nA function with the same arguments as `fun`, that evaluates the gradient of\n@@ -119,8 +112,8 @@ def value_and_grad(fun, argnums=0):\n`argnums` should be arrays, scalars, or standard Python containers. It\nshould return a scalar (which includes arrays with shape `()` but not\narrays with shape `(1,)` etc.)\n- argnums: Integer or tuple of integers. Specifies which positional\n- argument(s) to differentiate with respect to.\n+ argnums: Optional, integer or tuple of integers. Specifies which positional\n+ argument(s) to differentiate with respect to (default 0).\nReturns:\nA function with the same arguments as `fun` that evaluates both `fun` and\n@@ -144,6 +137,7 @@ def value_and_grad(fun, argnums=0):\n@curry\ndef jacfwd(fun, x):\n\"\"\"Jacobian of `fun`, evaluated column-by-column using forward-mode AD\"\"\"\n+ if not isinstance(fun, lu.WrappedFun):\nfun = lu.wrap_init(fun)\npushfwd = partial(jvp, fun, (x,))\nstd_basis = onp.eye(onp.size(x)).reshape((-1,) + onp.shape(x)),\n@@ -153,6 +147,7 @@ def jacfwd(fun, x):\n@curry\ndef jacrev(fun, x):\n\"\"\"Jacobian of `fun`, evaluated row-by-row using reverse-mode AD\"\"\"\n+ if not isinstance(fun, lu.WrappedFun):\nfun = lu.wrap_init(fun)\ny, pullback = vjp(fun, x)\nstd_basis = onp.eye(onp.size(y)).reshape((-1,) + onp.shape(y))\n@@ -162,6 +157,20 @@ def jacrev(fun, x):\ndef hessian(fun):\nreturn jacfwd(jacrev(fun))\n+\n+def general_jacobian(jacfun, fun):\n+ def jac_f(*args, **kwargs):\n+ f = lu.wrap_init(fun, kwargs)\n+ raveled_input, unravel_inputs = ravel_pytree(args)\n+ raveled_fun, unravel_outputs = ravel_fun(f, unravel_inputs)\n+ jacmat = jacfun(raveled_fun)(raveled_input)\n+ return tree_map(unravel_inputs, vmap(unravel_outputs(), in_axes=1)(jacmat))\n+ return jac_f\n+jacfwd2 = partial(general_jacobian, jacfwd)\n+jacrev2 = partial(general_jacobian, jacrev)\n+hessian2 = partial(general_jacobian, hessian) # TODO(mattjj): doesn't work yet\n+\n+\ndef vmap(fun, in_axes=0, out_axes=0):\n\"\"\"Vectorizing map. Creates a function which maps `fun` over additional axes.\n@@ -189,32 +198,32 @@ def vmap(fun, in_axes=0, out_axes=0):\nif not isinstance(fun, lu.WrappedFun):\nf = lu.wrap_init(fun)\nin_axes_ = (in_axes,) * len(args) if type(in_axes) is int else in_axes\n- in_flat, in_trees = unzip2(map(tree_to_jaxtuples, args))\n- flat_fun, out_tree = flatten_fun(f, in_trees)\n- out_flat = batching.batch(flat_fun, in_flat, in_axes_, out_axes)\n+ in_flat, in_trees = unzip2(map(pytree_to_jaxtupletree, args))\n+ jaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(f, in_trees)\n+ out_flat = batching.batch(jaxtree_fun, in_flat, in_axes_, out_axes)\nreturn build_tree(out_tree(), out_flat)\nreturn batched_fun\ndef jvp(fun, primals, tangents):\n- def flatten_arg(primal, tangent):\n- primal_jtuple, tree_def = tree_to_jaxtuples(primal)\n- tangent_jtuple, tree_def_2 = tree_to_jaxtuples(tangent)\n+ def trim_arg(primal, tangent):\n+ primal_jtuple, tree_def = pytree_to_jaxtupletree(primal)\n+ tangent_jtuple, tree_def_2 = pytree_to_jaxtupletree(tangent)\nassert tree_def == tree_def_2, (tree_def, tree_def_2)\nreturn primal_jtuple, tangent_jtuple, tree_def\nif not isinstance(fun, lu.WrappedFun):\nfun = lu.wrap_init(fun)\n- ps_flat, ts_flat, in_trees = unzip3(map(flatten_arg, primals, tangents))\n- flat_fun, out_tree = flatten_fun(fun, in_trees)\n- out_primal, out_tangent = ad.jvp(flat_fun).call_wrapped(ps_flat, ts_flat)\n+ ps_flat, ts_flat, in_trees = unzip3(map(trim_arg, primals, tangents))\n+ jaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(fun, in_trees)\n+ out_primal, out_tangent = ad.jvp(jaxtree_fun).call_wrapped(ps_flat, ts_flat)\nreturn (build_tree(out_tree(), out_primal), build_tree(out_tree(), out_tangent))\ndef linearize(traceable, *primals):\nfun = lu.wrap_init(traceable)\n- primals_flat, in_trees = unzip2(map(tree_to_jaxtuples, primals))\n- flat_fun, out_tree = flatten_fun(fun, in_trees)\n- out_primal, out_pval, jaxpr, consts = ad.linearize(flat_fun, *primals_flat)\n+ primals_flat, in_trees = unzip2(map(pytree_to_jaxtupletree, primals))\n+ jaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(fun, in_trees)\n+ out_primal, out_pval, jaxpr, consts = ad.linearize(jaxtree_fun, *primals_flat)\nout_tree = out_tree()\nout_primal_py = build_tree(out_tree, out_primal)\nlifted_jvp = partial(lift_linearized, jaxpr, consts, (in_trees, out_tree), out_pval)\n@@ -227,37 +236,37 @@ def lift_linearized(jaxpr, consts, io_tree, out_pval, py_args):\n_, ans = eval_jaxpr(jaxpr, consts, (), primals, tangents)\nreturn pe.merge_pvals(ans, out_pval)\n- return unflatten_fun(fun, io_tree, *py_args)\n+ return apply_jaxtree_fun(fun, io_tree, *py_args)\ndef vjp(fun, *primals):\nif not isinstance(fun, lu.WrappedFun):\nfun = lu.wrap_init(fun)\n- primals_flat, in_trees = unzip2(map(tree_to_jaxtuples, primals))\n+ primals_flat, in_trees = unzip2(map(pytree_to_jaxtupletree, primals))\ncheck_args(primals_flat)\n- flat_fun, out_tree = flatten_fun(fun, in_trees)\n- out_primal, out_vjp = ad.vjp(flat_fun, primals_flat)\n+ jaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(fun, in_trees)\n+ out_primal, out_vjp = ad.vjp(jaxtree_fun, primals_flat)\nout_tree = out_tree()\nout_primal_py = build_tree(out_tree, out_primal)\nct_in_trees = [out_tree]\nct_out_tree = PyTreeDef(node_types[tuple], None, in_trees)\ndef out_vjp_packed(cotangent_in):\nreturn out_vjp(cotangent_in)\n- vjp_py = partial(unflatten_fun, out_vjp_packed, (ct_in_trees, ct_out_tree))\n+ vjp_py = partial(apply_jaxtree_fun, out_vjp_packed, (ct_in_trees, ct_out_tree))\nreturn out_primal_py, vjp_py\ndef trace_to_jaxpr(traceable, py_pvals, **kwargs):\nfun = lu.wrap_init(traceable)\npvals, in_trees = unzip2(map(tree_to_pval_tuples, py_pvals))\n- flat_fun, out_tree = flatten_fun(fun, in_trees)\n- jaxpr, out_pval, consts = pe.trace_to_jaxpr(flat_fun, pvals, **kwargs)\n+ jaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(fun, in_trees)\n+ jaxpr, out_pval, consts = pe.trace_to_jaxpr(jaxtree_fun, pvals, **kwargs)\nreturn jaxpr, consts, out_pval, (in_trees, out_tree())\ndef lift_jaxpr(jaxpr, consts, io_tree, pvals, py_args):\ndef fun(*args):\nans = eval_jaxpr(jaxpr, consts, (), *args)\nreturn pe.merge_pvals(ans, pvals)\n- return unflatten_fun(fun, io_tree, *py_args)\n+ return apply_jaxtree_fun(fun, io_tree, *py_args)\ndef make_jaxpr(f):\ndef pv_like(x):\n@@ -265,45 +274,26 @@ def make_jaxpr(f):\nreturn pe.PartialVal((aval, core.unit))\nfun = lu.wrap_init(f)\n- @_wraps(f)\n+\n+ @wraps(f)\ndef jaxpr_maker(*args, **kwargs):\n- jax_args, in_trees = unzip2(map(tree_to_jaxtuples, args))\n- flat_fun, out_tree = flatten_fun(fun, in_trees)\n+ jax_args, in_trees = unzip2(map(pytree_to_jaxtupletree, args))\n+ jaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(fun, in_trees)\npvals = map(pv_like, jax_args)\n- jaxpr, _, _ = pe.trace_to_jaxpr(flat_fun, pvals, **kwargs)\n+ jaxpr, _, _ = pe.trace_to_jaxpr(jaxtree_fun, pvals, **kwargs)\nreturn jaxpr\njaxpr_maker.__name__ = \"make_jaxpr({})\".format(jaxpr_maker.__name__)\nreturn jaxpr_maker\n+tree_to_pval_tuples = partial(process_pytree, pe.pack_pvals)\n+\ndevice_put = jit(lambda x: x)\ndevice_get_array = lambda x: x.copy() if type(x) is xla.DeviceArray else x\ndevice_get = partial(tree_map, device_get_array)\n-@lu.transformation_with_aux\n-def flatten_fun(in_trees, *args, **kwargs):\n- py_args = map(build_tree, in_trees, args)\n- ans = yield py_args\n- yield process_pytree(pack, ans)\n-\n-\n-def unflatten_fun(fun, io_tree, *py_args):\n- in_trees_expected, out_tree = io_tree\n- args, in_trees = unzip2(map(tree_to_jaxtuples, py_args))\n- for i, (in_tree, expected) in enumerate(zip(in_trees, in_trees_expected)):\n- if in_tree != expected:\n- raise TypeError(\"Expected {}, got {}\".format(expected, in_tree))\n-\n- ans = fun(*args)\n- return build_tree(out_tree, ans)\n-\n-\n-tree_to_pval_tuples = partial(process_pytree, pe.pack_pvals)\n-tree_to_jaxtuples = partial(process_pytree, pack)\n-\n-\ndef argnums_partial(f, dyn_argnums, args):\nif isinstance(dyn_argnums, int):\ndyn_argnums = (dyn_argnums,)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/api_util.py",
"new_path": "jax/api_util.py",
"diff": "@@ -19,20 +19,29 @@ from __future__ import print_function\nfrom .core import pack\nfrom .tree_util import build_tree, process_pytree\nfrom .linear_util import transformation_with_aux\n-from .util import safe_map, unzip2, partial\n+from .util import safe_map, unzip2, partial, curry\nmap = safe_map\n+\n+@curry\n+def wraps(wrapped, wrapper):\n+ wrapper.__name__ = getattr(wrapped, \"__name__\", \"<unnamed function>\")\n+ wrapper.__module__ = getattr(wrapped, \"__module__\", \"<unknown module>\")\n+ if hasattr(wrapped, \"__doc__\"):\n+ wrapper.__doc__ = getattr(wrapped, \"__doc__\")\n+ return wrapper\n+\n+\n@transformation_with_aux\n-def flatten_fun(in_trees, *args, **kwargs):\n+def pytree_fun_to_jaxtupletree_fun(in_trees, *args, **kwargs):\npy_args = map(build_tree, in_trees, args)\nans = yield py_args\nyield process_pytree(pack, ans)\n-\n-def unflatten_fun(fun, io_tree, *py_args):\n+def apply_jaxtree_fun(fun, io_tree, *py_args):\nin_trees_expected, out_tree = io_tree\n- args, in_trees = unzip2(map(tree_to_jaxtuples, py_args))\n+ args, in_trees = unzip2(map(pytree_to_jaxtupletree, py_args))\nfor i, (in_tree, expected) in enumerate(zip(in_trees, in_trees_expected)):\nif in_tree != expected:\nraise TypeError(\"Expected {}, got {}\".format(expected, in_tree))\n@@ -40,5 +49,4 @@ def unflatten_fun(fun, io_tree, *py_args):\nans = fun(*args)\nreturn build_tree(out_tree, ans)\n-\n-tree_to_jaxtuples = partial(process_pytree, pack)\n+pytree_to_jaxtupletree = partial(process_pytree, pack)\n"
},
{
"change_type": "ADD",
"old_path": null,
"new_path": "jax/flatten_util.py",
"diff": "+# Copyright 2018 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 __future__ import absolute_import\n+from __future__ import division\n+from __future__ import print_function\n+\n+from .tree_util import tree_flatten, tree_unflatten\n+from .linear_util import transformation_with_aux\n+\n+\n+def ravel_pytree(pytree):\n+ from jax.api import vjp # TODO(mattjj): fix circular imports\n+ leaves, treedef = tree_flatten(pytree)\n+ flat, unravel_list = vjp(_ravel_list, *leaves)\n+ unravel_pytree = lambda flat: tree_unflatten(treedef, unravel_list(flat))\n+ return flat, unravel_pytree\n+\n+def _ravel_list(*lst):\n+ import jax.numpy as np # TODO(mattjj): fix circular imports\n+ return np.concatenate([np.ravel(elt) for elt in lst]) if lst else np.array([])\n+\n+\n+@transformation_with_aux\n+def ravel_fun(unravel_inputs, flat_in, **kwargs):\n+ pytree_args = unravel_inputs(flat_in)\n+ ans = yield pytree_args\n+ yield ravel_pytree(ans)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/lax.py",
"new_path": "jax/lax.py",
"diff": "@@ -32,7 +32,7 @@ from . import linear_util as lu\nfrom .core import Primitive\nfrom .abstract_arrays import (UnshapedArray, ShapedArray, ConcreteArray,\narray_types, make_shaped_array)\n-from .api_util import flatten_fun, tree_to_jaxtuples\n+from .api_util import pytree_fun_to_jaxtupletree_fun, pytree_to_jaxtupletree\nfrom .interpreters import partial_eval as pe\nfrom .interpreters import xla\nfrom .interpreters import ad\n@@ -389,9 +389,9 @@ def sort_key_val(keys, values, dimension=-1):\nreturn sorted_keys, sorted_values\ndef _while_loop(cond_fun, body_fun, init_val):\n- init_val_flat, in_tree = tree_to_jaxtuples(init_val)\n- flat_body_fun, out_tree = flatten_fun(lu.wrap_init(body_fun), (in_tree,))\n- flat_cond_fun, _ = flatten_fun(lu.wrap_init(cond_fun), (in_tree,))\n+ init_val_flat, in_tree = pytree_to_jaxtupletree(init_val)\n+ flat_body_fun, out_tree = pytree_fun_to_jaxtupletree_fun(lu.wrap_init(body_fun), (in_tree,))\n+ flat_cond_fun, _ = pytree_fun_to_jaxtupletree_fun(lu.wrap_init(cond_fun), (in_tree,))\npval_flat = _abstractify(init_val_flat)\ncond_jaxpr, _, cond_consts = pe.trace_to_jaxpr(flat_cond_fun, (pval_flat,))\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/tree_util.py",
"new_path": "jax/tree_util.py",
"diff": "@@ -90,12 +90,15 @@ def build_tree(treedef, xs):\ntree_flatten = partial(walk_pytree, concatenate, lambda x: [x])\n-def tree_unflatten(xs, treedef):\n- xs = iter(xs)\n+def tree_unflatten(treedef, xs):\n+ # like build_tree, but handles empty containers in the tree\n+ return _tree_unflatten(iter(xs), treedef)\n+\n+def _tree_unflatten(xs, treedef):\nif treedef is leaf:\nreturn next(xs)\nelse:\n- children = map(partial(tree_unflatten, xs), treedef.children)\n+ children = map(partial(_tree_unflatten, xs), treedef.children)\nreturn treedef.node_type.from_iterable(treedef.node_data, children)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/core_test.py",
"new_path": "tests/core_test.py",
"diff": "@@ -198,10 +198,10 @@ class CoreTest(jtu.JaxTestCase):\nassert flat == [1, 2, 3, 4]\ndef test_tree_unflatten(self):\n- tree = [(1, 2), {\"roy\": (3, [4, 5])}]\n+ tree = [(1, 2), {\"roy\": (3, [4, 5, ()])}]\nflat, treedef = tree_flatten(tree)\nassert flat == [1, 2, 3, 4, 5]\n- tree2 = tree_unflatten(flat, treedef)\n+ tree2 = tree_unflatten(treedef, flat)\nnodes_equal = tree_multimap(operator.eq, tree, tree2)\nassert tree_reduce(operator.and_, nodes_equal)\n"
}
] | Python | Apache License 2.0 | google/jax | playing around with flattening functions |
260,335 | 06.01.2019 11:59:33 | 28,800 | 0f7c7c4eabc7be7e35f6ed9f86e8c59a71035109 | generalize jacfwd and jacrev to handle pytrees | [
{
"change_type": "MODIFY",
"old_path": "jax/abstract_arrays.py",
"new_path": "jax/abstract_arrays.py",
"diff": "@@ -157,9 +157,14 @@ def make_shaped_array(x):\ndtype = xla_bridge.canonicalize_dtype(onp.result_type(x))\nreturn ShapedArray(onp.shape(x), dtype)\n+def zeros_like_array(x):\n+ dtype = xla_bridge.canonicalize_dtype(onp.result_type(x))\n+ return onp.broadcast_to(onp.array(0, dtype), onp.shape(x))\n+\narray_types = [onp.ndarray, onp.float64, onp.float32, onp.complex64,\nonp.int64, onp.int32, onp.bool_, onp.uint64, onp.uint32,\ncomplex, float, int, bool]\nfor t in array_types:\ncore.pytype_aval_mappings[t] = ConcreteArray\n+ ad_util.jaxval_zeros_likers[t] = zeros_like_array\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -25,6 +25,7 @@ from __future__ import division\nfrom __future__ import print_function\nimport itertools\n+import operator as op\nimport numpy as onp\n@@ -33,10 +34,12 @@ from . import linear_util as lu\nfrom .core import pack, eval_jaxpr\nfrom .api_util import (pytree_fun_to_jaxtupletree_fun, apply_jaxtree_fun,\npytree_to_jaxtupletree, wraps)\n-from .flatten_util import ravel_fun, ravel_pytree\n-from .tree_util import (process_pytree, node_types, build_tree, PyTreeDef, leaf,\n- tree_map)\n-from .util import unzip2, unzip3, curry, partial, safe_map, WrapHashably\n+from .tree_util import (process_pytree, node_types, build_tree, PyTreeDef,\n+ tree_map, tree_flatten, tree_unflatten, tree_structure,\n+ tree_transpose)\n+from .util import (unzip2, unzip3, curry, partial, safe_map, safe_zip,\n+ WrapHashably, prod)\n+from .lib.xla_bridge import canonicalize_dtype\nfrom .abstract_arrays import ShapedArray\nfrom .interpreters import partial_eval as pe\nfrom .interpreters import xla\n@@ -44,6 +47,7 @@ from .interpreters import ad\nfrom .interpreters import batching\nmap = safe_map\n+zip = safe_zip\ndef jit(fun, static_argnums=()):\n@@ -98,6 +102,12 @@ def grad(fun, argnums=0):\n\"\"\"\nvalue_and_grad_f = value_and_grad(fun, argnums)\n+ docstr = (\"Gradient of {fun} with respect to positional argument(s) \"\n+ \"{argnums}. Takes the same arguments as {fun} but returns the \"\n+ \"gradient, which has the same shape as the arguments at \"\n+ \"positions {argnums}.\")\n+\n+ @wraps(fun, docstr=docstr, argnums=argnums)\ndef grad_f(*args, **kwargs):\nans, g = value_and_grad_f(*args, **kwargs)\nreturn g\n@@ -123,6 +133,14 @@ def value_and_grad(fun, argnums=0):\nintegers, the gradient is a tuple of values with the same shapes and types\nas the corresponding arguments.\n\"\"\"\n+\n+ docstr = (\"Value and gradient of {fun} with respect to positional \"\n+ \"argument(s) {argnums}. Takes the same arguments as {fun} but \"\n+ \"returns a two-element tuple where the first element is the value \"\n+ \"of {fun} and the second element is the gradient, which has the \"\n+ \"same shape as the arguments at positions {argnums}.\")\n+\n+ @wraps(fun, docstr=docstr, argnums=argnums)\ndef value_and_grad_f(*args, **kwargs):\nf = lu.wrap_init(fun, kwargs)\nf_partial, dyn_args = argnums_partial(f, argnums, args)\n@@ -134,41 +152,61 @@ def value_and_grad(fun, argnums=0):\nreturn value_and_grad_f\n-@curry\n-def jacfwd(fun, x):\n- \"\"\"Jacobian of `fun`, evaluated column-by-column using forward-mode AD\"\"\"\n- if not isinstance(fun, lu.WrappedFun):\n- fun = lu.wrap_init(fun)\n- pushfwd = partial(jvp, fun, (x,))\n- std_basis = onp.eye(onp.size(x)).reshape((-1,) + onp.shape(x)),\n- y, jac_flat = vmap(pushfwd, out_axes=(None, -1))(std_basis)\n- return jac_flat.reshape(onp.shape(y) + onp.shape(x))\n-\n-@curry\n-def jacrev(fun, x):\n- \"\"\"Jacobian of `fun`, evaluated row-by-row using reverse-mode AD\"\"\"\n- if not isinstance(fun, lu.WrappedFun):\n- fun = lu.wrap_init(fun)\n- y, pullback = vjp(fun, x)\n- std_basis = onp.eye(onp.size(y)).reshape((-1,) + onp.shape(y))\n- jac_flat, = vmap(pullback, out_axes=0)(std_basis)\n- return jac_flat.reshape(onp.shape(y) + onp.shape(x))\n+\n+def jacfwd(fun, argnums=0):\n+ \"\"\"Jacobian of `fun` evaluated column-by-column using forward-mode AD.\"\"\"\n+\n+ def jacfun(*args, **kwargs):\n+ f = lu.wrap_init(fun, kwargs)\n+ f_partial, dyn_args = argnums_partial(f, argnums, args)\n+ pushfwd = partial(jvp, f_partial, dyn_args)\n+ y, jac = vmap(pushfwd, out_axes=(None, -1))(_std_basis(dyn_args))\n+ example_args = dyn_args[0] if isinstance(argnums, int) else dyn_args\n+ return tree_map(partial(_unravel_array_into_pytree, example_args, -1), jac)\n+\n+ return jacfun\n+\n+def jacrev(fun, argnums=0):\n+ \"\"\"Jacobian of `fun` evaluated row-by-row using reverse-mode AD.\"\"\"\n+\n+ def jacfun(*args, **kwargs):\n+ f = lu.wrap_init(fun, kwargs)\n+ f_partial, dyn_args = argnums_partial(f, argnums, args)\n+ y, pullback = vjp(f_partial, *dyn_args)\n+ jac = vmap(pullback)(_std_basis(y))\n+ jac = jac[0] if isinstance(argnums, int) else jac\n+ example_args = dyn_args[0] if isinstance(argnums, int) else dyn_args\n+ jac = tree_map(partial(_unravel_array_into_pytree, y, 0), jac)\n+ return tree_transpose(tree_structure(example_args), tree_structure(y), jac)\n+\n+ return jacfun\ndef hessian(fun):\nreturn jacfwd(jacrev(fun))\n+def _std_basis(pytree):\n+ leaves, _ = tree_flatten(pytree)\n+ ndim = sum(map(onp.size, leaves))\n+ return _unravel_array_into_pytree(pytree, 1, onp.eye(ndim))\n+\n+def _unravel_array_into_pytree(pytree, axis, arr):\n+ leaves, treedef = tree_flatten(pytree)\n+ axis = axis % arr.ndim\n+ dtypes = map(_dtype, leaves)\n+ shapes = [arr.shape[:axis] + onp.shape(l) + arr.shape[axis+1:] for l in leaves]\n+ parts = _split(arr, onp.cumsum(map(onp.size, leaves[:-1])), axis)\n+ reshaped_parts = [onp.reshape(part.astype(dtype), shape)\n+ for part, dtype, shape in zip(parts, dtypes, shapes)]\n+ return tree_unflatten(treedef, reshaped_parts)\n+\n+def _split(x, indices, axis):\n+ if isinstance(x, onp.ndarray):\n+ return onp.split(x, indices, axis)\n+ else:\n+ return x.split(indices, axis)\n-def general_jacobian(jacfun, fun):\n- def jac_f(*args, **kwargs):\n- f = lu.wrap_init(fun, kwargs)\n- raveled_input, unravel_inputs = ravel_pytree(args)\n- raveled_fun, unravel_outputs = ravel_fun(f, unravel_inputs)\n- jacmat = jacfun(raveled_fun)(raveled_input)\n- return tree_map(unravel_inputs, vmap(unravel_outputs(), in_axes=1)(jacmat))\n- return jac_f\n-jacfwd2 = partial(general_jacobian, jacfwd)\n-jacrev2 = partial(general_jacobian, jacrev)\n-hessian2 = partial(general_jacobian, hessian) # TODO(mattjj): doesn't work yet\n+def _dtype(x):\n+ return canonicalize_dtype(onp.result_type(x))\ndef vmap(fun, in_axes=0, out_axes=0):\n@@ -194,6 +232,11 @@ def vmap(fun, in_axes=0, out_axes=0):\n(`[a,b]` indicates an array with shape (a,b))\n\"\"\"\n+\n+ docstr = (\"Vectorized version of {fun}. Takes similar arguments as {fun} \"\n+ \"but with additional array axes over which {fun} is mapped.\")\n+\n+ @wraps(fun, docstr=docstr)\ndef batched_fun(*args, **kwargs):\nif not isinstance(fun, lu.WrappedFun):\nf = lu.wrap_init(fun)\n@@ -301,7 +344,7 @@ def argnums_partial(f, dyn_argnums, args):\ndyn_argnums = tuple(dyn_argnums)\nfixed_args = tuple([None if i in dyn_argnums else WrapHashably(arg)\nfor i, arg in enumerate(args)])\n- dyn_args = [args[i] for i in dyn_argnums]\n+ dyn_args = tuple(args[i] for i in dyn_argnums)\nreturn argnums_partial_(f, dyn_argnums, fixed_args), dyn_args\n@lu.transformation\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/api_util.py",
"new_path": "jax/api_util.py",
"diff": "@@ -25,12 +25,17 @@ map = safe_map\n@curry\n-def wraps(wrapped, wrapper):\n- wrapper.__name__ = getattr(wrapped, \"__name__\", \"<unnamed function>\")\n- wrapper.__module__ = getattr(wrapped, \"__module__\", \"<unknown module>\")\n- if hasattr(wrapped, \"__doc__\"):\n- wrapper.__doc__ = getattr(wrapped, \"__doc__\")\n- return wrapper\n+def wraps(wrapped, fun, namestr=\"{fun}\", docstr=\"{doc}\", **kwargs):\n+ try:\n+ fun.__name__ = namestr.format(fun=get_name(wrapped))\n+ fun.__module__ = get_module(wrapped)\n+ fun.__doc__ = docstr.format(fun=get_name(wrapped), doc=get_doc(wrapped), **kwargs)\n+ finally:\n+ return fun\n+\n+def get_name(fun): return getattr(fun, \"__name__\", \"<unnamed function>\")\n+def get_module(fun): return getattr(fun, \"__module__\", \"<unknown module>\")\n+def get_doc(fun): return getattr(fun, \"__doc__\", \"\")\n@transformation_with_aux\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/flatten_util.py",
"new_path": "jax/flatten_util.py",
"diff": "@@ -18,17 +18,21 @@ from __future__ import print_function\nfrom .tree_util import tree_flatten, tree_unflatten\nfrom .linear_util import transformation_with_aux\n+from .util import safe_zip\n+\n+import jax.numpy as np\n+from jax.api import vjp\n+\n+zip = safe_zip\ndef ravel_pytree(pytree):\n- from jax.api import vjp # TODO(mattjj): fix circular imports\nleaves, treedef = tree_flatten(pytree)\n- flat, unravel_list = vjp(_ravel_list, *leaves)\n+ flat, unravel_list = vjp(ravel_list, *leaves)\nunravel_pytree = lambda flat: tree_unflatten(treedef, unravel_list(flat))\nreturn flat, unravel_pytree\n-def _ravel_list(*lst):\n- import jax.numpy as np # TODO(mattjj): fix circular imports\n+def ravel_list(*lst):\nreturn np.concatenate([np.ravel(elt) for elt in lst]) if lst else np.array([])\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/batching.py",
"new_path": "jax/interpreters/batching.py",
"diff": "@@ -295,7 +295,7 @@ def moveaxis(sz, dst, src, x):\nreturn x\nelse:\nif src is None:\n- x = broadcast(x, sz)\n+ x = broadcast(x, sz, force_broadcast=True)\nsrc = 0\nif src == dst:\nreturn x\n@@ -306,21 +306,20 @@ def moveaxis(sz, dst, src, x):\nelse:\nraise TypeError(type(aval))\n-def broadcast(x, sz):\n+def broadcast(x, sz, force_broadcast=False):\naval = get_aval(x)\nif type(aval) is AbstractTuple:\nreturn pack(map(partial(broadcast, sz=sz), x))\nelif isinstance(aval, ShapedArray):\n- # for scalars, don't actually broadcast\n- if not onp.ndim(x):\n+ # for scalars, maybe don't actually broadcast\n+ if not onp.ndim(x) and not force_broadcast:\nreturn x\n- # See comment at the top of this section about this try/except.\n- try:\n- return x.broadcast((sz,))\n- except AttributeError:\n- assert not isinstance(x, Tracer)\n+ # see comment at the top of this section\n+ if isinstance(x, onp.ndarray) or onp.isscalar(x):\nreturn onp.broadcast_to(x, (sz,) + onp.shape(x))\n+ else:\n+ return x.broadcast((sz,)) # should be a JAX arraylike\nelse:\nraise TypeError(type(x))\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/xla.py",
"new_path": "jax/interpreters/xla.py",
"diff": "@@ -17,9 +17,12 @@ from __future__ import division\nfrom __future__ import print_function\nfrom collections import namedtuple, defaultdict\n+from distutils.util import strtobool\nimport itertools as it\n-import numpy as onp\nimport operator as op\n+import os\n+\n+import numpy as onp\nimport six\nfrom six.moves import xrange\n@@ -34,7 +37,9 @@ from ..lib import xla_bridge as xb\nfrom .partial_eval import trace_to_subjaxpr, merge_pvals, JaxprTrace, PartialVal\nFLAGS = flags.FLAGS\n-flags.DEFINE_bool('jax_device_values', True, 'Enable device-persistent values.')\n+flags.DEFINE_bool('jax_device_values',\n+ strtobool(os.getenv('JAX_DEVICE_VALUES', \"True\")),\n+ 'Enable device-persistent values.')\nmap = safe_map\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/lax.py",
"new_path": "jax/lax.py",
"diff": "@@ -679,7 +679,7 @@ def zeros_like_array(x):\nfor t in itertools.chain(array_types, [xla.DeviceArray]):\nad_util.jaxval_adders[t] = add\n- ad_util.jaxval_zeros_likers[t] = zeros_like_array\n+ad_util.jaxval_zeros_likers[xla.DeviceArray] = zeros_like_array\nbatching.pytype_aval_mappings[xla.DeviceArray] = make_shaped_array\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1724,3 +1724,4 @@ setattr(DeviceArray, \"astype\", lax.convert_element_type)\n# Extra methods that are handy\nsetattr(DeviceArray, \"broadcast\", lax.broadcast)\n+setattr(DeviceArray, \"split\", split)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/tree_util.py",
"new_path": "jax/tree_util.py",
"diff": "@@ -102,8 +102,34 @@ def _tree_unflatten(xs, treedef):\nreturn treedef.node_type.from_iterable(treedef.node_data, children)\n+def tree_transpose(outer_treedef, inner_treedef, pytree_to_transpose):\n+ flat, treedef = tree_flatten(pytree_to_transpose)\n+ expected_treedef = _nested_treedef(inner_treedef, outer_treedef)\n+ if treedef != expected_treedef:\n+ raise TypeError(\"Mismatch\\n{}\\n != \\n{}\".format(treedef, expected_treedef))\n+\n+ inner_size = _num_leaves(inner_treedef)\n+ outer_size = _num_leaves(outer_treedef)\n+ flat = iter(flat)\n+ lol = [[next(flat) for _ in range(inner_size)] for __ in range(outer_size)]\n+ transposed_lol = zip(*lol)\n+ subtrees = map(partial(tree_unflatten, outer_treedef), transposed_lol)\n+ return tree_unflatten(inner_treedef, subtrees)\n+\n+def _num_leaves(treedef):\n+ return 1 if treedef is leaf else sum(map(_num_leaves, treedef.children))\n+\n+def _nested_treedef(inner, outer):\n+ # just used in tree_transpose error checking\n+ if outer is leaf:\n+ return inner\n+ else:\n+ children = map(partial(_nested_treedef, inner), outer.children)\n+ return PyTreeDef(outer.node_type, outer.node_data, tuple(children))\n+\n+\ndef tree_structure(tree):\n- spec, _ = process_pytree(tree, lambda _: None)\n+ _, spec = process_pytree(lambda _: None, tree)\nreturn spec\n@@ -126,6 +152,9 @@ class PyTreeDef(object):\nreturn hash((self.node_type, self.node_data, tuple(self.children)))\ndef __eq__(self, other):\n+ if other is leaf:\n+ return False\n+ else:\nreturn (self.node_type == other.node_type and\nself.node_data == other.node_data and\nself.children == other.children)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/api_test.py",
"new_path": "tests/api_test.py",
"diff": "@@ -24,6 +24,7 @@ from jax import test_util as jtu\nimport jax.numpy as np\nfrom jax import jit, grad, device_get, device_put, jacfwd, jacrev\n+from jax import api\nfrom jax.core import Primitive\nfrom jax.interpreters.partial_eval import def_abstract_eval\nfrom jax.interpreters.ad import defjvp\n@@ -259,6 +260,22 @@ class APITest(jtu.JaxTestCase):\nf = lambda x: np.tanh(np.dot(A, x))\nassert onp.allclose(jacfwd(f)(x), jacrev(f)(x))\n+ def test_std_basis(self):\n+ basis = api._std_basis(np.zeros(3))\n+ assert getattr(basis, \"shape\", None) == (3, 3)\n+ assert onp.allclose(basis, onp.eye(3))\n+\n+ basis = api._std_basis(np.zeros((3, 3)))\n+ assert getattr(basis, \"shape\", None) == (9, 3, 3)\n+ assert onp.allclose(basis, onp.eye(9).reshape(9, 3, 3))\n+\n+ basis = api._std_basis([0., (np.zeros(3), np.zeros((3, 4)))])\n+ assert isinstance(basis, list) and len(basis) == 2\n+ assert getattr(basis[0], \"shape\", None) == (16,)\n+ assert isinstance(basis[1], tuple) and len(basis[1]) == 2\n+ assert getattr(basis[1][0], \"shape\", None) == (16, 3)\n+ assert getattr(basis[1][1], \"shape\", None) == (16, 3, 4)\n+\nif __name__ == '__main__':\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | generalize jacfwd and jacrev to handle pytrees |
260,335 | 06.01.2019 12:51:24 | 28,800 | 81788865458c34f07c536b1733c7ede602c00c1e | use distutils.util.str2bool on JAX_ENABLE_X64 | [
{
"change_type": "MODIFY",
"old_path": "jax/lib/xla_bridge.py",
"new_path": "jax/lib/xla_bridge.py",
"diff": "@@ -25,6 +25,7 @@ from __future__ import print_function\nimport os\nimport warnings\n+from distutils.util import strtobool\nfrom ..config import flags\nimport numpy as onp # 'onp' rather than 'np' to distinguish from autograd.numpy\n@@ -35,7 +36,7 @@ from jaxlib import xla_client\nFLAGS = flags.FLAGS\nflags.DEFINE_bool('jax_enable_x64',\n- os.getenv('JAX_ENABLE_X64', False),\n+ strtobool(os.getenv('JAX_ENABLE_X64', \"False\")),\n'Enable 64-bit types to be used.')\nflags.DEFINE_string('jax_dump_hlo_graph', None, 'Regexp of HLO graphs to dump.')\nflags.DEFINE_bool('jax_hlo_profile', False, 'Enables HLO profiling mode.')\n"
}
] | Python | Apache License 2.0 | google/jax | use distutils.util.str2bool on JAX_ENABLE_X64 |
260,335 | 06.01.2019 14:05:01 | 28,800 | e177205e98ecdff69b96f5542cfbd5f14a65634a | add split and broadcast methods to ShapedArrays | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1723,5 +1723,7 @@ setattr(DeviceArray, \"astype\", lax.convert_element_type)\n# Extra methods that are handy\n+setattr(ShapedArray, \"broadcast\", core.aval_method(lax.broadcast))\n+setattr(ShapedArray, \"split\", core.aval_method(split))\nsetattr(DeviceArray, \"broadcast\", lax.broadcast)\nsetattr(DeviceArray, \"split\", split)\n"
}
] | Python | Apache License 2.0 | google/jax | add split and broadcast methods to ShapedArrays |
260,335 | 07.01.2019 08:34:48 | 28,800 | e4f56d79110dc1c614871da1ff0067060d8c0d82 | minor batching bugfixes exposed by general hessian | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/batching.py",
"new_path": "jax/interpreters/batching.py",
"diff": "@@ -27,7 +27,7 @@ from six.moves import reduce\nfrom .. import core\nfrom ..core import Trace, Tracer, new_master, pack, AbstractTuple, JaxTuple\nfrom ..abstract_arrays import ShapedArray, make_shaped_array, array_types\n-from ..ad_util import add_jaxvals_p\n+from ..ad_util import add_jaxvals_p, zeros_like_p, zeros_like_jaxval\nfrom ..linear_util import transformation, transformation_with_aux, wrap_init\nfrom ..tree_util import register_pytree_node\nfrom ..util import unzip2, partial, safe_map\n@@ -228,6 +228,8 @@ def reducer_batcher(prim, batched_args, batch_dims, axes, **kwargs):\nkwargs['input_shape'] = operand.shape\nreturn prim.bind(operand, axes=axes, **kwargs), bdim_out\n+# set up primitive batches for ad_util primitives\n+\ndef add_batched(batched_args, batch_dims):\nbdx, bdy = batch_dims\nif bdx == bdy:\n@@ -238,6 +240,12 @@ def add_batched(batched_args, batch_dims):\nreturn add_jaxvals_p.bind(xs, ys), 0\nprimitive_batchers[add_jaxvals_p] = add_batched\n+def zeros_like_batched(batched_args, batch_dims):\n+ val, = batched_args\n+ bdim, = batch_dims\n+ return zeros_like_jaxval(val), bdim\n+primitive_batchers[zeros_like_p] = zeros_like_batched\n+\n### util\n@@ -287,6 +295,9 @@ def moveaxis(sz, dst, src, x):\nreturn pack(map(partial(moveaxis, sz), dst, src, x))\nelif type(src) is tuple:\nreturn pack(map(partial(moveaxis, sz, dst), src, x))\n+ elif type(dst) is tuple:\n+ srcs = (src,) * len(dst)\n+ return pack(map(partial(moveaxis, sz), dst, srcs, x))\nelse:\nreturn pack(map(partial(moveaxis, sz, dst, src), x))\nelif isinstance(aval, ShapedArray):\n"
}
] | Python | Apache License 2.0 | google/jax | minor batching bugfixes exposed by general hessian |
260,335 | 07.01.2019 08:54:14 | 28,800 | ca27f0a2b29bdf5499c4b0ae2a5e812989cbd3e5 | add jacobian / hessian pytree tests (fixes | [
{
"change_type": "MODIFY",
"old_path": "jax/test_util.py",
"new_path": "jax/test_util.py",
"diff": "@@ -427,6 +427,11 @@ class JaxTestCase(parameterized.TestCase):\nself.assertEqual(len(x), len(y))\nfor x_elt, y_elt in zip(x, y):\nself.assertAllClose(x_elt, y_elt, check_dtypes, atol=atol, rtol=rtol)\n+ elif isinstance(x, dict):\n+ self.assertIsInstance(y, dict)\n+ self.assertEqual(set(x.keys()), set(y.keys()))\n+ for k in x.keys():\n+ self.assertAllClose(x[k], y[k], check_dtypes, atol=atol, rtol=rtol)\nelse:\nis_array = lambda x: hasattr(x, '__array__') or onp.isscalar(x)\nself.assertTrue(is_array(x))\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/api_test.py",
"new_path": "tests/api_test.py",
"diff": "@@ -23,7 +23,7 @@ from absl.testing import absltest\nfrom jax import test_util as jtu\nimport jax.numpy as np\n-from jax import jit, grad, device_get, device_put, jacfwd, jacrev\n+from jax import jit, grad, device_get, device_put, jacfwd, jacrev, hessian\nfrom jax import api\nfrom jax.core import Primitive\nfrom jax.interpreters.partial_eval import def_abstract_eval\n@@ -260,6 +260,15 @@ class APITest(jtu.JaxTestCase):\nf = lambda x: np.tanh(np.dot(A, x))\nassert onp.allclose(jacfwd(f)(x), jacrev(f)(x))\n+ @jtu.skip_on_devices(\"tpu\")\n+ def test_hessian(self):\n+ R = onp.random.RandomState(0).randn\n+ A = R(4, 4)\n+ x = R(4)\n+\n+ f = lambda x: np.dot(x, np.dot(A, x))\n+ assert onp.allclose(hessian(f)(x), A + A.T)\n+\ndef test_std_basis(self):\nbasis = api._std_basis(np.zeros(3))\nassert getattr(basis, \"shape\", None) == (3, 3)\n@@ -276,6 +285,42 @@ class APITest(jtu.JaxTestCase):\nassert getattr(basis[1][0], \"shape\", None) == (16, 3)\nassert getattr(basis[1][1], \"shape\", None) == (16, 3, 4)\n+ @jtu.skip_on_devices(\"tpu\")\n+ def test_jacobian_on_pytrees(self):\n+ for jacfun in [jacfwd, jacrev]:\n+ ans = jacfun(lambda x, y: (x, y))(0., 1.)\n+ expected = (1., 0.)\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+ ans = jacfun(lambda x, y: (x, y), 1)(0., 1.)\n+ expected = (0., 1.)\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+ ans = jacfun(lambda x, y: (x, y), (0, 1))(0., 1.)\n+ expected = ((1., 0.),\n+ (0., 1.),)\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+ ans = jacfun(lambda x: x[:2])((1., 2., 3.))\n+ expected = ((1., 0., 0.),\n+ (0., 1., 0.))\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+ R = onp.random.RandomState(0).randn\n+ x = R(2)\n+ y = R(3)\n+ ans = jacfun(lambda x, y: {'x': x, 'xy': np.outer(x, y)})(x, y)\n+ expected = {'x': onp.eye(2),\n+ 'xy': onp.kron(onp.eye(2), y[:, None]).reshape(2, 3, 2)}\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+ @jtu.skip_on_devices(\"tpu\")\n+ def test_hessian_on_pytrees(self):\n+ ans = hessian(lambda x: np.array(x)**2)((1., 2.))\n+ expected = ((onp.array([2., 0.]), onp.array([0., 0.])),\n+ (onp.array([0., 0.]), onp.array([0., 2.])))\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\nif __name__ == '__main__':\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | add jacobian / hessian pytree tests (fixes #173) |
260,335 | 07.01.2019 08:59:56 | 28,800 | 75958898f975088d7f80e96b6cd2ec7c3d9a1347 | add copyright header to advi.py | [
{
"change_type": "MODIFY",
"old_path": "examples/advi.py",
"new_path": "examples/advi.py",
"diff": "+# Copyright 2018 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\"\"\"Automatic differentiation variational inference in Numpy and JAX.\nThis demo fits a Gaussian approximation to an intractable, unnormalized\n"
}
] | Python | Apache License 2.0 | google/jax | add copyright header to advi.py |
260,335 | 07.01.2019 12:28:52 | 28,800 | df87d5ce43ea07f96b6a573b3c3e6aa3902455cd | make lax.full require concrete shapes
improves error message for | [
{
"change_type": "MODIFY",
"old_path": "jax/lax.py",
"new_path": "jax/lax.py",
"diff": "@@ -418,6 +418,13 @@ def tie_in(x, y):\nreturn tie_in_p.bind(x, y)\ndef full(shape, fill_value, dtype):\n+ try:\n+ shape = tuple(map(int, shape))\n+ except TypeError:\n+ msg = (\"`full` requires shapes to be concrete. If using `jit`, try using \"\n+ \"`static_argnums` or applying `jit` to smaller subfunctions instead.\")\n+ raise TypeError(msg)\n+\nif onp.shape(fill_value):\nmsg = \"full must be called with scalar fill_value, got fill_value.shape {}.\"\nraise TypeError(msg.format(onp.shape(fill_value)))\n@@ -2532,7 +2539,9 @@ def _check_shapelike(fun_name, arg_name, obj):\ndef _dynamic_slice_indices(operand, start_indices):\nif isinstance(start_indices, (tuple, list)):\nstart_indices = concatenate([reshape(i, [1]) for i in start_indices], 0)\n- return rem(start_indices, onp.array(operand.shape, start_indices.dtype))\n+ # map int over operand.shape to raise any dynamic-shape errors\n+ shape = onp.asarray(map(int, operand.shape), start_indices.dtype)\n+ return rem(start_indices, shape)\ndef _const(example, val):\n"
}
] | Python | Apache License 2.0 | google/jax | make lax.full require concrete shapes
improves error message for #204 |
260,335 | 07.01.2019 12:38:46 | 28,800 | 47eb8fa17ca2ebc4b91a0e326da2c99e23d82661 | add another concreteness check to lax.iota | [
{
"change_type": "MODIFY",
"old_path": "jax/lax.py",
"new_path": "jax/lax.py",
"diff": "@@ -440,7 +440,7 @@ def full(shape, fill_value, dtype):\nreturn broadcast(convert_element_type(fill_value, dtype), shape)\ndef iota(dtype, size):\n- return broadcasted_iota(dtype, (size,), 0)\n+ return broadcasted_iota(dtype, (int(size),), 0)\ndef broadcasted_iota(dtype, shape, dimension):\ndtype = xla_bridge.canonicalize_dtype(dtype)\n"
}
] | Python | Apache License 2.0 | google/jax | add another concreteness check to lax.iota |
260,335 | 07.01.2019 16:47:13 | 28,800 | 1e84a3a0fb774955689c72e2b0c1408223d7a680 | make tuple unpacking cause a full_lower | [
{
"change_type": "MODIFY",
"old_path": "jax/core.py",
"new_path": "jax/core.py",
"diff": "@@ -449,7 +449,7 @@ class JaxTuple(tuple):\nclass AbstractTuple(AbstractValue, tuple):\n@staticmethod\ndef _iter(tracer):\n- return tracer.unpack()\n+ return map(full_lower, tracer.unpack())\ndef _len(self, ignored_tracer):\nreturn len(self) # tuples have a known length\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/ad.py",
"new_path": "jax/interpreters/ad.py",
"diff": "@@ -247,10 +247,9 @@ class JVPTracer(Tracer):\ndef unpack(self):\nif self.tangent is zero:\n- tangent = [zero] * len(self.primal)\n+ return self.full_lower()\nelse:\n- tangent = self.tangent\n- return map(partial(JVPTracer, self.trace), self.primal, tangent)\n+ return map(partial(JVPTracer, self.trace), self.primal, self.tangent)\ndef full_lower(self):\nif self.tangent is zero:\n"
}
] | Python | Apache License 2.0 | google/jax | make tuple unpacking cause a full_lower |
260,335 | 07.01.2019 16:54:51 | 28,800 | 280b3fe2fc2b03b1e9d0fb22c4631fee00666f3c | python3 likes list(map(...)) | [
{
"change_type": "MODIFY",
"old_path": "jax/lax.py",
"new_path": "jax/lax.py",
"diff": "@@ -2540,7 +2540,7 @@ def _dynamic_slice_indices(operand, start_indices):\nif isinstance(start_indices, (tuple, list)):\nstart_indices = concatenate([reshape(i, [1]) for i in start_indices], 0)\n# map int over operand.shape to raise any dynamic-shape errors\n- shape = onp.asarray(map(int, operand.shape), start_indices.dtype)\n+ shape = onp.asarray(list(map(int, operand.shape)), start_indices.dtype)\nreturn rem(start_indices, shape)\n"
}
] | Python | Apache License 2.0 | google/jax | python3 likes list(map(...)) |
260,335 | 12.01.2019 07:19:04 | 28,800 | aaf0e3cfaf88bb71540cf623850c537b505af958 | bump jaxlib version for new wheels | [
{
"change_type": "MODIFY",
"old_path": "build/setup.py",
"new_path": "build/setup.py",
"diff": "@@ -20,7 +20,7 @@ binary_libs = [os.path.basename(f) for f in glob('jaxlib/*.so*')]\nsetup(\nname='jaxlib',\n- version='0.1.3',\n+ version='0.1.4',\ndescription='XLA library for JAX',\nauthor='JAX team',\nauthor_email='jax-dev@google.com',\n"
}
] | Python | Apache License 2.0 | google/jax | bump jaxlib version for new wheels |
260,335 | 12.01.2019 11:09:15 | 28,800 | 6be53c7a0bd0e89c72e380386bd3b6f0a5579361 | fix isinstance check in indexing (fixes | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1592,8 +1592,8 @@ def _rewriting_take(arr, idx, axis=0):\naxis += isinstance(elt, slice) # advance axis index if not eliminated\nunexpanded_shape_itr = iter(result.shape)\nresult_shape = tuple(1 if elt is None else next(unexpanded_shape_itr)\n- for elt in canonical_idx if not isinstance(elt, int))\n- return lax.reshape(result, result_shape)\n+ for elt in canonical_idx if isinstance(elt, (type(None), slice)))\n+ return lax.reshape(result, result_shape) if result_shape else result\n# Handle advanced indexing (non-tuple sequence, ndarray of dtype int or bool,\n# or a tuple with at least one sequence object).\n"
}
] | Python | Apache License 2.0 | google/jax | fix isinstance check in indexing (fixes #227) |
260,335 | 12.01.2019 12:54:22 | 28,800 | 70d1a0044326e67ef5a236379f33e16ccf761770 | set behavior when random.randint has invalid range
(closes | [
{
"change_type": "MODIFY",
"old_path": "jax/random.py",
"new_path": "jax/random.py",
"diff": "@@ -245,6 +245,10 @@ def randint(key, shape, minval, maxval, dtype=onp.int32):\nif nbits not in (32, 64):\nraise TypeError(\"randint only accepts 32- or 64-bit dtypes.\")\n+ # if we don't have minval < maxval, just always return minval\n+ # https://github.com/google/jax/issues/222\n+ maxval = lax.max(lax.add(minval, onp.array(1, dtype)), maxval)\n+\n# This algorithm is biased whenever (maxval - minval) is not a power of 2.\n# We generate double the number of random bits required by the dtype so as to\n# reduce that bias.\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/random_test.py",
"new_path": "tests/random_test.py",
"diff": "@@ -149,6 +149,10 @@ class LaxRandomTest(jtu.JaxTestCase):\nself.assertFalse(onp.all(perm1 == x)) # seems unlikely!\nself.assertTrue(onp.all(onp.sort(perm1) == x))\n+ def testIssue222(self):\n+ x = random.randint(random.PRNGKey(10003), (), 0, 0)\n+ assert x == 0\n+\nif __name__ == \"__main__\":\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | set behavior when random.randint has invalid range
(closes #222) |
260,335 | 13.01.2019 11:37:34 | 28,800 | 78dbc031b87b262ca28701d5f604a528a5aa1866 | double linalg test tolerances to avoid flakiness | [
{
"change_type": "MODIFY",
"old_path": "tests/linalg_test.py",
"new_path": "tests/linalg_test.py",
"diff": "@@ -149,6 +149,7 @@ class NumpyLinalgTest(jtu.JaxTestCase):\ndef testSVD(self, m, n, dtype, full_matrices, compute_uv, rng):\nif not hasattr(lapack, \"jax_gesdd\"):\nself.skipTest(\"No singular value decomposition implementation available\")\n+\nargs_maker = lambda: [rng((m, n), dtype)]\n# Norm, adjusted for dimension and type.\n@@ -164,18 +165,18 @@ class NumpyLinalgTest(jtu.JaxTestCase):\nif full_matrices:\nk = min(m, n)\nif m < n:\n- self.assertTrue(onp.all(norm(a - onp.matmul(out[1] * out[0], out[2][:k, :])) < 50))\n+ self.assertTrue(onp.all(norm(a - onp.matmul(out[1] * out[0], out[2][:k, :])) < 100))\nelse:\n- self.assertTrue(onp.all(norm(a - onp.matmul(out[1] * out[0][:, :k], out[2])) < 50))\n+ self.assertTrue(onp.all(norm(a - onp.matmul(out[1] * out[0][:, :k], out[2])) < 100))\nelse:\n- self.assertTrue(onp.all(norm(a - onp.matmul(out[1] * out[0], out[2])) < 50))\n+ self.assertTrue(onp.all(norm(a - onp.matmul(out[1] * out[0], out[2])) < 100))\n# Check the unitary properties of the singular vector matrices.\n- self.assertTrue(onp.all(norm(onp.eye(out[0].shape[1]) - onp.matmul(onp.conj(T(out[0])), out[0])) < 5))\n+ self.assertTrue(onp.all(norm(onp.eye(out[0].shape[1]) - onp.matmul(onp.conj(T(out[0])), out[0])) < 10))\nif m >= n:\n- self.assertTrue(onp.all(norm(onp.eye(out[2].shape[1]) - onp.matmul(onp.conj(T(out[2])), out[2])) < 5))\n+ self.assertTrue(onp.all(norm(onp.eye(out[2].shape[1]) - onp.matmul(onp.conj(T(out[2])), out[2])) < 10))\nelse:\n- self.assertTrue(onp.all(norm(onp.eye(out[2].shape[0]) - onp.matmul(out[2], onp.conj(T(out[2])))) < 10))\n+ self.assertTrue(onp.all(norm(onp.eye(out[2].shape[0]) - onp.matmul(out[2], onp.conj(T(out[2])))) < 20))\nelse:\nself.assertTrue(onp.allclose(onp.linalg.svd(a, compute_uv=False), onp.asarray(out)))\n@@ -324,7 +325,7 @@ class ScipyLinalgTest(jtu.JaxTestCase):\nself.skipTest(\"No LU implementation available\")\na = rng(shape, dtype)\n- jtu.check_grads(jsp.linalg.lu, (a,), 2, rtol=2e-2)\n+ jtu.check_grads(jsp.linalg.lu, (a,), 2, rtol=1e-1)\n# TODO(phawkins): enable when there is an LU implementation for GPU/TPU.\n"
}
] | Python | Apache License 2.0 | google/jax | double linalg test tolerances to avoid flakiness |
260,335 | 13.01.2019 09:01:01 | 28,800 | 5a4713f108ae188f72d209bdf611970a2f1fe7d9 | add tests for np.sort (c.f. | [
{
"change_type": "MODIFY",
"old_path": "jax/lax.py",
"new_path": "jax/lax.py",
"diff": "@@ -391,7 +391,7 @@ def sort(operand, dimension=-1):\nreturn sort_p.bind(operand, dimension=dimension)\ndef sort_key_val(keys, values, dimension=-1):\n- # TODO new sort_key_val is variadic\n+ # TODO(mattjj): new sort_key_val is variadic\nresult = sort_key_val_p.bind(keys, values, dimension=dimension)\nsorted_keys, sorted_values = result\nreturn sorted_keys, sorted_values\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -235,7 +235,6 @@ absolute = abs = _one_to_one_unop(onp.absolute, lax.abs)\nfabs = _one_to_one_unop(onp.fabs, lax.abs, True)\nbitwise_not = _one_to_one_unop(onp.bitwise_not, lax.bitwise_not)\nnegative = _one_to_one_unop(onp.negative, lax.neg)\n-sort = _one_to_one_unop(onp.sort, lax.sort)\nsign = _one_to_one_unop(onp.sign, lax.sign)\nfloor = _one_to_one_unop(onp.floor, lax.floor, True)\n@@ -1523,6 +1522,20 @@ def _argminmax(op, a, axis):\nmask_idxs = where(lax._eq_meet(a, op(a, axis, keepdims=True)), idxs, maxval)\nreturn min(mask_idxs, axis)\n+\n+@_wraps(onp.sort)\n+def sort(a, axis=-1, kind='quicksort', order=None):\n+ if kind != 'quicksort':\n+ warnings.warn(\"'kind' argument to sort is ignored.\")\n+ if order is not None:\n+ msg = \"'order' argument to sort is not supported.\"\n+ raise ValueError(msg)\n+ if axis is None:\n+ return lax.sort(a.ravel(), 0)\n+ else:\n+ return lax.sort(a, axis % ndim(a))\n+\n+\n### Indexing\n@@ -1722,7 +1735,8 @@ def _static_idx(idx, size):\ndef _not_implemented(fun):\n@_wraps(fun)\ndef wrapped(*args, **kwargs):\n- raise Exception(\"Numpy function {} not yet implemented\".format(fun))\n+ msg = \"Numpy function {} not yet implemented\"\n+ raise NotImplementedError(msg.format(fun))\nreturn wrapped\n# Build a set of all unimplemented NumPy functions.\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_test.py",
"new_path": "tests/lax_numpy_test.py",
"diff": "@@ -932,7 +932,6 @@ class LaxBackedNumpyTests(jtu.JaxTestCase):\n# TODO(mattjj): test infix operator overrides\ndef testRavel(self):\n- # TODO(mattjj): support this method-based syntax?\nrng = onp.random.RandomState(0)\nargs_maker = lambda: [rng.randn(3, 4).astype(\"float32\")]\nself._CompileAndCheck(lambda x: x.ravel(), args_maker, check_dtypes=True)\n@@ -959,6 +958,28 @@ class LaxBackedNumpyTests(jtu.JaxTestCase):\nans = lnp.arange(0.0, 1.0, 0.1)\nself.assertAllClose(expected, ans, check_dtypes=True)\n+ def testSortManual(self):\n+ # manual tests for sort are nice because we don't have to worry about ties.\n+ # lax.sort is tested combinatorially.\n+ ans = lnp.sort(onp.array([16, 15, 23, 42, 8, 4]))\n+ expected = onp.array([4, 8, 15, 16, 23, 42])\n+ self.assertAllClose(expected, ans, check_dtypes=True)\n+\n+ a = onp.array([[1, 4], [3, 1]])\n+ ans = lnp.sort(a, axis=None)\n+ expected = onp.array([[1, 1, 3, 4]])\n+ self.assertAllClose(expected, ans, check_dtypes=True)\n+\n+ a = onp.array([[1, 4], [3, 1]])\n+ ans = lnp.sort(a) # last axis\n+ expected = onp.array([[1, 4], [1, 3]])\n+ self.assertAllClose(expected, ans, check_dtypes=True)\n+\n+ a = onp.array([[1, 4], [3, 1]])\n+ ans = lnp.sort(a, axis=0)\n+ expected = onp.array([[1, 1], [3, 4]])\n+ self.assertAllClose(expected, ans, check_dtypes=True)\n+\nif __name__ == \"__main__\":\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | add tests for np.sort (c.f. #221) |
260,335 | 13.01.2019 11:03:47 | 28,800 | 54886bd3109b3b4462e1e72e67cd7ffae69c5399 | add sort_key_val batching rule (fixes | [
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -240,7 +240,7 @@ def vmap(fun, in_axes=0, out_axes=0):\n@wraps(fun, docstr=docstr)\ndef batched_fun(*args, **kwargs):\nif not isinstance(fun, lu.WrappedFun):\n- f = lu.wrap_init(fun)\n+ f = lu.wrap_init(fun, kwargs)\nin_axes_ = (in_axes,) * len(args) if type(in_axes) is int else in_axes\nin_flat, in_trees = unzip2(map(pytree_to_jaxtupletree, args))\njaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(f, in_trees)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/lax.py",
"new_path": "jax/lax.py",
"diff": "@@ -2275,19 +2275,48 @@ def sort_key_val_jvp(primals, tangents, dimension):\ndef sort_key_val_transpose_rule(t, keys, values, dimension):\nt_keys, t_values = t\nassert t_keys is ad_util.zero\n- broadcasted_iota = broadcast_in_dim(\n- onp.arange(keys.shape[dimension]), keys.shape, [dimension % keys.ndim])\n- _, perm = sort_key_val(keys, broadcasted_iota)\n+ iota = broadcasted_iota(onp.int32, keys.shape, dimension % keys.ndim)\n+ _, perm = sort_key_val(keys, iota)\nkeys_result = ad_util.zero if keys is None else None\nvalues_result = sort_key_val(perm, t_values)[1] if values is None else None\nreturn [keys_result, values_result]\n+def sort_key_val_batch_rule(batched_args, batch_dims, dimension):\n+ keys, values = batched_args\n+ keys_bdim, values_bdim = batch_dims\n+ assert keys_bdim is not None or values_bdim is not None\n+ if keys_bdim == values_bdim:\n+ new_dimension = dimension + (keys_bdim <= dimension)\n+ out = sort_key_val(keys, values, new_dimension)\n+ return core.pack(out), keys_bdim\n+ elif keys_bdim is not None and values_bdim is not None:\n+ keys_trans = batching.moveaxis(keys.shape[keys_bdim], values_bdim,\n+ keys_bdim, keys)\n+ new_dimension = dimension + (values_bdim <= dimension)\n+ out = sort_key_val(keys_trans, values, new_dimension)\n+ return core.pack(out), values_bdim\n+ elif keys_bdim is None:\n+ broadcast_dimensions = onp.delete(onp.arange(values.ndim), values_bdim)\n+ new_keys = broadcast_in_dim(keys, values.shape, broadcast_dimensions)\n+ new_dimension = dimension + (values_bdim <= dimension)\n+ out = sort_key_val(new_keys, values, new_dimension)\n+ return core.pack(out), values_bdim\n+ elif values_bdim is None:\n+ broadcast_dimensions = onp.delete(onp.arange(keys.ndim), keys_bdim)\n+ new_values = broadcast_in_dim(values, keys.shape, broadcast_dimensions)\n+ new_dimension = dimension + (keys_bdim <= dimension)\n+ out = sort_key_val(keys, new_values, new_dimension)\n+ return core.pack(out), keys_bdim\n+ else:\n+ raise Exception # unreachable\n+\nsort_key_val_p = Primitive('sort_key_val')\nsort_key_val_p.def_impl(sort_key_val_impl)\nsort_key_val_p.def_abstract_eval(sort_key_val_abstract_eval)\nxla.translations[sort_key_val_p] = partial(standard_translate, 'sort_key_val')\nad.primitive_jvps[sort_key_val_p] = sort_key_val_jvp\nad.primitive_transposes[sort_key_val_p] = sort_key_val_transpose_rule\n+batching.primitive_batchers[sort_key_val_p] = sort_key_val_batch_rule\ndef while_loop_abstract_eval(init_val, opaque_params):\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/batching_test.py",
"new_path": "tests/batching_test.py",
"diff": "@@ -335,6 +335,36 @@ class BatchingTest(jtu.JaxTestCase):\nself.assertAllClose(ans, expected, check_dtypes=False)\nassert len(onp.unique(ans)) == 10 * 3 * 2\n+ def testSortKeyVal(self):\n+ k = onp.arange(12)[::-1].reshape(3, 4)\n+ v = onp.random.RandomState(0).permutation(12).reshape(3, 4)\n+\n+ sk, sv = vmap(partial(lax.sort_key_val, dimension=0), (0, 0))(k, v)\n+ self.assertAllClose(sk, k[:, ::-1], check_dtypes=True)\n+ self.assertAllClose(sv, v[:, ::-1], check_dtypes=True)\n+\n+ sk, sv = vmap(partial(lax.sort_key_val, dimension=0), (1, 1), 1)(k, v)\n+ self.assertAllClose(sk, k[::-1, :], check_dtypes=True)\n+ self.assertAllClose(sv, v[::-1, :], check_dtypes=True)\n+\n+ sk, sv = vmap(partial(lax.sort_key_val, dimension=0), (0, 1))(k, v.T)\n+ self.assertAllClose(sk, k[:, ::-1], check_dtypes=True)\n+ self.assertAllClose(sv, v[:, ::-1], check_dtypes=True)\n+\n+ sk, sv = vmap(partial(lax.sort_key_val, dimension=0), (1, 0))(k.T, v)\n+ self.assertAllClose(sk, k[:, ::-1], check_dtypes=True)\n+ self.assertAllClose(sv, v[:, ::-1], check_dtypes=True)\n+\n+ sk, sv = vmap(partial(lax.sort_key_val, dimension=0), (None, 0))(k[0], v)\n+ self.assertAllClose(sk, onp.broadcast_to(k[0, ::-1], (3, 4)),\n+ check_dtypes=True)\n+ self.assertAllClose(sv, v[:, ::-1], check_dtypes=True)\n+\n+ sk, sv = vmap(partial(lax.sort_key_val, dimension=0), (1, None))(k.T, v[0])\n+ self.assertAllClose(sk, k[:, ::-1], check_dtypes=True)\n+ self.assertAllClose(sv, onp.broadcast_to(v[0, ::-1], (3, 4)),\n+ check_dtypes=True)\n+\nif __name__ == '__main__':\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | add sort_key_val batching rule (fixes #221) |
260,335 | 13.01.2019 11:15:39 | 28,800 | 30683f8f4343f81a9b4ef4251710a4668056a50f | add numpy.argsort (c.f. | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -19,6 +19,7 @@ from __future__ import print_function\nimport collections\nimport itertools\nimport string\n+import warnings\nimport numpy as onp\nimport opt_einsum\n@@ -1528,14 +1529,30 @@ def sort(a, axis=-1, kind='quicksort', order=None):\nif kind != 'quicksort':\nwarnings.warn(\"'kind' argument to sort is ignored.\")\nif order is not None:\n- msg = \"'order' argument to sort is not supported.\"\n- raise ValueError(msg)\n+ raise ValueError(\"'order' argument to sort is not supported.\")\n+\nif axis is None:\nreturn lax.sort(a.ravel(), 0)\nelse:\nreturn lax.sort(a, axis % ndim(a))\n+@_wraps(onp.argsort)\n+def argsort(a, axis=-1, kind='quicksort', order=None):\n+ if kind != 'quicksort':\n+ warnings.warn(\"'kind' argument to argsort is ignored.\")\n+ if order is not None:\n+ raise ValueError(\"'order' argument to argsort is not supported.\")\n+\n+ if axis is None:\n+ return argsort(a.ravel(), 0)\n+ else:\n+ axis = axis % ndim(a)\n+ iota = lax.broadcasted_iota(onp.int64, shape(a), axis)\n+ _, perm = lax.sort_key_val(a, iota, dimension=axis)\n+ return perm\n+\n+\n### Indexing\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_test.py",
"new_path": "tests/lax_numpy_test.py",
"diff": "@@ -958,7 +958,7 @@ class LaxBackedNumpyTests(jtu.JaxTestCase):\nans = lnp.arange(0.0, 1.0, 0.1)\nself.assertAllClose(expected, ans, check_dtypes=True)\n- def testSortManual(self):\n+ def testSortManually(self):\n# manual tests for sort are nice because we don't have to worry about ties.\n# lax.sort is tested combinatorially.\nans = lnp.sort(onp.array([16, 15, 23, 42, 8, 4]))\n@@ -980,6 +980,32 @@ class LaxBackedNumpyTests(jtu.JaxTestCase):\nexpected = onp.array([[1, 1], [3, 4]])\nself.assertAllClose(expected, ans, check_dtypes=True)\n+ def testArgsortManually(self):\n+ x = onp.array([16, 15, 23, 42, 8, 4])\n+ ans = lnp.argsort(x)\n+ expected = onp.argsort(x)\n+ self.assertAllClose(expected, ans, check_dtypes=False)\n+\n+ x = onp.array([[16, 15, 23], [42, 8, 4]])\n+ ans = lnp.argsort(x, axis=0)\n+ expected = onp.argsort(x, axis=0)\n+ self.assertAllClose(expected, ans, check_dtypes=False)\n+\n+ x = onp.array([[16, 15, 23], [42, 8, 4]])\n+ ans = lnp.argsort(x, axis=1)\n+ expected = onp.argsort(x, axis=1)\n+ self.assertAllClose(expected, ans, check_dtypes=False)\n+\n+ x = onp.array([[16, 15, 23], [42, 8, 4]])\n+ ans = lnp.argsort(x, axis=None)\n+ expected = onp.argsort(x, axis=None)\n+ self.assertAllClose(expected, ans, check_dtypes=False)\n+\n+ x = onp.array([[16, 15, 23], [42, 8, 4]])\n+ ans = lnp.argsort(x)\n+ expected = onp.argsort(x)\n+ self.assertAllClose(expected, ans, check_dtypes=False)\n+\nif __name__ == \"__main__\":\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | add numpy.argsort (c.f. #221) |
260,335 | 12.01.2019 12:48:58 | 28,800 | f7c6284313f4c95c7c1c3d09e8c83eb4fb8360dd | add sort_along_axis, no tests (c.f. | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -1553,6 +1553,21 @@ def argsort(a, axis=-1, kind='quicksort', order=None):\nreturn perm\n+@_wraps(onp.take_along_axis)\n+def take_along_axis(arr, indices, axis):\n+ if axis is None and ndim(arr) != 1:\n+ return take_along_axis(arr.ravel(), indices.ravel(), 0)\n+ elif ndim(arr) == 1:\n+ return lax.index_take(arr, (indices,), (0,))\n+ else:\n+ all_indices = [lax.broadcasted_iota(_dtype(indices), shape(indices), i)\n+ for i in range(ndim(arr))]\n+ all_indices[axis] = indices\n+ all_indices = tuple(map(ravel, all_indices))\n+ out_flat = lax.index_take(arr, all_indices, tuple(range(ndim(arr))))\n+ return reshape(out_flat, shape(indices))\n+\n+\n### Indexing\n"
}
] | Python | Apache License 2.0 | google/jax | add sort_along_axis, no tests (c.f. #220) |
260,335 | 13.01.2019 12:26:37 | 28,800 | 4a1d189d0553b32960ea2405f4fc9e9bf58aec82 | add tests for numpy.take_along_axis (fixes | [
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_test.py",
"new_path": "tests/lax_numpy_test.py",
"diff": "@@ -1006,6 +1006,25 @@ class LaxBackedNumpyTests(jtu.JaxTestCase):\nexpected = onp.argsort(x)\nself.assertAllClose(expected, ans, check_dtypes=False)\n+ @parameterized.named_parameters(jtu.cases_from_list(\n+ {\"testcase_name\": \"_{}_axis={}\".format(\n+ jtu.format_shape_dtype_string(shape, dtype), axis),\n+ \"rng\": rng, \"shape\": shape, \"dtype\": dtype, \"axis\": axis}\n+ for shape in [(3,), (3, 4), (3, 4, 5)]\n+ for axis in itertools.chain(range(len(shape)), [-1], [None])\n+ for dtype in default_dtypes\n+ for rng in [jtu.rand_default()]))\n+ def testTakeAlongAxis(self, shape, dtype, axis, rng):\n+ def args_maker():\n+ x = rng(shape, dtype)\n+ i = onp.argsort(x, axis=axis)\n+ return x, i\n+\n+ lnp_op = lambda x, i: lnp.take_along_axis(x, i, axis=axis)\n+ onp_op = lambda x, i: onp.take_along_axis(x, i, axis=axis)\n+ self._CheckAgainstNumpy(lnp_op, onp_op, args_maker, check_dtypes=True)\n+ self._CompileAndCheck(lnp_op, args_maker, check_dtypes=True)\n+\nif __name__ == \"__main__\":\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | add tests for numpy.take_along_axis (fixes #220) |
260,335 | 14.01.2019 12:56:41 | 28,800 | ade92703ec100d54c04de83daec8660377db4ac2 | guard np.take_along_axis test in case of old numpy | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -201,13 +201,13 @@ def _constant_like(x, const):\ndef _wraps(fun):\n\"\"\"Like functools.wraps but works with numpy.ufuncs.\"\"\"\n+ def wrap(op):\n+ try:\ndocstr = \"\"\"\nLAX-backed implementation of {fun}. Original docstring below.\n{np_doc}\n\"\"\".format(fun=fun.__name__, np_doc=fun.__doc__)\n- def wrap(op):\n- try:\nop.__name__ = fun.__name__\nop.__doc__ = docstr\nfinally:\n@@ -1553,7 +1553,7 @@ def argsort(a, axis=-1, kind='quicksort', order=None):\nreturn perm\n-@_wraps(onp.take_along_axis)\n+@_wraps(getattr(onp, \"take_along_axis\", None))\ndef take_along_axis(arr, indices, axis):\nif axis is None and ndim(arr) != 1:\nreturn take_along_axis(arr.ravel(), indices.ravel(), 0)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_test.py",
"new_path": "tests/lax_numpy_test.py",
"diff": "@@ -1023,6 +1023,8 @@ class LaxBackedNumpyTests(jtu.JaxTestCase):\nreturn x, i\nlnp_op = lambda x, i: lnp.take_along_axis(x, i, axis=axis)\n+\n+ if hasattr(onp, \"take_along_axis\"):\nonp_op = lambda x, i: onp.take_along_axis(x, i, axis=axis)\nself._CheckAgainstNumpy(lnp_op, onp_op, args_maker, check_dtypes=True)\nself._CompileAndCheck(lnp_op, args_maker, check_dtypes=True)\n"
}
] | Python | Apache License 2.0 | google/jax | guard np.take_along_axis test in case of old numpy |
260,299 | 16.01.2019 16:51:54 | 0 | 38b2da82c5a1874ed65bccbc69150679f5ce5866 | Use slots for tracer classes | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/ad.py",
"new_path": "jax/interpreters/ad.py",
"diff": "@@ -233,6 +233,8 @@ class JVPTrace(Trace):\nclass JVPTracer(Tracer):\n+ __slots__ = ['primal', 'tangent']\n+\ndef __init__(self, trace, primal, tangent):\nself.trace = trace\nself.primal = primal\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/batching.py",
"new_path": "jax/interpreters/batching.py",
"diff": "@@ -72,6 +72,8 @@ def batch_subtrace(master, dims, *vals):\nclass BatchTracer(Tracer):\n+ __slots__ = ['val', 'batch_dim']\n+\ndef __init__(self, trace, val, batch_dim):\nself.trace = trace\nself.val = val\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/partial_eval.py",
"new_path": "jax/interpreters/partial_eval.py",
"diff": "@@ -117,6 +117,7 @@ def partial_eval_wrapper(avals, *consts, **kwargs):\nclass JaxprTracer(Tracer):\n+ __slots__ = ['pval', 'recipe']\ndef __init__(self, trace, pval, recipe):\nassert isinstance(pval, PartialVal)\n"
}
] | Python | Apache License 2.0 | google/jax | Use slots for tracer classes |
260,331 | 16.01.2019 23:05:16 | 18,000 | d707426caae0038609fcc71531fd5d7aa61f4f47 | Bump jaxlib version to 0.1.5 in preparation for building new wheels. | [
{
"change_type": "MODIFY",
"old_path": "build/setup.py",
"new_path": "build/setup.py",
"diff": "@@ -20,7 +20,7 @@ binary_libs = [os.path.basename(f) for f in glob('jaxlib/*.so*')]\nsetup(\nname='jaxlib',\n- version='0.1.4',\n+ version='0.1.5',\ndescription='XLA library for JAX',\nauthor='JAX team',\nauthor_email='jax-dev@google.com',\n"
}
] | Python | Apache License 2.0 | google/jax | Bump jaxlib version to 0.1.5 in preparation for building new wheels. |
260,335 | 18.01.2019 07:03:12 | 28,800 | 42bd253cbb61520383cc4e92300fd38f02d234e0 | add prng design doc in markdown format | [
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -237,11 +237,17 @@ def vmap(fun, in_axes=0, out_axes=0):\ndocstr = (\"Vectorized version of {fun}. Takes similar arguments as {fun} \"\n\"but with additional array axes over which {fun} is mapped.\")\n+ if (not isinstance(in_axes, (list, tuple, type(None), int))\n+ or not isinstance(out_axes, (list, tuple, type(None), int))):\n+ msg = (\"vmap arguments in_axes and out_axes must each be an integer, None, \"\n+ \"or a (nested) tuple of those types, got {} and {} respectively.\")\n+ raise TypeError(msg.format(type(in_axes), type(out_axes)))\n+\n@wraps(fun, docstr=docstr)\ndef batched_fun(*args, **kwargs):\nif not isinstance(fun, lu.WrappedFun):\nf = lu.wrap_init(fun, kwargs)\n- in_axes_ = (in_axes,) * len(args) if type(in_axes) is int else in_axes\n+ in_axes_ = in_axes if isinstance(in_axes, (list, tuple)) else (in_axes,) * len(args)\nin_flat, in_trees = unzip2(map(pytree_to_jaxtupletree, args))\njaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(f, in_trees)\nout_flat = batching.batch(jaxtree_fun, in_flat, in_axes_, out_axes)\n"
}
] | Python | Apache License 2.0 | google/jax | add prng design doc in markdown format |
260,331 | 18.01.2019 20:48:40 | 18,000 | 82ce80f1e12e9fe326771121684810a5ed62a57b | Bump Jaxlib version. | [
{
"change_type": "MODIFY",
"old_path": "build/setup.py",
"new_path": "build/setup.py",
"diff": "@@ -20,7 +20,7 @@ binary_libs = [os.path.basename(f) for f in glob('jaxlib/*.so*')]\nsetup(\nname='jaxlib',\n- version='0.1.5',\n+ version='0.1.6',\ndescription='XLA library for JAX',\nauthor='JAX team',\nauthor_email='jax-dev@google.com',\n"
}
] | Python | Apache License 2.0 | google/jax | Bump Jaxlib version. |
260,335 | 22.01.2019 15:34:09 | 28,800 | b95669eb79c1e2148397cd46a4d4b6f2c35c72b8 | enable value-and-grad api test | [
{
"change_type": "MODIFY",
"old_path": "tests/api_test.py",
"new_path": "tests/api_test.py",
"diff": "@@ -45,7 +45,7 @@ class APITest(jtu.JaxTestCase):\nassert grad(f, argnums=1)(1.0, 1.0, 1.0, flag=True) == 2.0\nassert grad(f, argnums=(2, 0))(1.0, 1.0, 1.0, flag=True) == (3.0, 1.0)\n- def value_and_grad_argnums(self):\n+ def test_value_and_grad_argnums(self):\ndef f(x, y, z, flag=False):\nassert flag\nreturn 1.0 * x + 2.0 * y + 3.0 * z\n"
}
] | Python | Apache License 2.0 | google/jax | enable value-and-grad api test |
260,335 | 24.01.2019 13:35:29 | 28,800 | 781577226dbddd28b33c8c80e16424ca8a863e7d | clean up parallel_test.py file | [
{
"change_type": "MODIFY",
"old_path": "tests/parallel_test.py",
"new_path": "tests/parallel_test.py",
"diff": "@@ -31,115 +31,88 @@ from jax.config import config\nconfig.parse_flags_with_absl()\n-# class PmapTest(jtu.JaxTestCase):\n+class PmapTest(jtu.JaxTestCase):\n-# def testConstantFunction(self):\n-# f = lambda x: 3\n-# ans = pmap(f, axis_name='i')(onp.ones(4))\n-# expected = 3 * onp.ones(4)\n-# self.assertAllClose(ans, expected, check_dtypes=False)\n-\n-# def testReduceSum(self):\n-# f = lambda x: psum(x, 'i')\n-# ans = pmap(f, axis_name='i')(onp.ones(4))\n-# expected = 4 * onp.ones(4)\n-# self.assertAllClose(ans, expected, check_dtypes=False)\n-\n-# def testLogSoftmax(self):\n-# f = lambda x: x - np.log(psum(np.exp(x), 'i'))\n-# x = onp.log(onp.arange(1., 10., dtype=onp.float32))\n-# ans = pmap(f, axis_name='i')(x)\n-# expected = x - onp.log(onp.sum(onp.exp(x)))\n-# self.assertAllClose(ans, expected, check_dtypes=False)\n-\n-# # def testPmapOfJit(self):\n-# # f = jit(lambda x: psum(x, 'i'))\n-# # x = onp.arange(12.)\n-# # ans = pmap(f, axis_name='i')(x)\n-# # expected = onp.sum(x)\n-# # self.assertAllClose(ans, expected, check_dtypes=False)\n-\n-\n-# class PapplyTest(jtu.JaxTestCase):\n-\n-# def testIdentity(self):\n-# pfun, axis_name = papply(lambda x: x)\n-# ans = pfun(onp.arange(3))\n-# expected = onp.arange(3)\n-# self.assertAllClose(ans, expected, check_dtypes=False)\n+ def testConstantFunction(self):\n+ f = lambda x: 3\n+ ans = pmap(f, axis_name='i')(onp.ones(4))\n+ expected = 3 * onp.ones(4)\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n-# def testMap(self):\n-# pfun, axis_name = papply(np.sin)\n-# ans = pfun(onp.arange(3.))\n-# expected = onp.sin(onp.arange(3.))\n-# self.assertAllClose(ans, expected, check_dtypes=False)\n+ def testReduceSum(self):\n+ f = lambda x: psum(x, 'i')\n+ ans = pmap(f, axis_name='i')(onp.ones(4))\n+ expected = 4 * onp.ones(4)\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n-# def testSum(self):\n-# pfun, axis_name = papply(np.sum)\n+ def testLogSoftmax(self):\n+ f = lambda x: x - np.log(psum(np.exp(x), 'i'))\n+ x = onp.log(onp.arange(1., 10., dtype=onp.float32))\n+ ans = pmap(f, axis_name='i')(x)\n+ expected = x - onp.log(onp.sum(onp.exp(x)))\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n-# jaxpr = make_jaxpr(pfun)(onp.zeros(5))\n-# expected_jaxpr = make_jaxpr(lambda x: psum(x, axis_name))(onp.zeros(5))\n-# assert repr(jaxpr) == repr(expected_jaxpr)\n-# ans = pmap(pfun, axis_name)(onp.arange(3.))\n-# expected = onp.sum(onp.arange(3.))\n-# self.assertAllClose(ans, expected, check_dtypes=False)\n+class PapplyTest(jtu.JaxTestCase):\n-# def testLogSoftmax(self):\n+ def testIdentity(self):\n+ pfun, axis_name = papply(lambda x: x)\n+ ans = pfun(onp.arange(3))\n+ expected = onp.arange(3)\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n-# def fun(x):\n-# return x - np.log(np.sum(np.exp(x)))\n+ def testMap(self):\n+ pfun, axis_name = papply(np.sin)\n+ ans = pfun(onp.arange(3.))\n+ expected = onp.sin(onp.arange(3.))\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n-# pfun, axis_name = papply(fun)\n+ def testSum(self):\n+ pfun, axis_name = papply(np.sum)\n-# jaxpr = make_jaxpr(pfun)(onp.zeros(5))\n-# expected_jaxpr = make_jaxpr(lambda x: x - np.log(psum(np.exp(x), axis_name))\n-# )(onp.zeros(5))\n-# assert repr(jaxpr) == repr(expected_jaxpr)\n+ jaxpr = make_jaxpr(pfun)(onp.zeros(5))\n+ expected_jaxpr = make_jaxpr(lambda x: psum(x, axis_name))(onp.zeros(5))\n+ assert repr(jaxpr) == repr(expected_jaxpr)\n-# ans = pmap(pfun, axis_name)(onp.arange(1., 5.))\n-# expected = fun(onp.arange(1., 5.))\n-# self.assertAllClose(ans, expected, check_dtypes=False)\n+ ans = pmap(pfun, axis_name)(onp.arange(3.))\n+ expected = onp.sum(onp.arange(3.))\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n-# def testAdd(self):\n-# x = onp.array([[1, 2, 3], [4, 5, 6]])\n-# expected = x + x\n+ def testLogSoftmax(self):\n-# pfun, axis_name = papply(np.add)\n-# ans = pmap(pfun, axis_name)(x, x)\n-# self.assertAllClose(ans, expected, check_dtypes=True)\n+ def fun(x):\n+ return x - np.log(np.sum(np.exp(x)))\n-# # def testAddDifferentSharding(self):\n-# # x = onp.array([[1, 2, 3], [4, 5, 6]])\n-# # expected = x + x\n+ pfun, axis_name = papply(fun)\n-# # pfun, axis_name = papply(np.add, (0, 1))\n-# # ans = pmap(pfun, axis_name)(x, x)\n-# # self.assertAllClose(ans, expected, check_dtypes=True)\n+ jaxpr = make_jaxpr(pfun)(onp.zeros(5))\n+ expected_jaxpr = make_jaxpr(lambda x: x - np.log(psum(np.exp(x), axis_name))\n+ )(onp.zeros(5))\n+ assert repr(jaxpr) == repr(expected_jaxpr)\n-# # def testScatterLike(self):\n-# # def fun(y):\n-# # x_scattered = scatter_like(x, y)\n-# # return lax.add(x_scattered, y) # TODO replace with x + y\n+ ans = pmap(pfun, axis_name)(onp.arange(1., 5.))\n+ expected = fun(onp.arange(1., 5.))\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n-# # x = onp.array([[1, 2], [3, 4]])\n-# # expected = x + x\n+ def testAdd(self):\n+ x = onp.array([[1, 2, 3], [4, 5, 6]])\n+ expected = x + x\n-# # pfun, axis_name = papply(fun)\n-# # ans = pmap(pfun, axis_name)(x)\n-# # self.assertAllClose(ans, expected, check_dtypes=True)\n+ pfun, axis_name = papply(np.add)\n+ ans = pmap(pfun, axis_name)(x, x)\n+ self.assertAllClose(ans, expected, check_dtypes=True)\n-# def testAddBroadcasting(self):\n+ def testAddBroadcasting(self):\n-# def fun(x):\n-# return x + 3\n+ def fun(x):\n+ return x + 3\n-# x = onp.array([[1, 2], [3, 4]])\n-# expected = x + 3\n+ x = onp.array([[1, 2], [3, 4]])\n+ expected = x + 3\n-# pfun, axis_name = papply(fun)\n-# ans = pmap(pfun, axis_name)(x)\n-# self.assertAllClose(ans, expected, check_dtypes=True)\n+ pfun, axis_name = papply(fun)\n+ ans = pmap(pfun, axis_name)(x)\n+ self.assertAllClose(ans, expected, check_dtypes=True)\nclass ChunkTest(jtu.JaxTestCase):\n"
}
] | Python | Apache License 2.0 | google/jax | clean up parallel_test.py file |
260,335 | 24.01.2019 14:16:17 | 28,800 | b34c87dc221163d224ced455b61abc8c7fd3a3c8 | remove 'chunk' for now | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -220,133 +220,6 @@ scatter_p = PmapPrimitive('scatter')\npmap_primitive_rules[scatter_p] = scatter_pmap_rule\n-### chunk\n-# TODO expreses chunk in terms of a index-split composed with pmap\n-\n-# chunk :: spmd_traceable{G, i}[N] -> i -> axis -> chunksize\n-# -> spmd_traceable{G, i}[N // chunksize]\n-\n-def chunk(fun, chunksize, name, in_vals, in_axes, out_axis_target):\n- sizes = reduce(set.union, map(batching.dimsize, in_axes, in_vals))\n- if not sizes:\n- return fun.call_wrapped(*in_vals)\n- elif len(sizes) == 1:\n- out_val, out_axis = chunk_transform(fun).call_wrapped(\n- name, in_vals, in_axes, chunksize)\n- return batching.moveaxis(sizes.pop(), out_axis_target, out_axis, out_val)\n- else:\n- raise TypeError(\"got inconsistent map dimension sizes: {}\".format(sizes))\n-\n-\n-@lu.transformation\n-def chunk_transform(name, vals, axes, chunksize):\n- with new_master(ChunkTrace) as master:\n- trace = ChunkTrace(master, core.cur_sublevel())\n- in_tracers = map(partial(ChunkTracer, trace, name, chunksize), vals, axes)\n- ans = yield in_tracers\n- out_tracer = trace.full_raise(ans)\n- out_val, out_axis = out_tracer.val, out_tracer.axis\n- del master\n- yield out_val, out_axis\n-\n-\n-class ChunkTracer(Tracer):\n- def __init__(self, trace, name, chunksize, val, axis):\n- self.trace = trace\n- self.name = name\n- self.chunksize = chunksize\n- self.val = val\n- self.axis = axis\n-\n- @property\n- def aval(self):\n- batched_aval = batching.get_aval(self.val)\n- return batching.remove_batch_dim_from_aval(self.axis, batched_aval)\n-\n- def unpack(self):\n- t = type(self.axis)\n- if t is tuple:\n- axes = self.axis\n- elif t is int:\n- axes = [self.axis] * len(self.val)\n- elif t is type(None):\n- return tuple(self.val)\n- else:\n- raise TypeError(t)\n- new_tracer = partial(ChunkTracer, self.trace, self.name, self.chunksize)\n- return map(new_tracer, self.val, axes)\n-\n- def full_lower(self):\n- if self.axis is None:\n- return core.full_lower(self.val)\n- else:\n- return self\n-\n-class ChunkTrace(Trace):\n- def pure(self, val):\n- return ChunkTracer(self, None, None, val, None)\n-\n- def lift(self, val):\n- return ChunkTracer(self, None, None, val, None)\n-\n- def sublift(self, val):\n- return ChunkTracer(self, val.name, val.chunksize, val.val, val.axis)\n-\n- def process_primitive(self, primitive, tracers, params):\n- names_in, vals_in, axes_in = unzip3((t.name, t.val, t.axis) for t in tracers)\n- if all(axis is None for axis in axes_in):\n- return primitive.bind(*vals_in, **params)\n- else:\n- name = next(name for name in names_in if name is not None) # all same\n- if primitive in chunk_primitive_rules:\n- if name == params['axis_name']:\n- chunksize = next(t.chunksize for t in tracers if t.chunksize)\n- rule = chunk_primitive_rules[primitive]\n- params = {k: params[k] for k in params if k != 'axis_name'}\n- val_out, axis_out = rule(chunksize, name, vals_in, axes_in, **params)\n- return ChunkTracer(self, name, chunksize, val_out, axis_out)\n- else:\n- return primitive.bind(val, **params)\n- else:\n- rule = batching.get_primitive_batcher(primitive)\n- val_out, axis_out = rule(vals_in, axes_in, **params)\n- return ChunkTracer(self, name, chunksize, val_out, axis_out)\n-\n- def process_call(self, call_primitive, f, tracers, params):\n- names, vals, axes = unzip3((t.name, t.val, t.axis) for t in tracers)\n- if all(axis is None for axis in axes):\n- return call_primitive.bind(f, *vals, **params)\n- else:\n- name = next(name for name in names if name is not None) # all same\n- chunksize = next(t.chunksize for t in tracers if t.chunksize)\n- f, axis_out = chunk_subtrace(f, self.master, name, chunksize, axes)\n- val_out = call_primitive.bind(f, *vals, **params)\n- return ChunkTracer(self, name, chunksize, val_out, axis_out())\n-\n- def post_process_call(self, _, out_tracer):\n- raise NotImplementedError # TODO(mattjj,dougalm)\n-\n- def pack(self, tracers):\n- vals = pack([t.val for t in tracers])\n- axis = tuple(t.axis for t in tracers)\n- name = next(t.name for t in tracers if t.name)\n- chunksize = next(t.chunksize for t in tracers if t.chunksize)\n- return ChunkTracer(self, name, chunksize, vals, axis)\n-\n-\n-chunk_primitive_rules = {}\n-\n-\n-def psum_chunk_rule(chunksize, name, vals, axes):\n- val, = vals\n- axis, = axes\n- shape = list(val.shape)\n- shape[axis] = val.shape[axis] // chunksize\n- shape.insert(axis, chunksize)\n- return psum(val.sum(axis), name), None\n-chunk_primitive_rules[psum_p] = psum_chunk_rule\n-\n-\n### papply\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/parallel_test.py",
"new_path": "tests/parallel_test.py",
"diff": "@@ -25,7 +25,7 @@ from jax import test_util as jtu\nfrom jax import lax\nfrom jax.api import pmap, papply, jit, make_jaxpr\nfrom jax.linear_util import wrap_init\n-from jax.interpreters.parallel import psum, scatter_like, chunk\n+from jax.interpreters.parallel import psum, scatter_like\nfrom jax.config import config\nconfig.parse_flags_with_absl()\n@@ -115,16 +115,16 @@ class PapplyTest(jtu.JaxTestCase):\nself.assertAllClose(ans, expected, check_dtypes=True)\n-class ChunkTest(jtu.JaxTestCase):\n+# class ChunkTest(jtu.JaxTestCase):\n- def testChunkingSum(self):\n- f = lambda x: psum(x, 'i')\n+# def testChunkingSum(self):\n+# f = lambda x: psum(x, 'i')\n- x = 3 * onp.ones((4, 2))\n- ans = pmap(lambda x: chunk(wrap_init(f), 2, 'i', (x,), (0,), 0), 'i')(x)\n- expected = 24\n+# x = 3 * onp.ones((4, 2))\n+# ans = pmap(lambda x: chunk(wrap_init(f), 2, 'i', (x,), (0,), 0), 'i')(x)\n+# expected = 24\n- self.assertAllClose(ans, expected, check_dtypes=False)\n+# self.assertAllClose(ans, expected, check_dtypes=False)\nif __name__ == '__main__':\n"
}
] | Python | Apache License 2.0 | google/jax | remove 'chunk' for now |
260,335 | 24.01.2019 16:08:03 | 28,800 | 7e05f94c48c69863f6988e038afb87576764b12d | fix pmap nesting bug, sketch out index splitting | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -116,14 +116,21 @@ class PmapTrace(Trace):\nelse:\nname = next(name for name in names_in if name is not None) # all same\nif primitive in pmap_primitive_rules:\n+ # if it's a pmap collective primitive, do something special\n+ val_in, = vals_in\n+ axis_in, = axes_in\nif name == params['axis_name']:\n+ # if the name matches this tracer's name, apply the pmap rule\nrule = pmap_primitive_rules[primitive]\nparams = {k: params[k] for k in params if k != 'axis_name'}\n- val_out, axis_out = rule(vals_in, axes_in, **params)\n+ val_out, axis_out = rule(val_in, axis_in, **params)\nreturn PmapTracer(self, name, val_out, axis_out)\nelse:\n- return primitive.bind(val, **params)\n+ # if not, bind the primitive so that any other pmap tracers can see it\n+ val_out = primitive.bind(val_in, **params)\n+ return PmapTracer(self, name, val_out, axis_in)\nelse:\n+ # if it's not a pmap collective primitive, act just like vmap\nrule = batching.get_primitive_batcher(primitive)\nval_out, axis_out = rule(vals_in, axes_in, **params)\nreturn PmapTracer(self, name, val_out, axis_out)\n@@ -166,13 +173,10 @@ pmap_primitive_rules = {}\ndef psum(x, axis_name):\nreturn psum_p.bind(x, axis_name=axis_name)\n-def psum_pmap_rule(vals, axes):\n- val, = vals\n- axis, = axes\n+def psum_pmap_rule(val, axis):\nreturn val.sum(axis), None\n-def psum_parallel_translation_rule(c, in_nodes, device_grp):\n- val, = in_nodes\n+def psum_parallel_translation_rule(c, val, device_grp):\n# return c.CrossReplicaSum(val, device_grp) # TODO\nreturn c.CrossReplicaSum(val)\n@@ -184,40 +188,99 @@ pxla.parallel_translation_rules[psum_p] = psum_parallel_translation_rule\ndef gather(x, axis_name):\nreturn gather_p.bind(x, axis_name=axis_name)\n-def gather_pmap_rule(vals, axes):\n- val, = vals\n+def gather_pmap_rule(val, axis):\nreturn val, None\ngather_p = PmapPrimitive('gather')\npmap_primitive_rules[gather_p] = gather_pmap_rule\n-def rescatter(x, new_axis, axis_name):\n- return rescatter_p.bind(x, new_axis=new_axis, axis_name=axis_name)\n+### axis variable splitting and computation chunking\n+\n-def rescatter_pmap_rule(vals, axes, new_axis):\n- val, = vals\n- axis, = axes\n- raise NotImplementedError # TODO why the transpose, instead of identity?\n- return batching.moveaxis(None, new_axis, axis, val), new_axis\n+@lu.transformation\n+def axisvar_split_transform(name, new_names, *args):\n+ with new_master(SplitTrace) as master:\n+ trace = Trace(master, core.cur_sublevel())\n+ in_tracers = map(partial(SplitTracer, name, new_names), args)\n+ ans = yield in_tracers\n+ out_tracer = trace.full_raise(ans)\n+ out_val = out_tracer.val\n+ del master\n+ yield out_val\n+\n+class SplitTracer(Tracer):\n+ def __init__(self, trace, name, new_names, val):\n+ self.trace = trace\n+ self.name = name\n+ self.new_names = new_names\n+ self.val = val\n-rescatter_p = PmapPrimitive('rescatter')\n-pmap_primitive_rules[rescatter_p] = rescatter_pmap_rule\n+ @property\n+ def aval(self):\n+ return core.get_aval(self.val)\n+ def unpack(self):\n+ raise NotImplementedError # TODO(mattjj)\n-# TODO maybe this isn't a great primitive, and it's the only one that needs more\n-# than one operand at the moment\n-def _scatter(source, dummy, target_axis, axis_name):\n- return scatter_p.bind(source, dummy, target_axis=target_axis, axis_name=axis_name)\n+ def full_lower(self):\n+ if self.name is None:\n+ return core.full_lower(self.val)\n+ else:\n+ return self\n-def scatter_pmap_rule(vals, axes, target_axis):\n- source, _ = vals\n- source_axis, _ = axes\n- assert source_axis is None\n- return source, target_axis\n+class SplitTrace(Trace):\n+ def pure(self, val):\n+ return SplitTracer(self, None, (), val)\n-scatter_p = PmapPrimitive('scatter')\n-pmap_primitive_rules[scatter_p] = scatter_pmap_rule\n+ def lift(self, val):\n+ return SplitTracer(self, None, (), val)\n+\n+ def sublift(self, val):\n+ return SplitTracer(self, val.name, val.new_names, val.val)\n+\n+ def process_primitive(self, primitive, tracers, params):\n+ names_in, vals_in = unzip2((t.name, t.val) for t in tracers)\n+ if all(name is None for name in names_in):\n+ return primitive.bind(*vals_in, **params)\n+ else:\n+ name = next(name for name in names if name is not None)\n+ new_names = next(t.new_names for t in tracers if t.name is not None)\n+ if primitive in pmap_primitive_rules:\n+ val_in, = vals_in\n+ if name == params['axis_name']:\n+ new_params = {k: params[k] for k in params if k != 'axis_name'}\n+ val = val_in\n+ for new_name in new_names:\n+ val = primitive.bind(val, axis_name=new_name, **new_params)\n+ val_out = val\n+ return SplitTracer(self, name, new_names, val_out)\n+ else:\n+ val_out = primitive.bind(val_in, **params)\n+ return SplitTracer(self, name, new_names, val_out)\n+ else:\n+ val_out = primitive.bind(*vals_in, **params)\n+ return SplitTracer(self, name, new_names, val_out)\n+\n+ def process_call(self, call_primitive, f, tracers, params):\n+ names_in, vals_in = unzip2((t.name, t.val) for t in tracers)\n+ if all(name is None for name in names_in):\n+ return call_primitive.bind(f, *vals, **params)\n+ else:\n+ name = next(name for name in names if name is not None)\n+ new_names = next(t.new_names for t in tracers if t.name is not None)\n+ f = axisvar_split_subtrace(f, self.master, name, new_names)\n+ val_out = call_primitive.bind(f, *vals, **params)\n+ return SplitTracer(self, name, new_names, val_out)\n+\n+ def post_process_call(self, _, out_tracer):\n+ raise NotImplementedError # TODO(mattjj,dougalm)\n+\n+ def pack(self, tracers):\n+ vals = pack([t.val for t in tracers])\n+ name = next(t.name for t in tracers if t.name is not None)\n+ new_names = next(t.new_names for t in tracers if t.name is not None)\n+ return SplitTracer(self, name, new_names, vals)\n### papply\n@@ -351,7 +414,6 @@ def broadcasting_papply(prim, name, vals, axes, **params):\nelif xdim == ydim:\nreturn prim.bind(x, y, **params), xdim\nelse:\n- # TODO rescatter based on sizes\nraise NotImplementedError # this isn't right, need to think about names\nx = rescatter(x, ydim, name)\nreturn prim.bind(x, y, **params), ydim\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/parallel_test.py",
"new_path": "tests/parallel_test.py",
"diff": "@@ -52,6 +52,15 @@ class PmapTest(jtu.JaxTestCase):\nexpected = x - onp.log(onp.sum(onp.exp(x)))\nself.assertAllClose(ans, expected, check_dtypes=False)\n+ def testNested(self):\n+ f = lambda x: psum(psum(x, 'i'), 'j')\n+ x = onp.ones((2, 2))\n+ ans1 = pmap(pmap(f, 'i'), 'j')(x)\n+ ans2 = pmap(pmap(f, 'j'), 'i')(x)\n+ expected = 4 * onp.ones((2, 2))\n+ self.assertAllClose(ans1, expected, check_dtypes=False)\n+ self.assertAllClose(ans2, expected, check_dtypes=False)\n+\nclass PapplyTest(jtu.JaxTestCase):\n"
}
] | Python | Apache License 2.0 | google/jax | fix pmap nesting bug, sketch out index splitting |
260,335 | 24.01.2019 16:27:34 | 28,800 | ae86b9a640acbed02fc055cc440e908d29ac3386 | fix split tracer bugs | [
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -270,6 +270,18 @@ def pmap(fun, axis_name, in_axes=0, out_axes=0):\nreturn pmap_fun\n+def axisvar_split(fun, name, new_names):\n+ \"\"\"Split axis variable names into new names.\"\"\"\n+ def split_fun(*args, **kwargs):\n+ f = lu.wrap_init(fun, kwargs)\n+ in_flat, in_trees = unzip2(map(pytree_to_jaxtupletree, args))\n+ jaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(f, in_trees)\n+ out_flat = parallel.axisvar_split(jaxtree_fun, name, new_names).call_wrapped(*args)\n+ return build_tree(out_tree(), out_flat)\n+\n+ return split_fun\n+\n+\ndef papply(fun, in_axes=0):\n\"\"\"Apply a function using parallel computation by sharding inputs.\"\"\"\naxis_name = parallel.newvar()\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -199,10 +199,10 @@ pmap_primitive_rules[gather_p] = gather_pmap_rule\n@lu.transformation\n-def axisvar_split_transform(name, new_names, *args):\n+def axisvar_split(name, new_names, *args):\nwith new_master(SplitTrace) as master:\n- trace = Trace(master, core.cur_sublevel())\n- in_tracers = map(partial(SplitTracer, name, new_names), args)\n+ trace = SplitTrace(master, core.cur_sublevel())\n+ in_tracers = map(partial(SplitTracer, trace, name, new_names), args)\nans = yield in_tracers\nout_tracer = trace.full_raise(ans)\nout_val = out_tracer.val\n@@ -244,7 +244,7 @@ class SplitTrace(Trace):\nif all(name is None for name in names_in):\nreturn primitive.bind(*vals_in, **params)\nelse:\n- name = next(name for name in names if name is not None)\n+ name = next(name for name in names_in if name is not None)\nnew_names = next(t.new_names for t in tracers if t.name is not None)\nif primitive in pmap_primitive_rules:\nval_in, = vals_in\n@@ -267,7 +267,7 @@ class SplitTrace(Trace):\nif all(name is None for name in names_in):\nreturn call_primitive.bind(f, *vals, **params)\nelse:\n- name = next(name for name in names if name is not None)\n+ name = next(name for name in names_in if name is not None)\nnew_names = next(t.new_names for t in tracers if t.name is not None)\nf = axisvar_split_subtrace(f, self.master, name, new_names)\nval_out = call_primitive.bind(f, *vals, **params)\n"
}
] | Python | Apache License 2.0 | google/jax | fix split tracer bugs |
260,335 | 24.01.2019 16:58:41 | 28,800 | c1be2aa2fa5acee18aa8b0c8e317221161303c79 | add basic split test | [
{
"change_type": "MODIFY",
"old_path": "tests/parallel_test.py",
"new_path": "tests/parallel_test.py",
"diff": "@@ -23,7 +23,7 @@ from absl.testing import parameterized\nimport jax.numpy as np\nfrom jax import test_util as jtu\nfrom jax import lax\n-from jax.api import pmap, papply, jit, make_jaxpr\n+from jax.api import pmap, papply, jit, make_jaxpr, axisvar_split\nfrom jax.linear_util import wrap_init\nfrom jax.interpreters.parallel import psum, scatter_like\n@@ -124,7 +124,16 @@ class PapplyTest(jtu.JaxTestCase):\nself.assertAllClose(ans, expected, check_dtypes=True)\n-# class ChunkTest(jtu.JaxTestCase):\n+class SplitTest(jtu.JaxTestCase):\n+\n+ def testSplitBasic(self):\n+ f = lambda x: psum(np.sin(x), 'i')\n+ x = onp.ones((2, 2))\n+ fsplit = axisvar_split(f, 'i', ('j', 'k'))\n+ ans = pmap(pmap(fsplit, 'j'), 'k')(x)\n+ expected = onp.sum(onp.sin(x))\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n# def testChunkingSum(self):\n# f = lambda x: psum(x, 'i')\n"
}
] | Python | Apache License 2.0 | google/jax | add basic split test |
260,335 | 24.01.2019 17:55:03 | 28,800 | e546f13b03d60ed0c1842dfc6b0baeab2697d7c2 | add chunking transform | [
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -271,7 +271,7 @@ def pmap(fun, axis_name, in_axes=0, out_axes=0):\ndef axisvar_split(fun, name, new_names):\n- \"\"\"Split axis variable names into new names.\"\"\"\n+ \"\"\"Split axis variable names into new names in an SPMD function.\"\"\"\ndef split_fun(*args, **kwargs):\nf = lu.wrap_init(fun, kwargs)\nin_flat, in_trees = unzip2(map(pytree_to_jaxtupletree, args))\n@@ -282,6 +282,24 @@ def axisvar_split(fun, name, new_names):\nreturn split_fun\n+def chunk(fun, name, chunksize, in_axes=0, out_axes=0):\n+ \"\"\"Stage SPMD primitives to first operate on chunks, then use collectives.\"\"\"\n+ temp_name = object()\n+\n+ def chunked_fun(*args, **kwargs):\n+ f = lu.wrap_init(fun, kwargs)\n+ in_axes_ = in_axes if isinstance(in_axes, (list, tuple)) else (in_axes,) * len(args)\n+ in_flat, in_trees = unzip2(map(pytree_to_jaxtupletree, args))\n+ f, out_tree = pytree_fun_to_jaxtupletree_fun(f, in_trees)\n+ f = parallel.axisvar_split(f, name, (temp_name, name))\n+ reshape = partial(parallel.reshape_axis, chunksize)\n+ reshaped_args = map(reshape, in_axes_, args)\n+ out_flat = parallel.pmap(f, temp_name, reshaped_args, in_axes_, out_axes)\n+ return build_tree(out_tree(), out_flat)\n+\n+ return chunked_fun\n+\n+\ndef papply(fun, in_axes=0):\n\"\"\"Apply a function using parallel computation by sharding inputs.\"\"\"\naxis_name = parallel.newvar()\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -282,6 +282,23 @@ class SplitTrace(Trace):\nnew_names = next(t.new_names for t in tracers if t.name is not None)\nreturn SplitTracer(self, name, new_names, vals)\n+def reshape_axis(chunksize, in_axis, arg):\n+ aval = core.get_aval(arg)\n+ if type(aval) is core.AbstractTuple:\n+ if type(in_axis) is int:\n+ return core.pack(map(partial(reshape_axis, chunksize, in_axis), arg))\n+ elif isinstance(in_axis, (list, tuple)):\n+ return core.pack(map(partial(reshape_axis, chunksize), in_axis, arg))\n+ else:\n+ raise TypeError(\"unexpected in_axis type: {}\".format(type(in_axis)))\n+ elif isinstance(aval, ShapedArray):\n+ in_axis = in_axis % arg.ndim\n+ split_shape = (arg.shape[in_axis] // chunksize, chunksize)\n+ new_shape = arg.shape[:in_axis] + split_shape + arg.shape[in_axis+1:]\n+ return arg.reshape(new_shape)\n+ else:\n+ raise TypeError(type(arg))\n+\n### papply\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/parallel_test.py",
"new_path": "tests/parallel_test.py",
"diff": "@@ -23,7 +23,7 @@ from absl.testing import parameterized\nimport jax.numpy as np\nfrom jax import test_util as jtu\nfrom jax import lax\n-from jax.api import pmap, papply, jit, make_jaxpr, axisvar_split\n+from jax.api import pmap, papply, jit, make_jaxpr, axisvar_split, chunk\nfrom jax.linear_util import wrap_init\nfrom jax.interpreters.parallel import psum, scatter_like\n@@ -134,15 +134,13 @@ class SplitTest(jtu.JaxTestCase):\nexpected = onp.sum(onp.sin(x))\nself.assertAllClose(ans, expected, check_dtypes=False)\n-\n- # def testChunkingSum(self):\n- # f = lambda x: psum(x, 'i')\n-\n- # x = 3 * onp.ones((4, 2))\n- # ans = pmap(lambda x: chunk(wrap_init(f), 2, 'i', (x,), (0,), 0), 'i')(x)\n- # expected = 24\n-\n- # self.assertAllClose(ans, expected, check_dtypes=False)\n+ def testChunkingSum(self):\n+ f = lambda x: x - psum(x, 'i')\n+ x = onp.ones((4, 2))\n+ fchunked = chunk(f, 'i', 2)\n+ ans = pmap(fchunked, 'i')(x)\n+ expected = pmap(f, 'i')(x)\n+ self.assertAllClose(ans, expected, check_dtypes=False)\nif __name__ == '__main__':\n"
}
] | Python | Apache License 2.0 | google/jax | add chunking transform |
260,335 | 25.01.2019 08:20:33 | 28,800 | d321e2a3700996a55f5c2a0a9732f0d867ff432b | add pjit to api.py | [
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -43,6 +43,7 @@ from .lib.xla_bridge import canonicalize_dtype\nfrom .abstract_arrays import ShapedArray\nfrom .interpreters import partial_eval as pe\nfrom .interpreters import xla\n+from .interpreters import pxla\nfrom .interpreters import ad\nfrom .interpreters import batching\nfrom .interpreters import parallel\n@@ -51,7 +52,7 @@ map = safe_map\nzip = safe_zip\n-def jit(fun, static_argnums=(), **params):\n+def jit(fun, static_argnums=()):\n\"\"\"Sets up `fun` for just-in-time compilation with XLA.\nArgs:\n@@ -76,7 +77,7 @@ def jit(fun, static_argnums=(), **params):\nargs_flat, in_trees = unzip2(map(pytree_to_jaxtupletree, dyn_args))\ncheck_args(args_flat)\njaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(f, in_trees)\n- out_flat = xla.xla_call(jaxtree_fun, *args_flat, **params)\n+ out_flat = xla.xla_call(jaxtree_fun, *args_flat)\nreturn build_tree(out_tree(), out_flat)\nf_jitted.__name__ = \"jit({})\".format(f_jitted.__name__)\n@@ -257,6 +258,25 @@ def vmap(fun, in_axes=0, out_axes=0):\nreturn batched_fun\n+def pjit(fun, axis_map, out_axis_map, mesh_spec, mesh_map, static_argnums=()):\n+ \"\"\"Set up SPMD function for JIT compilation and parallel execution with XLA.\"\"\"\n+ @wraps(fun)\n+ def f_jitted(*args, **kwargs):\n+ f = lu.wrap_init(fun, kwargs)\n+ dyn_argnums = [i for i in range(len(args)) if i not in static_argnums]\n+ f, dyn_args = argnums_partial(f, dyn_argnums, args)\n+ args_flat, in_trees = unzip2(map(pytree_to_jaxtupletree, dyn_args))\n+ check_args(args_flat)\n+ jaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(f, in_trees)\n+ out_flat = pxla.xla_pcall(jaxtree_fun, *args_flat,\n+ axis_map=axis_map, out_axis_map=out_axis_map,\n+ mesh_map=mesh_map, mesh_spec=mesh_spec)\n+ return build_tree(out_tree(), out_flat)\n+\n+ f_jitted.__name__ = \"pjit({})\".format(f_jitted.__name__)\n+ return f_jitted\n+\n+\ndef pmap(fun, axis_name, in_axes=0, out_axes=0):\n\"\"\"Vectorizing pseudo-map for single-program multiple-data (SPMD) functions.\"\"\"\ndef pmap_fun(*args, **kwargs):\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -176,7 +176,7 @@ def psum(x, axis_name):\ndef psum_pmap_rule(val, axis):\nreturn val.sum(axis), None\n-def psum_parallel_translation_rule(c, val, device_grp):\n+def psum_parallel_translation_rule(c, val, device_groups):\n# return c.CrossReplicaSum(val, device_grp) # TODO\nreturn c.CrossReplicaSum(val)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -189,7 +189,7 @@ def replicated_jaxpr_computation(jaxpr, devicegrps,\nrule = parallel_translation_rules[eqn.primitive]\naxis_name = eqn.params['axis_name']\nparams = {k: eqn.params[k] for k in eqn.params if k != 'axis_name'}\n- ans = rule(c, in_nodes, devicegrps[axis_name], **params)\n+ ans = rule(c, *in_nodes, device_groups=devicegrps[axis_name], **params)\nelse:\nif eqn.bound_subjaxprs: raise NotImplementedError # TODO check primitive\nans = translation_rule(eqn.primitive)(c, *in_nodes, **eqn.params)\n@@ -260,10 +260,11 @@ def execute_replicated(axis_map, mesh_map, mesh_spec, compiled, pval,\ninput_bufs = map(partial(shard_array, mesh_spec, mesh_map), axis_maps, args)\nout_bufs = compiled.ExecutePerReplica(zip(*input_bufs))\nif out_tree is leaf:\n+ # TODO sharded device persistence\nout_shards = [merge_pvals(out_buf.to_py(), pval) for out_buf in out_bufs]\nreturn unshard_array(mesh_spec, mesh_map, out_axis_map, out_shards)\nelse:\n- raise NotImplementedError\n+ raise NotImplementedError # TODO\nxla_pcall_p = core.Primitive('xla_pcall')\n"
}
] | Python | Apache License 2.0 | google/jax | add pjit to api.py |
260,335 | 26.01.2019 05:10:22 | 28,800 | 8a6c09491b9264f6eaa947bc59fca2a9d8fb57b6 | promising... but why do we need post_process_call? | [
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -258,7 +258,7 @@ def vmap(fun, in_axes=0, out_axes=0):\nreturn batched_fun\n-def pjit(fun, axis_map, out_axis_map, mesh_spec, mesh_map, static_argnums=()):\n+def pjit(fun, axis_name, in_axes=0, out_axes=0, mesh_axis=0, static_argnums=()):\n\"\"\"Set up SPMD function for JIT compilation and parallel execution with XLA.\"\"\"\n@wraps(fun)\ndef f_jitted(*args, **kwargs):\n@@ -269,8 +269,8 @@ def pjit(fun, axis_map, out_axis_map, mesh_spec, mesh_map, static_argnums=()):\ncheck_args(args_flat)\njaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(f, in_trees)\nout_flat = pxla.xla_pcall(jaxtree_fun, *args_flat,\n- axis_map=axis_map, out_axis_map=out_axis_map,\n- mesh_map=mesh_map, mesh_spec=mesh_spec)\n+ axis_name=axis_name, in_axes=in_axes,\n+ out_axes=out_axes, mesh_axis=mesh_axis)\nreturn build_tree(out_tree(), out_flat)\nf_jitted.__name__ = \"pjit({})\".format(f_jitted.__name__)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -29,7 +29,6 @@ from ..abstract_arrays import ShapedArray, ConcreteArray, make_shaped_array\nfrom ..util import safe_zip, unzip2, unzip3, partialmethod, prod\nfrom ..lib import xla_bridge as xb\nfrom . import partial_eval as pe\n-from . import pxla\nfrom . import batching\nzip = safe_zip\n@@ -45,13 +44,14 @@ def pmap(fun, name, in_vals, in_axes, out_axis_target):\nif not sizes:\nreturn fun.call_wrapped(*in_vals)\nelif len(sizes) == 1:\n- out_val, out_axis = pmap_transform(fun).call_wrapped(name, in_vals, in_axes)\n- return batching.moveaxis(sizes.pop(), out_axis_target, out_axis, out_val)\n+ fun, out_axis = pmap_transform(fun, name, in_axes)\n+ out_val = fun.call_wrapped(*in_vals)\n+ return batching.moveaxis(sizes.pop(), out_axis_target, out_axis(), out_val)\nelse:\nraise TypeError(\"got inconsistent map dimension sizes: {}\".format(sizes))\n-@lu.transformation\n-def pmap_transform(name, vals, axes):\n+@lu.transformation_with_aux\n+def pmap_transform(name, axes, *vals):\nwith new_master(PmapTrace) as master:\ntrace = PmapTrace(master, core.cur_sublevel())\nin_tracers = map(partial(PmapTracer, trace, name), vals, axes)\n@@ -168,6 +168,7 @@ def PmapPrimitive(name):\npmap_primitive_rules = {}\n+parallel_translation_rules = {}\ndef psum(x, axis_name):\n@@ -182,7 +183,7 @@ def psum_parallel_translation_rule(c, val, device_groups):\npsum_p = PmapPrimitive('psum')\npmap_primitive_rules[psum_p] = psum_pmap_rule\n-pxla.parallel_translation_rules[psum_p] = psum_parallel_translation_rule\n+parallel_translation_rules[psum_p] = psum_parallel_translation_rule\ndef gather(x, axis_name):\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -37,6 +37,8 @@ from .xla import (flatten_fun, tree_flatten, build_tree, leaf, xla_shape,\nxla_destructure, translation_rule, abstractify,\nxla_shape_to_result_shape)\nfrom .partial_eval import trace_to_subjaxpr, merge_pvals, JaxprTrace, PartialVal\n+from .parallel import parallel_translation_rules\n+from . import parallel\nmap = safe_map\n@@ -44,6 +46,26 @@ map = safe_map\n### util\n+def chunk_transform(fun, name, in_axes, out_axes_dst):\n+ temp_name = object() # TODO gensym\n+ fun = parallel.axisvar_split(fun, name, (temp_name, name))\n+ fun, out_axes_src = parallel.pmap_transform(fun, temp_name, in_axes)\n+ fun = move_output_axis_transform(fun, out_axes_src, out_axes_dst)\n+ return fun\n+\n+@lu.transformation\n+def move_output_axis_transform(src, dst, *args):\n+ ans = yield args\n+ yield batching.moveaxis(None, dst(), src(), ans)\n+\n+def chunk_aval(chunksize, aval, axis):\n+ if axis is None:\n+ return aval\n+ else:\n+ shape = list(aval.shape)\n+ shape[axis] = chunksize\n+ return ShapedArray(tuple(shape), aval.dtype)\n+\ndef canonicalize_axis_spec(in_trees, spec):\nspec = (spec,) * len(in_trees) if type(spec) is int else spec\nspec = map(build_axis_spec_tree, spec, in_trees)\n@@ -200,48 +222,66 @@ def replicated_jaxpr_computation(jaxpr, devicegrps,\ndef xla_pcall_impl(fun, *args, **params):\n- axis_map = params.pop('axis_map') # e.g. {'i': 0, 'j': (None, 1)}\n- mesh_map = params.pop('mesh_map') # e.g. {'i': 0, 'j': 2}\n- mesh_spec = params.pop('mesh_spec') # e.g. (2, 2, 2)\n- out_axis_map = params.pop('out_axis_map') # e.g. {'i': 0, 'j': (None, 1)}\n+ axis_name = params.pop('axis_name') # e.g. 'i'\n+ in_axes = params.pop('in_axes') # e.g. 0 or (0, None)\n+ out_axes = params.pop('out_axes') # e.g. 0 or (None, 1)\n+ mesh_axis = params.pop('mesh_axis') # e.g. 0 or 1\nassert not params\nflat_args, in_trees = unzip2(map(tree_flatten, args))\nflat_args = concatenate(flat_args)\nfun, out_tree = flatten_fun(fun, in_trees)\n- mesh_map = tuple(sorted(mesh_map.items()))\n- axis_map = tuple((axis_name, canonicalize_axis_spec(in_trees, spec))\n- for axis_name, spec in sorted(axis_map.items()))\n- compiled_fun = xla_parallel_callable(fun, axis_map, mesh_map, mesh_spec,\n- *map(abstractify, flat_args))\n+ @HideFromMemoizer\n+ def out_axes_thunk():\n+ return canonicalize_axis_spec([out_tree()], out_axes)[0]\n+\n+ in_axes = canonicalize_axis_spec(in_trees, in_axes)\n+ compiled_fun = xla_parallel_callable(\n+ fun, axis_name, in_axes, out_axes_thunk,\n+ mesh_axis, mesh_spec, *map(abstractify, flat_args))\n- out_axis_map = {axis_name : canonicalize_axis_spec([out_tree()], spec)[0]\n- for axis_name, spec in out_axis_map.items()}\n- flat_ans = compiled_fun(out_tree(), out_axis_map, *args)\n+ leaf_out = out_tree() is leaf\n+ flat_ans = compiled_fun(leaf_out, out_axes_thunk(), *args)\n- if out_tree() is leaf:\n+ if leaf_out:\nreturn flat_ans\nelse:\nreturn build_tree(iter(flat_ans), out_tree())\n+class HideFromMemoizer(object):\n+ def __init__(self, val):\n+ self.val = val\n+ def __call__(self):\n+ return self.val()\n+ def __hash__(self):\n+ return 0\n+ def __eq__(self, other):\n+ return type(other) is HideFromMemoizer\n+\n@lu.memoize\n-def xla_parallel_callable(fun, axis_map, mesh_map, mesh_spec, *abstract_args):\n- axis_map, mesh_map = dict(axis_map), dict(mesh_map)\n-\n- # check that all mapped axes have the right size\n- for axis_name in axis_map:\n- if not all(axis is None or arg.shape[axis] == mesh_spec[mesh_map[axis_name]]\n- for arg, axis in zip(abstract_args, axis_map[axis_name])):\n- msg = \"axis size does not match mesh size for axis name {}\"\n+def xla_parallel_callable(fun, axis_name, in_axes, out_axes,\n+ mesh_axis, mesh_spec, *abstract_args):\n+ axis_sizes = {arg.shape[axis] for arg, axis in zip(abstract_args, in_axes)\n+ if axis is not None}\n+ if len(axis_sizes) == 0:\n+ msg = \"axis name '{}' not bound to any input axes.\"\nraise ValueError(msg.format(axis_name))\n-\n- # construct abstract args with sharded dimensions removed\n- abstract_args = map(remove_mapped_dims, abstract_args, *axis_map.values())\n-\n- # process mesh_spec and mesh_map into a mapping to device groups\n- devicegrps = {axis_name : meshgroups(mesh_spec, mesh_map[axis_name])\n- for axis_name in mesh_map}\n+ elif len(axis_sizes) > 1:\n+ msg = \"axis name '{}' bound to multiple axes with different sizes: {}.\"\n+ raise ValueError(msg.format(axis_name, axis_sizes))\n+ else:\n+ axis_size = axis_sizes.pop()\n+ if axis_size % mesh_spec[mesh_axis]:\n+ msg = (\"axis name '{}' bound to input axis of size {} mapped to mesh \"\n+ \"axis index {} with size {}, which does not evenly divide {}.\")\n+ raise ValueError(msg.format(axis_name, axis_size, mesh_axis,\n+ mesh_spec[mesh_axis], axis_size))\n+\n+ chunksize = axis_size // mesh_spec[mesh_axis]\n+ abstract_args = map(partial(chunk_aval, chunksize), abstract_args, in_axes)\n+ fun = chunk_transform(fun, axis_name, in_axes, out_axes)\n+ device_groups = meshgroups(mesh_spec, mesh_axis)\npvals = [PartialVal((aval, core.unit)) for aval in abstract_args]\nwith core.new_master(JaxprTrace, True) as master:\n@@ -250,17 +290,17 @@ def xla_parallel_callable(fun, axis_map, mesh_map, mesh_spec, *abstract_args):\ncompiled, result_shape = compile_replicated(jaxpr, devicegrps,\nconsts, *abstract_args)\ndel master, consts, jaxpr, env\n+ return partial(execute_replicated, in_axes, mesh_axis, mesh_spec, compiled, pval)\n- return partial(execute_replicated, axis_map, mesh_map, mesh_spec, compiled, pval)\n-\n-def execute_replicated(axis_map, mesh_map, mesh_spec, compiled, pval,\n- out_tree, out_axis_map, *args):\n+def execute_replicated(in_axes, mesh_axis, mesh_spec, compiled, pval,\n+ leaf_out, out_axes, *args):\n+ assert False\naxis_maps = [{axis_name : axes[i] for axis_name, axes in axis_map.items()}\nfor i in range(len(args))]\ninput_bufs = map(partial(shard_array, mesh_spec, mesh_map), axis_maps, args)\nout_bufs = compiled.ExecutePerReplica(zip(*input_bufs))\n- if out_tree is leaf:\n- # TODO sharded device persistence\n+ if leaf_out:\n+ # TODO sharded device persistence, remove the .to_py()\nout_shards = [merge_pvals(out_buf.to_py(), pval) for out_buf in out_bufs]\nreturn unshard_array(mesh_spec, mesh_map, out_axis_map, out_shards)\nelse:\n"
}
] | Python | Apache License 2.0 | google/jax | promising... but why do we need post_process_call? |
260,335 | 26.01.2019 08:10:01 | 28,800 | 6494504aed4d8748e9c56dd32e1e84a838ae8f6b | woo post_process_call, it scrolls like butter | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -146,7 +146,13 @@ class PmapTrace(Trace):\nreturn PmapTracer(self, name, val_out, axis_out())\ndef post_process_call(self, _, out_tracer):\n- raise NotImplementedError # TODO(mattjj,dougalm)\n+ name, val, axis = out_tracer.name, out_tracer.val, out_tracer.axis\n+ master = self.master\n+ def todo(x):\n+ trace = PmapTrace(master, core.cur_sublevel())\n+ return PmapTracer(trace, name, x, axis)\n+\n+ return val, todo\ndef pack(self, tracers):\nvals = pack([t.val for t in tracers])\n@@ -275,7 +281,13 @@ class SplitTrace(Trace):\nreturn SplitTracer(self, name, new_names, val_out)\ndef post_process_call(self, _, out_tracer):\n- raise NotImplementedError # TODO(mattjj,dougalm)\n+ name, new_names, val = out_tracer.name, out_tracer.new_names, out_tracer.val\n+ master = self.master\n+ def todo(x):\n+ trace = SplitTrace(master, core.cur_sublevel())\n+ return SplitTracer(trace, name, new_names, x)\n+\n+ return val, todo\ndef pack(self, tracers):\nvals = pack([t.val for t in tracers])\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -38,6 +38,7 @@ from .xla import (flatten_fun, tree_flatten, build_tree, leaf, xla_shape,\nxla_shape_to_result_shape)\nfrom .partial_eval import trace_to_subjaxpr, merge_pvals, JaxprTrace, PartialVal\nfrom .parallel import parallel_translation_rules\n+from .batching import moveaxis\nfrom . import parallel\nmap = safe_map\n@@ -56,7 +57,7 @@ def chunk_transform(fun, name, in_axes, out_axes_dst):\n@lu.transformation\ndef move_output_axis_transform(src, dst, *args):\nans = yield args\n- yield batching.moveaxis(None, dst(), src(), ans)\n+ yield moveaxis(1, dst(), src(), ans) # inserts singleton if src is None\ndef chunk_aval(chunksize, aval, axis):\nif axis is None:\n@@ -181,14 +182,14 @@ def split_array(x, axis):\n### xla_pcall\n-def compile_replicated(jaxpr, devicegrps, consts, *abstract_args):\n+def compile_replicated(jaxpr, device_groups, consts, *abstract_args):\narg_shapes = list(map(xla_shape, abstract_args))\n- built_c = replicated_jaxpr_computation(jaxpr, devicegrps, consts, (),\n+ built_c = replicated_jaxpr_computation(jaxpr, device_groups, consts, (),\n*arg_shapes)\nresult_shape = xla_shape_to_result_shape(built_c.GetReturnValueShape())\nreturn built_c.Compile(arg_shapes, xb.get_compile_options()), result_shape\n-def replicated_jaxpr_computation(jaxpr, devicegrps,\n+def replicated_jaxpr_computation(jaxpr, device_groups,\nconst_vals, freevar_shapes, *arg_shapes):\nc = xb.make_computation_builder(\"replicated_jaxpr_computation\")\n@@ -211,7 +212,7 @@ def replicated_jaxpr_computation(jaxpr, devicegrps,\nrule = parallel_translation_rules[eqn.primitive]\naxis_name = eqn.params['axis_name']\nparams = {k: eqn.params[k] for k in eqn.params if k != 'axis_name'}\n- ans = rule(c, *in_nodes, device_groups=devicegrps[axis_name], **params)\n+ ans = rule(c, *in_nodes, device_groups=device_groups, **params)\nelse:\nif eqn.bound_subjaxprs: raise NotImplementedError # TODO check primitive\nans = translation_rule(eqn.primitive)(c, *in_nodes, **eqn.params)\n@@ -287,7 +288,7 @@ def xla_parallel_callable(fun, axis_name, in_axes, out_axes,\nwith core.new_master(JaxprTrace, True) as master:\njaxpr, (pval, consts, env) = trace_to_subjaxpr(fun, master).call_wrapped(pvals)\nassert not env\n- compiled, result_shape = compile_replicated(jaxpr, devicegrps,\n+ compiled, result_shape = compile_replicated(jaxpr, device_groups,\nconsts, *abstract_args)\ndel master, consts, jaxpr, env\nreturn partial(execute_replicated, in_axes, mesh_axis, mesh_spec, compiled, pval)\n@@ -311,6 +312,3 @@ xla_pcall_p = core.Primitive('xla_pcall')\nxla_pcall = partial(core.call_bind, xla_pcall_p)\nxla_pcall_p.def_custom_bind(xla_pcall)\nxla_pcall_p.def_impl(xla_pcall_impl)\n-\n-\n-parallel_translation_rules = {}\n"
}
] | Python | Apache License 2.0 | google/jax | woo post_process_call, it scrolls like butter |
260,335 | 26.01.2019 08:21:20 | 28,800 | 8bc579aebc3c150c8fe9b470f7ecca154743e58a | chunk transform outside of xla_parallel_callable | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -233,36 +233,25 @@ def xla_pcall_impl(fun, *args, **params):\nflat_args = concatenate(flat_args)\nfun, out_tree = flatten_fun(fun, in_trees)\n- @HideFromMemoizer\n- def out_axes_thunk():\n+ in_axes = canonicalize_axis_spec(in_trees, in_axes)\n+ def canonicalized_out_axes():\nreturn canonicalize_axis_spec([out_tree()], out_axes)[0]\n+ fun = chunk_transform(fun, axis_name, in_axes, canonicalized_out_axes)\n- in_axes = canonicalize_axis_spec(in_trees, in_axes)\n- compiled_fun = xla_parallel_callable(\n- fun, axis_name, in_axes, out_axes_thunk,\n- mesh_axis, mesh_spec, *map(abstractify, flat_args))\n+ compiled_fun = xla_parallel_callable(fun, axis_name, in_axes, mesh_axis,\n+ mesh_spec, *map(abstractify, flat_args))\nleaf_out = out_tree() is leaf\n- flat_ans = compiled_fun(leaf_out, out_axes_thunk(), *args)\n+ flat_ans = compiled_fun(leaf_out, canonicalized_out_axes(), *args)\nif leaf_out:\nreturn flat_ans\nelse:\nreturn build_tree(iter(flat_ans), out_tree())\n-class HideFromMemoizer(object):\n- def __init__(self, val):\n- self.val = val\n- def __call__(self):\n- return self.val()\n- def __hash__(self):\n- return 0\n- def __eq__(self, other):\n- return type(other) is HideFromMemoizer\n-\n@lu.memoize\n-def xla_parallel_callable(fun, axis_name, in_axes, out_axes,\n- mesh_axis, mesh_spec, *abstract_args):\n+def xla_parallel_callable(fun, axis_name, in_axes, mesh_axis, mesh_spec,\n+ *abstract_args):\naxis_sizes = {arg.shape[axis] for arg, axis in zip(abstract_args, in_axes)\nif axis is not None}\nif len(axis_sizes) == 0:\n@@ -281,7 +270,6 @@ def xla_parallel_callable(fun, axis_name, in_axes, out_axes,\nchunksize = axis_size // mesh_spec[mesh_axis]\nabstract_args = map(partial(chunk_aval, chunksize), abstract_args, in_axes)\n- fun = chunk_transform(fun, axis_name, in_axes, out_axes)\ndevice_groups = meshgroups(mesh_spec, mesh_axis)\npvals = [PartialVal((aval, core.unit)) for aval in abstract_args]\n"
}
] | Python | Apache License 2.0 | google/jax | chunk transform outside of xla_parallel_callable |
260,335 | 26.01.2019 13:13:29 | 28,800 | da724d315927d0f478e014d62336ad5073c12d88 | single-axis-var version runs! and some cleanup | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -33,9 +33,9 @@ from .. import linear_util as lu\nfrom ..abstract_arrays import ShapedArray\nfrom ..util import partial, unzip2, concatenate, safe_map, prod\nfrom ..lib import xla_bridge as xb\n-from .xla import (flatten_fun, tree_flatten, build_tree, leaf, xla_shape,\n+from .xla import (flatten_fun, tree_flatten, build_tree, xla_shape,\nxla_destructure, translation_rule, abstractify,\n- xla_shape_to_result_shape)\n+ xla_shape_to_result_shape, leaf, JTupleTreeDef)\nfrom .partial_eval import trace_to_subjaxpr, merge_pvals, JaxprTrace, PartialVal\nfrom .parallel import parallel_translation_rules\nfrom .batching import moveaxis\n@@ -44,10 +44,14 @@ from . import parallel\nmap = safe_map\n+mesh_spec = None\n+\n+\n### util\ndef chunk_transform(fun, name, in_axes, out_axes_dst):\n+ \"\"\"Rewrite SPMD operations to act first on local chunks then cross-replica.\"\"\"\ntemp_name = object() # TODO gensym\nfun = parallel.axisvar_split(fun, name, (temp_name, name))\nfun, out_axes_src = parallel.pmap_transform(fun, temp_name, in_axes)\n@@ -56,10 +60,13 @@ def chunk_transform(fun, name, in_axes, out_axes_dst):\n@lu.transformation\ndef move_output_axis_transform(src, dst, *args):\n+ \"\"\"Function transformation that moves output axes from src to dst.\"\"\"\nans = yield args\n+ # TODO singleton or chunksize? i think chunksize...\nyield moveaxis(1, dst(), src(), ans) # inserts singleton if src is None\ndef chunk_aval(chunksize, aval, axis):\n+ \"\"\"Transform an abstract value's shape to have chunksize extent along axis.\"\"\"\nif axis is None:\nreturn aval\nelse:\n@@ -67,116 +74,74 @@ def chunk_aval(chunksize, aval, axis):\nshape[axis] = chunksize\nreturn ShapedArray(tuple(shape), aval.dtype)\n-def canonicalize_axis_spec(in_trees, spec):\n+def canonicalize_in_axis_spec(in_trees, spec):\n+ \"\"\"Given argument list in_trees, canonicalize and flatten an in_axes spec.\"\"\"\nspec = (spec,) * len(in_trees) if type(spec) is int else spec\nspec = map(build_axis_spec_tree, spec, in_trees)\n- spec = tuple(tree_util.tree_flatten(spec)[0])\n+ return tuple(tree_util.tree_flatten(spec)[0])\n+\n+def canonicalize_out_axis_spec(out_tree, spec):\n+ \"\"\"Given output out_tree, canonicalize and flatten an out_axes spec.\"\"\"\n+ if out_tree is leaf:\nreturn spec\n+ else:\n+ spec = build_axis_spec_tree(spec, out_tree)\n+ return tuple(tree_util.tree_flatten(spec)[0])\n-def build_axis_spec_tree(spec, in_tree):\n- if in_tree is leaf:\n+def build_axis_spec_tree(spec, tree):\n+ \"\"\"Given a JaxTuple treedef, canonicalize an axis spec for that tree.\"\"\"\n+ if tree is leaf:\nassert type(spec) is int\nreturn spec\n- elif type(in_tree) is JTupleTreeDef:\n+ elif type(tree) is JTupleTreeDef:\nspec_type = type(spec)\nif spec_type is int:\n- return tuple(map(partial(build_axis_spec_tree, spec), in_tree.child_specs))\n+ return tuple(map(partial(build_axis_spec_tree, spec), tree.child_specs))\nelif spec_type is tuple:\n- return tuple(map(build_axis_spec_tree, spec, in_tree.child_specs))\n+ return tuple(map(build_axis_spec_tree, spec, tree.child_specs))\nelse:\nraise TypeError(spec_type)\nelse:\n- raise TypeError(type(in_tree))\n-\n-def remove_mapped_dims(aval, *axes):\n- assert type(aval) is ShapedArray\n- axes = [d for d in axes if d is not None]\n- if len(set(axes)) != len(axes):\n- raise ValueError(\"multiple names mapped to the same axis\")\n- shape = tuple(onp.delete(aval.shape, axes))\n- return ShapedArray(shape, aval.dtype)\n-\n-def meshgroups(mesh_spec, mesh_axis):\n+ raise TypeError(type(tree))\n+\n+def shard_arg(mesh_spec, mesh_axis, axis, arg):\n+ \"\"\"Shard and device_put an input array argument along a logical axis.\"\"\"\n+ num_replicas = xb.get_replica_count()\n+ if prod(mesh_spec) != num_replicas:\n+ msg = \"mesh spec {} total size of {} doesn't match number of replicas {}.\"\n+ raise ValueError(msg.format(mesh_spec, prod(mesh_spec), num_replicas))\n+ shards = split_array(arg, mesh_spec[mesh_axis], axis)\n+ replica_shards = [shards[i] for i in shard_assignments(mesh_spec, mesh_axis)]\n+ return map(xb.device_put, replica_shards, range(num_replicas))\n+\n+def unshard_output(mesh_spec, mesh_axis, out_axis, out_shards):\n+ \"\"\"Collect and concatenate sharded device results.\"\"\"\n+ _, ids = onp.unique(shard_assignments(mesh_spec, mesh_axis), return_index=True)\n+ shards = [out_shards[i] for i in ids]\n+ return onp.concatenate(shards, out_axis)\n+\n+def shard_assignments(mesh_spec, mesh_axis):\n+ \"\"\"Given a mesh axis long which to shard data, compute replica assignments.\"\"\"\n+ indices_shape = [1] * len(mesh_spec)\n+ indices_shape[mesh_axis] = mesh_spec[mesh_axis]\n+ indices = onp.arange(mesh_spec[mesh_axis]).reshape(indices_shape)\n+ return tuple(onp.broadcast_to(indices, mesh_spec).ravel())\n+\n+def replica_groups(mesh_spec, mesh_axis):\n+ \"\"\"Given a mesh axis along which to operate, compute XLA replica_groups.\"\"\"\ngroups = onp.split(onp.arange(prod(mesh_spec)).reshape(mesh_spec),\nmesh_spec[mesh_axis], axis=mesh_axis)\nreturn tuple(tuple(group.ravel()) for group in groups)\n-def shard_array(mesh_spec, mesh_map, axis_map, x):\n- # axis_map , e.g. {'i': 0, 'j': None} (axis indices)\n- # mesh_map , e.g. {'i': 0, 'k': 2} (mesh indices)\n- # mesh_spec, e.g. (2, 4, 4)\n- # return flat list of device buffers - one per replica\n- mesh_ndim = len(mesh_spec)\n- mesh_size = onp.prod(mesh_spec)\n- mesh_map_inverted = {v : k for k, v in mesh_map.items()}\n- ordered_idx_names = map(mesh_map_inverted.get, range(mesh_ndim)) # [i,None,k]\n- axes = map(axis_map.get, ordered_idx_names)\n- xs = list_ravel(unstack_axes(mesh_spec, axes, x))\n- return map(xb.device_put, xs, range(mesh_size))\n-\n-def unstack_axes(mesh_spec, axes, x):\n- # axes: list of ints. logical axes of x to split, ordered as in mesh_spec\n- # e.g. zeros(4, 10, 2, 6)\n- # axes (2, 0, None[broadcast_size=10])\n- # results in (8,) nested lists each with (10,6) arrays\n- if axes:\n- ax0 = axes[0]\n- recur = partial(unstack_axes, mesh_spec[1:], axes[1:])\n- if ax0 is None:\n- return [recur(x)] * mesh_spec[0]\n- else:\n- assert x.shape[ax0] == mesh_spec[0]\n- xs = split_array(x, axes[0])\n- return list(map(recur, xs))\n- else:\n- return x\n-\n-def unshard_array(mesh_spec, mesh_map, axis_map, xs):\n- mesh_ndim = len(mesh_spec)\n- mesh_size = onp.prod(mesh_spec)\n- mesh_map_inverted = {v : k for k, v in mesh_map.items()}\n- ordered_idx_names = map(mesh_map_inverted.get, range(mesh_ndim)) # [i,None,k]\n- axes = map(axis_map.get, ordered_idx_names)\n-\n- example_shard = xs[0]\n- num_splits = len([i for i in axes if i is not None])\n- shape = iter(example_shard.shape)\n- newshape = [1 if i in axes else next(shape)\n- for i in range(num_splits + example_shard.ndim)]\n-\n- xs = [x.reshape(newshape) for x in xs]\n- xs = list_reshape(mesh_spec, iter(xs))\n- x = stack_axes(mesh_spec, axes, xs)\n- return x\n-\n-def list_reshape(mesh_spec, flat_xs):\n- if mesh_spec:\n- return [list_reshape(mesh_spec[1:], flat_xs) for _ in range(mesh_spec[0])]\n- else:\n- return next(flat_xs)\n-\n-def stack_axes(mesh_spec, axes, xs):\n- if mesh_spec:\n- if mesh_spec[0] is None:\n- return stack_axes(mesh_spec[1:], axes[1:], xs[0])\n- else:\n- components = map(partial(stack_axes, mesh_spec[1:], axes[1:]), xs)\n- return onp.concatenate(components, axis=axes[0])\n- else:\n- return xs\n-\n-def list_ravel(xs):\n- if isinstance(xs, list):\n- return concatenate(map(list_ravel, xs))\n- else:\n- return [xs]\n-\n-def split_array(x, axis):\n+def split_array(x, num_splits, axis):\n+ \"\"\"A special-case of numpy.split implemented in terms of indexing.\"\"\"\n+ assert x.shape[axis] % num_splits == 0\n+ split_size = x.shape[axis] // num_splits\ndef get_nth_subarray(n):\nidx = [slice(None)] * x.ndim\n- idx[axis] = n\n+ idx[axis] = slice(n * split_size, (n+1) * split_size)\nreturn x[tuple(idx)]\n- return map(get_nth_subarray, range(x.shape[axis]))\n+ return map(get_nth_subarray, range(num_splits))\n### xla_pcall\n@@ -229,20 +194,21 @@ def xla_pcall_impl(fun, *args, **params):\nmesh_axis = params.pop('mesh_axis') # e.g. 0 or 1\nassert not params\n+ global mesh_spec\n+ mesh_spec_ = mesh_spec or (xb.get_replica_count(),)\n+\nflat_args, in_trees = unzip2(map(tree_flatten, args))\nflat_args = concatenate(flat_args)\nfun, out_tree = flatten_fun(fun, in_trees)\n- in_axes = canonicalize_axis_spec(in_trees, in_axes)\n- def canonicalized_out_axes():\n- return canonicalize_axis_spec([out_tree()], out_axes)[0]\n- fun = chunk_transform(fun, axis_name, in_axes, canonicalized_out_axes)\n+ in_axes = canonicalize_in_axis_spec(in_trees, in_axes)\n+ out_axes_thunk = lambda: canonicalize_out_axis_spec(out_tree(), out_axes)\n+ fun = chunk_transform(fun, axis_name, in_axes, out_axes_thunk)\ncompiled_fun = xla_parallel_callable(fun, axis_name, in_axes, mesh_axis,\n- mesh_spec, *map(abstractify, flat_args))\n-\n+ mesh_spec_, *map(abstractify, flat_args))\nleaf_out = out_tree() is leaf\n- flat_ans = compiled_fun(leaf_out, canonicalized_out_axes(), *args)\n+ flat_ans = compiled_fun(leaf_out, out_axes_thunk(), *args)\nif leaf_out:\nreturn flat_ans\n@@ -270,7 +236,7 @@ def xla_parallel_callable(fun, axis_name, in_axes, mesh_axis, mesh_spec,\nchunksize = axis_size // mesh_spec[mesh_axis]\nabstract_args = map(partial(chunk_aval, chunksize), abstract_args, in_axes)\n- device_groups = meshgroups(mesh_spec, mesh_axis)\n+ device_groups = replica_groups(mesh_spec, mesh_axis)\npvals = [PartialVal((aval, core.unit)) for aval in abstract_args]\nwith core.new_master(JaxprTrace, True) as master:\n@@ -283,17 +249,13 @@ def xla_parallel_callable(fun, axis_name, in_axes, mesh_axis, mesh_spec,\ndef execute_replicated(in_axes, mesh_axis, mesh_spec, compiled, pval,\nleaf_out, out_axes, *args):\n- assert False\n- axis_maps = [{axis_name : axes[i] for axis_name, axes in axis_map.items()}\n- for i in range(len(args))]\n- input_bufs = map(partial(shard_array, mesh_spec, mesh_map), axis_maps, args)\n+ input_bufs = map(partial(shard_arg, mesh_spec, mesh_axis), in_axes, args)\nout_bufs = compiled.ExecutePerReplica(zip(*input_bufs))\nif leaf_out:\n- # TODO sharded device persistence, remove the .to_py()\nout_shards = [merge_pvals(out_buf.to_py(), pval) for out_buf in out_bufs]\n- return unshard_array(mesh_spec, mesh_map, out_axis_map, out_shards)\n+ return unshard_output(mesh_spec, mesh_axis, out_axes, out_shards)\nelse:\n- raise NotImplementedError # TODO\n+ raise NotImplementedError # TODO zip*\nxla_pcall_p = core.Primitive('xla_pcall')\n"
}
] | Python | Apache License 2.0 | google/jax | single-axis-var version runs! and some cleanup |
260,335 | 26.01.2019 13:27:04 | 28,800 | 80b9bdc449c4f18bfb4f3e78793430ed28ceaabc | cleanup, fix chunksize bug | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -50,20 +50,19 @@ mesh_spec = None\n### util\n-def chunk_transform(fun, name, in_axes, out_axes_dst):\n+def chunk_transform(fun, chunksize, name, in_axes, out_axes_dst):\n\"\"\"Rewrite SPMD operations to act first on local chunks then cross-replica.\"\"\"\ntemp_name = object() # TODO gensym\nfun = parallel.axisvar_split(fun, name, (temp_name, name))\nfun, out_axes_src = parallel.pmap_transform(fun, temp_name, in_axes)\n- fun = move_output_axis_transform(fun, out_axes_src, out_axes_dst)\n+ fun = move_output_axis_transform(fun, chunksize, out_axes_src, out_axes_dst)\nreturn fun\n@lu.transformation\n-def move_output_axis_transform(src, dst, *args):\n+def move_output_axis_transform(chunksize, src, dst, *args):\n\"\"\"Function transformation that moves output axes from src to dst.\"\"\"\nans = yield args\n- # TODO singleton or chunksize? i think chunksize...\n- yield moveaxis(1, dst(), src(), ans) # inserts singleton if src is None\n+ yield moveaxis(chunksize, dst(), src(), ans)\ndef chunk_aval(chunksize, aval, axis):\n\"\"\"Transform an abstract value's shape to have chunksize extent along axis.\"\"\"\n@@ -143,8 +142,8 @@ def split_array(x, num_splits, axis):\nreturn x[tuple(idx)]\nreturn map(get_nth_subarray, range(num_splits))\n-def axis_size(mesh_spec, mesh_axis, in_axes, abstract_args):\n- \"\"\"Compute the size of mapped axes, checking for errors.\"\"\"\n+def chunk_size(mesh_spec, mesh_axis, in_axes, abstract_args):\n+ \"\"\"Compute the chunk size for mapped axes, checking for errors.\"\"\"\naxis_sizes = {arg.shape[axis] for arg, axis in zip(abstract_args, in_axes)\nif axis is not None}\nif len(axis_sizes) == 0:\n@@ -160,7 +159,8 @@ def axis_size(mesh_spec, mesh_axis, in_axes, abstract_args):\n\"axis index {} with size {}, which does not evenly divide {}.\")\nraise ValueError(msg.format(axis_name, axis_size, mesh_axis,\nmesh_spec[mesh_axis], axis_size))\n- return axis_size\n+\n+ return axis_size // mesh_spec[mesh_axis]\n### xla_pcall\n@@ -219,12 +219,14 @@ def xla_pcall_impl(fun, *args, **params):\nflat_args = concatenate(flat_args)\nfun, out_tree = flatten_fun(fun, in_trees)\n+ abstract_args = map(abstractify, flat_args)\nin_axes = canonicalize_in_axis_spec(in_trees, in_axes)\n+ chunksize = chunk_size(mesh_spec_, mesh_axis, in_axes, abstract_args)\nout_axes_thunk = lambda: canonicalize_out_axis_spec(out_tree(), out_axes)\n- fun = chunk_transform(fun, axis_name, in_axes, out_axes_thunk)\n+ fun = chunk_transform(fun, chunksize, axis_name, in_axes, out_axes_thunk)\ncompiled_fun = xla_parallel_callable(fun, axis_name, in_axes, mesh_axis,\n- mesh_spec_, *map(abstractify, flat_args))\n+ mesh_spec_, *abstract_args)\nleaf_out = out_tree() is leaf\nflat_ans = compiled_fun(leaf_out, out_axes_thunk(), *args)\n@@ -236,8 +238,7 @@ def xla_pcall_impl(fun, *args, **params):\n@lu.memoize\ndef xla_parallel_callable(fun, axis_name, in_axes, mesh_axis, mesh_spec,\n*abstract_args):\n- ax_size = axis_size(mesh_spec, mesh_axis, in_axes, abstract_args)\n- chunksize = ax_size // mesh_spec[mesh_axis]\n+ chunksize = chunk_size(mesh_spec, mesh_axis, in_axes, abstract_args)\nabstract_args = map(partial(chunk_aval, chunksize), abstract_args, in_axes)\ndevice_groups = replica_groups(mesh_spec, mesh_axis)\npvals = [PartialVal((aval, core.unit)) for aval in abstract_args]\n"
}
] | Python | Apache License 2.0 | google/jax | cleanup, fix chunksize bug |
260,335 | 26.01.2019 13:57:19 | 28,800 | a5661ce1b276ddd1de35364c291214365c524297 | hmmm leak bug somewhere | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -58,7 +58,7 @@ def pmap_transform(name, axes, *vals):\nans = yield in_tracers\nout_tracer = trace.full_raise(ans)\nout_val, out_axis = out_tracer.val, out_tracer.axis\n- del master\n+ del master, out_tracer\nyield out_val, out_axis\n@lu.transformation_with_aux\n@@ -213,7 +213,7 @@ def axisvar_split(name, new_names, *args):\nans = yield in_tracers\nout_tracer = trace.full_raise(ans)\nout_val = out_tracer.val\n- del master\n+ del master, out_tracer\nyield out_val\nclass SplitTracer(Tracer):\n@@ -270,6 +270,7 @@ class SplitTrace(Trace):\nreturn SplitTracer(self, name, new_names, val_out)\ndef process_call(self, call_primitive, f, tracers, params):\n+ import ipdb; ipdb.set_trace()\nnames_in, vals_in = unzip2((t.name, t.val) for t in tracers)\nif all(name is None for name in names_in):\nreturn call_primitive.bind(f, *vals, **params)\n@@ -281,6 +282,7 @@ class SplitTrace(Trace):\nreturn SplitTracer(self, name, new_names, val_out)\ndef post_process_call(self, _, out_tracer):\n+ import ipdb; ipdb.set_trace()\nname, new_names, val = out_tracer.name, out_tracer.new_names, out_tracer.val\nmaster = self.master\ndef todo(x):\n@@ -329,7 +331,7 @@ def papply_transform(name, args, axes):\nout_tracer = yield in_tracers\nout_tracer = trace.full_raise(out_tracer)\nout_val = out_tracer.val\n- del master\n+ del master, out_tracer\nyield out_val\nclass PapplyTracer(Tracer):\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -244,6 +244,7 @@ def xla_parallel_callable(fun, axis_name, in_axes, mesh_axis, mesh_spec,\npvals = [PartialVal((aval, core.unit)) for aval in abstract_args]\nwith core.new_master(JaxprTrace, True) as master:\njaxpr, (pval, consts, env) = trace_to_subjaxpr(fun, master).call_wrapped(pvals)\n+ import ipdb; ipdb.set_trace()\nassert not env\ncompiled, result_shape = compile_replicated(jaxpr, device_groups,\nconsts, *abstract_args)\n"
}
] | Python | Apache License 2.0 | google/jax | hmmm leak bug somewhere |
260,335 | 26.01.2019 14:16:47 | 28,800 | afc2b9feb4dad75d5c3d5b73a85bd3aab0ce3e8a | add leak_bug.py for repro | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -270,7 +270,6 @@ class SplitTrace(Trace):\nreturn SplitTracer(self, name, new_names, val_out)\ndef process_call(self, call_primitive, f, tracers, params):\n- import ipdb; ipdb.set_trace()\nnames_in, vals_in = unzip2((t.name, t.val) for t in tracers)\nif all(name is None for name in names_in):\nreturn call_primitive.bind(f, *vals, **params)\n@@ -282,7 +281,6 @@ class SplitTrace(Trace):\nreturn SplitTracer(self, name, new_names, val_out)\ndef post_process_call(self, _, out_tracer):\n- import ipdb; ipdb.set_trace()\nname, new_names, val = out_tracer.name, out_tracer.new_names, out_tracer.val\nmaster = self.master\ndef todo(x):\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -244,7 +244,6 @@ def xla_parallel_callable(fun, axis_name, in_axes, mesh_axis, mesh_spec,\npvals = [PartialVal((aval, core.unit)) for aval in abstract_args]\nwith core.new_master(JaxprTrace, True) as master:\njaxpr, (pval, consts, env) = trace_to_subjaxpr(fun, master).call_wrapped(pvals)\n- import ipdb; ipdb.set_trace()\nassert not env\ncompiled, result_shape = compile_replicated(jaxpr, device_groups,\nconsts, *abstract_args)\n"
},
{
"change_type": "ADD",
"old_path": null,
"new_path": "leak_bug.py",
"diff": "+import jax.numpy as np\n+\n+from jax.interpreters import pxla\n+from jax.interpreters.parallel import psum\n+from jax import pjit\n+\n+import numpy as onp\n+pxla.mesh_spec = (1,)\n+\n+def f(x):\n+ return x - np.log(psum(np.exp(x), 'i'))\n+\n+x = onp.ones((4, 2), onp.float32)\n+f = pjit(f, axis_name='i', in_axes=0, out_axes=0, mesh_axis=0)\n+print f(x)\n"
}
] | Python | Apache License 2.0 | google/jax | add leak_bug.py for repro |
260,335 | 28.01.2019 08:37:49 | 28,800 | 780106f892406590cf6c974e9c19caf59558e01c | moving pxla flattening/chunking to api.py, wip | [
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -32,8 +32,8 @@ import numpy as onp\nfrom . import core\nfrom . import linear_util as lu\nfrom .core import pack, eval_jaxpr\n-from .api_util import (pytree_fun_to_jaxtupletree_fun, apply_jaxtree_fun,\n- pytree_to_jaxtupletree, wraps)\n+from .api_util import (pytree_fun_to_jaxtupletree_fun, pytree_to_jaxtupletree,\n+ pytree_fun_to_flatjaxtuple_fun, apply_jaxtree_fun, wraps)\nfrom .tree_util import (process_pytree, node_types, build_tree, PyTreeDef,\ntree_map, tree_flatten, tree_unflatten, tree_structure,\ntree_transpose)\n@@ -258,19 +258,20 @@ def vmap(fun, in_axes=0, out_axes=0):\nreturn batched_fun\n-def pjit(fun, axis_name, in_axes=0, out_axes=0, mesh_axis=0, static_argnums=()):\n+def pjit(fun, axis_name, in_axes=0, out_axes=0, mesh_axis=0):\n\"\"\"Set up SPMD function for JIT compilation and parallel execution with XLA.\"\"\"\n@wraps(fun)\ndef f_jitted(*args, **kwargs):\nf = lu.wrap_init(fun, kwargs)\n- dyn_argnums = [i for i in range(len(args)) if i not in static_argnums]\n- f, dyn_args = argnums_partial(f, dyn_argnums, args)\n- args_flat, in_trees = unzip2(map(pytree_to_jaxtupletree, dyn_args))\n- check_args(args_flat)\n- jaxtree_fun, out_tree = pytree_fun_to_jaxtupletree_fun(f, in_trees)\n- out_flat = pxla.xla_pcall(jaxtree_fun, *args_flat,\n- axis_name=axis_name, in_axes=in_axes,\n- out_axes=out_axes, mesh_axis=mesh_axis)\n+ args_flat, in_tree = tree_flatten(args)\n+ f, out_tree = pytree_fun_to_flatjaxtuple_fun(f, in_tree)\n+ in_axes_ = pxla.canonicalize_in_axis_spec(in_tree, in_axes)\n+ out_axes_ = lambda: pxla.canonicalize_out_axis_spec(out_tree(), out_axes)\n+ chunksize = pxla.chunk_size(mesh_axis, in_axes_, args_flat)\n+ f = pxla.chunk_transform(f, chunksize, axis_name, in_axes_, out_axes_)\n+ out_flat = pxla.xla_pcall(f, *args_flat, axis_name=axis_name,\n+ in_axes=in_axes_, out_axes=out_axes_,\n+ mesh_axis=mesh_axis)\nreturn build_tree(out_tree(), out_flat)\nf_jitted.__name__ = \"pjit({})\".format(f_jitted.__name__)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/api_util.py",
"new_path": "jax/api_util.py",
"diff": "@@ -17,7 +17,8 @@ from __future__ import division\nfrom __future__ import print_function\nfrom .core import pack\n-from .tree_util import build_tree, process_pytree\n+from .tree_util import (build_tree, process_pytree, tree_flatten,\n+ tree_unflatten, leaf)\nfrom .linear_util import transformation_with_aux\nfrom .util import safe_map, unzip2, partial, curry\n@@ -39,10 +40,10 @@ def get_doc(fun): return getattr(fun, \"__doc__\", \"\")\n@transformation_with_aux\n-def pytree_fun_to_jaxtupletree_fun(in_trees, *args, **kwargs):\n+def pytree_fun_to_jaxtupletree_fun(in_trees, *args):\npy_args = map(build_tree, in_trees, args)\nans = yield py_args\n- yield process_pytree(pack, ans)\n+ yield pytree_to_jaxtupletree(ans)\ndef apply_jaxtree_fun(fun, io_tree, *py_args):\nin_trees_expected, out_tree = io_tree\n@@ -55,3 +56,14 @@ def apply_jaxtree_fun(fun, io_tree, *py_args):\nreturn build_tree(out_tree, ans)\npytree_to_jaxtupletree = partial(process_pytree, pack)\n+\n+\n+@transformation_with_aux\n+def pytree_fun_to_flatjaxtuple_fun(in_tree, *args):\n+ py_args = tuple(tree_unflatten(in_tree, args))\n+ ans = yield py_args\n+ flat_ans, out_tree = tree_flatten(ans)\n+ if out_tree is leaf:\n+ yield flat_ans[0], out_tree\n+ else:\n+ yield pack(flat_ans), out_tree\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -155,7 +155,7 @@ class PmapTrace(Trace):\nreturn val, todo\ndef pack(self, tracers):\n- vals = pack([t.val for t in tracers])\n+ vals = core.pack([t.val for t in tracers])\naxis = tuple(t.axis for t in tracers)\nname = next(t.name for t in tracers if t.name)\nreturn PmapTracer(self, name, vals, axis)\n@@ -290,7 +290,7 @@ class SplitTrace(Trace):\nreturn val, todo\ndef pack(self, tracers):\n- vals = pack([t.val for t in tracers])\n+ vals = core.pack([t.val for t in tracers])\nname = next(t.name for t in tracers if t.name is not None)\nnew_names = next(t.new_names for t in tracers if t.name is not None)\nreturn SplitTracer(self, name, new_names, vals)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -32,10 +32,11 @@ from .. import tree_util\nfrom .. import linear_util as lu\nfrom ..abstract_arrays import ShapedArray\nfrom ..util import partial, unzip2, concatenate, safe_map, prod\n+from ..tree_util import leaf\nfrom ..lib import xla_bridge as xb\nfrom .xla import (flatten_fun, tree_flatten, build_tree, xla_shape,\nxla_destructure, translation_rule, abstractify,\n- xla_shape_to_result_shape, leaf, JTupleTreeDef)\n+ xla_shape_to_result_shape)\nfrom .partial_eval import trace_to_subjaxpr, merge_pvals, JaxprTrace, PartialVal\nfrom .parallel import parallel_translation_rules\nfrom .batching import moveaxis\n@@ -73,35 +74,32 @@ def chunk_aval(chunksize, aval, axis):\nshape[axis] = chunksize\nreturn ShapedArray(tuple(shape), aval.dtype)\n-def canonicalize_in_axis_spec(in_trees, spec):\n+def canonicalize_in_axis_spec(in_tree, spec_tree_prefix):\n\"\"\"Given argument list in_trees, canonicalize and flatten an in_axes spec.\"\"\"\n- spec = (spec,) * len(in_trees) if type(spec) is int else spec\n- spec = map(build_axis_spec_tree, spec, in_trees)\n- return tuple(tree_util.tree_flatten(spec)[0])\n+ spec_tree = build_axis_spec_tree(spec_tree_prefix, in_tree)\n+ return tuple(tree_util.tree_flatten(spec_tree)[0])\n-def canonicalize_out_axis_spec(out_tree, spec):\n+def canonicalize_out_axis_spec(out_tree, spec_tree_prefix):\n\"\"\"Given output out_tree, canonicalize and flatten an out_axes spec.\"\"\"\nif out_tree is leaf:\n- return spec\n+ return spec_tree_prefix\nelse:\n- spec = build_axis_spec_tree(spec, out_tree)\n+ spec_tree = build_axis_spec_tree(spec_tree_prefix, out_tree)\nreturn tuple(tree_util.tree_flatten(spec)[0])\n-def build_axis_spec_tree(spec, tree):\n- \"\"\"Given a JaxTuple treedef, canonicalize an axis spec for that tree.\"\"\"\n- if tree is leaf:\n+def build_axis_spec_tree(spec, treedef):\n+ \"\"\"Given a JaxTuple treedef, canonicalize an axis spec for that treedef.\"\"\"\n+ if treedef is leaf:\nassert type(spec) is int\nreturn spec\n- elif type(tree) is JTupleTreeDef:\n+ else:\nspec_type = type(spec)\nif spec_type is int:\n- return tuple(map(partial(build_axis_spec_tree, spec), tree.child_specs))\n+ return tuple(map(partial(build_axis_spec_tree, spec), treedef.children))\nelif spec_type is tuple:\n- return tuple(map(build_axis_spec_tree, spec, tree.child_specs))\n+ return tuple(map(build_axis_spec_tree, spec, treedef.children))\nelse:\nraise TypeError(spec_type)\n- else:\n- raise TypeError(type(tree))\ndef shard_arg(mesh_spec, mesh_axis, axis, arg):\n\"\"\"Shard and device_put an input array argument along a logical axis.\"\"\"\n@@ -142,8 +140,10 @@ def split_array(x, num_splits, axis):\nreturn x[tuple(idx)]\nreturn map(get_nth_subarray, range(num_splits))\n-def chunk_size(mesh_spec, mesh_axis, in_axes, abstract_args):\n+def chunk_size(mesh_axis, in_axes, abstract_args):\n\"\"\"Compute the chunk size for mapped axes, checking for errors.\"\"\"\n+ global mesh_spec\n+ mesh_spec_ = mesh_spec or (xb.get_replica_count(),)\naxis_sizes = {arg.shape[axis] for arg, axis in zip(abstract_args, in_axes)\nif axis is not None}\nif len(axis_sizes) == 0:\n@@ -154,13 +154,13 @@ def chunk_size(mesh_spec, mesh_axis, in_axes, abstract_args):\nraise ValueError(msg.format(axis_name, axis_sizes))\nelse:\naxis_size = axis_sizes.pop()\n- if axis_size % mesh_spec[mesh_axis]:\n+ if axis_size % mesh_spec_[mesh_axis]:\nmsg = (\"axis name '{}' bound to input axis of size {} mapped to mesh \"\n\"axis index {} with size {}, which does not evenly divide {}.\")\nraise ValueError(msg.format(axis_name, axis_size, mesh_axis,\n- mesh_spec[mesh_axis], axis_size))\n+ mesh_spec_[mesh_axis], axis_size))\n- return axis_size // mesh_spec[mesh_axis]\n+ return axis_size // mesh_spec_[mesh_axis]\n### xla_pcall\n@@ -215,30 +215,14 @@ def xla_pcall_impl(fun, *args, **params):\nglobal mesh_spec\nmesh_spec_ = mesh_spec or (xb.get_replica_count(),)\n- flat_args, in_trees = unzip2(map(tree_flatten, args))\n- flat_args = concatenate(flat_args)\n- fun, out_tree = flatten_fun(fun, in_trees)\n-\n- abstract_args = map(abstractify, flat_args)\n- in_axes = canonicalize_in_axis_spec(in_trees, in_axes)\n- chunksize = chunk_size(mesh_spec_, mesh_axis, in_axes, abstract_args)\n- out_axes_thunk = lambda: canonicalize_out_axis_spec(out_tree(), out_axes)\n- fun = chunk_transform(fun, chunksize, axis_name, in_axes, out_axes_thunk)\n-\ncompiled_fun = xla_parallel_callable(fun, axis_name, in_axes, mesh_axis,\n- mesh_spec_, *abstract_args)\n- leaf_out = out_tree() is leaf\n- flat_ans = compiled_fun(leaf_out, out_axes_thunk(), *args)\n-\n- if leaf_out:\n- return flat_ans\n- else:\n- return build_tree(iter(flat_ans), out_tree())\n+ mesh_spec_, *map(abstractify, args))\n+ return compiled_fun(out_axes(), *args)\n@lu.memoize\ndef xla_parallel_callable(fun, axis_name, in_axes, mesh_axis, mesh_spec,\n*abstract_args):\n- chunksize = chunk_size(mesh_spec, mesh_axis, in_axes, abstract_args)\n+ chunksize = chunk_size(mesh_axis, in_axes, abstract_args)\nabstract_args = map(partial(chunk_aval, chunksize), abstract_args, in_axes)\ndevice_groups = replica_groups(mesh_spec, mesh_axis)\npvals = [PartialVal((aval, core.unit)) for aval in abstract_args]\n@@ -251,10 +235,10 @@ def xla_parallel_callable(fun, axis_name, in_axes, mesh_axis, mesh_spec,\nreturn partial(execute_replicated, in_axes, mesh_axis, mesh_spec, compiled, pval)\ndef execute_replicated(in_axes, mesh_axis, mesh_spec, compiled, pval,\n- leaf_out, out_axes, *args):\n+ out_axes, *args):\ninput_bufs = map(partial(shard_arg, mesh_spec, mesh_axis), in_axes, args)\nout_bufs = compiled.ExecutePerReplica(zip(*input_bufs))\n- if leaf_out:\n+ if True: # TODO\n# TODO device persistence\nout_shards = [merge_pvals(out_buf.to_py(), pval) for out_buf in out_bufs]\nreturn unshard_output(mesh_spec, mesh_axis, out_axes, out_shards)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/xla.py",
"new_path": "jax/interpreters/xla.py",
"diff": "@@ -368,6 +368,7 @@ def xla_shape(x):\n# instead, for values returned to the user, always destructure tuples.\n# The code here is similar to that in tree_util, but is meant to flatten\n# JaxTuple trees only.\n+# TODO(mattjj): since pjit does flattening in api.py, can move/de-duplicate this\n@transformation_with_aux\ndef flatten_fun(in_trees, *flat_args):\n"
},
{
"change_type": "MODIFY",
"old_path": "leak_bug.py",
"new_path": "leak_bug.py",
"diff": "@@ -8,8 +8,9 @@ import numpy as onp\npxla.mesh_spec = (1,)\ndef f(x):\n- return x - np.log(psum(np.exp(x), 'i'))\n+ return x - psum(x, 'i')\n-x = onp.ones((4, 2), onp.float32)\n+x = onp.arange(8., dtype=onp.float32).reshape(4, 2)\nf = pjit(f, axis_name='i', in_axes=0, out_axes=0, mesh_axis=0)\nprint f(x)\n+print x - x.sum(0)\n"
}
] | Python | Apache License 2.0 | google/jax | moving pxla flattening/chunking to api.py, wip |
260,335 | 28.01.2019 09:35:57 | 28,800 | 2487eb2d04725d1d5bcc5d6c39a27e1b270520c1 | woo tuple output works | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -86,7 +86,7 @@ def canonicalize_out_axis_spec(out_tree, spec_tree_prefix):\nreturn spec_tree_prefix\nelse:\nspec_tree = build_axis_spec_tree(spec_tree_prefix, out_tree)\n- return tuple(tree_util.tree_flatten(spec)[0])\n+ return tuple(tree_util.tree_flatten(spec_tree)[0])\ndef build_axis_spec_tree(spec, treedef):\n\"\"\"Given a JaxTuple treedef, canonicalize an axis spec for that treedef.\"\"\"\n@@ -249,12 +249,12 @@ def execute_replicated(in_axes, mesh_axis, mesh_spec, compiled, pval,\nout_axes, *args):\ninput_bufs = map(partial(shard_arg, mesh_spec, mesh_axis), in_axes, args)\nout_bufs = compiled.ExecutePerReplica(zip(*input_bufs))\n- if True: # TODO\n- # TODO device persistence\n- out_shards = [merge_pvals(out_buf.to_py(), pval) for out_buf in out_bufs]\n+ out_shards = [merge_pvals(buf.to_py(), pval) for buf in out_bufs] # TODO\n+ if type(out_axes) is int:\nreturn unshard_output(mesh_spec, mesh_axis, out_axes, out_shards)\nelse:\n- raise NotImplementedError # TODO zip*\n+ return map(partial(unshard_output, mesh_spec, mesh_axis), out_axes,\n+ zip(*out_shards))\nxla_pcall_p = core.Primitive('xla_pcall')\n"
},
{
"change_type": "MODIFY",
"old_path": "leak_bug.py",
"new_path": "leak_bug.py",
"diff": "@@ -7,10 +7,10 @@ from jax import pjit\nimport numpy as onp\ndef f(x):\n- return x - psum(x, 'i')\n+ return (x - psum(x, 'i'),)\nx = onp.arange(8., dtype=onp.float32).reshape(4, 2)\nf = pjit(f, axis_name='i', in_axes=0, out_axes=0, mesh_axis=0)\nprint f(x)\n-print x - x.sum(0)\n+print (x - x.sum(0),)\n"
}
] | Python | Apache License 2.0 | google/jax | woo tuple output works |
260,335 | 28.01.2019 10:09:42 | 28,800 | 32cda396892ae4b7f13507eb2e7d33ea76803a29 | remove chunk transform from api.py for now | [
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -306,24 +306,6 @@ def axisvar_split(fun, name, new_names):\nreturn split_fun\n-def chunk(fun, name, chunksize, in_axes=0, out_axes=0):\n- \"\"\"Stage SPMD primitives to first operate on chunks, then use collectives.\"\"\"\n- temp_name = object()\n-\n- def chunked_fun(*args, **kwargs):\n- f = lu.wrap_init(fun, kwargs)\n- in_axes_ = in_axes if isinstance(in_axes, (list, tuple)) else (in_axes,) * len(args)\n- in_flat, in_trees = unzip2(map(pytree_to_jaxtupletree, args))\n- f, out_tree = pytree_fun_to_jaxtupletree_fun(f, in_trees)\n- f = parallel.axisvar_split(f, name, (temp_name, name))\n- reshape = partial(parallel.reshape_axis, chunksize)\n- reshaped_args = map(reshape, in_axes_, args)\n- out_flat = parallel.pmap(f, temp_name, reshaped_args, in_axes_, out_axes)\n- return build_tree(out_tree(), out_flat)\n-\n- return chunked_fun\n-\n-\ndef papply(fun, in_axes=0):\n\"\"\"Apply a function using parallel computation by sharding inputs.\"\"\"\naxis_name = parallel.newvar()\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -184,7 +184,7 @@ def psum_pmap_rule(val, axis):\nreturn val.sum(axis), None\ndef psum_parallel_translation_rule(c, val, device_groups):\n- # return c.CrossReplicaSum(val, device_grp) # TODO\n+ # return c.CrossReplicaSum(val, device_grp) # TODO needs updated jaxlib\nreturn c.CrossReplicaSum(val)\npsum_p = PmapPrimitive('psum')\n@@ -228,7 +228,11 @@ class SplitTracer(Tracer):\nreturn core.get_aval(self.val)\ndef unpack(self):\n- raise NotImplementedError # TODO(mattjj)\n+ if self.name is None:\n+ return self.full_lower()\n+ else:\n+ elt_tracer = partial(SplitTracer, self.trace, self.name, self.new_names)\n+ return map(elt_tracer, self.val)\ndef full_lower(self):\nif self.name is None:\n@@ -344,7 +348,7 @@ class PapplyTracer(Tracer):\nreturn batching.get_aval(self.val)\ndef unpack(self):\n- raise NotImplementedError # TODO\n+ raise NotImplementedError # TODO(mattjj,frostig)\ndef full_lower(self):\nif self.axis is None:\n@@ -373,10 +377,10 @@ class PapplyTrace(Trace):\nreturn PapplyTracer(self, name, val_out, axis_out)\ndef process_call(self, call_primitive, f, tracers, params):\n- raise NotImplementedError # TODO(mattjj)\n+ raise NotImplementedError # TODO(mattjj,frostig)\ndef post_process_call(self, _, out_tracer):\n- raise NotImplementedError # TODO(mattjj)\n+ raise NotImplementedError # TODO(mattjj,frostig)\ndef pack(self, tracers):\nvals = core.pack([t.val for t in tracers])\n"
},
{
"change_type": "DELETE",
"old_path": "leak_bug.py",
"new_path": null,
"diff": "-import jax.numpy as np\n-\n-from jax.interpreters import pxla\n-from jax.interpreters.parallel import psum\n-from jax import pjit\n-\n-import numpy as onp\n-\n-def f(x):\n- return (x - psum(x, 'i'),)\n-\n-x = onp.arange(8., dtype=onp.float32).reshape(4, 2)\n-f = pjit(f, axis_name='i', in_axes=0, out_axes=0, mesh_axis=0)\n-\n-print f(x)\n-print (x - x.sum(0),)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/parallel_test.py",
"new_path": "tests/parallel_test.py",
"diff": "@@ -23,7 +23,7 @@ from absl.testing import parameterized\nimport jax.numpy as np\nfrom jax import test_util as jtu\nfrom jax import lax\n-from jax.api import pmap, papply, jit, make_jaxpr, axisvar_split, chunk\n+from jax.api import pmap, papply, jit, make_jaxpr, axisvar_split\nfrom jax.linear_util import wrap_init\nfrom jax.interpreters.parallel import psum, scatter_like\n@@ -134,14 +134,6 @@ class SplitTest(jtu.JaxTestCase):\nexpected = onp.sum(onp.sin(x))\nself.assertAllClose(ans, expected, check_dtypes=False)\n- def testChunkingSum(self):\n- f = lambda x: x - psum(x, 'i')\n- x = onp.ones((4, 2))\n- fchunked = chunk(f, 'i', 2)\n- ans = pmap(fchunked, 'i')(x)\n- expected = pmap(f, 'i')(x)\n- self.assertAllClose(ans, expected, check_dtypes=False)\n-\nif __name__ == '__main__':\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | remove chunk transform from api.py for now |
260,335 | 28.01.2019 10:23:00 | 28,800 | 1a494d0752c527def252f8c2e0132fed7692a35c | add post_process_call for vmap (untested) | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/batching.py",
"new_path": "jax/interpreters/batching.py",
"diff": "@@ -131,7 +131,13 @@ class BatchTrace(Trace):\nreturn BatchTracer(self, val_out, dim_out())\ndef post_process_call(self, _, out_tracer):\n- raise NotImplementedError # TODO(mattjj,dougalm)\n+ val, dim = out_tracer.val, out_tracer.batch_dim\n+ master = self.master\n+ def todo(x):\n+ trace = BatchTrace(master, core.cur_sublevel())\n+ return BatchTracer(trace, val, dim)\n+\n+ return val, todo\ndef pack(self, tracers):\nvals = pack([t.val for t in tracers])\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -216,6 +216,14 @@ def axisvar_split(name, new_names, *args):\ndel master, out_tracer\nyield out_val\n+@lu.transformation\n+def axisvar_split_subtrace(master, name, new_names, *vals):\n+ trace = SplitTrace(master, core.cur_sublevel())\n+ ans = yield map(partial(SplitTracer, trace, name, new_names), vals)\n+ out_tracer = trace.full_raise(ans)\n+ out_val = out_tracer.val\n+ yield out_val\n+\nclass SplitTracer(Tracer):\ndef __init__(self, trace, name, new_names, val):\nself.trace = trace\n"
}
] | Python | Apache License 2.0 | google/jax | add post_process_call for vmap (untested) |
260,335 | 28.01.2019 11:13:34 | 28,800 | 1360a7031d4389f2ecdef24ce3190a88e5f8f794 | add trivial pjit tests | [
{
"change_type": "ADD",
"old_path": null,
"new_path": "tests/pjit_test.py",
"diff": "+# Copyright 2018 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 __future__ import absolute_import\n+from __future__ import division\n+from __future__ import print_function\n+\n+import numpy as onp\n+from absl.testing import absltest\n+from absl.testing import parameterized\n+\n+import jax.numpy as np\n+from jax import test_util as jtu\n+from jax.api import pjit\n+from jax.interpreters.parallel import psum\n+\n+from jax.config import config\n+config.parse_flags_with_absl()\n+\n+\n+class PmapTest(jtu.JaxTestCase):\n+\n+ @jtu.skip_on_devices(\"gpu\")\n+ def testBasic(self):\n+ f = lambda x: x - psum(x, 'i')\n+ x = onp.arange(8., dtype=onp.float32).reshape(4, 2)\n+ f = pjit(f, axis_name='i', in_axes=0, out_axes=0, mesh_axis=0)\n+ ans = f(x)\n+ expected = x - x.sum(0)\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+ @jtu.skip_on_devices(\"gpu\")\n+ def testTupleOutput(self):\n+ f = lambda x: (x - psum(x, 'i'),)\n+ x = onp.arange(8., dtype=onp.float32).reshape(4, 2)\n+ f = pjit(f, axis_name='i', in_axes=0, out_axes=0, mesh_axis=0)\n+ ans = f(x)\n+ expected = (x - x.sum(0),)\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+ @jtu.skip_on_devices(\"gpu\")\n+ def testTupleInput(self):\n+ f = lambda x: x[0] - psum(x[0], 'i')\n+ x = onp.arange(8., dtype=onp.float32).reshape(4, 2)\n+ f = pjit(f, axis_name='i', in_axes=0, out_axes=0, mesh_axis=0)\n+ ans = f((x,))\n+ expected = x - x.sum(0)\n+ self.assertAllClose(ans, expected, check_dtypes=False)\n+\n+\n+if __name__ == '__main__':\n+ absltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | add trivial pjit tests |
260,335 | 28.01.2019 12:55:24 | 28,800 | 5f5baaa4cdea64545d3e546cbf595a3c835e6f4c | tweak tests for internal purposes | [
{
"change_type": "MODIFY",
"old_path": "jax/test_util.py",
"new_path": "jax/test_util.py",
"diff": "@@ -63,7 +63,7 @@ def numpy_eq(x, y):\ntesting_tpu = FLAGS.jax_test_dut and FLAGS.jax_test_dut.startswith(\"tpu\")\ntesting_x32 = not FLAGS.jax_enable_x64\nif testing_tpu or testing_x32:\n- return onp.allclose(x, y, 1e-3, 1e-3)\n+ return onp.allclose(x, y, 1e-3, 1e-3, equal_nan=testing_tpu)\nelse:\nreturn onp.allclose(x, y)\n@@ -76,7 +76,7 @@ def numpy_close(a, b, atol=ATOL, rtol=RTOL, equal_nan=False):\nrtol = max(rtol, 1e-1)\nassert a.shape == b.shape\nreturn onp.allclose(a, b, atol=atol * a.size, rtol=rtol * b.size,\n- equal_nan=equal_nan)\n+ equal_nan=equal_nan or testing_tpu)\ndef check_eq(xs, ys):\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/batching_test.py",
"new_path": "tests/batching_test.py",
"diff": "@@ -293,6 +293,7 @@ class BatchingTest(jtu.JaxTestCase):\nexpected = np.array([True, False])\nself.assertAllClose(ans, expected, check_dtypes=True)\n+ @jtu.skip_on_devices(\"tpu\")\ndef testHessian(self):\n# test based on code from sindhwani@google\ndef fun(x, t):\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_test.py",
"new_path": "tests/lax_test.py",
"diff": "@@ -1730,6 +1730,7 @@ class LaxAutodiffTest(jtu.JaxTestCase):\nfor lhs_shape in [(2,), (3, 2)] for rhs_shape in [(2,), (2, 4)]\nfor dtype in float_dtypes))\n@jtu.skip_on_flag(\"jax_xla_backend\", \"xrt\")\n+ @jtu.skip_on_devices(\"tpu\")\ndef testDotGrad(self, lhs_shape, rhs_shape, dtype, rng):\ntol = 1e-1 if num_float_bits(dtype) == 32 else 1e-3\nlhs = rng(lhs_shape, dtype)\n"
}
] | Python | Apache License 2.0 | google/jax | tweak tests for internal purposes |
260,335 | 28.01.2019 14:11:11 | 28,800 | d968e1e5729bee9d6d21a087eb5989e1110a65f6 | fix replica_groups logic | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -184,7 +184,9 @@ def psum_pmap_rule(val, axis):\nreturn val.sum(axis), None\ndef psum_parallel_translation_rule(c, val, device_groups):\n- # return c.CrossReplicaSum(val, device_grp) # TODO needs updated jaxlib\n+ if len(device_groups) > 1:\n+ return c.CrossReplicaSum(val, device_groups)\n+ else:\nreturn c.CrossReplicaSum(val)\npsum_p = PmapPrimitive('psum')\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -129,7 +129,8 @@ def replica_groups(mesh_spec, mesh_axis):\n\"\"\"Given a mesh axis along which to operate, compute XLA replica_groups.\"\"\"\ngroups = onp.split(onp.arange(prod(mesh_spec)).reshape(mesh_spec),\nmesh_spec[mesh_axis], axis=mesh_axis)\n- return tuple(tuple(group.ravel()) for group in groups)\n+ groups = map(onp.ravel, groups)\n+ return tuple(tuple(group) for group in zip(*groups))\ndef split_array(x, num_splits, axis):\n\"\"\"A special-case of numpy.split implemented in terms of indexing.\"\"\"\n"
}
] | Python | Apache License 2.0 | google/jax | fix replica_groups logic |
260,554 | 28.01.2019 14:33:57 | 28,800 | a15bad401f33ff01e9e80df609f70a3bc11b50a0 | Added batching rules for convolutions + pooling.
Added batching rules:
conv_general_dilated_batch_rule
select_and_scatter_add_batch_rule
reduce_window_max_batch_rule
reduce_window_sum_batch_rule | [
{
"change_type": "MODIFY",
"old_path": "jax/lax.py",
"new_path": "jax/lax.py",
"diff": "@@ -1128,13 +1128,61 @@ def conv_general_dilated_translation_rule(\nreturn c.ConvGeneralDilated(lhs, rhs, window_strides, padding, lhs_dilation,\nrhs_dilation, dimension_numbers)\n+def conv_general_dilated_batch_rule(\n+ batched_args, batch_dims, window_strides, padding,\n+ lhs_dilation, rhs_dilation, dimension_numbers, **unused_kwargs):\n+ lhs, rhs = batched_args\n+ lhs_bdim, rhs_bdim = batch_dims\n+ lhs_dim, rhs_dim, out_dim = dimension_numbers\n+\n+ if lhs_bdim is not None and rhs_bdim is not None:\n+ lhs = batching.move_dim_to_front(lhs, lhs_bdim)\n+ rhs = batching.move_dim_to_front(rhs, rhs_bdim)\n+\n+ outputs = [\n+ conv_general_dilated(l, r, window_strides, padding,\n+ lhs_dilation, rhs_dilation, dimension_numbers)\n+ for l, r in zip(lhs, rhs)]\n+ outputs = [reshape(out, (1,) + out.shape) for out in outputs]\n+ outputs = concatenate(outputs, 0)\n+ return outputs, 0\n+\n+ elif lhs_bdim is not None:\n+ # Currently we don't handle cases where the batch dimension of the\n+ # convolution isn't the first dimension.\n+ if lhs_dim[0] != 0 or out_dim[0] != 0:\n+ raise NotImplementedError\n+ lhs = batching.move_dim_to_front(lhs, lhs_dim[0])\n+ lhs = batching.move_dim_to_front(lhs, lhs_bdim)\n+\n+ batched_size = lhs.shape[0]\n+ n_size = lhs.shape[1]\n+\n+ lhs = reshape(lhs, (batched_size * n_size,) + lhs.shape[2:])\n+ outputs = conv_general_dilated(\n+ lhs, rhs, window_strides, padding,\n+ lhs_dilation, rhs_dilation, dimension_numbers)\n+ outputs = reshape(outputs, (batched_size, n_size,) + outputs.shape[1:])\n+\n+ return outputs, 0\n+ elif rhs_bdim is not None:\n+ # TODO(schsam): Consider a loop instead of unrolling.\n+ rhs = batching.move_dim_to_front(rhs, rhs_bdim)\n+ outputs = [\n+ conv_general_dilated(lhs, x, window_strides, padding,\n+ lhs_dilation, rhs_dilation, dimension_numbers)\n+ for x in rhs]\n+ outputs = [reshape(out, (1,) + out.shape) for out in outputs]\n+ outputs = concatenate(outputs, 0)\n+ return outputs, 0\nconv_general_dilated_p = standard_primitive(\nconv_general_dilated_shape_rule, conv_general_dilated_dtype_rule,\n'conv_general_dilated', conv_general_dilated_translation_rule)\nad.defbilinear(conv_general_dilated_p,\nconv_general_dilated_transpose_lhs,\nconv_general_dilated_transpose_rhs)\n-\n+batching.primitive_batchers[\n+ conv_general_dilated_p] = conv_general_dilated_batch_rule\ndef dot_shape_rule(lhs, rhs):\nif lhs.ndim == 0 or rhs.ndim == 0:\n@@ -2291,12 +2339,26 @@ def reduce_window_sum_transpose_rule(cotangent, window_dimensions,\nxla_bridge.get_xla_client().PaddingType.VALID)\nassert result.shape == input_shape\nreturn [result]\n+def reduce_window_sum_batch_rule(\n+ batched_args, bdims, window_dimensions, window_strides, padding, **kwargs):\n+ operand, = batched_args\n+ bdim, = bdims\n+\n+ if bdim is not None:\n+ window_dimensions = \\\n+ window_dimensions[:bdim] + (1,) + window_dimensions[bdim:]\n+ window_strides = window_strides[:bdim] + (1,) + window_strides[bdim:]\n+\n+ oprand = _reduce_window_sum(\n+ operand, window_dimensions, window_strides, padding)\n+\n+ return oprand, 0\nreduce_window_sum_p = standard_primitive(\nreduce_window_sum_shape_rule, _input_dtype, 'reduce_window_sum',\nreduce_window_sum_translation_rule)\nad.deflinear(reduce_window_sum_p, reduce_window_sum_transpose_rule)\n-\n+batching.primitive_batchers[reduce_window_sum_p] = reduce_window_sum_batch_rule\ndef reduce_window_chooser_translation_rule(\nprim, identity, c, operand, window_dimensions, window_strides, padding):\n@@ -2338,6 +2400,20 @@ def reduce_window_shape_tuple(operand_shape, window_dimensions, window_strides,\nonp.subtract(operand_padded, window_dimensions), window_strides) + 1\nreturn tuple(t)\n+def reduce_window_max_batch_rule(\n+ batched_args, bdims, window_dimensions, window_strides, padding, **kwargs):\n+ operand, = batched_args\n+ bdim, = bdims\n+\n+ if bdim is not None:\n+ window_dimensions = \\\n+ window_dimensions[:bdim] + (1,) + window_dimensions[bdim:]\n+ window_strides = window_strides[:bdim] + (1,) + window_strides[bdim:]\n+\n+ operand = _reduce_window_max(\n+ operand, window_dimensions, window_strides, padding)\n+\n+ return operand, 0\nreduce_window_max_translation_rule = partial(\nreduce_window_chooser_translation_rule, max_p, _get_max_identity)\n@@ -2345,7 +2421,7 @@ reduce_window_max_p = standard_primitive(\ncommon_reduce_window_shape_rule, _input_dtype, 'reduce_window_max',\nreduce_window_max_translation_rule)\nad.defjvp(reduce_window_max_p, partial(reduce_window_chooser_jvp_rule, max_p))\n-\n+batching.primitive_batchers[reduce_window_max_p] = reduce_window_max_batch_rule\nreduce_window_min_translation_rule = partial(\nreduce_window_chooser_translation_rule, min_p, _get_min_identity)\n@@ -2402,12 +2478,40 @@ def select_and_scatter_add_transpose(\nwindow_strides, padding)\nreturn [result, None]\n+def select_and_scatter_add_batch_rule(batched_args, batch_dims, **kwargs):\n+ source, operand = batched_args\n+ s_bdims, o_bdims = batch_dims\n+\n+ if s_bdims is not None and o_bdims is not None:\n+ source = batching.move_dim_to_front(source, s_bdims)\n+ operand = batching.move_dim_to_front(operand, o_bdims)\n+ outputs = [\n+ _select_and_scatter_add(s, o, **kwargs) for s, o in zip(source, operand)]\n+ outputs = [reshape(out, (1,) + out.shape) for out in outputs]\n+ outputs = concatenate(outputs, 0)\n+ return outputs, 0\n+ elif s_bdims is not None:\n+ source = batching.move_dim_to_front(source, s_bdims)\n+ outputs = [\n+ _select_and_scatter_add(s, operand, **kwargs) for s in source]\n+ outputs = [reshape(out, (1,) + out.shape) for out in outputs]\n+ outputs = concatenate(outputs, 0)\n+ return outputs, 0\n+ elif o_bdims is not None:\n+ operand = batching.move_dim_to_front(operand, o_bdims)\n+ outputs = [\n+ _select_and_scatter_add(source, o, **kwargs) for o in operand]\n+ outputs = [reshape(out, (1,) + out.shape) for out in outputs]\n+ outputs = concatenate(outputs, 0)\n+ return outputs, 0\n+\nselect_and_scatter_add_p = standard_primitive(\nselect_and_scatter_add_shape_rule, _input_dtype, 'select_and_scatter_add',\nselect_and_scatter_add_translation)\nad.primitive_transposes[select_and_scatter_add_p] = \\\nselect_and_scatter_add_transpose\n-\n+batching.primitive_batchers[select_and_scatter_add_p] = \\\n+ select_and_scatter_add_batch_rule\ndef _select_and_gather_add_shape_rule(\ntangents, operand, select_prim, pair_select_jaxpr, pair_select_consts,\n"
}
] | Python | Apache License 2.0 | google/jax | Added batching rules for convolutions + pooling.
Added batching rules:
conv_general_dilated_batch_rule
select_and_scatter_add_batch_rule
reduce_window_max_batch_rule
reduce_window_sum_batch_rule |
260,554 | 28.01.2019 14:37:49 | 28,800 | dfced4fcc56670832341fbf911ec1646ad033a6d | Added tests for conv + pooling batching rules. | [
{
"change_type": "MODIFY",
"old_path": "tests/batching_test.py",
"new_path": "tests/batching_test.py",
"diff": "@@ -367,6 +367,96 @@ class BatchingTest(jtu.JaxTestCase):\nself.assertAllClose(sv, onp.broadcast_to(v[0, ::-1], (3, 4)),\ncheck_dtypes=True)\n+ def testConvGeneralDilated(self):\n+ W = onp.random.randn(3, 3, 1, 5)\n+ X = onp.random.randn(10, 5, 5, 1)\n+\n+ def f(params, x):\n+ one = (1, 1)\n+ dimension_numbers = ('NHWC', 'HWIO', 'NHWC')\n+ y = lax.conv_general_dilated(\n+ x, params, one, 'SAME', one, one, dimension_numbers)\n+ return y\n+ grad_loss = grad(lambda params, x: np.mean(f(params, x) ** 2))\n+\n+ # NOTE(schsam): We have to do this reshape thing because the current\n+ # implementation of conv general expects a 4d-matrix.\n+\n+ # Test forward prop.\n+ per_example = vmap(partial(f, W))(np.reshape(X, (10, 1, 5, 5, 1)))\n+ per_example = np.reshape(per_example, (10, 5, 5, 5))\n+ per_example_direct = f(W, X)\n+ self.assertAllClose(per_example, per_example_direct, check_dtypes=True)\n+\n+ # Test gradients.\n+ per_example = vmap(partial(grad_loss, W))(np.reshape(X, (10, 1, 5, 5, 1)))\n+ per_example_direct = []\n+ for i in range(10):\n+ g = grad_loss(W, np.reshape(X[i], (1, 5, 5, 1)))\n+ per_example_direct += [\n+ np.reshape(g, (1,) + g.shape)]\n+ per_example_direct = np.concatenate(per_example_direct, axis=0)\n+ self.assertAllClose(per_example, per_example_direct, check_dtypes=True)\n+\n+ def testMaxPool(self):\n+ W = onp.random.randn(3, 3, 1, 5)\n+ X = onp.random.randn(10, 5, 5, 1)\n+\n+ def f(params, x):\n+ one = (1, 1)\n+ dimension_numbers = ('NHWC', 'HWIO', 'NHWC')\n+ y = lax.conv_general_dilated(\n+ x, params, one, 'SAME', one, one, dimension_numbers)\n+ y = lax.reduce_window(\n+ y, -np.inf, lax.max, (1, 2, 2, 1), (1, 1, 1, 1), 'SAME')\n+ return y\n+ grad_loss = grad(lambda params, x: np.mean(f(params, x) ** 2))\n+\n+ # Test forward prop.\n+ per_example = vmap(partial(f, W))(np.reshape(X, (10, 1, 5, 5, 1)))\n+ per_example = np.reshape(per_example, (10, 5, 5, 5))\n+ per_example_direct = f(W, X)\n+ self.assertAllClose(per_example, per_example_direct, check_dtypes=True)\n+\n+ # Test gradients.\n+ per_example = vmap(partial(grad_loss, W))(np.reshape(X, (10, 1, 5, 5, 1)))\n+ per_example_direct = []\n+ for i in range(10):\n+ g = grad_loss(W, np.reshape(X[i], (1, 5, 5, 1)))\n+ per_example_direct += [\n+ np.reshape(g, (1,) + g.shape)]\n+ per_example_direct = np.concatenate(per_example_direct, axis=0)\n+ self.assertAllClose(per_example, per_example_direct, check_dtypes=True)\n+\n+ def testSumPool(self):\n+ W = onp.random.randn(3, 3, 1, 5)\n+ X = onp.random.randn(10, 5, 5, 1)\n+\n+ def f(params, x):\n+ one = (1, 1)\n+ dimension_numbers = ('NHWC', 'HWIO', 'NHWC')\n+ y = lax.conv_general_dilated(\n+ x, params, one, 'SAME', one, one, dimension_numbers)\n+ y = lax.reduce_window(\n+ y, 0.0, lax.add, (1, 2, 2, 1), (1, 1, 1, 1), 'SAME')\n+ return y\n+ grad_loss = grad(lambda params, x: np.mean(f(params, x) ** 2))\n+\n+ # Test forward prop.\n+ per_example = vmap(partial(f, W))(np.reshape(X, (10, 1, 5, 5, 1)))\n+ per_example = np.reshape(per_example, (10, 5, 5, 5))\n+ per_example_direct = f(W, X)\n+ self.assertAllClose(per_example, per_example_direct, check_dtypes=True)\n+\n+ # Test gradients.\n+ per_example = vmap(partial(grad_loss, W))(np.reshape(X, (10, 1, 5, 5, 1)))\n+ per_example_direct = []\n+ for i in range(10):\n+ g = grad_loss(W, np.reshape(X[i], (1, 5, 5, 1)))\n+ per_example_direct += [\n+ np.reshape(g, (1,) + g.shape)]\n+ per_example_direct = np.concatenate(per_example_direct, axis=0)\n+ self.assertAllClose(per_example, per_example_direct, check_dtypes=True)\nif __name__ == '__main__':\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | Added tests for conv + pooling batching rules. |
260,554 | 28.01.2019 15:26:47 | 28,800 | 6181560ef026597a0eefd5a1af6e27e40ea3a673 | Changed tests to always use float32, for conv compatibility. | [
{
"change_type": "MODIFY",
"old_path": "tests/batching_test.py",
"new_path": "tests/batching_test.py",
"diff": "@@ -368,8 +368,8 @@ class BatchingTest(jtu.JaxTestCase):\ncheck_dtypes=True)\ndef testConvGeneralDilated(self):\n- W = onp.random.randn(3, 3, 1, 5)\n- X = onp.random.randn(10, 5, 5, 1)\n+ W = np.array(onp.random.randn(3, 3, 1, 5), dtype=onp.float32)\n+ X = np.array(onp.random.randn(10, 5, 5, 1), dtype=onp.float32)\ndef f(params, x):\none = (1, 1)\n@@ -399,8 +399,8 @@ class BatchingTest(jtu.JaxTestCase):\nself.assertAllClose(per_example, per_example_direct, check_dtypes=True)\ndef testMaxPool(self):\n- W = onp.random.randn(3, 3, 1, 5)\n- X = onp.random.randn(10, 5, 5, 1)\n+ W = np.array(onp.random.randn(3, 3, 1, 5), dtype=onp.float32)\n+ X = np.array(onp.random.randn(10, 5, 5, 1), dtype=onp.float32)\ndef f(params, x):\none = (1, 1)\n@@ -429,8 +429,8 @@ class BatchingTest(jtu.JaxTestCase):\nself.assertAllClose(per_example, per_example_direct, check_dtypes=True)\ndef testSumPool(self):\n- W = onp.random.randn(3, 3, 1, 5)\n- X = onp.random.randn(10, 5, 5, 1)\n+ W = np.array(onp.random.randn(3, 3, 1, 5), dtype=onp.float32)\n+ X = np.array(onp.random.randn(10, 5, 5, 1), dtype=onp.float32)\ndef f(params, x):\none = (1, 1)\n"
}
] | Python | Apache License 2.0 | google/jax | Changed tests to always use float32, for conv compatibility. |
260,554 | 28.01.2019 19:08:05 | 28,800 | 3b8d43cefae3e37668c82ea4bd4d9ec61ccabff7 | Misc. small fixes. | [
{
"change_type": "MODIFY",
"old_path": "jax/lax.py",
"new_path": "jax/lax.py",
"diff": "@@ -1136,9 +1136,9 @@ def conv_general_dilated_batch_rule(\nlhs_dim, rhs_dim, out_dim = dimension_numbers\nif lhs_bdim is not None and rhs_bdim is not None:\n+ #TODO(#212): use a map construct instead of unrolling.\nlhs = batching.move_dim_to_front(lhs, lhs_bdim)\nrhs = batching.move_dim_to_front(rhs, rhs_bdim)\n-\noutputs = [\nconv_general_dilated(l, r, window_strides, padding,\nlhs_dilation, rhs_dilation, dimension_numbers)\n@@ -1152,12 +1152,10 @@ def conv_general_dilated_batch_rule(\n# convolution isn't the first dimension.\nif lhs_dim[0] != 0 or out_dim[0] != 0:\nraise NotImplementedError\n- lhs = batching.move_dim_to_front(lhs, lhs_dim[0])\n- lhs = batching.move_dim_to_front(lhs, lhs_bdim)\n+ lhs = batching.move_dim_to_front(lhs, lhs_bdim)\nbatched_size = lhs.shape[0]\nn_size = lhs.shape[1]\n-\nlhs = reshape(lhs, (batched_size * n_size,) + lhs.shape[2:])\noutputs = conv_general_dilated(\nlhs, rhs, window_strides, padding,\n@@ -1166,7 +1164,7 @@ def conv_general_dilated_batch_rule(\nreturn outputs, 0\nelif rhs_bdim is not None:\n- # TODO(schsam): Consider a loop instead of unrolling.\n+ #TODO(#212): use a map construct instead of unrolling.\nrhs = batching.move_dim_to_front(rhs, rhs_bdim)\noutputs = [\nconv_general_dilated(lhs, x, window_strides, padding,\n@@ -2339,6 +2337,7 @@ def reduce_window_sum_transpose_rule(cotangent, window_dimensions,\nxla_bridge.get_xla_client().PaddingType.VALID)\nassert result.shape == input_shape\nreturn [result]\n+\ndef reduce_window_sum_batch_rule(\nbatched_args, bdims, window_dimensions, window_strides, padding, **kwargs):\noperand, = batched_args\n@@ -2483,6 +2482,7 @@ def select_and_scatter_add_batch_rule(batched_args, batch_dims, **kwargs):\ns_bdims, o_bdims = batch_dims\nif s_bdims is not None and o_bdims is not None:\n+ #TODO(#212): use a map construct instead of unrolling.\nsource = batching.move_dim_to_front(source, s_bdims)\noperand = batching.move_dim_to_front(operand, o_bdims)\noutputs = [\n@@ -2491,6 +2491,7 @@ def select_and_scatter_add_batch_rule(batched_args, batch_dims, **kwargs):\noutputs = concatenate(outputs, 0)\nreturn outputs, 0\nelif s_bdims is not None:\n+ #TODO(#212): use a map construct instead of unrolling.\nsource = batching.move_dim_to_front(source, s_bdims)\noutputs = [\n_select_and_scatter_add(s, operand, **kwargs) for s in source]\n@@ -2498,6 +2499,7 @@ def select_and_scatter_add_batch_rule(batched_args, batch_dims, **kwargs):\noutputs = concatenate(outputs, 0)\nreturn outputs, 0\nelif o_bdims is not None:\n+ #TODO(#212): use a map construct instead of unrolling.\noperand = batching.move_dim_to_front(operand, o_bdims)\noutputs = [\n_select_and_scatter_add(source, o, **kwargs) for o in operand]\n"
}
] | Python | Apache License 2.0 | google/jax | Misc. small fixes. |
260,554 | 28.01.2019 19:30:45 | 28,800 | e538eb1a53700068523b2c5377e868c62e1722d9 | Removed comment from test. | [
{
"change_type": "MODIFY",
"old_path": "tests/batching_test.py",
"new_path": "tests/batching_test.py",
"diff": "@@ -379,9 +379,6 @@ class BatchingTest(jtu.JaxTestCase):\nreturn y\ngrad_loss = grad(lambda params, x: np.mean(f(params, x) ** 2))\n- # NOTE(schsam): We have to do this reshape thing because the current\n- # implementation of conv general expects a 4d-matrix.\n-\n# Test forward prop.\nper_example = vmap(partial(f, W))(np.reshape(X, (10, 1, 5, 5, 1)))\nper_example = np.reshape(per_example, (10, 5, 5, 5))\n"
}
] | Python | Apache License 2.0 | google/jax | Removed comment from test. |
260,335 | 30.01.2019 10:39:35 | 28,800 | c293b3775b144f944a665af3329613fdf118160d | add basic lax.stop_gradient primitive | [
{
"change_type": "MODIFY",
"old_path": "jax/lax.py",
"new_path": "jax/lax.py",
"diff": "@@ -485,6 +485,10 @@ def broadcasted_eye(dtype, shape, axes):\nreturn EyeConstant(shape, axes, dtype)\n+def stop_gradient(x):\n+ return stop_gradient_p.bind(x)\n+\n+\n### convenience wrappers around traceables\n@@ -2827,6 +2831,27 @@ for t in [FilledConstant, IotaConstant, EyeConstant]:\nad_util.jaxval_zeros_likers[t] = zeros_like_array\n+### stop_gradient\n+\n+\n+def stop_gradient_jvp_rule(primals, tangents):\n+ # if we don't call stop_gradient here, we'd only peel off one autodiff tracer\n+ x, = primals\n+ return stop_gradient(x), ad_util.zero\n+\n+def stop_gradient_batch_rule(batched_args, batch_dims):\n+ x, = batched_args\n+ dim, = batch_dims\n+ return stop_gradient(x), dim\n+\n+stop_gradient_p = Primitive('stop_gradient')\n+stop_gradient_p.def_impl(identity)\n+stop_gradient_p.def_abstract_eval(identity)\n+xla.translations[stop_gradient_p] = lambda c, x: x\n+ad.primitive_jvps[stop_gradient_p] = stop_gradient_jvp_rule\n+batching.primitive_batchers[stop_gradient_p] = stop_gradient_batch_rule\n+\n+\n### util\ndef _ndim(x):\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_test.py",
"new_path": "tests/lax_test.py",
"diff": "@@ -2186,6 +2186,19 @@ class LaxAutodiffTest(jtu.JaxTestCase):\ny = rng(update_shape, dtype)\ncheck_grads(scatter_add, (x, y), 2, 1e-2, 1e-2, 1e-2)\n+ def testStopGradient(self):\n+ def f(x):\n+ return lax.sin(x) * lax.cos(lax.stop_gradient(x))\n+\n+ def f2(x, y):\n+ return lax.sin(x) * lax.cos(y)\n+\n+ x = 3.14\n+ ans = api.grad(f)(x)\n+ expected = api.grad(f2)(x, x)\n+\n+ self.assertAllClose(ans, expected, check_dtypes=True)\n+\nif __name__ == '__main__':\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | add basic lax.stop_gradient primitive |
260,335 | 30.01.2019 10:43:57 | 28,800 | 26ac350cfd32b5e0cfd2f96c4b51f9a70aad4fdf | add higher-order test for stop_gradient | [
{
"change_type": "MODIFY",
"old_path": "tests/lax_test.py",
"new_path": "tests/lax_test.py",
"diff": "@@ -2196,7 +2196,10 @@ class LaxAutodiffTest(jtu.JaxTestCase):\nx = 3.14\nans = api.grad(f)(x)\nexpected = api.grad(f2)(x, x)\n+ self.assertAllClose(ans, expected, check_dtypes=True)\n+ ans = api.grad(api.grad(f))(x)\n+ expected = api.grad(api.grad(f2))(x, x)\nself.assertAllClose(ans, expected, check_dtypes=True)\n"
}
] | Python | Apache License 2.0 | google/jax | add higher-order test for stop_gradient |
260,268 | 31.01.2019 12:57:43 | 28,800 | 89e3b3a1051fda175ea7bcafebe00a544c55a50c | Add and numpy functions. | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -493,6 +493,16 @@ def flip(m, axis):\nreturn lax.rev(m, [axis])\n+@_wraps(onp.fliplr)\n+def fliplr(m):\n+ return flip(m, 1)\n+\n+\n+@_wraps(onp.flipup)\n+def flipup(m):\n+ return flip(m, 0)\n+\n+\n@_wraps(onp.conjugate)\ndef conjugate(x):\nreturn lax.conj(x) if iscomplexobj(x) else x\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_test.py",
"new_path": "tests/lax_numpy_test.py",
"diff": "@@ -911,6 +911,36 @@ class LaxBackedNumpyTests(jtu.JaxTestCase):\nself._CheckAgainstNumpy(onp_op, lnp_op, args_maker, check_dtypes=True)\nself._CompileAndCheck(lnp_op, args_maker, check_dtypes=True)\n+ @parameterized.named_parameters(jtu.cases_from_list(\n+ {\"testcase_name\": \"_{}\".format(\n+ jtu.format_shape_dtype_string(shape, dtype)),\n+ \"rng\": rng, \"shape\": shape, \"dtype\": dtype}\n+ for shape in [(3,), (2, 3)]\n+ for dtype in default_dtypes\n+ for rng in [jtu.rand_default()]))\n+ def testFlipud(self, shape, dtype, rng):\n+ args_maker = self._GetArgsMaker(rng, [shape], [dtype])\n+ lnp_op = lambda x: lnp.flipud(x)\n+ onp_op = lambda x: onp.flipud(x)\n+ self._CheckAgainstNumpy(onp_op, lnp_op, args_maker, check_dtypes=True)\n+ self._CompileAndCheck(lnp_op, args_maker, check_dtypes=True)\n+\n+\n+ @parameterized.named_parameters(jtu.cases_from_list(\n+ {\"testcase_name\": \"_{}\".format(\n+ jtu.format_shape_dtype_string(shape, dtype)),\n+ \"rng\": rng, \"shape\": shape, \"dtype\": dtype}\n+ for shape in [(3, 2), (2, 3)]\n+ for dtype in default_dtypes\n+ for rng in [jtu.rand_default()]))\n+ def testFliplr(self, shape, dtype, rng):\n+ args_maker = self._GetArgsMaker(rng, [shape], [dtype])\n+ lnp_op = lambda x: lnp.fliplr(x)\n+ onp_op = lambda x: onp.fliplr(x)\n+ self._CheckAgainstNumpy(onp_op, lnp_op, args_maker, check_dtypes=True)\n+ self._CompileAndCheck(lnp_op, args_maker, check_dtypes=True)\n+\n+\n@parameterized.named_parameters(jtu.cases_from_list(\n{\"testcase_name\": \"_{}_k={}_axes={}\".format(\njtu.format_shape_dtype_string(shape, dtype), k, axes),\n"
}
] | Python | Apache License 2.0 | google/jax | Add and numpy functions. |
260,268 | 31.01.2019 20:30:38 | 28,800 | 4c37d2491d4aef52e0887fa4ea65d7484b28d1bf | Add support for negative indices and tests of rank 3 tensors. | [
{
"change_type": "MODIFY",
"old_path": "jax/numpy/lax_numpy.py",
"new_path": "jax/numpy/lax_numpy.py",
"diff": "@@ -490,6 +490,12 @@ def rot90(m, k=1, axes=(0, 1)):\n@_wraps(onp.flip)\ndef flip(m, axis):\n+ # Negative axes wrap around\n+ if axis < 0:\n+ rank = len(m.shape)\n+ assert axis >= -rank, \"axis={} is invalid for the {}-dimensional input array\".format(axis, rank)\n+ return lax.rev(m, [axis % rank])\n+ else:\nreturn lax.rev(m, [axis])\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/lax_numpy_test.py",
"new_path": "tests/lax_numpy_test.py",
"diff": "@@ -902,7 +902,7 @@ class LaxBackedNumpyTests(jtu.JaxTestCase):\n\"rng\": rng, \"shape\": shape, \"dtype\": dtype, \"axis\": axis}\nfor shape in [(3,), (2, 3)]\nfor dtype in default_dtypes\n- for axis in range(len(shape))\n+ for axis in range(-len(shape), len(shape)) # Test negative axes\nfor rng in [jtu.rand_default()]))\ndef testFlip(self, shape, dtype, axis, rng):\nargs_maker = self._GetArgsMaker(rng, [shape], [dtype])\n@@ -915,7 +915,7 @@ class LaxBackedNumpyTests(jtu.JaxTestCase):\n{\"testcase_name\": \"_{}\".format(\njtu.format_shape_dtype_string(shape, dtype)),\n\"rng\": rng, \"shape\": shape, \"dtype\": dtype}\n- for shape in [(3,), (2, 3)]\n+ for shape in [(3,), (2, 3), (3, 2, 4)]\nfor dtype in default_dtypes\nfor rng in [jtu.rand_default()]))\ndef testFlipud(self, shape, dtype, rng):\n@@ -930,7 +930,7 @@ class LaxBackedNumpyTests(jtu.JaxTestCase):\n{\"testcase_name\": \"_{}\".format(\njtu.format_shape_dtype_string(shape, dtype)),\n\"rng\": rng, \"shape\": shape, \"dtype\": dtype}\n- for shape in [(3, 2), (2, 3)]\n+ for shape in [(3, 2), (2, 3), (3, 2, 4)]\nfor dtype in default_dtypes\nfor rng in [jtu.rand_default()]))\ndef testFliplr(self, shape, dtype, rng):\n"
}
] | Python | Apache License 2.0 | google/jax | Add support for negative indices and tests of rank 3 tensors. |
260,268 | 31.01.2019 21:47:05 | 28,800 | a9b221a1d362c8ee2d6ee1d7ce9c5a4d8d375a3a | Add batching rule for rev. | [
{
"change_type": "MODIFY",
"old_path": "jax/lax.py",
"new_path": "jax/lax.py",
"diff": "@@ -1657,8 +1657,15 @@ def rev_shape_rule(operand, dimensions):\nraise TypeError(msg.format(dimensions, operand.ndim))\nreturn operand.shape\n+def rev_batch_rule(batched_args, batch_dims, dimensions):\n+ operand, = batched_args\n+ bdim, = batch_dims\n+ new_dimensions = [i + 1 if i >= bdim else i for i in dimensions]\n+ return rev(operand, new_dimensions), bdim\n+\nrev_p = standard_primitive(rev_shape_rule, _input_dtype, 'rev')\nad.deflinear(rev_p, lambda t, dimensions: [rev(t, dimensions)])\n+batching.primitive_batchers[rev_p] = rev_batch_rule\ndef transpose_shape_rule(operand, permutation):\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/batching_test.py",
"new_path": "tests/batching_test.py",
"diff": "@@ -157,6 +157,24 @@ class BatchingTest(jtu.JaxTestCase):\nexpected_ans = x[:, :, 2]\nself.assertAllClose(ans, expected_ans, check_dtypes=False)\n+ def testRevLax(self):\n+ fun = lambda x: lax.rev(x, [0])\n+ R = onp.random.RandomState(0).randn\n+ x = R(2, 3)\n+\n+ ans = vmap(fun)(x)\n+ expected_ans = x[:, ::-1]\n+ self.assertAllClose(ans, expected_ans, check_dtypes=False)\n+\n+ def testRevNumpy(self):\n+ fun = lambda x: x[:, ::-1]\n+ R = onp.random.RandomState(0).randn\n+ x = R(3, 2, 4)\n+\n+ ans = vmap(fun)(x)\n+ expected_ans = x[:, :, ::-1]\n+ self.assertAllClose(ans, expected_ans, check_dtypes=False)\n+\ndef testNpMaximum(self):\nfun = lambda x: np.maximum(x, 0.0)\nR = onp.random.RandomState(0).randn\n"
}
] | Python | Apache License 2.0 | google/jax | Add batching rule for rev. |
260,335 | 29.01.2019 18:22:15 | 28,800 | da620a8edf605f89f0ec0faf9da29ff73bd4f9a5 | working on nested pjit, misc bug fixes | [
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -266,7 +266,7 @@ def pjit(fun, axis_name, in_axes=0, out_axes=0, mesh_axis=0):\nargs_flat, in_tree = tree_flatten(args)\nf, out_tree = pytree_fun_to_flatjaxtuple_fun(f, in_tree)\nin_axes_ = pxla.canonicalize_in_axis_spec(in_tree, in_axes)\n- out_axes_ = lambda: pxla.canonicalize_out_axis_spec(out_tree(), out_axes)\n+ out_axes_ = OutAxesThunk(out_tree, out_axes) # for pretty-printing\nchunksize = pxla.chunk_size(mesh_axis, in_axes_, args_flat)\nf = pxla.chunk_transform(f, chunksize, axis_name, in_axes_, out_axes_)\nout_flat = pxla.xla_pcall(f, *args_flat, axis_name=axis_name,\n@@ -280,6 +280,20 @@ def pjit(fun, axis_name, in_axes=0, out_axes=0, mesh_axis=0):\nf_jitted.__name__ = \"pjit({})\".format(f_jitted.__name__)\nreturn f_jitted\n+class OutAxesThunk(object):\n+ # This class is just used for its __repr__ method in pretty-printing jaxprs\n+\n+ def __init__(self, out_tree_thunk, out_axes):\n+ self.out_tree_thunk = out_tree_thunk\n+ self.out_axes = out_axes\n+\n+ def __call__(self):\n+ out_tree = self.out_tree_thunk()\n+ return pxla.canonicalize_out_axis_spec(out_tree, self.out_axes)\n+\n+ def __repr__(self):\n+ return repr(self())\n+\ndef pmap(fun, axis_name, in_axes=0, out_axes=0):\n\"\"\"Vectorizing pseudo-map for single-program multiple-data (SPMD) functions.\"\"\"\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/parallel.py",
"new_path": "jax/interpreters/parallel.py",
"diff": "@@ -291,7 +291,7 @@ class SplitTrace(Trace):\nname = next(name for name in names_in if name is not None)\nnew_names = next(t.new_names for t in tracers if t.name is not None)\nf = axisvar_split_subtrace(f, self.master, name, new_names)\n- val_out = call_primitive.bind(f, *vals, **params)\n+ val_out = call_primitive.bind(f, *vals_in, **params)\nreturn SplitTracer(self, name, new_names, val_out)\ndef post_process_call(self, _, out_tracer):\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -76,9 +76,9 @@ def chunk_aval(chunksize, aval, axis):\nreturn ShapedArray(tuple(shape), aval.dtype)\ndef canonicalize_in_axis_spec(in_tree, spec_tree_prefix):\n- \"\"\"Given argument list in_trees, canonicalize and flatten an in_axes spec.\"\"\"\n+ \"\"\"Given argument list in_tree, canonicalize and flatten an in_axes spec.\"\"\"\nspec_tree = build_axis_spec_tree(spec_tree_prefix, in_tree)\n- return tuple(tree_util.tree_flatten(spec_tree)[0])\n+ return flatten_axis_spec_tree(spec_tree)\ndef canonicalize_out_axis_spec(out_tree, spec_tree_prefix):\n\"\"\"Given output out_tree, canonicalize and flatten an out_axes spec.\"\"\"\n@@ -86,15 +86,19 @@ def canonicalize_out_axis_spec(out_tree, spec_tree_prefix):\nreturn spec_tree_prefix\nelse:\nspec_tree = build_axis_spec_tree(spec_tree_prefix, out_tree)\n- return tuple(tree_util.tree_flatten(spec_tree)[0])\n+ return flatten_axis_spec_tree(spec_tree)\ndef build_axis_spec_tree(spec, treedef):\n- \"\"\"Given a JaxTuple treedef, canonicalize an axis spec for that treedef.\"\"\"\n+ \"\"\"Given a tree_util treedef, canonicalize an axis spec for that treedef.\"\"\"\n+ spec_type = type(spec)\nif treedef is leaf:\n- assert type(spec) is int\n+ if spec_type is int:\nreturn spec\n+ elif spec_type is type(None):\n+ return no_mapped_axis\n+ else:\n+ raise TypeError(spec_type)\nelse:\n- spec_type = type(spec)\nif spec_type is int:\nreturn tuple(map(partial(build_axis_spec_tree, spec), treedef.children))\nelif spec_type is tuple:\n@@ -102,6 +106,16 @@ def build_axis_spec_tree(spec, treedef):\nelse:\nraise TypeError(spec_type)\n+def flatten_axis_spec_tree(spec_tree):\n+ \"\"\"Flatten an axis spec tree and replace no_mapped_axis with None.\"\"\"\n+ spec_flat, _ = tree_util.tree_flatten(spec_tree)\n+ return tuple(None if i is no_mapped_axis else i for i in spec_flat)\n+\n+# We use a special symbol for 'no mapped axis' instead of using None because\n+# tree_util.py treats None as a tree node.\n+class NoMappedAxis(object): pass\n+no_mapped_axis = NoMappedAxis()\n+\ndef shard_arg(mesh_spec, mesh_axis, axis, arg):\n\"\"\"Shard and device_put an input array argument along a logical axis.\"\"\"\nnum_replicas = xb.get_replica_count()\n@@ -134,6 +148,9 @@ def replica_groups(mesh_spec, mesh_axis):\ndef split_array(x, num_splits, axis):\n\"\"\"A special-case of numpy.split implemented in terms of indexing.\"\"\"\n+ if axis is None:\n+ return [x] * num_splits\n+ else:\nassert x.shape[axis] % num_splits == 0\nsplit_size = x.shape[axis] // num_splits\ndef get_nth_subarray(n):\n@@ -180,15 +197,14 @@ def device_mesh(spec):\n### xla_pcall\n-def compile_replicated(jaxpr, device_groups, consts, *abstract_args):\n+def compile_replicated(jaxpr, axis_env, consts, *abstract_args):\narg_shapes = list(map(xla_shape, abstract_args))\n- built_c = replicated_jaxpr_computation(jaxpr, device_groups, consts, (),\n- *arg_shapes)\n+ built_c = replicated_jaxpr_computation(jaxpr, axis_env, consts, (), *arg_shapes)\nresult_shape = xla_shape_to_result_shape(built_c.GetReturnValueShape())\nreturn built_c.Compile(arg_shapes, xb.get_compile_options()), result_shape\n-def replicated_jaxpr_computation(jaxpr, device_groups,\n- const_vals, freevar_shapes, *arg_shapes):\n+def replicated_jaxpr_computation(jaxpr, axis_env, const_vals, freevar_shapes,\n+ *arg_shapes):\nc = xb.make_computation_builder(\"replicated_jaxpr_computation\")\ndef read(v):\n@@ -208,11 +224,11 @@ def replicated_jaxpr_computation(jaxpr, device_groups,\nin_nodes = map(read, eqn.invars)\nif eqn.primitive in parallel_translation_rules:\nrule = parallel_translation_rules[eqn.primitive]\n- axis_name = eqn.params['axis_name']\n+ device_groups = axis_env[eqn.params['axis_name']] # TODO check var sharding\nparams = {k: eqn.params[k] for k in eqn.params if k != 'axis_name'}\nans = rule(c, *in_nodes, device_groups=device_groups, **params)\nelse:\n- if eqn.bound_subjaxprs: raise NotImplementedError # TODO check primitive\n+ if eqn.bound_subjaxprs: raise NotImplementedError # TODO check if pcall\nans = translation_rule(eqn.primitive)(c, *in_nodes, **eqn.params)\nout_nodes = xla_destructure(c, ans) if eqn.destructure else [ans]\n@@ -227,6 +243,9 @@ def xla_pcall_impl(fun, *args, **params):\nmesh_axis = params.pop('mesh_axis') # e.g. 0 or 1\nassert not params\n+ if all(arg is core.unit for arg in args):\n+ return fun.call_wrapped(*args)\n+ else:\ncompiled_fun = xla_parallel_callable(fun, axis_name, in_axes, mesh_axis,\nmesh_spec(), *map(abstractify, args))\nreturn compiled_fun(out_axes(), *args)\n@@ -236,13 +255,12 @@ def xla_parallel_callable(fun, axis_name, in_axes, mesh_axis, mesh_spec,\n*abstract_args):\nchunksize = chunk_size(mesh_axis, in_axes, abstract_args)\nabstract_args = map(partial(chunk_aval, chunksize), abstract_args, in_axes)\n- device_groups = replica_groups(mesh_spec, mesh_axis)\n+ axis_env = new_env({axis_name: replica_groups(mesh_spec, mesh_axis)})\npvals = [PartialVal((aval, core.unit)) for aval in abstract_args]\nwith core.new_master(JaxprTrace, True) as master:\njaxpr, (pval, consts, env) = trace_to_subjaxpr(fun, master).call_wrapped(pvals)\nassert not env\n- compiled, result_shape = compile_replicated(jaxpr, device_groups,\n- consts, *abstract_args)\n+ compiled, _ = compile_replicated(jaxpr, axis_env, consts, *abstract_args)\ndel master, consts, jaxpr, env\nreturn partial(execute_replicated, in_axes, mesh_axis, mesh_spec, compiled, pval)\n@@ -262,3 +280,30 @@ xla_pcall_p = core.Primitive('xla_pcall')\nxla_pcall = partial(core.call_bind, xla_pcall_p)\nxla_pcall_p.def_custom_bind(xla_pcall)\nxla_pcall_p.def_impl(xla_pcall_impl)\n+\n+\n+\n+def new_env(d):\n+ return d\n+\n+def extend_env(d1, d2):\n+ return dict(d1, **d2)\n+\n+\n+# def new_env(d):\n+# return AxisEnv(d, {})\n+\n+# def extend_env(d1, d2):\n+# return AxisEnv(d1, d2)\n+\n+# class AxisEnv(dict):\n+# def __init__(self, d1, d2):\n+# self.update(d1)\n+# self.parent = d2\n+\n+# def __missing__(self, key):\n+# return self.parent[key]\n+\n+# def __repr__(self):\n+# flat = dict(self, **self.parent)\n+# return repr(flat)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/xla.py",
"new_path": "jax/interpreters/xla.py",
"diff": "@@ -30,10 +30,10 @@ from ..config import flags\nfrom .. import core\nfrom .. import ad_util\nfrom .. import tree_util\n+from .. import linear_util as lu\nfrom ..abstract_arrays import ConcreteArray, ShapedArray, make_shaped_array, array_types\nfrom ..core import AbstractTuple, JaxTuple, pack, valid_jaxtype\nfrom ..util import partial, partialmethod, memoize, unzip2, concatenate, safe_map, prod\n-from ..linear_util import transformation_with_aux, memoize as linear_memoize\nfrom ..lib import xla_bridge as xb\nfrom .partial_eval import trace_to_subjaxpr, merge_pvals, JaxprTrace, PartialVal\n@@ -372,7 +372,7 @@ def xla_shape(x):\n# JaxTuple trees only.\n# TODO(mattjj): since pjit does flattening in api.py, can move/de-duplicate this\n-@transformation_with_aux\n+@lu.transformation_with_aux\ndef flatten_fun(in_trees, *flat_args):\njtuple_trees = tuple(map(partial(build_tree, iter(flat_args)), in_trees))\nans = yield jtuple_trees\n@@ -420,7 +420,7 @@ def xla_call_impl(fun, *args):\nelse:\nreturn build_tree(iter(flat_ans), out_tree())\n-@linear_memoize\n+@lu.memoize\ndef xla_callable(fun, *abstract_args):\npvals = [PartialVal((aval, core.unit)) for aval in abstract_args]\nwith core.new_master(JaxprTrace, True) as master:\n"
}
] | Python | Apache License 2.0 | google/jax | working on nested pjit, misc bug fixes |
260,335 | 29.01.2019 19:38:04 | 28,800 | 41c98ddcc0e255745eb613908f8143797d6f3ac0 | add basic pjit_nesting.py work file | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -224,7 +224,7 @@ def replicated_jaxpr_computation(jaxpr, axis_env, const_vals, freevar_shapes,\nin_nodes = map(read, eqn.invars)\nif eqn.primitive in parallel_translation_rules:\nrule = parallel_translation_rules[eqn.primitive]\n- device_groups = axis_env[eqn.params['axis_name']] # TODO check var sharding\n+ device_groups = axis_env[eqn.params['axis_name']]\nparams = {k: eqn.params[k] for k in eqn.params if k != 'axis_name'}\nans = rule(c, *in_nodes, device_groups=device_groups, **params)\nelse:\n"
},
{
"change_type": "ADD",
"old_path": null,
"new_path": "pjit_nesting.py",
"diff": "+import numpy as onp\n+\n+from jax import pjit, pmap, make_jaxpr\n+from jax.interpreters.parallel import psum\n+\n+\n+# def f(x):\n+# return psum(psum(x, 'i'), 'j')\n+# f = pjit(f, 'i')\n+# f = pjit(f, 'j')\n+\n+# x = onp.zeros((3, 4), onp.float32)\n+# print make_jaxpr(f)(x)\n+\n+\n+def f(x, y):\n+ return psum(psum(x, 'i'), 'j')\n+f = pjit(f, 'i')\n+f = pjit(f, 'j')\n+\n+x = onp.zeros((3, 4), onp.float32)\n+print make_jaxpr(f)(x, x)\n"
}
] | Python | Apache License 2.0 | google/jax | add basic pjit_nesting.py work file |
260,335 | 29.01.2019 20:23:41 | 28,800 | 6efb7b1c8f3142f7f28d8de1430c2f1b1c009078 | basic nested pjit works | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -37,11 +37,12 @@ from ..tree_util import leaf\nfrom ..lib import xla_bridge as xb\nfrom .xla import (flatten_fun, tree_flatten, build_tree, xla_shape,\nxla_destructure, translation_rule, abstractify,\n- xla_shape_to_result_shape)\n+ xla_shape_to_result_shape, jaxpr_computation)\nfrom .partial_eval import trace_to_subjaxpr, merge_pvals, JaxprTrace, PartialVal\nfrom .parallel import parallel_translation_rules\nfrom .batching import moveaxis\nfrom . import parallel\n+from . import xla\nmap = safe_map\n@@ -199,13 +200,13 @@ def device_mesh(spec):\ndef compile_replicated(jaxpr, axis_env, consts, *abstract_args):\narg_shapes = list(map(xla_shape, abstract_args))\n- built_c = replicated_jaxpr_computation(jaxpr, axis_env, consts, (), *arg_shapes)\n+ built_c = replicated_computation(jaxpr, axis_env, consts, (), *arg_shapes)\nresult_shape = xla_shape_to_result_shape(built_c.GetReturnValueShape())\nreturn built_c.Compile(arg_shapes, xb.get_compile_options()), result_shape\n-def replicated_jaxpr_computation(jaxpr, axis_env, const_vals, freevar_shapes,\n+def replicated_computation(jaxpr, axis_env, const_vals, freevar_shapes,\n*arg_shapes):\n- c = xb.make_computation_builder(\"replicated_jaxpr_computation\")\n+ c = xb.make_computation_builder(\"replicated_computation\")\ndef read(v):\nreturn env[v]\n@@ -228,7 +229,31 @@ def replicated_jaxpr_computation(jaxpr, axis_env, const_vals, freevar_shapes,\nparams = {k: eqn.params[k] for k in eqn.params if k != 'axis_name'}\nans = rule(c, *in_nodes, device_groups=device_groups, **params)\nelse:\n- if eqn.bound_subjaxprs: raise NotImplementedError # TODO check if pcall\n+ if eqn.bound_subjaxprs:\n+ in_shapes = map(c.GetShape, in_nodes)\n+ if eqn.primitive is xla_pcall_p:\n+ device_groups = replica_groups(mesh_spec(), eqn.params['mesh_axis'])\n+ new_axis_binding = {eqn.params['axis_name'] : device_groups}\n+ (subjaxpr, const_bindings, freevar_bindings), = eqn.bound_subjaxprs\n+ subc = replicated_computation(\n+ subjaxpr, extend_env(new_axis_binding, axis_env),\n+ [consts_env[b] for b in const_bindings],\n+ map(c.GetShape, map(read, freevar_bindings)),\n+ *in_shapes)\n+ subfun = (subc, tuple(map(read, freevar_bindings)))\n+ ans = translation_rule(eqn.primitive)(c, subfun, *in_nodes)\n+ else:\n+ subcs = [jaxpr_computation(subjaxpr,\n+ [consts_env[b] for b in const_bindings],\n+ map(c.GetShape, map(read, freevar_bindings)),\n+ *in_shapes)\n+ for subjaxpr, const_bindings, freevar_bindings\n+ in eqn.bound_subjaxprs]\n+ subfuns = [(subc, tuple(map(read, freevar_bindings)))\n+ for subc, (_, _, freevar_bindings)\n+ in zip(subcs, eqn.bound_subjaxprs)]\n+ ans = translation_rule(eqn.primitive)(c, *(subfuns + in_nodes), **eqn.params)\n+ else:\nans = translation_rule(eqn.primitive)(c, *in_nodes, **eqn.params)\nout_nodes = xla_destructure(c, ans) if eqn.destructure else [ans]\n@@ -280,6 +305,7 @@ xla_pcall_p = core.Primitive('xla_pcall')\nxla_pcall = partial(core.call_bind, xla_pcall_p)\nxla_pcall_p.def_custom_bind(xla_pcall)\nxla_pcall_p.def_impl(xla_pcall_impl)\n+xla.translations[xla_pcall_p] = xla.xla_call_translation_rule\n"
},
{
"change_type": "MODIFY",
"old_path": "pjit_nesting.py",
"new_path": "pjit_nesting.py",
"diff": "@@ -20,3 +20,4 @@ f = pjit(f, 'j')\nx = onp.zeros((3, 4), onp.float32)\nprint make_jaxpr(f)(x, x)\n+print f(x, x)\n"
}
] | Python | Apache License 2.0 | google/jax | basic nested pjit works |
260,335 | 29.01.2019 21:42:33 | 28,800 | 9fa8077901909988dad2620f4bb41e541a37dd3a | tweak batching.moveaxis behavior | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/batching.py",
"new_path": "jax/interpreters/batching.py",
"diff": "@@ -309,18 +309,19 @@ def moveaxis(sz, dst, src, x):\nelse:\nreturn pack(map(partial(moveaxis, sz, dst, src), x))\nelif isinstance(aval, ShapedArray):\n- dst = (dst % aval.ndim) if dst is not None and aval.ndim else dst\n- if src == dst:\n+ dst_ = (dst % aval.ndim) if dst is not None and aval.ndim else dst\n+ if src == dst_:\nreturn x\nelse:\nif src is None:\nx = broadcast(x, sz, force_broadcast=True)\nsrc = 0\n- if src == dst:\n+ dst_ = dst % (aval.ndim + 1)\n+ if src == dst_:\nreturn x\nelse:\nperm = [i for i in range(onp.ndim(x)) if i != src]\n- perm.insert(dst, src)\n+ perm.insert(dst_, src)\nreturn x.transpose(perm)\nelse:\nraise TypeError(type(aval))\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -47,9 +47,6 @@ from . import xla\nmap = safe_map\n-mesh_spec = None\n-\n-\n### util\n"
},
{
"change_type": "MODIFY",
"old_path": "pjit_nesting.py",
"new_path": "pjit_nesting.py",
"diff": "@@ -16,8 +16,8 @@ from jax.interpreters.parallel import psum\ndef f(x, y):\nreturn psum(psum(x, 'i'), 'j')\nf = pjit(f, 'i')\n-f = pjit(f, 'j')\n+f = pjit(f, 'j', out_axes=1)\n-x = onp.zeros((3, 4), onp.float32)\n+x = onp.ones((3, 4), onp.float32)\nprint make_jaxpr(f)(x, x)\nprint f(x, x)\n"
}
] | Python | Apache License 2.0 | google/jax | tweak batching.moveaxis behavior |
260,335 | 29.01.2019 22:04:41 | 28,800 | 2c447b98289b0b9104bbbce588ebf22fde7f47df | add temp axis name class | [
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -43,21 +43,25 @@ from .parallel import parallel_translation_rules\nfrom .batching import moveaxis\nfrom . import parallel\nfrom . import xla\n+from . import partial_eval as pe\nmap = safe_map\n### util\n-\ndef chunk_transform(fun, chunksize, name, in_axes, out_axes_dst):\n\"\"\"Rewrite SPMD operations to act first on local chunks then cross-replica.\"\"\"\n- temp_name = object() # TODO gensym\n+ temp_name = TempAxisName()\nfun = parallel.axisvar_split(fun, name, (temp_name, name))\nfun, out_axes_src = parallel.pmap_transform(fun, temp_name, in_axes)\nfun = move_output_axis_transform(fun, chunksize, out_axes_src, out_axes_dst)\nreturn fun\n+class TempAxisName(object):\n+ def __repr__(self):\n+ return '<temp axis {}>'.format(hex(id(self)))\n+\n@lu.transformation\ndef move_output_axis_transform(chunksize, src, dst, *args):\n\"\"\"Function transformation that moves output axes from src to dst.\"\"\"\n"
}
] | Python | Apache License 2.0 | google/jax | add temp axis name class |
260,335 | 30.01.2019 07:51:20 | 28,800 | 893ec5151a347acc58639602736844682eb2498a | jaxtuple flattening problems... | [
{
"change_type": "MODIFY",
"old_path": "jax/api.py",
"new_path": "jax/api.py",
"diff": "@@ -267,7 +267,7 @@ def pjit(fun, axis_name, in_axes=0, out_axes=0, mesh_axis=0):\nf, out_tree = pytree_fun_to_flatjaxtuple_fun(f, in_tree)\nin_axes_ = pxla.canonicalize_in_axis_spec(in_tree, in_axes)\nout_axes_ = OutAxesThunk(out_tree, out_axes) # for pretty-printing\n- chunksize = pxla.chunk_size(mesh_axis, in_axes_, args_flat)\n+ chunksize = pxla.chunk_size(axis_name, mesh_axis, in_axes_, args_flat)\nf = pxla.chunk_transform(f, chunksize, axis_name, in_axes_, out_axes_)\nout_flat = pxla.xla_pcall(f, *args_flat, axis_name=axis_name,\nin_axes=in_axes_, out_axes=out_axes_,\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/ad.py",
"new_path": "jax/interpreters/ad.py",
"diff": "@@ -184,7 +184,7 @@ class JVPTrace(Trace):\ntangents = [t.tangent for t in tracers]\nnonzero_tangents, in_tree_def = tree_to_jaxtuples(tangents)\nf, out_tree_def = traceable(jvp_subtrace(f, self.master), in_tree_def)\n- result = call_primitive.bind(f, pack(primals), nonzero_tangents)\n+ result = call_primitive.bind(f, pack(primals), nonzero_tangents, **params)\nprimal_out, tangent_out = build_tree(out_tree_def(), result)\nreturn JVPTracer(self, primal_out, tangent_out)\n"
},
{
"change_type": "MODIFY",
"old_path": "jax/interpreters/pxla.py",
"new_path": "jax/interpreters/pxla.py",
"diff": "@@ -161,7 +161,7 @@ def split_array(x, num_splits, axis):\nreturn x[tuple(idx)]\nreturn map(get_nth_subarray, range(num_splits))\n-def chunk_size(mesh_axis, in_axes, abstract_args):\n+def chunk_size(axis_name, mesh_axis, in_axes, abstract_args):\n\"\"\"Compute the chunk size for mapped axes, checking for errors.\"\"\"\nglobal mesh_spec\naxis_sizes = {arg.shape[axis] for arg, axis in zip(abstract_args, in_axes)\n@@ -237,7 +237,7 @@ def replicated_computation(jaxpr, axis_env, const_vals, freevar_shapes,\nnew_axis_binding = {eqn.params['axis_name'] : device_groups}\n(subjaxpr, const_bindings, freevar_bindings), = eqn.bound_subjaxprs\nsubc = replicated_computation(\n- subjaxpr, extend_env(new_axis_binding, axis_env),\n+ subjaxpr, extend_axis_env(new_axis_binding, axis_env),\n[consts_env[b] for b in const_bindings],\nmap(c.GetShape, map(read, freevar_bindings)),\n*in_shapes)\n@@ -269,9 +269,6 @@ def xla_pcall_impl(fun, *args, **params):\nmesh_axis = params.pop('mesh_axis') # e.g. 0 or 1\nassert not params\n- if all(arg is core.unit for arg in args):\n- return fun.call_wrapped(*args)\n- else:\ncompiled_fun = xla_parallel_callable(fun, axis_name, in_axes, mesh_axis,\nmesh_spec(), *map(abstractify, args))\nreturn compiled_fun(out_axes(), *args)\n@@ -279,9 +276,9 @@ def xla_pcall_impl(fun, *args, **params):\n@lu.memoize\ndef xla_parallel_callable(fun, axis_name, in_axes, mesh_axis, mesh_spec,\n*abstract_args):\n- chunksize = chunk_size(mesh_axis, in_axes, abstract_args)\n+ chunksize = chunk_size(axis_name, mesh_axis, in_axes, abstract_args)\nabstract_args = map(partial(chunk_aval, chunksize), abstract_args, in_axes)\n- axis_env = new_env({axis_name: replica_groups(mesh_spec, mesh_axis)})\n+ axis_env = new_axis_env({axis_name: replica_groups(mesh_spec, mesh_axis)})\npvals = [PartialVal((aval, core.unit)) for aval in abstract_args]\nwith core.new_master(JaxprTrace, True) as master:\njaxpr, (pval, consts, env) = trace_to_subjaxpr(fun, master).call_wrapped(pvals)\n@@ -309,28 +306,6 @@ xla_pcall_p.def_impl(xla_pcall_impl)\nxla.translations[xla_pcall_p] = xla.xla_call_translation_rule\n-\n-def new_env(d):\n- return d\n-\n-def extend_env(d1, d2):\n- return dict(d1, **d2)\n-\n-\n-# def new_env(d):\n-# return AxisEnv(d, {})\n-\n-# def extend_env(d1, d2):\n-# return AxisEnv(d1, d2)\n-\n-# class AxisEnv(dict):\n-# def __init__(self, d1, d2):\n-# self.update(d1)\n-# self.parent = d2\n-\n-# def __missing__(self, key):\n-# return self.parent[key]\n-\n-# def __repr__(self):\n-# flat = dict(self, **self.parent)\n-# return repr(flat)\n+# axis environments are tiny, so we don't worry about the cost of copying keys\n+def new_axis_env(d): return d\n+def extend_axis_env(d1, d2): return dict(d1, **d2)\n"
},
{
"change_type": "MODIFY",
"old_path": "pjit_nesting.py",
"new_path": "pjit_nesting.py",
"diff": "import numpy as onp\n-from jax import pjit, pmap, make_jaxpr\n+import jax.numpy as np\n+from jax import grad, pjit, pmap, make_jaxpr\nfrom jax.interpreters.parallel import psum\n-# def f(x):\n+# def f(x, y):\n# return psum(psum(x, 'i'), 'j')\n# f = pjit(f, 'i')\n-# f = pjit(f, 'j')\n+# f = pjit(f, 'j', out_axes=1)\n+# x = onp.ones((3, 4), onp.float32)\n+# print make_jaxpr(f)(x, x)\n+# print f(x, x)\n-# x = onp.zeros((3, 4), onp.float32)\n-# print make_jaxpr(f)(x)\n+def f(x):\n+ return x - psum(x, 'i')\n-def f(x, y):\n- return psum(psum(x, 'i'), 'j')\n-f = pjit(f, 'i')\n-f = pjit(f, 'j', out_axes=1)\n+x = np.zeros(4)\n+print grad(lambda x: np.sum(pmap(f, 'i')(x)))(x)\n+print grad(lambda x: np.sum(x - np.sum(x)))(x)\n-x = onp.ones((3, 4), onp.float32)\n-print make_jaxpr(f)(x, x)\n-print f(x, x)\n+g = pjit(f, axis_name='i')\n+print grad(lambda x: np.sum(g(x)))(x)\n"
},
{
"change_type": "MODIFY",
"old_path": "tests/pjit_test.py",
"new_path": "tests/pjit_test.py",
"diff": "@@ -58,6 +58,18 @@ class PmapTest(jtu.JaxTestCase):\nexpected = x - x.sum(0)\nself.assertAllClose(ans, expected, check_dtypes=False)\n+ @jtu.skip_on_devices(\"gpu\")\n+ def testNested(self):\n+ def f(x, y):\n+ return psum(psum(x, 'i'), 'j')\n+ f = pjit(f, 'i')\n+ f = pjit(f, 'j', out_axes=1)\n+\n+ x = onp.ones((3, 4), onp.float32)\n+ ans = f(x, x)\n+ expected = 12 * onp.ones((4, 3), onp.float32)\n+ self.assertAllClose(ans, expected, check_dtypes=True)\n+\nif __name__ == '__main__':\nabsltest.main()\n"
}
] | Python | Apache License 2.0 | google/jax | jaxtuple flattening problems... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.