funcflows 0.1.2__py3-none-any.whl

FuncFlows/transports/continuous/vector_fields.py

@@ -0,0 +1,306 @@
+import torch
+
+
+
+
+def combine_context(stack, context, weights):
+    """sum_t w_t (stack_t @ context) without forming the [batch, out, context] tensor.    """
+
+    partial = torch.einsum("toc,bc->bto", stack, context)
+
+    return (weights.reshape(-1, stack.shape[0], 1) * partial).sum(1)
+
+
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+
+class VectorField(torch.nn.Module):
+    """dv/dt = velocity(coeffs, time). Must also expose the trace of its Jacobian.   
+    
+    'v' is used to refer to the function space coefficient vectors 
+    
+    """
+
+    supports_batched_time = False           # can `time_value` carry one entry per sample?
+    trace_samples = 1                       # Hutchinson probes, where the trace is estimated
+
+
+    def velocity(self, coeffs, time_value, context=None):
+        raise NotImplementedError
+
+    def trace(self, coeffs, time_value, context=None):
+        return self.estimated_trace(coeffs, time_value, context)
+
+    def estimated_trace(self, coeffs, time_value, context=None):
+        return self.estimated_velocity_and_trace(coeffs, time_value, context)[1]
+
+    def estimated_velocity_and_trace(self, coeffs, time_value, context=None):
+        """Hutchinson (FFJORD): Tr J = E[probe . J probe] for any probe with unit covariance."""
+        needs_graph = torch.is_grad_enabled()
+
+        with torch.enable_grad():
+            state = coeffs if coeffs.requires_grad else coeffs.detach().requires_grad_(True)
+            velocity = self.velocity(state, time_value, context)
+            total = torch.zeros_like(coeffs[..., 0])
+
+            for index in range(self.trace_samples):
+
+                probe = 2.0 * torch.randint(0, 2, coeffs.shape, device=coeffs.device).to(coeffs) - 1.0
+                slope, = torch.autograd.grad(velocity, state, grad_outputs=probe,
+                                             create_graph=needs_graph,
+                                             retain_graph=index + 1 < self.trace_samples or needs_graph)
+                total = total + (probe * slope).sum(-1)
+        total = total / self.trace_samples
+
+        return (velocity, total) if needs_graph else (velocity.detach(), total.detach())
+
+
+    def velocity_and_trace(self, coeffs, time_value, context=None):
+        """Both at once. Subclasses that share work between them should override this."""
+
+        return self.velocity(coeffs, time_value, context), self.trace(coeffs, time_value, context)
+
+
+
+
+
+
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+class TimeCosines(torch.nn.Module):
+    """cosine_time_weights with the order vector held as a buffer instead of rebuilt per call.    """
+
+    def __init__(self, num_time_modes, total_time, dtype, time_pair=False):
+        super().__init__()
+        self.total_time, self.time_pair = total_time, time_pair
+        self.register_buffer("orders", torch.arange(num_time_modes, dtype=dtype), persistent=False)
+
+        per_axis = int(num_time_modes ** 0.5 - 1e-9) + 1                    # ceil, so per_axis^2 >= n
+        pairs = torch.cartesian_prod(torch.arange(per_axis, dtype=dtype),
+                                     torch.arange(per_axis, dtype=dtype))
+        
+        chosen = pairs[torch.argsort(pairs.sum(1), stable=True)[:num_time_modes]]
+
+        self.register_buffer("end_orders", chosen[:, 0].contiguous(), persistent=False)
+        self.register_buffer("span_orders", chosen[:, 1].contiguous(), persistent=False)
+
+        self.cached = {}
+
+    def as_times(self, time_value):
+        """-> a tensor, or a (start, end) tuple of tensors, on this module's device and dtype."""
+
+        def cast(value):
+            return torch.as_tensor(value, dtype=self.orders.dtype, device=self.orders.device)
+        
+        if isinstance(time_value, tuple):
+            return cast(time_value[0]), cast(time_value[1])
+        
+        return (cast(time_value), cast(time_value)) if self.time_pair else cast(time_value)
+
+
+    def weights(self, times):
+        if not self.time_pair:
+            return torch.cos(torch.pi * self.orders * (times.unsqueeze(-1) / self.total_time))
+        start_time, end_time = times
+        span = (end_time - start_time).unsqueeze(-1) / self.total_time
+        return (torch.cos(torch.pi * self.end_orders * (end_time.unsqueeze(-1) / self.total_time))
+                * torch.cos(torch.pi * self.span_orders * span))
+
+    def forward(self, time_value):
+        compiling = getattr(torch.compiler, "is_compiling", lambda: False)()
+        tensor_time = (torch.is_tensor(time_value)
+                       or (isinstance(time_value, tuple) and torch.is_tensor(time_value[0])))
+
+        
+        if tensor_time or compiling:
+            return self.weights(self.as_times(time_value))
+        
+        label = (time_value if isinstance(time_value, tuple) else (time_value,),
+                 self.orders.device.type, self.orders.dtype)
+        
+        if label not in self.cached:
+            if len(self.cached) > 512:
+                self.cached.clear()
+            self.cached[label] = self.weights(self.as_times(time_value))
+        
+        return self.cached[label]
+
+
+
+
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+
+class LinearField(VectorField):
+    """h(v,t,c) = gain_k(t) \odot v + s \odot W(t) c    """
+
+    def __init__(self, num_functions, context_dim=None, num_time_modes=4, total_time=1.0, init_scale=0.0,
+                 time_pair=False, dtype=torch.float64, mode_scale=None, rank=None, ):
+        super().__init__()
+
+        self.num_time_modes, self.total_time, self.dtype = num_time_modes, total_time, dtype
+
+        self.gain_stack = torch.nn.Parameter(
+                                            init_scale * torch.randn(num_time_modes, num_functions, dtype=dtype)
+                                            )
+        
+        self.cosines = TimeCosines(num_time_modes, total_time, dtype, time_pair)
+
+        self.mode_scale, self.rank = mode_scale, rank
+
+        self.has_drift = bool(context_dim)
+
+
+        if self.has_drift:
+            if rank:
+                self.left = torch.nn.Parameter(
+                    init_scale / rank ** 0.5 * torch.randn(num_functions, rank, dtype=dtype))
+                self.right = torch.nn.Parameter(
+                    init_scale / (context_dim * num_time_modes) ** 0.5
+                    * torch.randn(num_time_modes, rank, context_dim, dtype=dtype))
+            else:
+                self.drift_stack = torch.nn.Parameter(
+                    init_scale / (context_dim * num_time_modes) ** 0.5
+                    * torch.randn(num_time_modes, num_functions, context_dim, dtype=dtype))
+
+
+    def _gains(self, time_value):
+        return self.cosines(time_value) @ self.gain_stack
+
+    def velocity(self, coeffs, time_value, context=None):
+
+        if self.has_drift:
+            if context is None:
+                return self._gains(time_value) * coeffs
+            
+            weights = self.cosines(time_value)
+
+            if self.rank:
+                update = combine_context(self.right, context, weights) @ self.left.T
+            else:
+                update = combine_context(self.drift_stack, context, weights)
+            drift_update = update if self.mode_scale is None else update * self.mode_scale
+
+            return self._gains(time_value) * coeffs + drift_update
+
+        else:
+
+            return self._gains(time_value) * coeffs
+
+
+    def trace(self, coeffs, time_value, context=None):
+        return self._gains(time_value).sum(-1).expand(coeffs.shape[:-1])
+
+
+    def velocity_and_trace(self, coeffs, time_value, context=None):
+
+        gains = self._gains(time_value) 
+
+        return self.velocity(coeffs, time_value, context=context), gains.sum(-1).expand(coeffs.shape[:-1])
+
+
+
+
+
+
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+
+class MatrixField(VectorField):
+    """Based off of arXiv:1803.05649 Sylvester flows
+
+    """
+
+    supports_batched_time = False
+
+    def __init__(self, conditioner, activation="tanh", mode_scale=None, num_active=None):
+        super().__init__()
+        self.conditioner = conditioner
+        self.activation = activation
+        self.mode_scale = mode_scale
+        self.num_active = num_active or conditioner.num_functions
+
+
+
+    def _parts(self, coeffs, time_value, context=None):
+
+        output_matrix, input_matrix, biases = self.conditioner(time_value, context)
+        active = coeffs[..., :self.num_active]
+
+        if self.mode_scale is not None:
+            active = active / self.mode_scale[:self.num_active]
+        pre_activation = active @ input_matrix.T + biases
+
+        if self.activation == "identity":
+            return output_matrix, input_matrix, pre_activation, torch.ones_like(pre_activation)
+        hidden = torch.tanh(pre_activation)
+
+        return output_matrix, input_matrix, hidden, 1 - hidden ** 2
+
+
+
+    def _update(self, coeffs, output_matrix, hidden):
+        update = hidden @ output_matrix.T
+        if self.mode_scale is not None:
+            update = update * self.mode_scale[:self.num_active]
+
+        return torch.nn.functional.pad(update, (0, coeffs.shape[-1] - self.num_active))
+
+
+    def velocity(self, coeffs, time_value, context=None):
+        output_matrix, _, hidden, _ = self._parts(coeffs, time_value, context)
+
+        return self._update(coeffs, output_matrix, hidden)
+
+
+    def trace(self, coeffs, time_value, context=None):
+        output_matrix, input_matrix, _, derivative = self._parts(coeffs, time_value, context)
+
+        return (derivative * (input_matrix * output_matrix.T).sum(1)).sum(-1)
+
+
+    def velocity_and_trace(self, coeffs, time_value, context=None):
+        output_matrix, input_matrix, hidden, derivative = self._parts(coeffs, time_value, context)
+
+        return (self._update(coeffs, output_matrix, hidden),
+                (derivative * (input_matrix * output_matrix.T).sum(1)).sum(-1))
+
+
+
+
+
+
+################################################################################################################
+################################################################################################################
+################################################################################################################
+
+
+class SumField(VectorField):
+    """h = sum of the given fields. Velocities add; traces add."""
+
+    def __init__(self, *fields):
+        super().__init__()
+        self.fields = torch.nn.ModuleList(fields)
+
+    @property
+    def supports_batched_time(self):
+        return all(field.supports_batched_time for field in self.fields)
+
+    def velocity(self, coeffs, time_value, context=None):
+        return sum(field.velocity(coeffs, time_value, context) for field in self.fields)
+
+    def trace(self, coeffs, time_value, context=None):
+        return sum(field.trace(coeffs, time_value, context) for field in self.fields)
+
+    def velocity_and_trace(self, coeffs, time_value, context=None):
+        parts = [field.velocity_and_trace(coeffs, time_value, context) for field in self.fields]
+        return sum(part[0] for part in parts), sum(part[1] for part in parts)
+

FuncFlows/transports/layers/__init__.py

@@ -0,0 +1,2 @@
+from .base_discrete import DiscreteTransformation
+from .layer_classes import DiscreteLayer, HouseholderLayer, SylvesterLayer

FuncFlows/transports/layers/base_discrete.py

@@ -0,0 +1,29 @@
+import torch
+
+from ..abstract_transformation import Transformation
+from .layer_classes import DiscreteLayer
+from FuncFlows.base_measures import ReferenceMeasure
+
+
+class DiscreteTransformation(Transformation):
+    """A stack of DiscreteLayers. Pass either a list of layers, or a layer class + count + its kwargs."""
+
+    def __init__(self, base_measure: ReferenceMeasure,
+                 layers=None, layer_class: type[DiscreteLayer] = None,
+                 num_layers: int = 1, **layer_kwargs):
+        super().__init__(base_measure)
+        if layers is None:
+            layers = [layer_class(base_measure, **layer_kwargs) for _ in range(num_layers)]
+        self.layers = torch.nn.ModuleList(layers)
+
+    def _map(self, coeffs, context=None):
+        log_det_term = torch.zeros_like(coeffs[..., 0])           # inherits device and dtype
+        for layer in self.layers:
+            coeffs, layer_log_det = layer._map(coeffs, context)
+            log_det_term = log_det_term + layer_log_det
+        return coeffs, log_det_term
+
+    def pull_back(self, coeffs_out, context=None):
+        for layer in reversed(self.layers):
+            coeffs_out = layer.pull_back(coeffs_out, context)
+        return coeffs_out

FuncFlows/transports/layers/layer_classes.py

@@ -0,0 +1,81 @@
+import math
+
+import torch
+
+from ..abstract_transformation import Transformation
+
+
+class DiscreteLayer(Transformation):
+    """One invertible layer acting on the leading num_modes coefficients; the tail passes through."""
+
+    def __init__(self, base_measure, num_modes):
+        super().__init__(base_measure)
+        if num_modes > base_measure.num_functions:
+            raise ValueError(f"num_modes {num_modes} exceeds the measure's {base_measure.num_functions}")
+        self.num_modes = num_modes
+
+
+class HouseholderLayer(DiscreteLayer):
+    """f(u) = u - 0.5 v (v.u + b), unit v. P1 §2.3.1; Jacobian I - 0.5 v v^T has det 0.5 exactly."""
+
+    def __init__(self, base_measure, num_modes):
+        super().__init__(base_measure, num_modes)
+        self.direction_raw = torch.nn.Parameter(0.1 * torch.randn(num_modes, dtype=base_measure.dtype))
+        self.bias = torch.nn.Parameter(torch.zeros(1, dtype=base_measure.dtype))
+
+    def _map(self, coeffs, context=None):
+        direction = self.direction_raw / self.direction_raw.norm()          # P1 Thm 2.4 normalisation
+        head = coeffs[..., :self.num_modes]
+        head = head - 0.5 * direction * (head @ direction + self.bias)[..., None]
+        coeffs_out = torch.cat([head, coeffs[..., self.num_modes:]], dim=-1)
+        log_det = torch.full_like(coeffs[..., 0], math.log(0.5))         # inherits device
+        return coeffs_out, log_det
+
+    def pull_back(self, coeffs_out, context=None):
+        direction = self.direction_raw / self.direction_raw.norm()
+        head = coeffs_out[..., :self.num_modes]
+        head = head + direction * (head @ direction + self.bias)[..., None]
+        return torch.cat([head, coeffs_out[..., self.num_modes:]], dim=-1)
+
+
+class SylvesterLayer(DiscreteLayer):
+    """f(u) = u + A tanh(B u + b) with A, B upper-triangular (P1 §2.3.2, van den Berg et al. 2018).
+
+    diag(B) = 1 and diag(A) = tanh(.) in (-1, 1), so by Sylvester's identity
+    log|det Df| = sum_j log(1 + (1 - h_j^2) diag(A)_j) is exact and O(num_modes).
+    """
+
+    def __init__(self, base_measure, num_modes, init_scale=0.1):
+        super().__init__(base_measure, num_modes)
+        dtype = base_measure.dtype
+        self.upper_before = torch.nn.Parameter(init_scale * torch.randn(num_modes, num_modes, dtype=dtype))   # R_B
+        self.upper_after = torch.nn.Parameter(init_scale * torch.randn(num_modes, num_modes, dtype=dtype))    # R_A
+        self.diag_after_raw = torch.nn.Parameter(init_scale * torch.randn(num_modes, dtype=dtype))
+        self.bias = torch.nn.Parameter(torch.zeros(num_modes, dtype=dtype))
+        self.register_buffer("identity", torch.eye(num_modes, dtype=dtype))   # a buffer, so .to() moves it
+
+    def matrices(self):
+        before = torch.triu(self.upper_before, diagonal=1) + self.identity                  # unit diagonal
+        diag_after = torch.tanh(self.diag_after_raw)
+        after = torch.triu(self.upper_after, diagonal=1) + torch.diag(diag_after)
+        return before, after, diag_after
+
+    def _map(self, coeffs, context=None):
+        before, after, diag_after = self.matrices()
+        head, tail = coeffs[..., :self.num_modes], coeffs[..., self.num_modes:]
+        hidden = torch.tanh(head @ before.T + self.bias)
+        head = head + hidden @ after.T
+        log_det = torch.log1p((1 - hidden ** 2) * diag_after).sum(-1)
+        return torch.cat([head, tail], dim=-1), log_det
+
+    def pull_back(self, coeffs_out, context=None, num_iterations=30):
+        """Fixed-point inverse. Converges when the layer is a contraction, which the small
+        init_scale and |diag(A)| < 1 encourage but do not guarantee. No residual check inside
+        the loop: on a GPU that would be a sync per iteration. Check once outside if in doubt:
+        (layer._map(layer.pull_back(x))[0] - x).abs().max()."""
+        before, after, _ = self.matrices()
+        head_out, tail = coeffs_out[..., :self.num_modes], coeffs_out[..., self.num_modes:]
+        head = head_out
+        for _ in range(num_iterations):
+            head = head_out - torch.tanh(head @ before.T + self.bias) @ after.T
+        return torch.cat([head, tail], dim=-1)

FuncFlows/utils/gaussian_misfit.py

@@ -0,0 +1,16 @@
+
+# This is here just as an example
+    # it's just a gaussian likelihood but the coefficients are part of the call
+
+
+class GaussianMisfit:
+    """Phi(coeffs) = ½ ||data - forward_map(coeffs)||² / noise_std².
+
+    forward_map: coeffs [..., r] -> [..., num_data].
+    """
+
+    def __init__(self, forward_map, data, noise_std):
+        self.forward_map, self.data, self.noise_std = forward_map, data, noise_std
+
+    def __call__(self, coeffs, extra_variance=0.0):
+        return 0.5 * ((self.data - self.forward_map(coeffs)) ** 2).sum(-1) / (self.noise_std ** 2 + extra_variance)

FuncFlows/utils/train.py

@@ -0,0 +1,31 @@
+import torch
+from tqdm import trange
+
+
+def train(objective, parameters, num_steps=5000, learning_rate=0.01, decay=0.8, decay_every=500,
+          sync_every=50):
+    """The standard loop: objective() returns the loss, parameters are whatever it should move.
+
+    parameters is materialised with list() because model.parameters() is a generator: reusing
+    one across two train() calls used to hand Adam an empty list on the second call.
+    Losses are read back every sync_every steps in one transfer; loss.item() on every step
+    is a device sync per step, which on a GPU/MPS stalls the whole pipeline.
+    """
+    parameters = list(parameters)
+    optimiser = torch.optim.Adam(parameters, lr=learning_rate)
+    scheduler = torch.optim.lr_scheduler.StepLR(optimiser, decay_every, decay)
+
+    losses, pending = [], []
+    for _ in trange(num_steps, desc="Training"):
+        optimiser.zero_grad()
+        loss = objective()
+        loss.backward()
+        optimiser.step()
+        scheduler.step()
+        pending.append(loss.detach())
+        if len(pending) == sync_every:
+            losses += torch.stack(pending).tolist()
+            pending = []
+    if pending:
+        losses += torch.stack(pending).tolist()
+    return losses

funcflows-0.1.2.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: funcflows
+Version: 0.1.2
+Summary: Normalizing flows and flow matching on function spaces, with exact-trace vector fields
+Author: Liam Pinchbeck
+License: MIT
+Project-URL: Homepage, https://github.com/YOUR_USER/FuncFlows
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: tqdm
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Provides-Extra: ot
+Requires-Dist: scipy; extra == "ot"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# FuncFlows
+
+Normalizing flows and flow matching on function spaces. Functions are represented by
+coefficients on a Laplacian eigenbasis (cosine or Fourier), the reference measure is a Gaussian
+on those coefficients, and transports are neural ODEs whose vector fields (`LinearField`,
+`MatrixField`, `PointwiseField`) all have closed-form divergences, so densities relative to the
+reference measure are exact.
+
+```bash
+pip install funcflows 
+```
+
+Objectives: flow matching (conditional / amortised), reverse KL, alpha-divergences, negative
+log-likelihood. Samplers and diagnostics: latent-space pCN, importance correction, TARP coverage.
+
+`torch` is a hard dependency and is large; install it first from pytorch.org if you need a
+specific CUDA/MPS build.

funcflows-0.1.2.dist-info/RECORD

@@ -0,0 +1,33 @@
+FuncFlows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FuncFlows/base_measures/__init__.py,sha256=MNpfvHZo9zM1UB4PKWseAHo9Dd_VokwxNxgY1glgyfQ,173
+FuncFlows/base_measures/abstract_reference_measure.py,sha256=6CZnVtzA9W6y4YHKIXIKHzYG8WIHv7JAEmQIzU7RkfU,1033
+FuncFlows/base_measures/bases.py,sha256=mRUeWnaa6teIRhgEnzwKj_txsQo3hCRxhDzvjxmEF0w,6302
+FuncFlows/base_measures/gaussian_reference_measure.py,sha256=OLv908JPr38etrQ6VhvKhgOnL-DOEzgJ5a9x09Jpwq0,1792
+FuncFlows/diagnostics/__init__.py,sha256=E7vdcr_nUgyHvV3eifOhW7-w9by4Bcw_P7_BIOutR8Y,98
+FuncFlows/diagnostics/coverage.py,sha256=Llx46y0BglCP_dOfuOH_eNHVp37KtBYvBaRRKc_pfig,2541
+FuncFlows/diagnostics/importance.py,sha256=X0AlezvmopR5JEJi_6x6W9lSyda1AcjSuq22eBoM5E4,2708
+FuncFlows/objectives/__init__.py,sha256=UpYH2M7HUFcpbtaEJfVrb76svRousxl4hB9eqwlMxQo,286
+FuncFlows/objectives/alpha_divergence.py,sha256=_iwwPUoyovy3d4dl5Bcndu70TDR7lJTuFG3kC01MkY0,3822
+FuncFlows/objectives/flow_matching.py,sha256=DuTNDdjZ13o156H9aQORV-1qjrCpgrcrWWs0R8Qu3zM,7313
+FuncFlows/objectives/negative_logl.py,sha256=QWHIOMp1uBZxFgBn-Wh8SRUD6tlY5Wh1H15rR470Qpg,758
+FuncFlows/objectives/reverse_kl.py,sha256=ZXlVxWgwh5uJ7xjuLv1iYu1oSQXppiwFsD7O3Wl4ONw,2690
+FuncFlows/samplers/__init__.py,sha256=D9V3yCl_qqmsYjhVeEUpk6SJZMK3uMUx13sJ8Fo6uHI,35
+FuncFlows/samplers/latent_pcn.py,sha256=os6PcqMeC64yMb86PDTpSi8Tec4jDBAgzYuT2dR4Jgc,2907
+FuncFlows/transports/__init__.py,sha256=R6In-pSfeB6IVV-e_RbdqLrQ_6Ex8dJCsZKc2d-2JN4,144
+FuncFlows/transports/abstract_transformation.py,sha256=56b7NDhulD7xC4f0HKHnUq6anHAMtK6N7bKDiyF_ohY,1331
+FuncFlows/transports/continuous/__init__.py,sha256=gcCzACXLajQrcV8wdZ766jm-2nw84Bzlv-r-66SUzAc,349
+FuncFlows/transports/continuous/base_continuous.py,sha256=CFTkVdvDmayzCcqLreaMRLpMDDu6AYGYJr2STNWotwk,3339
+FuncFlows/transports/continuous/conditioners.py,sha256=VXj2ZigjV3TzjfzlcNH08Yoken1JrwVCfG2Mq_jf67Y,3449
+FuncFlows/transports/continuous/grid_fields.py,sha256=4pVDMgK79NKtrLQbOZzAHaUbmDT7fLu7JzdR82OtaTA,18876
+FuncFlows/transports/continuous/vector_fields.py,sha256=i4WwubIOFX84Jp2epmS5FIjUgZI0eFFIJ6xGwSKxkxc,12180
+FuncFlows/transports/layers/__init__.py,sha256=PMgHayKpTCIgG_1uOYPW5wqGnREiPShBYBNE0vbXTw0,125
+FuncFlows/transports/layers/base_discrete.py,sha256=RqDSup0lnOm01qSzUQlkP9-z348J04X1irvtN-kzIYM,1216
+FuncFlows/transports/layers/layer_classes.py,sha256=qoed6aVZh1AUN_kZz0p9t8TsH02UpfF_HwVF-ykaYI8,4144
+FuncFlows/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FuncFlows/utils/gaussian_misfit.py,sha256=Q4znj86c62DmxQcmZP1pNp1Pm7xcb-Nd1-Xg3E3meSc,579
+FuncFlows/utils/train.py,sha256=HfoxFW-Sjs8ppc0oO8xg8gX7gnHbX1VVo0k7hwaAz_4,1236
+funcflows-0.1.2.dist-info/licenses/LICENSE,sha256=0SJU1dVe5uk0rKC9g3BKPevyAWTYQxcqVtDVW9ORk5Y,1065
+funcflows-0.1.2.dist-info/METADATA,sha256=f1U_LTAnuouWSjGU-jNfhhUbWW_1HMpN5WU-hQJq-uE,1577
+funcflows-0.1.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+funcflows-0.1.2.dist-info/top_level.txt,sha256=3aOZIxxmKc6v_UD7mIKrW-60jGIFU4s9Ro7XWmgfaik,10
+funcflows-0.1.2.dist-info/RECORD,,

funcflows-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

funcflows-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

funcflows-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+FuncFlows