Download annotations/annotation_22/universal_neural_functional/algorithm.py from mcy98/RECODE-H: direct link, hf CLI and curl.
- Browser
- Download file 6.29 kB
-
https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_22/universal_neural_functional/algorithm.py
- Command line
-
hf download hf://datasets/mcy98/RECODE-H/annotations/annotation_22/universal_neural_functional/algorithm.py
-
curl -L -o algorithm.py https://huggingface.co/datasets/mcy98/RECODE-H/resolve/main/annotations/annotation_22/universal_neural_functional/algorithm.py
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 | |