pyopu 0.1.0__tar.gz

pyopu-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: pyopu
+Version: 0.1.0
+Summary: Organoid Processing Unit (OPU) framework for Organoid Computing
+Author: Neuroqudit Research & Development
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: brian2>=2.5.0
+Requires-Dist: matplotlib>=3.3.0
+Requires-Dist: networkx>=2.5
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# pyopu: Organoid Processing Unit Framework
+
+`pyopu` is a Python framework for simulating and executing combinatorial optimization tasks on biological wetware (Brain Organoids) using the **Holographic Tensorial Paradigm**.
+
+## Features
+- **Agnostic Math Engine:** Compile NP-Hard problems into Rank-2 and Rank-3 Tensors.
+- **Interchangeable Backends:** Run problems on virtual MEAs (Microelectrode Arrays) or advanced Dual-Opsin Optogenetic interfaces.
+- **Observer Telemetry:** Extract spikes, opsin kinetics, and energy dynamics cleanly without cluttering the engine.
+
+## Quickstart
+Check the `examples/` directory for full implementations of the Max-Cut and 3-SAT problems.

pyopu-0.1.0/README.md

@@ -0,0 +1,11 @@
+# pyopu: Organoid Processing Unit Framework
+
+`pyopu` is a Python framework for simulating and executing combinatorial optimization tasks on biological wetware (Brain Organoids) using the **Holographic Tensorial Paradigm**.
+
+## Features
+- **Agnostic Math Engine:** Compile NP-Hard problems into Rank-2 and Rank-3 Tensors.
+- **Interchangeable Backends:** Run problems on virtual MEAs (Microelectrode Arrays) or advanced Dual-Opsin Optogenetic interfaces.
+- **Observer Telemetry:** Extract spikes, opsin kinetics, and energy dynamics cleanly without cluttering the engine.
+
+## Quickstart
+Check the `examples/` directory for full implementations of the Max-Cut and 3-SAT problems.

pyopu-0.1.0/pyopu/__init__.py

@@ -0,0 +1 @@
+from .engine import TensorEngine, OPUResult

pyopu-0.1.0/pyopu/engine.py

@@ -0,0 +1,55 @@
+import numpy as np
+from pyopu.tensors.base_tensor import Rank1Tensor, Rank2Tensor, Rank3Tensor
+from pyopu.telemetry.base_telemetry import Observable
+
+class OPUResult:
+    def __init__(self, final_probabilities):
+        self.final_probabilities = final_probabilities
+
+    def get_binary_state(self, threshold=0.5):
+        return [1 if p > threshold else 0 for p in self.final_probabilities]
+
+class TensorEngine(Observable):
+    def __init__(self, organoid, interface):
+        super().__init__()
+        self.organoid = organoid
+        self.interface = interface
+        self.T1 = None; self.T2 = None; self.T3 = None
+
+    def set_tensors(self, t1: Rank1Tensor, t2: Rank2Tensor = None, t3: Rank3Tensor = None):
+        nv = t1.num_vars
+        if t2 is not None and t2.num_vars != nv: raise ValueError("Rank-2 var mismatch.")
+        if t3 is not None and t3.num_vars != nv: raise ValueError("Rank-3 var mismatch.")
+        self.T1 = t1.data
+        self.T2 = t2.data if t2 is not None else None
+        self.T3 = t3.data if t3 is not None else None
+
+    def _calculate_force(self):
+        Force = np.copy(self.T1)
+        if self.T2 is not None:
+            Force += np.dot(self.T2, self.organoid.x_state) + np.dot(self.T2.T, self.organoid.x_state)
+        if self.T3 is not None:
+            F3 = np.einsum('ijk,j,k->i', self.T3, self.organoid.x_state, self.organoid.x_state)
+            F3 += np.einsum('jik,j,k->i', self.T3, self.organoid.x_state, self.organoid.x_state)
+            F3 += np.einsum('jki,j,k->i', self.T3, self.organoid.x_state, self.organoid.x_state)
+            Force += F3
+        return Force
+
+    def run(self, duration_ms=1000.0, dt_kernel_ms=10.0):
+        if self.T1 is None: raise ValueError("Tensors not set.")
+        steps = int(duration_ms / dt_kernel_ms)
+        print(f"Starting OPU Simulation ({self.organoid.num_neobits} Neobits)...")
+
+        for step in range(steps):
+            x_inst = self.interface.read_from_organoid(self.organoid._control_spike_mon, self.organoid.neurons_per_neobit, self.organoid.num_neobits)
+            self.organoid.x_state = 0.8 * self.organoid.x_state + 0.2 * x_inst
+            force = self._calculate_force()
+            self.interface.write_to_organoid(self.organoid.neuron_group, force, self.organoid.neurons_per_neobit)
+            
+            # Notify observers (like EnergyTelemetry)
+            self.notify_telemetries(x_state=self.organoid.x_state, force=force)
+            
+            self.organoid.run_step(dt_kernel_ms)
+            
+        print("Execution Complete.")
+        return OPUResult(self.organoid.x_state)

pyopu-0.1.0/pyopu/interfaces/base_interface.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+class BaseInterface(ABC):
+    @abstractmethod
+    def get_biological_equations(self): pass
+    @abstractmethod
+    def read_from_organoid(self, spike_monitor, neurons_per_neobit, num_neobits): pass
+    @abstractmethod
+    def write_to_organoid(self, neuron_group, force_array, neurons_per_neobit): pass

pyopu-0.1.0/pyopu/interfaces/mea_interface.py

@@ -0,0 +1,30 @@
+import numpy as np
+import brian2 as b2
+from .base_interface import BaseInterface
+
+class MEAInterface(BaseInterface):
+    def __init__(self, temperature=1.0, max_current_na=2.0):
+        self.T_sys = temperature
+        self.max_current = max_current_na * b2.nA
+        self.last_spike_count = None
+
+    def get_biological_equations(self):
+        return '''
+        I_stim = I_op : amp
+        I_op : amp
+        '''
+
+    def read_from_organoid(self, spike_monitor, neurons_per_neobit, num_neobits):
+        if self.last_spike_count is None: self.last_spike_count = np.zeros(num_neobits * neurons_per_neobit)
+        curr = np.array(spike_monitor.count)
+        delta = curr - self.last_spike_count
+        self.last_spike_count = curr
+        x_inst = np.zeros(num_neobits)
+        for i in range(num_neobits):
+            if np.sum(delta[i*neurons_per_neobit : (i+1)*neurons_per_neobit]) > 1: x_inst[i] = 1.0
+        return x_inst
+
+    def write_to_organoid(self, neuron_group, force_array, neurons_per_neobit):
+        prob = 1.0 / (1.0 + np.exp(force_array / self.T_sys))
+        currents = (prob - 0.5) * 2.0 * self.max_current
+        neuron_group.I_op = np.repeat(currents, neurons_per_neobit)

pyopu-0.1.0/pyopu/interfaces/opto_interface.py

@@ -0,0 +1,40 @@
+import numpy as np
+import brian2 as b2
+from .base_interface import BaseInterface
+
+class OptoInterface(BaseInterface):
+    def __init__(self, temperature=1.0, max_rate_hz=200.0):
+        self.T_sys = temperature
+        self.max_rate_hz = max_rate_hz
+        self.last_spike_count = None
+
+    def get_biological_equations(self):
+        return '''
+        I_stim = I_blue + I_yellow : amp
+        I_blue = 2.0 * nA * O_blue * (0*mV - v) / (60*mV) : amp
+        I_yellow = 2.0 * nA * O_yellow * (-90*mV - v) / (60*mV) : amp
+        dO_blue/dt = (phi_blue * (1 - O_blue) - 0.1/ms * O_blue) : 1
+        dO_yellow/dt = (phi_yellow * (1 - O_yellow) - 0.05/ms * O_yellow) : 1
+        phi_blue : Hz
+        phi_yellow : Hz
+        '''
+
+    def read_from_organoid(self, spike_monitor, neurons_per_neobit, num_neobits):
+        if self.last_spike_count is None: self.last_spike_count = np.zeros(num_neobits * neurons_per_neobit)
+        curr = np.array(spike_monitor.count)
+        delta = curr - self.last_spike_count
+        self.last_spike_count = curr
+        x_inst = np.zeros(num_neobits)
+        for i in range(num_neobits):
+            if np.sum(delta[i*neurons_per_neobit : (i+1)*neurons_per_neobit]) > 1: x_inst[i] = 1.0
+        return x_inst
+
+    def write_to_organoid(self, neuron_group, force_array, neurons_per_neobit):
+        num_neobits = len(force_array)
+        prob = 1.0 / (1.0 + np.exp(force_array / self.T_sys))
+        blue = np.zeros(num_neobits); yellow = np.zeros(num_neobits)
+        for i in range(num_neobits):
+            if prob[i] > 0.5: blue[i] = (prob[i] - 0.5) * 2.0
+            else: yellow[i] = (0.5 - prob[i]) * 2.0
+        neuron_group.phi_blue = np.repeat(blue, neurons_per_neobit) * self.max_rate_hz * b2.Hz
+        neuron_group.phi_yellow = np.repeat(yellow, neurons_per_neobit) * self.max_rate_hz * b2.Hz

pyopu-0.1.0/pyopu/organoids/base_organoid.py

@@ -0,0 +1,5 @@
+from abc import ABC, abstractmethod
+
+class BaseOrganoid(ABC):
+    @abstractmethod
+    def run_step(self, dt_ms): pass

pyopu-0.1.0/pyopu/organoids/lif_organoid.py

@@ -0,0 +1,34 @@
+import numpy as np
+import brian2 as b2
+from .base_organoid import BaseOrganoid
+from pyopu.telemetry.base_telemetry import Observable
+
+class LIFOrganoid(BaseOrganoid, Observable):
+    def __init__(self, num_neobits, neurons_per_neobit, interface, noise_sigma=5.0):
+        Observable.__init__(self)
+        self.num_neobits = num_neobits
+        self.neurons_per_neobit = neurons_per_neobit
+        self.x_state = np.zeros(num_neobits)
+        
+        b2.start_scope()
+        b2.defaultclock.dt = 0.1 * b2.ms
+        
+        base_eqs = '''
+        dv/dt = (-70*mV - v + 100*Mohm * I_stim + noise_sigma * (20*ms)**-0.5 * xi) / (20*ms) : volt (unless refractory)
+        '''
+        full_eqs = base_eqs + interface.get_biological_equations()
+        
+        self.neuron_group = b2.NeuronGroup(
+            num_neobits * neurons_per_neobit, full_eqs, 
+            threshold='v > -50*mV', reset='v = -75*mV', refractory=2*b2.ms, method='heun',
+            namespace={'noise_sigma': noise_sigma * b2.mV}
+        )
+        self.neuron_group.v = '-70*mV + rand() * 20*mV'
+        self._control_spike_mon = b2.SpikeMonitor(self.neuron_group)
+        self.network = b2.Network(self.neuron_group, self._control_spike_mon)
+
+    def register_hardware(self, brian_object):
+        self.network.add(brian_object)
+
+    def run_step(self, dt_ms):
+        self.network.run(dt_ms * b2.ms)

pyopu-0.1.0/pyopu/telemetry/base_telemetry.py

@@ -0,0 +1,25 @@
+from abc import ABC, abstractmethod
+
+class BaseTelemetry(ABC):
+    @abstractmethod
+    def attach(self, subject):
+        pass
+
+    def update(self, *args, **kwargs):
+        pass
+        
+    @abstractmethod
+    def get_data(self):
+        pass
+
+class Observable:
+    def __init__(self):
+        self._telemetries = []
+
+    def attach_telemetry(self, telemetry: BaseTelemetry):
+        self._telemetries.append(telemetry)
+        telemetry.attach(self)
+
+    def notify_telemetries(self, *args, **kwargs):
+        for telemetry in self._telemetries:
+            telemetry.update(*args, **kwargs)

pyopu-0.1.0/pyopu/telemetry/bio_telemetry.py

@@ -0,0 +1,37 @@
+import brian2 as b2
+from .base_telemetry import BaseTelemetry
+
+class SpikeTelemetry(BaseTelemetry):
+    def __init__(self):
+        self.spike_monitor = None
+
+    def attach(self, organoid):
+        self.spike_monitor = b2.SpikeMonitor(organoid.neuron_group)
+        organoid.register_hardware(self.spike_monitor)
+
+    def get_data(self):
+        return {
+            "times_ms": self.spike_monitor.t / b2.ms,
+            "neuron_ids": self.spike_monitor.i
+        }
+
+class OpsinTelemetry(BaseTelemetry):
+    def __init__(self, record_indices):
+        self.record_indices = record_indices
+        self.state_monitor = None
+
+    def attach(self, organoid):
+        if 'O_blue' in organoid.neuron_group.equations.names:
+            self.state_monitor = b2.StateMonitor(
+                organoid.neuron_group, ['O_blue', 'O_yellow'], record=self.record_indices
+            )
+            organoid.register_hardware(self.state_monitor)
+        else:
+            raise ValueError("OpsinTelemetry attached to an organoid without Opsins.")
+
+    def get_data(self):
+        return {
+            "times_ms": self.state_monitor.t / b2.ms,
+            "O_blue": self.state_monitor.O_blue,
+            "O_yellow": self.state_monitor.O_yellow
+        }

pyopu-0.1.0/pyopu/telemetry/engine_telemetry.py

@@ -0,0 +1,16 @@
+import numpy as np
+from .base_telemetry import BaseTelemetry
+
+class EnergyTelemetry(BaseTelemetry):
+    def __init__(self):
+        self.history_energy = []
+
+    def attach(self, engine):
+        pass
+
+    def update(self, x_state, force):
+        energy = -np.sum(x_state * force)
+        self.history_energy.append(energy)
+
+    def get_data(self):
+        return {"energy_over_time": self.history_energy}

pyopu-0.1.0/pyopu/telemetry/interface_telemetry.py

@@ -0,0 +1,37 @@
+import brian2 as b2
+from .base_telemetry import BaseTelemetry
+
+class MeaTelemetry(BaseTelemetry):
+    def __init__(self, record_indices):
+        self.record_indices = record_indices
+        self.state_monitor = None
+
+    def attach(self, organoid):
+        if 'I_op' not in organoid.neuron_group.equations.names:
+            raise ValueError("MeaTelemetry attached to non-MEA organoid.")
+        self.state_monitor = b2.StateMonitor(organoid.neuron_group, ['I_op'], record=self.record_indices)
+        organoid.register_hardware(self.state_monitor)
+
+    def get_data(self):
+        return {
+            "times_ms": self.state_monitor.t / b2.ms,
+            "injected_current_nA": self.state_monitor.I_op / b2.nA
+        }
+
+class OptoTelemetry(BaseTelemetry):
+    def __init__(self, record_indices):
+        self.record_indices = record_indices
+        self.state_monitor = None
+
+    def attach(self, organoid):
+        if 'phi_blue' not in organoid.neuron_group.equations.names:
+            raise ValueError("OptoTelemetry attached to non-Opto organoid.")
+        self.state_monitor = b2.StateMonitor(organoid.neuron_group, ['phi_blue', 'phi_yellow'], record=self.record_indices)
+        organoid.register_hardware(self.state_monitor)
+
+    def get_data(self):
+        return {
+            "times_ms": self.state_monitor.t / b2.ms,
+            "light_blue_hz": self.state_monitor.phi_blue / b2.Hz,
+            "light_yellow_hz": self.state_monitor.phi_yellow / b2.Hz
+        }

pyopu-0.1.0/pyopu/tensors/base_tensor.py

@@ -0,0 +1,28 @@
+import numpy as np
+
+class Tensor:
+    def __init__(self, data, expected_rank):
+        self._data = np.array(data, dtype=np.float64)
+        self.rank = expected_rank
+        if self._data.ndim != self.rank:
+            raise ValueError(f"Expected Rank-{self.rank}, got dim={self._data.ndim}.")
+        self.shape = self._data.shape
+        if self.rank > 1 and not all(dim == self.shape[0] for dim in self.shape):
+            raise ValueError(f"Rank-{self.rank} Tensor must be hypercubic. Shape: {self.shape}.")
+        self.num_vars = self.shape[0] if self.shape else 0
+
+    @property
+    def data(self):
+        return self._data
+
+class Rank1Tensor(Tensor):
+    def __init__(self, data):
+        super().__init__(data, expected_rank=1)
+
+class Rank2Tensor(Tensor):
+    def __init__(self, data):
+        super().__init__(data, expected_rank=2)
+
+class Rank3Tensor(Tensor):
+    def __init__(self, data):
+        super().__init__(data, expected_rank=3)

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

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: pyopu
+Version: 0.1.0
+Summary: Organoid Processing Unit (OPU) framework for Organoid Computing
+Author: Neuroqudit Research & Development
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: brian2>=2.5.0
+Requires-Dist: matplotlib>=3.3.0
+Requires-Dist: networkx>=2.5
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# pyopu: Organoid Processing Unit Framework
+
+`pyopu` is a Python framework for simulating and executing combinatorial optimization tasks on biological wetware (Brain Organoids) using the **Holographic Tensorial Paradigm**.
+
+## Features
+- **Agnostic Math Engine:** Compile NP-Hard problems into Rank-2 and Rank-3 Tensors.
+- **Interchangeable Backends:** Run problems on virtual MEAs (Microelectrode Arrays) or advanced Dual-Opsin Optogenetic interfaces.
+- **Observer Telemetry:** Extract spikes, opsin kinetics, and energy dynamics cleanly without cluttering the engine.
+
+## Quickstart
+Check the `examples/` directory for full implementations of the Max-Cut and 3-SAT problems.

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

@@ -0,0 +1,23 @@
+README.md
+setup.py
+pyopu/__init__.py
+pyopu/engine.py
+pyopu.egg-info/PKG-INFO
+pyopu.egg-info/SOURCES.txt
+pyopu.egg-info/dependency_links.txt
+pyopu.egg-info/requires.txt
+pyopu.egg-info/top_level.txt
+pyopu/interfaces/__init__.py
+pyopu/interfaces/base_interface.py
+pyopu/interfaces/mea_interface.py
+pyopu/interfaces/opto_interface.py
+pyopu/organoids/__init__.py
+pyopu/organoids/base_organoid.py
+pyopu/organoids/lif_organoid.py
+pyopu/telemetry/__init__.py
+pyopu/telemetry/base_telemetry.py
+pyopu/telemetry/bio_telemetry.py
+pyopu/telemetry/engine_telemetry.py
+pyopu/telemetry/interface_telemetry.py
+pyopu/tensors/__init__.py
+pyopu/tensors/base_tensor.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,4 @@
+numpy>=1.20.0
+brian2>=2.5.0
+matplotlib>=3.3.0
+networkx>=2.5

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

@@ -0,0 +1 @@
+pyopu

pyopu-0.1.0/setup.cfg

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

pyopu-0.1.0/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="pyopu",
+    version="0.1.0",
+    author="Neuroqudit Research & Development",
+    description="Organoid Processing Unit (OPU) framework for Organoid Computing",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    packages=find_packages(),
+    install_requires=[
+        "numpy>=1.20.0",
+        "brian2>=2.5.0",
+        "matplotlib>=3.3.0",
+        "networkx>=2.5"
+    ],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+        "Topic :: Scientific/Engineering :: Bio-Informatics",
+    ],
+    python_requires='>=3.8',
+)