mcy98's picture
Upload folder using huggingface_hub
2d13eb2 verified
Raw History Blame Contribute Delete
6.29 kB
import typing as tp
import collections
import itertools
import jax
import jax.numpy as jnp
class LeafTuple(tuple):
"""Custom tuple class treated as a leaf by Jax pytree utils."""
def __new__(cls, *args):
return tuple.__new__(cls, args)
def group_indices_by_perms(indices, perms):
"""Group indices by corresponding values in perms."""
groups = collections.defaultdict(list)
for index, perm in zip(indices, perms):
groups[perm].append(index)
return groups
def generate_partitions(items):
"""Generate all non-empty partitions of items."""
if len(items) == 1:
yield [items]
return
first = items[0]
for subpart in generate_partitions(items[1:]):
for n, subset in enumerate(subpart):
yield subpart[:n] + [[first] + subset] + subpart[n + 1 :]
yield [[first]] + subpart
def valid_partitions(indices, perms):
"""Only partitions of indices such that subsets share value in perms."""
# Create a mapping from perm to indices
groups_map = group_indices_by_perms(indices, perms)
groups = list(groups_map.values())
# Generate all possible products of non-empty subsets of the groups
partitions = [
itertools.chain(*p)
for p in itertools.product(*[generate_partitions(g) for g in groups])
]
for partition in partitions:
yield [p for p in partition]
def get_repeated_idcs(lst):
"""Get indices of list for values that repeat."""
index_map = {}
for index, item in enumerate(lst):
if item in index_map:
index_map[item].append(index)
else:
index_map[item] = [index]
rep_idcs = []
for idcs in index_map.values():
if len(idcs) > 1:
rep_idcs.append(idcs)
return rep_idcs
def diagonal_slice(X, matching_dims):
"""Take X's diagonal along some subset of dimensions."""
# len(matching_dims) must be at least 2
out = jnp.diagonal(X, axis1=matching_dims[0], axis2=matching_dims[1])
for dim in matching_dims[2:]:
# The diagonal dim is always kept at the end.
out = jnp.diagonal(out, axis1=dim, axis2=-1)
return out
def move_dims_to_end(X, dims):
"""Move the specified dims of X to the end."""
new_in_order = remove_idcs(list(range(X.ndim)), dims) + dims
return jnp.transpose(X, new_in_order)
def remove_idcs(lst, idcs):
return [l for idx, l in enumerate(lst) if idx not in idcs]
def find_missing_indices(lstA, lstB):
"""Find the indices for elements of A not in B."""
setB = set(lstB)
missing = []
for i, el in enumerate(lstA):
if el not in setB:
missing.append(i)
return missing
def is_broadcastable(shp1, shp2):
"""Check two array shapes are broadcastable."""
for a, b in zip(shp1[::-1], shp2[::-1]):
if a == 1 or b == 1 or a == b:
pass
else:
return False
return True
def match_dim_order(X, X_idcs, out_idcs):
"""Given X and idcs naming each dimension, reorder them to match out_idcs."""
X_idcs_copy = X_idcs[:]
perm = []
for idx in out_idcs:
if idx in X_idcs_copy:
i = X_idcs_copy.index(idx)
perm.append(i)
X_idcs_copy[i] = None # "use up" this index.
X = jnp.transpose(X, perm)
X_idcs = [X_idcs[i] for i in perm]
return X, X_idcs
def gen_basis(
out_spec: tp.Tuple[int], in_spec: tp.Tuple[int], out_shape: tp.Tuple[int], inp: jax.Array
) -> tp.List[jax.Array]:
"""Generate the basis terms of an equivariant map from in_spec to out_spec.
Args:
out_spec: specifies which permutation affects each axis of the output (except final axis, which is channels)
in_spec: specifies which permutation affects each axis of the input (except final axis, which is channels)
out_shape: shape of output tensor
inp: input tensor
"""
terms = []
k1, k2 = len(out_spec), len(in_spec) # number of output/input indices
for partition in valid_partitions(list(range(k1 + k2)), out_spec + in_spec):
indices = [-1] * (k1 + k2)
for subset_idx, subset in enumerate(partition):
for dim in subset:
indices[dim] = subset_idx
out_indices, in_indices = indices[:k1], indices[k1:]
term = inp
# For repeated input idcs, take the corresponding diagonals
while rep_idcs := get_repeated_idcs(in_indices):
term = diagonal_slice(term, rep_idcs[0])
# Diagonal is a new dim at the end
idx = in_indices[rep_idcs[0][0]]
in_indices = remove_idcs(in_indices, rep_idcs[0])
in_indices.append(idx)
# Aggregate over in_indices that aren't in out_indices
agg_idcs = find_missing_indices(in_indices, out_indices)
term = jnp.mean(term, axis=agg_idcs)
in_indices = remove_idcs(in_indices, agg_idcs)
# If we are outputting onto a diagonal, construct a larger tensor and then
# embed term into the appropriate diagonal.
for diag_set in get_repeated_idcs(out_indices):
dim_size, out_idx = out_shape[diag_set[0]], out_indices[diag_set[0]]
matching_in_dims = [
i for i, idx in enumerate(in_indices) if idx == out_idx
]
num_new_dims = len(diag_set) - len(matching_in_dims)
# move matching in dimensions to end
term = move_dims_to_end(term, matching_in_dims)
new_term = jnp.zeros(term.shape + (dim_size,) * num_new_dims)
diag_slice = (jnp.s_[:],) * (new_term.ndim - len(diag_set)) + (
jnp.arange(dim_size),
) * len(diag_set)
if not matching_in_dims:
term = jnp.expand_dims(term, axis=-1)
term = new_term.at[diag_slice].add(term)
in_indices = remove_idcs(in_indices, matching_in_dims)
in_indices.extend([out_idx] * len(diag_set))
# Permute term dimensions to match out_indices.
term, in_indices = match_dim_order(term, in_indices, out_indices)
# Broadcast
term = jnp.expand_dims(
term, axis=find_missing_indices(out_indices, in_indices)
)
terms.append(term)
return terms