Datasets:
Formats:
parquet
Size:
1K - 10K
Tags:
computer-vision
orbit-recovery
projected-mra
periodic-translation
image-reconstruction
bispectrum
License:
Download source/grid.py from PureOne/Xoryn-II: direct link, hf CLI and curl.
- Browser
- Download file 12.2 kB
-
https://huggingface.co/datasets/PureOne/Xoryn-II/resolve/main/source/grid.py
- Command line
-
hf download hf://datasets/PureOne/Xoryn-II/source/grid.py
-
curl -L -o grid.py https://huggingface.co/datasets/PureOne/Xoryn-II/resolve/main/source/grid.py
12.2 kB
| """Fourier sensing and recovery on finite product grids.""" | |
| from dataclasses import dataclass | |
| from collections import deque | |
| from itertools import combinations_with_replacement | |
| import math | |
| import numpy as np | |
| class Grid: | |
| def __init__(self, shape): | |
| self.shape = tuple(shape) | |
| self.size = math.prod(shape) | |
| self.points = np.indices(shape).reshape(len(shape), -1).T | |
| self.minus = self.index(-self.points) | |
| self.representative = np.minimum(self.minus, np.arange(self.size)) | |
| self.real = self.minus == np.arange(self.size) | |
| self.sign = np.where(self.representative == np.arange(self.size), 1, -1) | |
| self.odd = np.flatnonzero(~self.real & (self.sign == 1)) | |
| self.anchors = self.index(np.eye(len(shape), dtype=int)) | |
| def index(self, points): | |
| coordinates = np.moveaxis(np.asarray(points) % self.shape, -1, 0) | |
| return np.ravel_multi_index(coordinates, self.shape) | |
| def add(self, a, b): | |
| return self.index(self.points[a] + self.points[b]) | |
| def phases(self, poses): | |
| return np.exp(2j * np.pi * ((np.asarray(poses) / self.shape) @ self.points.T)) | |
| def product(self, z, rows): | |
| a, b, c = np.asarray(rows).T | |
| return z[..., a] * z[..., b] * z[..., c] | |
| class Step: | |
| anchor: int | |
| parent: int | |
| child: int | |
| row: int | |
| class OneTap: | |
| """Select cubic rows so that all other sine contributions cancel exactly.""" | |
| def __init__(self, grid): | |
| self.grid = grid | |
| self.weights = np.zeros(grid.size) | |
| active_anchors = grid.anchors[~grid.real[grid.anchors]] | |
| if len(active_anchors): | |
| self.weights[active_anchors] = 1 / np.sqrt(len(active_anchors)) | |
| rows = [] | |
| self.axis = [] | |
| for a, order in zip(grid.anchors, grid.shape): | |
| harmonic = [int(grid.index(j * grid.points[a])) for j in range(order)] | |
| q = order // 2 | |
| first = len(rows) | |
| rows.extend((a, harmonic[j], harmonic[-j-1]) for j in range(1, q)) | |
| wrap = None | |
| if order % 2: | |
| wrap = len(rows) | |
| rows.append((a, harmonic[q], harmonic[q])) | |
| self.axis.append((harmonic, slice(first, first + q-1), wrap)) | |
| centered = np.where(grid.points <= np.array(grid.shape)//2, | |
| grid.points, grid.points - grid.shape) | |
| self.steps = [] | |
| for k in np.argsort(np.abs(centered).sum(axis=1), kind="stable"): | |
| if grid.sign[k] < 0: | |
| continue | |
| axes = np.flatnonzero(centered[k]) | |
| if len(axes) < 2: | |
| continue | |
| long_axes = axes[np.array(grid.shape)[axes] > 2] | |
| axis = (long_axes if len(long_axes) else axes)[-1] | |
| a = grid.anchors[axis] | |
| if centered[k, axis] < 0: | |
| a = grid.minus[a] | |
| parent = int(grid.index(grid.points[k] - grid.points[a])) | |
| self.steps.append(Step(int(a), parent, int(k), len(rows))) | |
| rows.append((a, parent, grid.minus[k])) | |
| self.rows = np.asarray(rows, dtype=int).reshape(-1, 3) | |
| self.cos_indices = grid.representative[self.rows] | |
| powers = (~grid.real[self.rows]).sum(axis=1) | |
| self.factors = 2.0 ** np.maximum(0, powers - 1) | |
| first = self.rows[:, 0] | |
| self.uses_tap = ~grid.real[first] | |
| self.tap_factors = np.zeros(len(rows)) | |
| q = self.uses_tap | |
| self.tap_factors[q] = self.factors[q] / ( | |
| grid.sign[first[q]] * self.weights[grid.representative[first[q]]] | |
| ) | |
| def estimates(self, cosine, tap, sigma=0): | |
| """Views are axis -2 of cosine and axis -1 of tap.""" | |
| a, b, c = self.cos_indices.T | |
| A, B, C = cosine[..., a], cosine[..., b], cosine[..., c] | |
| var = sigma**2 | |
| real = (A*B*C - var*((a == b)*C + (a == c)*B + (b == c)*A)).mean(axis=-2) | |
| imag = (tap[..., :, None] * (B*C - var*(b == c))).mean(axis=-2) | |
| return real*self.factors + 1j*imag*self.tap_factors | |
| def recover(self, magnitude, invariants, dc=0): | |
| """Returns one Fourier representative. Positive magnitudes are required.""" | |
| grid = self.grid | |
| if np.any(np.abs(invariants) < 1e-60): | |
| raise ValueError("a selected invariant is zero") | |
| phase = invariants / abs(invariants) | |
| unit = np.ones_like(magnitude, dtype=complex) | |
| for harmonic, chain, wrap in self.axis: | |
| order = len(harmonic) | |
| q = order // 2 | |
| product = np.prod(phase[..., chain], axis=-1) | |
| root_power = product**2 | |
| if wrap is not None: | |
| root_power *= phase[..., wrap] | |
| root = np.exp(1j*np.angle(root_power)/order) | |
| unit[..., harmonic[1]] = root | |
| for j, row in enumerate(range(chain.start, chain.stop), start=1): | |
| unit[..., harmonic[j+1]] = root * unit[..., harmonic[j]] / phase[..., row] | |
| for j in range(1, (order+1)//2): | |
| unit[..., harmonic[-j]] = unit[..., harmonic[j]].conj() | |
| if order % 2 == 0: | |
| unit[..., harmonic[q]] = np.where(unit[..., harmonic[q]].real < 0, -1, 1) | |
| for step in self.steps: | |
| unit[..., step.child] = ( | |
| unit[..., step.anchor] * unit[..., step.parent] / phase[..., step.row] | |
| ) | |
| twin = grid.minus[step.child] | |
| if step.child == twin: | |
| unit[..., twin] = np.where(unit[..., twin].real < 0, -1, 1) | |
| else: | |
| unit[..., twin] = unit[..., step.child].conj() | |
| z = magnitude * unit | |
| z[..., 0] = dc | |
| return z | |
| def completions(grid, i, j): | |
| """Return signed triples with a non-real third slot, modulo negation.""" | |
| if grid.real[i] and grid.real[j]: | |
| return [] | |
| alternatives = (j, grid.minus[j]) if not grid.real[i] and not grid.real[j] else (j,) | |
| result = [] | |
| for b in alternatives: | |
| c = int(grid.minus[grid.add(i, b)]) | |
| if not grid.real[c]: | |
| result.append((i, int(b), c)) | |
| return result | |
| def dense_weights(grid): | |
| ws = np.zeros((2, grid.size)) | |
| ws[0, grid.odd] = 1 | |
| ws[1, grid.odd] = np.linspace(1, 2, len(grid.odd)) | |
| if len(grid.odd): | |
| ws /= np.linalg.norm(ws, axis=1, keepdims=True) | |
| return ws | |
| def restore_two_taps(grid, z): | |
| ws = dense_weights(grid) | |
| views = grid.phases(grid.points)*z | |
| C = views.real | |
| Q = views.imag @ ws.T | |
| vertices = np.unique(grid.representative[np.flatnonzero(abs(z)>1e-13)]) | |
| vertices = vertices[vertices != 0] | |
| error = 0.0 | |
| real_error = 0.0 | |
| constraints = 0 | |
| for i, j in combinations_with_replacement(vertices, 2): | |
| rows = [row for row in completions(grid, i, j) if abs(z[row[2]]) > 1e-13] | |
| if not rows: | |
| continue | |
| constraints += len(rows) | |
| a, b, c = np.asarray(rows).T | |
| F = 2.0 ** ((~grid.real[np.asarray(rows)]).sum(axis=1)-1) | |
| W = ws[:,grid.representative[c]] * grid.sign[c] / F | |
| rhs = (Q.T @ (C[:,i]*C[:,j])) / len(Q) | |
| obs = np.linalg.lstsq(W, rhs, rcond=None)[0] | |
| cube = z[a]*z[b]*z[c] | |
| measured_real = F * (C[:,i,None]*C[:,j,None]*C[:,grid.representative[c]]).mean(axis=0) | |
| real_error = max(real_error, float(np.max(abs(measured_real-cube.real)))) | |
| error = max(error, float(np.max(abs(obs-cube.imag)))) | |
| return max(error, real_error), constraints | |
| def sparse_recovery_rows(grid, support): | |
| """Use intact coordinate cycles and paths in the active frequency graph.""" | |
| anchors = grid.anchors | |
| if not support[anchors].all(): | |
| raise ValueError("the support is missing a unit generator") | |
| rows, cycles, steps = [], [], [] | |
| for a, length in zip(anchors, grid.shape): | |
| offsets = np.arange(length)[:,None]*grid.points[a] | |
| lines = grid.index(grid.points[support,None,:] + offsets[None,:,:]) | |
| intact = lines[np.all(support[lines],axis=1)] | |
| if not len(intact): | |
| raise ValueError("the support has no intact cycle for a unit generator") | |
| line = intact[0] | |
| cycles.append(slice(len(rows),len(rows)+length)) | |
| rows.extend((int(a),int(b),int(grid.minus[c])) for b,c in zip(line,np.roll(line,-1))) | |
| directions = np.unique(np.r_[anchors,grid.minus[anchors]]) | |
| reached = set(directions) | |
| queue = deque(directions) | |
| while queue: | |
| parent = queue.popleft() | |
| for a in directions: | |
| child = int(grid.add(parent,a)) | |
| if not support[child] or child in reached: | |
| continue | |
| steps.append(Step(int(a),int(parent),child,len(rows))) | |
| rows.append((int(a),int(parent),int(grid.minus[child]))) | |
| for new in (child,int(grid.minus[child])): | |
| if new not in reached: | |
| reached.add(new) | |
| queue.append(new) | |
| if len(reached) != support.sum(): | |
| raise ValueError("a component of the support is disconnected from all generators") | |
| return np.array(rows), cycles, steps | |
| def two_tap_products(grid, cosine, taps, weights, rows, support): | |
| """Decode specified complex products from exact mixed moments.""" | |
| order = np.argsort(grid.real[rows], axis=1, kind="stable") | |
| rows = np.take_along_axis(rows, order, axis=1) | |
| a,b,c = grid.representative[rows].T | |
| factors = 2.0**np.maximum(0,(~grid.real[rows]).sum(axis=1)-1) | |
| result = ((cosine[...,a]*cosine[...,b]*cosine[...,c]).mean(axis=-2)*factors).astype(complex) | |
| for index, (target,i,j) in enumerate(zip(rows,b,c)): | |
| if grid.real[target].all(): | |
| continue | |
| candidates = [u for u in completions(grid,i,j) if support[u[2]]] | |
| row = tuple(sorted(target)) | |
| negative = tuple(sorted(grid.minus[target])) | |
| column = next(k for k,t in enumerate(candidates) if tuple(sorted(t)) in (row,negative)) | |
| sign = 1 if tuple(sorted(candidates[column])) == row else -1 | |
| signed = np.asarray(candidates) | |
| completion = signed[:,2] | |
| scales = 2.0**((~grid.real[signed]).sum(axis=1)-1) | |
| matrix = weights[:,grid.representative[completion]]*grid.sign[completion]/scales | |
| linear = np.linalg.pinv(matrix)[column] | |
| rhs = (taps*(cosine[...,i]*cosine[...,j])[...,None]).mean(axis=-2) | |
| result[...,index] += 1j * sign * (rhs@linear) | |
| return result | |
| def recover_sparse(grid, z, support, phase): | |
| """Population recovery for supports with intact basis cycles and paths.""" | |
| views = z[:,None,:]*phase | |
| weights = dense_weights(grid) | |
| cosine = views.real | |
| measured = np.sqrt((cosine*cosine).mean(axis=1)*np.where(grid.real,1,2)) | |
| rows, cycles, steps = sparse_recovery_rows(grid,support) | |
| moments = two_tap_products(grid,cosine,views.imag@weights.T,weights,rows,support) | |
| normalized = moments / abs(moments) | |
| unit = np.ones_like(z) | |
| for a,length,cycle in zip(grid.anchors,grid.shape,cycles): | |
| root = np.exp(1j*np.angle(np.prod(normalized[:,cycle],axis=-1))/length) | |
| unit[:,a] = root | |
| unit[:,grid.minus[a]] = root.conj() | |
| for s in steps: | |
| unit[:,s.child] = unit[:,s.anchor]*unit[:,s.parent]/normalized[:,s.row] | |
| unit[:,grid.minus[s.child]] = unit[:,s.child].conj() | |
| recovered = unit*measured | |
| recovered[:,0] = cosine[:,0,0] | |
| return recovered | |
| def signed_graph_nullity(p): | |
| grid = Grid((p, p)) | |
| support = grid.odd | |
| parent = {} | |
| ground = (0, 0, 0) | |
| parent[ground] = ground | |
| def root(v): | |
| parent.setdefault(v, v) | |
| while parent[v] != v: | |
| parent[v] = parent[parent[v]] | |
| v = parent[v] | |
| return v | |
| def canonical(row): | |
| return min(tuple(sorted(row)), tuple(sorted(grid.minus[list(row)]))) | |
| for i,j in combinations_with_replacement(support, 2): | |
| vertices = [canonical(row) for row in completions(grid, i, j)] | |
| if len(vertices) == 1: | |
| vertices.append(ground) | |
| if len(vertices) == 2: | |
| parent[root(vertices[0])] = root(vertices[1]) | |
| components = len({root(v) for v in parent}) - 1 | |
| assert components == (p-1)//2 | |
| return {"p": p, "ungrounded_components": components, "remaining_after_Q_cubed": components-1} | |