neural-spatial-nets 0.1.0__tar.gz

neural_spatial_nets-0.1.0/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.

neural_spatial_nets-0.1.0/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: neural_spatial_nets
+Version: 0.1.0
+Summary: A Python library for spatial and Hopfield neural networks.
+Author-email: SK SAMIUL HQ <sksamiul5045@gmail.com>
+Project-URL: Homepage, https://github.com/sksamiul5045-lang/neural_spatial_nets
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# neural_spatial_nets
+
+A Python package for implementing spatial, Euclidean, and Hopfield neural networks.
+
+## Installation
+
+You can install this package locally for development:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+from neural_spatial_nets import SpatialNetwork, Euclidean_network, HP_network
+```

neural_spatial_nets-0.1.0/README.md

@@ -0,0 +1,17 @@
+# neural_spatial_nets
+
+A Python package for implementing spatial, Euclidean, and Hopfield neural networks.
+
+## Installation
+
+You can install this package locally for development:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+from neural_spatial_nets import SpatialNetwork, Euclidean_network, HP_network
+```

neural_spatial_nets-0.1.0/neural_spatial_nets/Euclidean.py

@@ -0,0 +1,80 @@
+import numpy as np
+
+class Euclidean_network:
+
+    def __init__(self, N, d, beta, m):
+
+        self.N = N
+        self.d = d
+        self.beta = beta
+        self.m = m
+
+        self.positions = np.random.rand(N, d)
+
+        self.degree = np.zeros(N, dtype=int)
+        self.edges = []
+
+        # Initial complete graph of m nodes
+        for i in range(m):
+            for j in range(i + 1, m):
+                self.edges.append((i, j))
+                self.degree[i] += 1
+                self.degree[j] += 1
+
+        self.grow_network()
+
+        self.A = self.generate_adjacency_matrix()
+
+    def compute_distances(self,a,b):
+        return np.linalg.norm(self.positions[a] - self.positions[b])
+    
+
+    def generate_adjacency_matrix(self):
+        adjacency_matrix = np.zeros((self.N, self.N), dtype=int)
+        for u,v in self.edges:
+            adjacency_matrix[u][v] = 1
+            adjacency_matrix[v][u] = 1
+        return adjacency_matrix
+    
+    def link_length(self):
+        length = []
+        for u,v in self.edges:
+            length.append(self.compute_distances(u,v))
+        return np.array(length)
+    
+    def grow_network(self):
+
+        for t in range(self.m, self.N):
+
+            weight = np.zeros(t)
+
+            for i in range(t):
+
+                l = self.compute_distances(t, i)
+
+                # avoid division by zero
+                l = max(l, 1e-12)
+
+                weight[i] = self.degree[i] * (l ** self.beta)
+
+            prob = weight / weight.sum()
+
+            targets = np.random.choice(
+                np.arange(t),
+                size=self.m,
+                replace=False,
+                p=prob
+            )
+
+            for target in targets:
+
+                self.edges.append((t, target))
+
+                self.degree[t] += 1
+                self.degree[target] += 1
+
+
+    def degree_distribution(self):
+        k, counts = np.unique(self.degree, return_counts=True)
+        Pk = counts / counts.sum()
+        return k, Pk

neural_spatial_nets-0.1.0/neural_spatial_nets/Hopfield.py

@@ -0,0 +1,97 @@
+import numpy as np
+import networkx as nx
+import matplotlib.pyplot as plt
+
+class HP_network:
+
+    def __init__(self, Network):
+        self.Network = Network
+        self.N = len(Network)
+        self.A = self.adjacency_matrix()
+        self.pattern = None
+        self.J = None
+
+    def adjacency_matrix(self):
+        return nx.adjacency_matrix(
+            self.Network
+        ).toarray().astype(float)
+
+    def train(self, patterns):
+
+        self.pattern = np.asarray(patterns)
+
+        self.J = np.zeros((self.N, self.N))
+
+        for p in self.pattern:
+            self.J += np.outer(p, p)
+
+        k_mean = np.mean(np.sum(self.A, axis=1))
+
+        self.J /= k_mean
+        self.J *= self.A
+
+        np.fill_diagonal(self.J, 0)
+
+    def energy(self, state):
+        return -0.5 * state @ self.J @ state
+
+    def overlap(self, target, state):
+        return np.dot(target, state) / self.N
+
+    def update_async(self, state):
+
+        new_state = state.copy()
+
+        for i in np.random.permutation(self.N):
+
+            h_i = self.J[i] @ new_state
+
+            if h_i >= 0:
+                new_state[i] = 1
+            else:
+                new_state[i] = -1
+
+        return new_state
+
+    def recall(self, initial_state, target_state, max_iter):
+
+        state = initial_state.copy()
+
+        energies = [self.energy(state)]
+        overlaps = [self.overlap(target_state, state)]
+        magnetizations = [np.mean(state)]
+        times = [0]
+
+        retrieval_time = max_iter
+
+        for t in range(1, max_iter + 1):
+
+            new_state = self.update_async(state)
+
+            energies.append(self.energy(new_state))
+            overlaps.append(self.overlap(target_state, new_state))
+            magnetizations.append(np.mean(new_state))
+            times.append(t)
+
+            if np.array_equal(new_state, state):
+                retrieval_time = t
+                state = new_state
+                break
+
+            state = new_state
+
+        return state, energies, overlaps, magnetizations, retrieval_time
+
+    def add_noise(self, pattern, noise_lv=0.10):
+
+        noisy = pattern.copy()
+
+        flip = np.random.choice(
+            self.N,
+            size=int(noise_lv * self.N),
+            replace=False
+        )
+
+        noisy[flip] *= -1
+
+        return noisy

neural_spatial_nets-0.1.0/neural_spatial_nets/__init__.py

@@ -0,0 +1,6 @@
+from .spatial_network import SpatialNetwork
+from .euclidean import Euclidean_network
+from .hopfield import HP_network
+
+# Defines what gets imported when someone uses "from neural_spatial_nets import *"
+__all__ = ["SpatialNetwork", "Euclidean_network", "HP_network"]

neural_spatial_nets-0.1.0/neural_spatial_nets/spatial_network.py

@@ -0,0 +1,270 @@
+import numpy as np
+import networkx as nx
+
+
+class SpatialNetwork:
+
+    def __init__(self, N, M=0, delta=0, dimension=1, seed=None):
+
+        self.N = N
+        self.M = M
+        self.delta = delta
+        self.dimension = dimension
+
+        self.rng = np.random.default_rng(seed)
+
+        self.network = nx.Graph()
+
+        self.positions = None
+        self.A = None
+
+        # Dimensions of the lattice
+        if self.dimension == 1:
+
+            self.L = N
+
+        elif self.dimension == 2:
+
+            self.Lx, self.Ly = self.get_dimensions()
+
+        else:
+
+            raise ValueError(
+                "dimension must be 1 or 2"
+            )
+
+
+    # ========================================================
+    # 2D lattice dimensions
+    # ========================================================
+
+    def get_dimensions(self):
+
+        Lx = int(np.sqrt(self.N))
+
+        while Lx > 1 and self.N % Lx != 0:
+
+            Lx -= 1
+
+        Ly = self.N // Lx
+
+        if Lx == 1:
+
+            raise ValueError(
+                "N must have two factors for a 2D periodic lattice"
+            )
+
+        return Lx, Ly
+
+
+    # ========================================================
+    # 2D coordinate -> node number
+    # ========================================================
+
+    def node(self, x, y):
+
+        return x * self.Ly + y
+
+
+    # ========================================================
+    # Distance
+    # ========================================================
+
+    def distance(self, i, j):
+
+        # -------------------------
+        # 1D periodic distance
+        # -------------------------
+
+        if self.dimension == 1:
+
+            d = abs(i - j)
+
+            return min(d,self.N - d)
+        # -------------------------
+        # 2D periodic distance
+        # -------------------------
+
+        elif self.dimension == 2:
+
+            x1, y1 = self.positions[i]
+            x2, y2 = self.positions[j]
+
+            dx = abs(x1 - x2)
+            dy = abs(y1 - y2)
+
+            dx = min(dx,self.Lx - dx)
+
+            dy = min(dy,self.Ly - dy)
+
+            return np.sqrt(dx**2 + dy**2)
+
+
+    # ========================================================
+    # Distance-dependent weight
+    # ========================================================
+
+    def probability(self, r):
+
+        if self.delta == 0:
+
+            return 1.0
+
+        return float(r) ** (-self.delta)
+
+
+    # ========================================================
+    # Construct regular lattice
+    # ========================================================
+
+    def regular_lattice(self):
+
+        # ----------------------------------------------------
+        # 1D periodic ring
+        # ----------------------------------------------------
+
+        if self.dimension == 1:
+
+            self.positions = np.arange(self.N).reshape(-1, 1)
+
+            self.network.add_nodes_from(range(self.N))
+            for i in range(self.N):
+
+                j = (i + 1) % self.N
+
+                self.network.add_edge(i,j)
+
+        # ----------------------------------------------------
+        # 2D periodic square lattice
+        # ----------------------------------------------------
+
+        elif self.dimension == 2:
+
+            self.positions = np.array([
+                (x, y)
+                for x in range(self.Lx)
+                for y in range(self.Ly)
+            ])
+
+            self.network.add_nodes_from(range(self.N))
+
+            for x in range(self.Lx):
+
+                for y in range(self.Ly):
+
+                    i = self.node(x,y)
+
+     # Right neighbour
+                    j = self.node((x + 1) % self.Lx , y)
+
+                    self.network.add_edge(i,j)
+
+                    # Up neighbour
+                    j = self.node(x,(y + 1) % self.Ly)
+
+                    self.network.add_edge(i,j)
+
+
+    # ========================================================
+    # Add M extra bonds
+    # ========================================================
+
+    def add_links(self):
+
+        pairs = []
+        weights = []
+
+        # ----------------------------------------------------
+        # Find all possible non-existing pairs
+        # ----------------------------------------------------
+
+        for i in range(self.N):
+
+            for j in range(i + 1, self.N):
+
+                # Do not select existing lattice bonds
+                if self.network.has_edge(i, j):
+
+                    continue
+
+                # Distance
+                r = self.distance(i, j)
+
+                # No self loops
+                if r == 0:
+
+                    continue
+
+                # Distance-dependent weight
+                w = self.probability(r)
+
+                pairs.append((i, j))
+
+                weights.append(w)
+
+
+        # ----------------------------------------------------
+        # Normalize probabilities
+        # ----------------------------------------------------
+
+        weights = np.asarray(weights,dtype=float)
+
+        weights /= weights.sum()
+
+        # ----------------------------------------------------
+        # Select M different pairs
+        # ----------------------------------------------------
+
+        M = min(self.M,len(pairs))
+
+        selected = self.rng.choice(
+            len(pairs),
+            size=M,
+            replace=False,
+            p=weights
+        )
+
+
+        # ----------------------------------------------------
+        # Add extra bonds
+        # ----------------------------------------------------
+
+        for k in selected:
+
+            i, j = pairs[k]
+
+            self.network.add_edge(i,j)
+
+
+    # ========================================================
+    # Generate network
+    # ========================================================
+
+    def generate(self):
+
+        self.regular_lattice()
+
+        if self.M > 0:
+
+            self.add_links()
+
+        self.A = nx.to_numpy_array(
+            self.network,
+            dtype=int)
+
+        return self.network
+
+
+    # ========================================================
+    # Adjacency matrix
+    # ========================================================
+
+    def adjacency_matrix(self):
+
+        if self.A is None:
+
+            self.generate()
+
+        return self.A
+
+

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

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: neural_spatial_nets
+Version: 0.1.0
+Summary: A Python library for spatial and Hopfield neural networks.
+Author-email: SK SAMIUL HQ <sksamiul5045@gmail.com>
+Project-URL: Homepage, https://github.com/sksamiul5045-lang/neural_spatial_nets
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# neural_spatial_nets
+
+A Python package for implementing spatial, Euclidean, and Hopfield neural networks.
+
+## Installation
+
+You can install this package locally for development:
+
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+from neural_spatial_nets import SpatialNetwork, Euclidean_network, HP_network
+```

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

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+neural_spatial_nets/Euclidean.py
+neural_spatial_nets/Hopfield.py
+neural_spatial_nets/__init__.py
+neural_spatial_nets/spatial_network.py
+neural_spatial_nets.egg-info/PKG-INFO
+neural_spatial_nets.egg-info/SOURCES.txt
+neural_spatial_nets.egg-info/dependency_links.txt
+neural_spatial_nets.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+neural_spatial_nets

neural_spatial_nets-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "neural_spatial_nets"
+version = "0.1.0"
+authors = [
+  { name="SK SAMIUL HQ", email="sksamiul5045@gmail.com" },
+]
+description = "A Python library for spatial and Hopfield neural networks."
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/sksamiul5045-lang/neural_spatial_nets"

neural_spatial_nets-0.1.0/setup.cfg

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