spinn 0.1.0__tar.gz

spinn-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Marek Wojciechowski
+
+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.

spinn-0.1.0/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: spinn
+Version: 0.1.0
+Summary: Simple Physics Informed Neural Networks
+Home-page: https://github.com/mrkwjc/spinn
+Author: Marek Wojciechowski
+Author-email: mwojc@p.lodz.pl
+License: LGPL-2.1
+Keywords: ann,pinn
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jax
+Requires-Dist: jaxlib
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: networkx
+
+# spinn - Simple Physics Informed Neural Networks
+Makes PINNs easy (with jax), see examples...

spinn-0.1.0/README.md

@@ -0,0 +1,2 @@
+# spinn - Simple Physics Informed Neural Networks
+Makes PINNs easy (with jax), see examples...

spinn-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires=["setuptools"]
+build-backend = "setuptools.build_meta"

spinn-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

spinn-0.1.0/setup.py

@@ -0,0 +1,25 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="spinn",
+    version="0.1.0",
+    author="Marek Wojciechowski",
+    author_email="mwojc@p.lodz.pl",
+    description="Simple Physics Informed Neural Networks",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/mrkwjc/spinn",
+    packages=setuptools.find_packages(),
+    keywords=['ann', 'pinn'],
+    license='LGPL-2.1',
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires='>=3.6',
+    install_requires=['jax', 'jaxlib', 'numpy', 'scipy', 'networkx'],
+)

spinn-0.1.0/spinn/__init__.py

@@ -0,0 +1,6 @@
+import jax
+jax.config.update('jax_default_matmul_precision', 'high')  # 'bfloat16_3x'
+
+from .trees import spinn
+from .utils import hcube, left, right, bottom, top
+from .graphs import mlgraph

spinn-0.1.0/spinn/graphs.py

@@ -0,0 +1,93 @@
+import numpy as np
+import networkx as nx
+from spinn import utils
+
+
+def _shoot(src, trg, mindeg, d=None, reverse=False):
+    mindeg = min(mindeg, len(trg))
+    if d is None:
+        s = np.repeat(src, mindeg)
+        t = [np.random.choice(trg, mindeg, replace=False)
+             for i in range(len(src))]
+    else:
+        s, t = [], []
+        for i, ei in enumerate(d):
+            toshoot = mindeg-len(ei)
+            if toshoot > 0:
+                s += [src[i]]*toshoot
+                if toshoot == mindeg:
+                    ti = trg
+                else:
+                    ei = np.asarray(ei)
+                    ni = ei[:, 0] if reverse else ei[:, 1]
+                    ti = np.setdiff1d(trg, ni)
+                t += [np.random.choice(ti, toshoot, replace=False)]
+    if not len(s):
+        return []
+    e = np.asarray((s, np.concatenate(t)))
+    e = e[::-1] if reverse else e
+    return e.T.tolist()
+
+
+def _multilayer(arch, full=False, mindeg=None, G=None):
+    extents = utils.pacc((0,) + tuple(arch))
+    layers = [range(start, end) for start, end in extents]
+    G = nx.DiGraph() if G is None else G
+    for i, layer in enumerate(layers):
+        G.add_nodes_from(layer, layer=i)
+    if not full:
+        for layer1, layer2 in utils.pairwise(layers):
+            if mindeg is None:
+                G.add_edges_from(utils.prod(layer1, layer2))
+            else:
+                e = _shoot(layer1, layer2, mindeg)
+                G.add_edges_from(e)
+                d = [tuple(G.in_edges(n)) for n in layer2]
+                e = _shoot(layer2, layer1, mindeg, d, reverse=True)
+                G.add_edges_from(e)
+    else:
+        if mindeg is None:
+            for i, layer1 in enumerate(layers[:-1]):
+                for layer2 in layers[i+1:]:
+                    G.add_edges_from(utils.prod(layer1, layer2))
+        else:
+            for i, layer1 in enumerate(layers[:-1]):
+                trg = np.concatenate(layers[i+1:])
+                e = _shoot(layer1, trg, mindeg)
+                G.add_edges_from(e)
+            for i, layer2 in enumerate(layers[::-1][:-1]):
+                trg = np.concatenate(layers[::-1][i+1:])
+                d = [tuple(G.in_edges(n)) for n in layer2]
+                e = _shoot(layer2, trg, mindeg, d, reverse=True)
+                G.add_edges_from(e)
+    return G
+
+
+class mlgraph(nx.DiGraph):
+    def __init__(self, arch=None, full=False, d=None):
+        nx.DiGraph.__init__(self)
+        if arch is not None:
+            _multilayer(arch, full, d, self)
+
+    def preview(self, fname=None, **kwargs):
+        pos = nx.multipartite_layout(self, subset_key="layer")
+        import matplotlib.pyplot as plt
+        plt.figure(figsize=(8, 4))
+        nx.draw_networkx(self, pos, **kwargs)
+        # plt.axis("equal")
+        if fname is not None:
+            plt.savefig(fname, dpi=300, bbox_inches="tight")
+        plt.show()
+
+
+if __name__ == '__main__':
+    g = mlgraph((5, 20, 20, 1), full=True, d=3)
+    # g.preview()
+    g.preview(fname=None,
+              with_labels=False,
+              node_size=50,
+              node_color='k',
+              edge_color='grey',
+              width=0.5,
+              linewidths=0.5,
+              arrows=False)

spinn-0.1.0/spinn/trees.py

@@ -0,0 +1,295 @@
+import networkx as nx
+import numpy as np
+import jax
+import jax.numpy as jnp
+from functools import partial
+from scipy.optimize import minimize
+from jax.experimental.sparse import BCOO
+from spinn import utils, graphs
+
+# import os
+# os.environ['CUDA_VISIBLE_DEVICES'] = ''
+# jax.config.update("jax_enable_x64", True)
+# jax.config.update('jax_default_matmul_precision', 'high')  # 'bfloat16_3x'
+
+
+class spinn:
+    def __init__(self, G, f=None, p=None,
+                 initx=None, inity=None,
+                 key=None,
+                 sparse=False):
+        if G is None:
+            return  # for tree unflattenning
+        if isinstance(G, (list, tuple, np.ndarray)):
+            G = graphs.mlgraph(G)
+        assert nx.is_directed_acyclic_graph(G)
+        layers = [sorted(g) for g in nx.topological_generations(G)]
+        nlst = sum(layers, [])
+        H = nx.relabel_nodes(G, dict(zip(nlst, range(len(G)))))
+        layers = [sorted(g) for g in nx.topological_generations(H)]
+        arch = [len(li) for li in layers]
+        carch = utils.acc(arch)  # list(itertools.accumulate(arch))
+        sizes = list(zip(arch[1:], carch[:-1]))  # sizes of weight matrices
+        conecs = [list(zip(*H.in_edges(li))) for li in layers[1:]]
+        wmrk = utils.pacc([0] + [len(ci[0]) for ci in conecs])
+        bmrk = utils.pacc([wmrk[-1][1]] + arch[1:])
+        inps = sorted((n for n, d in G.in_degree() if d == 0))
+        outs = sorted((n for n, d in G.out_degree() if d == 0))
+        f, p = utils.unroll_fp(f, p, arch)
+        self.nlst = nlst
+        self.n = len(H)
+        self.inps = inps
+        self.outs = outs
+        self.ni = len(self.inps)
+        self.no = len(self.outs)
+        self.nw = len(H.edges)
+        self.nb = self.n - self.ni
+        self.wshp = [(s, (tuple(np.asarray(i1)-i1[0]), i0), wm, bm)
+                     for s, (i0, i1), wm, bm in zip(sizes, conecs, wmrk, bmrk)]
+        self.f = f
+        self.p = p
+        self.sparse = sparse
+        self.initw(key=key)
+        if initx is not None:
+            self.initx(initx)
+        if inity is not None:
+            self.inity(inity)
+        # self.codes = {None: [[i] for i in range(self.ni)],
+        #               'F': [[0]], 'dFx': [[0, 0]]}
+        self._register_pytree()
+
+    def initw(self, key=None):
+        w = []
+        b = []
+        for s, (i0, i1), _, _ in self.wshp:
+            u, c = np.unique(i0, return_counts=True)
+            n = np.repeat(c, c)
+            state = np.random.get_state()
+            np.random.seed(key)
+            r = np.random.uniform(-1., 1., size=len(i0)+s[0])
+            np.random.set_state(state)
+            w += [jnp.asarray(2.38*r[:len(i0)]/np.sqrt(n+1))]
+            b += [jnp.asarray(2.38*r[len(i0):]/np.sqrt(c+1))]
+        w = jnp.concatenate(w + b)
+        self.w = w
+        return w
+
+    def initx(self, x):
+        x = jnp.atleast_2d(x)
+        assert x.shape[1] == self.ni
+        ax, bx = utils.to01c(x)
+        self.f[0] = 'linear'
+        self.p[0] = (ax, bx)
+        return ax, bx
+
+    def inity(self, y):
+        y = jnp.atleast_2d(y)
+        assert y.shape[1] == self.no
+        ay, by = utils.from01c(y)
+        self.f[-1] = 'linear'
+        self.p[-1] = (ay, by)
+        return ay, by
+
+    def afunc(self, xi, i):
+        f = self.f[i]
+        p = self.p[i]
+        match f:
+            case 'identity':
+                return xi
+            case 'linear':
+                return self.linear(xi, *p)
+            case 'relu':
+                return jax.nn.relu(xi, *p)
+            case 'sigmoid':
+                return jax.nn.sigmoid(xi, *p)
+            case 'softplus':
+                return jax.nn.softplus(xi, *p)
+            case _:
+                return f(xi, *p)
+
+    def _prop(self, x):
+        y = self.afunc(x, 0)
+        Y = jnp.zeros(self.n).at[jnp.asarray(self.inps)].set(y)
+        for i, (s, (i0, i1), (j, k), (l, m)) in enumerate(self.wshp):
+            wi = self.w[j:k]
+            bi = self.w[l:m]
+            if self.sparse:
+                wi = BCOO((wi, jnp.asarray((i0, i1)).T), shape=s)
+            else:
+                wi = jnp.zeros(s).at[i0, i1].set(wi)  # dense is default
+            yi = Y[:s[1]]
+            xi = wi@yi + bi
+            y = self.afunc(xi, i+1)
+            Y = Y.at[s[1]:s[1]+s[0]].set(y)
+        return Y[jnp.asarray(self.outs)]
+
+    @jax.jit
+    @partial(jax.vmap, in_axes=(None, 0, None))
+    def propd(self, x, spec):
+        f = self._prop
+
+        def deriv(f, x, v):
+            return jax.jvp(f, [x], [v])[1]
+
+        def one_hot(i):
+            return jnp.zeros(len(x)).at[i].set(1)
+
+        df = []
+        dy = []
+        for i, a, in enumerate(spec):
+            df += [[f]]
+            for j, n in enumerate(a[1:]):
+                def dfij(x, i=i, j=j, n=n):
+                    vn = one_hot(n)
+                    return deriv(df[i][j], x, vn)
+                df[i] += [dfij]
+            k = jnp.atleast_1d(jnp.asarray(a[0]))
+            dy += [df[i][-1](x)[k]]
+        return jnp.concatenate(dy)
+
+    @jax.jit
+    def propx(self, xspec):
+        return tuple(self.propd(a[0], [a[1:]]).ravel() for a in xspec)
+
+    @jax.jit
+    @partial(jax.vmap, in_axes=(None, 0))
+    def __call__(self, x):
+        return self._prop(x)
+
+    # @jax.jit
+    # def __call__(self, x, spec=None):
+    #     spec = self.codes.get(spec, spec)
+    #     return self._propd(x, spec)
+
+    @jax.jit
+    def loss(self, w, x, t):
+        self.w = jnp.asarray(w)
+        return self.mse(self(x), t)
+
+    @jax.jit
+    @partial(jax.grad, argnums=1)
+    def lossg(self, w, *args):
+        return self.loss(w, *args)
+
+    @jax.jit
+    @partial(jax.value_and_grad, argnums=1)
+    def lossvg(self, w, *args):
+        return self.loss(w, *args)
+
+    @jax.jit
+    @partial(jax.jacobian, argnums=1)
+    def eqcj(self, w, *args):
+        return self.eqc(w, *args)
+
+    @jax.jit
+    @partial(jax.jacobian, argnums=1)
+    def ineqcj(self, w, *args):
+        return self.ineqc(w, *args)
+
+    # @jax.jit
+    # def loss(self, w, *args):
+    #     self.w = jnp.asarray(w)
+    #     y = self.eqs(w, *args)
+    #     return sum(mse(yi) for yi in y)
+
+    # This is concrete represntation of eqs
+    # @jax.jit
+    # def eqs(self, w, x, t):
+    #     self.w = jnp.asarray(w)
+    #     return [self(x) - t]
+
+    # Unfortunately jax's BFGS most of the time fails because of 3 - zoom error
+    # def train(self, *args, maxiter=None, tol=None, method='BFGS', **kwargs):
+    #     from jax.scipy.optimize import minimize
+    #     res = minimize(self.loss, self.w, args,
+    #                    tol=tol,
+    #                    options={'maxiter': maxiter},
+    #                    method=method,
+    #                    **kwargs)
+    #     self.w = jnp.asarray(res.x)
+    #     return res
+
+    # We use scipy.optimize.minimize here. It has many advantages,
+    # but cannot be jitted...
+    def train(self, *args, tol=1e-5, maxiter=None, disp=False, **kwargs):
+        options = kwargs.pop('options', {})
+        options.setdefault('maxiter', maxiter)
+        options.setdefault('disp', disp)
+        cstr = []
+        if hasattr(self, 'eqc'):
+            cstr += [{'type': 'eq',
+                      'fun': self.eqc,
+                      'jac': self.eqcj,
+                      'args': args}]
+        if hasattr(self, 'ineqc'):
+            cstr += [{'type': 'ineq',
+                      'fun': self.ineqc,
+                      'jac': self.ineqcj,
+                      'args': args}]
+        method = 'BFGS' if len(cstr) == 0 else 'SLSQP'
+        if method == 'SLSQP':
+            options['ftol'] = tol  # it seems this is set here
+        res = minimize(self.loss, self.w, args, jac=self.lossg,
+                       method=method,
+                       tol=tol,
+                       constraints=cstr,
+                       options=options,
+                       **kwargs)
+        self.w = jnp.asarray(res.x)
+        return res
+
+    @staticmethod
+    def linear(x, a=1., b=0.):
+        return a*x + b
+
+    @staticmethod
+    def mse(y, t=0.):
+        y = jnp.asarray(y).ravel()
+        t = jnp.asarray(t).ravel()
+        return jnp.mean((y - t)**2)
+
+    @staticmethod
+    def rmse(y, t=0.):
+        return jnp.sqrt(spinn.mse(y, t))
+
+    def _tree_flatten(self):
+        children = (self.w, self.p)     # dynamic values
+        aux_data = {'nlst': self.nlst,
+                    'n': self.n,
+                    'inps': self.inps,
+                    'outs': self.outs,
+                    'ni': self.ni,
+                    'no': self.no,
+                    'nw': self.nw,
+                    'nb': self.nb,
+                    'wshp': self.wshp,
+                    'f': self.f,
+                    'sparse': self.sparse}  # static values
+        return (children, aux_data)
+
+    @classmethod
+    def _tree_unflatten(cls, aux_data, children):
+        obj = cls(None)
+        obj.w = children[0]
+        obj.p = children[1]
+        obj.__dict__.update(aux_data)
+        return obj
+
+    @classmethod
+    def _register_pytree(cls):
+        # This method is called at __init__ and allows for
+        # automatic pytree registration of subclasses.
+        # Function 'register_pytree_node' returns ValueError when registering
+        # the same class many times, so there is the 'if' below. Anyway,
+        # in case of troubles try to do this explicitly!
+        if cls not in jax._src.tree_util._registry:
+            jax.tree_util.register_pytree_node(cls,
+                                               cls._tree_flatten,
+                                               cls._tree_unflatten)
+
+
+if __name__ == "__main__":
+    import os
+    import subprocess
+    fname = os.path.dirname(os.path.realpath(__file__))
+    subprocess.call(['pytest', fname])

spinn-0.1.0/spinn/utils.py

@@ -0,0 +1,166 @@
+import itertools
+import functools
+import random
+import jax
+import jax.numpy as jnp
+
+
+def prod(s1, s2):
+    return list(itertools.product(s1, s2))
+
+
+def acc(s):
+    return list(itertools.accumulate(s))
+
+
+def pairwise(s):
+    return list(itertools.pairwise(s))
+
+
+def pacc(s):
+    return list(itertools.pairwise(itertools.accumulate(s)))
+
+
+def to01c(x):
+    assert len(x.shape) == 2
+    assert x.shape[0] >= 2
+
+    def _to01(lim):
+        a, b = lim.T
+        c0 = 1./(b-a)
+        c1 = -a * c0
+        return c0, c1
+
+    xlim = jnp.asarray([(i.min(), i.max()) for i in x.T])
+    ax, bx = _to01(xlim)
+    return ax, bx
+
+
+def from01c(x):
+    def _from01(lim):
+        c, d = lim.T
+        c0 = d - c
+        c1 = c
+        return c0, c1
+
+    if isinstance(x, int):
+        xlim = jnp.asarray([(0., 1.)]*x)
+    else:
+        xlim = jnp.asarray([(i.min(), i.max()) for i in x.T])
+
+    ax, bx = _from01(xlim)
+    return ax, bx
+
+
+def unroll_fp(f, p, arch):
+    nl = len(arch)
+    if f is None:
+        f = ['identity'] + ['softplus']*(nl-2) + ['identity']
+    elif isinstance(f, str) or callable(f):
+        f = ['identity'] + [f]*(nl-2) + ['identity']
+    elif isinstance(f, list):
+        if len(f) == 3:
+            f = [f[0]] + [f[1]]*(nl-2) + [f[2]]
+        elif len(f) == len(arch):
+            f = f
+        else:
+            raise ValueError(f"{len(f)} funcs given for {len(arch)} layers.")
+    else:
+        raise ValueError("'f' have to be None, str, callable or a list.")
+    if p is None:
+        p = [()]*nl
+    elif isinstance(p, tuple):
+        p = [()] + [p]*(nl-2) + [()]
+    elif isinstance(p, list):
+        if len(p) == 3:
+            p = [p[0]] + [p[1]]*(nl-2) + [p[2]]
+        elif len(p) == len(arch):
+            p = p
+        else:
+            raise ValueError(f"{len(p)} params given for {len(arch)} layers")
+    else:
+        raise ValueError("'p' have to be None, tuple or a list.")
+    return f, p
+
+
+def meshgrid(*arrs):
+    arrs = tuple(reversed(arrs))
+    lens = tuple(map(len, arrs))
+    dim = len(arrs)
+    sz = 1
+    for s in lens:
+        sz *= s
+    ans = []
+    for i, arr in enumerate(arrs):
+        slc = [1]*dim
+        slc[i] = lens[i]
+        arr2 = jnp.asarray(arr).reshape(slc)
+        for j, sz in enumerate(lens):
+            if j != i:
+                arr2 = arr2.repeat(sz, axis=j)
+        ans.append(arr2)
+    return tuple(ans)
+
+
+def hcube(dims, n=11, origin=None):
+    dims = (1.,)*dims if isinstance(dims, int) else dims
+    dims = (dims,) if isinstance(dims, float) else dims
+    d = len(dims)
+    n = (n,)*d if isinstance(n, int) else n
+    origin = (0,)*d if origin is None else origin
+    xyz = [jnp.linspace(origin[i], dims[i]+origin[i], n[i]) for i in range(d)]
+    XYZ = meshgrid(*xyz)
+    return jnp.vstack(tuple(map(jnp.ravel, XYZ))).T
+
+
+def left(pts):
+    x = pts[:, 0]
+    return pts[jnp.isclose(x, min(x))]
+
+
+def right(pts):
+    x = pts[:, 0]
+    return pts[jnp.isclose(x, max(x))]
+
+
+def bottom(pts):
+    x = pts[:, 1]
+    return pts[jnp.isclose(x, min(x))]
+
+
+def top(pts):
+    x = pts[:, 1]
+    return pts[jnp.isclose(x, max(x))]
+
+
+def uniform(low=0., high=1., shape=(), key=None):
+    shape = (shape,) if isinstance(shape, int) else shape
+    key = random.randint(0, 10000000000) if key is None else key
+    key = jax.random.PRNGKey(key) if isinstance(key, int) else key
+    return jax.random.uniform(key, shape=shape, minval=low, maxval=high)
+
+
+def randomweights(arch, key=None):
+    W = []
+    wshp = list(itertools.pairwise(arch))
+    bshp = arch[1:]
+    for i, n in enumerate(arch[:-1]):
+        bound = 2.38/jnp.sqrt(n+1)
+        w = uniform(-bound, bound, shape=wshp[i])
+        b = uniform(-bound, bound, shape=bshp[i])
+        W += [[w, b]]
+    return W
+
+
+@jax.jit
+@functools.partial(jax.vmap, in_axes=(None, 0, None))
+def simpleprop(w, x, c):
+    ax, bx, ay, by = c
+    y = ax*x + bx
+    for wi, bi in w[:-1]:
+        yi = y.dot(wi) + bi
+        y = jax.nn.softplus(yi)
+    wi, bi = w[-1]
+    y = y.dot(wi) + bi
+    y = ay*y + by
+    return y

spinn-0.1.0/spinn.egg-info/PKG-INFO

@@ -0,0 +1,23 @@
+Metadata-Version: 2.1
+Name: spinn
+Version: 0.1.0
+Summary: Simple Physics Informed Neural Networks
+Home-page: https://github.com/mrkwjc/spinn
+Author: Marek Wojciechowski
+Author-email: mwojc@p.lodz.pl
+License: LGPL-2.1
+Keywords: ann,pinn
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jax
+Requires-Dist: jaxlib
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: networkx
+
+# spinn - Simple Physics Informed Neural Networks
+Makes PINNs easy (with jax), see examples...

spinn-0.1.0/spinn.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+spinn/__init__.py
+spinn/graphs.py
+spinn/trees.py
+spinn/utils.py
+spinn.egg-info/PKG-INFO
+spinn.egg-info/SOURCES.txt
+spinn.egg-info/dependency_links.txt
+spinn.egg-info/requires.txt
+spinn.egg-info/top_level.txt

spinn-0.1.0/spinn.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

spinn-0.1.0/spinn.egg-info/requires.txt

@@ -0,0 +1,5 @@
+jax
+jaxlib
+numpy
+scipy
+networkx

spinn-0.1.0/spinn.egg-info/top_level.txt

@@ -0,0 +1 @@
+spinn