haliax 1.4.dev313__tar.gz → 1.4.dev315__tar.gz

{haliax-1.4.dev313 → haliax-1.4.dev315}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: haliax
-Version: 1.4.dev313
+Version: 1.4.dev315
 Summary: Named Tensors for Legible Deep Learning in JAX
 Project-URL: Homepage, https://github.com/stanford-crfm/haliax
 Project-URL: Bug Tracker, https://github.com/stanford-crfm/haliax/issues/

haliax-1.4.dev315/src/haliax/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.4.dev315"

{haliax-1.4.dev313 → haliax-1.4.dev315}/src/haliax/core.py

@@ -952,6 +952,7 @@ def _compute_new_axes_and_slices_for_index(
             # we allow this if it's a 0-d or 1-d array
             if slice_.ndim == 0:
                 ordered_slices[axis_index] = slice_
+                kept_axes[axis_index] = False
             elif slice_.ndim == 1:
                 # we allow this if it's a 1-d array, in which case we treat it as sugar for NamedArray(slice_, sliced-axis)
                 ordered_slices[axis_index] = haliax.named(slice_, axis_name(axis))

{haliax-1.4.dev313 → haliax-1.4.dev315}/src/haliax/jax_utils.py

@@ -80,7 +80,7 @@ def filter_checkpoint(fun: Callable, *, prevent_cse: bool = True, policy: Option
 
 
 def is_jax_array_like(x):
-    return hasattr(x, "shape") and hasattr(x, "dtype")
+    return hasattr(x, "shape") and hasattr(x, "dtype")  # and not isinstance(x, haliax.NamedArray)
 
 
 # adapted from jax but exposed so i can use it

{haliax-1.4.dev313 → haliax-1.4.dev315}/src/haliax/nn/scan.py

@@ -102,7 +102,14 @@ class BlockSeq(eqx.Module, Generic[M]):
             (block_args, block_kwargs) = haliax.tree_util.tree_map(
                 functools.partial(BlockSeq._slice_out, self.Block, i), (extra_args, extra_kwargs)
             )
-            carry, extra = block(carry, *block_args, **block_kwargs)
+            block_result = block(carry, *block_args, **block_kwargs)
+            if not isinstance(block_result, (tuple, list)) or len(block_result) != 2:
+                raise ValueError(
+                    f"BlockSeq.scan expects the block to return a pair of (carry, extra), got {block_result}"
+                )
+
+            carry, extra = block_result
+
             out.append(extra)
 
         # TODO: do we want to stack the outputs?
@@ -124,8 +131,11 @@ class BlockSeq(eqx.Module, Generic[M]):
 
     @staticmethod
     def _slice_out(Block, i, x):
-        if haliax.is_named_array(x) and haliax.selects_axis(x.axes, Block):
-            return x[Block, i]
+        if haliax.is_named_array(x):
+            if haliax.selects_axis(x.axes, Block):
+                return x[Block, i]
+            else:
+                return x
         elif haliax.jax_utils.is_jax_array_like(x):
             return x[i]
         else:

{haliax-1.4.dev313 → haliax-1.4.dev315}/tests/core_test.py

@@ -543,6 +543,23 @@ def test_index():
     assert jnp.all(jnp.equal(named1[{"H": 0, "W": 0, "D": 0}], named1.array[0, 0, 0]))
 
 
+def test_index_with_tracer():
+    H = Axis("H", 20)
+    W = Axis("W", 30)
+    D = Axis("D", 40)
+    named1 = hax.random.uniform(PRNGKey(0), (H, W, D))
+
+    @jax.jit
+    def f(idx):
+        return named1["H", idx]
+
+    idx = jnp.array([1, 2, 3])
+    assert jnp.all(jnp.equal(f(idx).array, named1.array[1:4, :, :]))
+
+    idx = jnp.array(0)
+    assert jnp.all(jnp.equal(f(idx).array, named1.array[0, :, :]))
+
+
 def test_index_array_slices():
     # fancier tests with array slices with named array args
     H = Axis("H", 10)

{haliax-1.4.dev313 → haliax-1.4.dev315}/tests/test_scan.py

@@ -1,5 +1,6 @@
 import equinox as eqx
 import jax
+import pytest
 
 import haliax as hax
 from haliax.nn.scan import BlockSeq, Stacked
@@ -66,9 +67,14 @@ def test_seq_and_stacked_give_same_results():
     x = hax.random.uniform(jax.random.PRNGKey(1), (E,))
     y = m.fold(x, key=jax.random.split(jax.random.PRNGKey(2), Block.size))
     y_seq = m_seq.fold(x, key=jax.random.split(jax.random.PRNGKey(2), Block.size))
-
     assert hax.all(hax.isclose(y, y_seq, atol=1e-5))
 
+    with pytest.raises(ValueError):
+        m.scan(x, key=jax.random.split(jax.random.PRNGKey(2), Block.size))
+
+    with pytest.raises(ValueError):
+        m_seq.scan(x, key=jax.random.split(jax.random.PRNGKey(2), Block.size))
+
 
 def test_using_scan():
     class Module(eqx.Module):
@@ -95,3 +101,35 @@ def test_using_scan():
 
     assert y.axes == (E,)
     assert intermediates.axes == (Block, E)
+
+
+def test_scan_with_aux_named_args():
+    class Module(eqx.Module):
+        named: hax.NamedArray
+        array: jax.Array
+        static: int = eqx.static_field()
+
+        def __call__(self, x, y, *, key):
+            return x + self.array + self.static + hax.random.normal(key, x.axes), x * 2 + y
+
+        @staticmethod
+        def init(named, array, static):
+            return Module(named=named, array=array, static=static)
+
+    Block = hax.Axis("block", 4)
+    E = hax.Axis("E", 10)
+
+    initial_named = hax.random.uniform(jax.random.PRNGKey(0), (Block, E))
+    initial_y = hax.random.uniform(jax.random.PRNGKey(1), (E,))
+
+    m = Stacked.init(Block, Module)(named=initial_named, array=jax.numpy.ones(Block.size), static=1)
+    m_seq = BlockSeq.init(Block, Module)(named=initial_named, array=jax.numpy.ones(Block.size), static=1)
+
+    x = hax.random.uniform(jax.random.PRNGKey(1), (E,))
+    z, z_scan = m.scan(x, initial_y, key=jax.random.split(jax.random.PRNGKey(2), Block.size))
+    z_seq, z_seq_scan = m_seq.scan(x, initial_y, key=jax.random.split(jax.random.PRNGKey(2), Block.size))
+    assert hax.all(hax.isclose(z, z_seq, atol=1e-5))
+
+    z_seq_scan = hax.stack(Block, z_seq_scan)
+
+    assert hax.all(hax.isclose(z_scan, z_seq_scan, atol=1e-5))

haliax-1.4.dev313/src/haliax/__about__.py

@@ -1 +0,0 @@
-__version__ = "1.4.dev313"