pyqrack-cuda 1.40.3__tar.gz → 1.42.0__tar.gz

{pyqrack_cuda-1.40.3/pyqrack_cuda.egg-info → pyqrack_cuda-1.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqrack-cuda
-Version: 1.40.3
+Version: 1.42.0
 Summary: pyqrack - Pure Python vm6502q/qrack Wrapper
 Home-page: https://github.com/vm6502q/pyqrack
 Author: Daniel Strano

{pyqrack_cuda-1.40.3 → pyqrack_cuda-1.42.0}/pyqrack/__init__.py

@@ -1,12 +1,14 @@
-# (C) Daniel Strano and the Qrack contributors 2017-2021. All rights reserved.
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
 #
 # Use of this source code is governed by an MIT-style license that can be
 # found in the LICENSE file or at https://opensource.org/licenses/MIT.
 
-from .qrack_system import QrackSystem, Qrack
-from .qrack_simulator import QrackSimulator
-from .qrack_neuron import QrackNeuron
-from .qrack_circuit import QrackCircuit
 from .pauli import Pauli
 from .neuron_activation_fn import NeuronActivationFn
 from .quimb_circuit_type import QuimbCircuitType
+from .qrack_circuit import QrackCircuit
+from .qrack_neuron import QrackNeuron
+from .qrack_neuron_torch_layer import QrackTorchNeuron, QrackNeuronFunction, QrackNeuronTorchLayer
+from .qrack_simulator import QrackSimulator
+from .qrack_system import QrackSystem, Qrack
+from .stats.quantize_by_range import quantize_by_range

{pyqrack_cuda-1.40.3 → pyqrack_cuda-1.42.0}/pyqrack/neuron_activation_fn.py

@@ -1,4 +1,4 @@
-# (C) Daniel Strano and the Qrack contributors 2017-2021. All rights reserved.
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
 #
 # Pauli operators are specified for "b" (or "basis") parameters.
 #

{pyqrack_cuda-1.40.3 → pyqrack_cuda-1.42.0}/pyqrack/pauli.py

@@ -1,4 +1,4 @@
-# (C) Daniel Strano and the Qrack contributors 2017-2021. All rights reserved.
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
 #
 # Pauli operators are specified for "b" (or "basis") parameters.
 #

{pyqrack_cuda-1.40.3 → pyqrack_cuda-1.42.0}/pyqrack/qrack_circuit.py

@@ -1,4 +1,4 @@
-# (C) Daniel Strano and the Qrack contributors 2017-2023. All rights reserved.
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
 #
 # Use of this source code is governed by an MIT-style license that can be
 # found in the LICENSE file or at https://opensource.org/licenses/MIT.

{pyqrack_cuda-1.40.3 → pyqrack_cuda-1.42.0}/pyqrack/qrack_neuron.py

@@ -1,4 +1,4 @@
-# (C) Daniel Strano and the Qrack contributors 2017-2023. All rights reserved.
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
 #
 # Use of this source code is governed by an MIT-style license that can be
 # found in the LICENSE file or at https://opensource.org/licenses/MIT.
@@ -9,6 +9,7 @@ import sys
 from .qrack_system import Qrack
 from .neuron_activation_fn import NeuronActivationFn
 
+
 class QrackNeuron:
     """Class that exposes the QNeuron class of Qrack
 

pyqrack_cuda-1.42.0/pyqrack/qrack_neuron_torch_layer.py

@@ -0,0 +1,144 @@
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
+#
+# Initial draft by Elara (OpenAI custom GPT)
+# Refined and architecturally clarified by Dan Strano
+#
+# Use of this source code is governed by an MIT-style license that can be
+# found in the LICENSE file or at https://opensource.org/licenses/MIT.
+
+_IS_TORCH_AVAILABLE = True
+try:
+    import torch
+    import torch.nn as nn
+    from torch.autograd import Function
+except ImportError:
+    _IS_TORCH_AVAILABLE = False
+
+from .qrack_simulator import QrackSimulator
+from .qrack_neuron import QrackNeuron
+from .neuron_activation_fn import NeuronActivationFn
+
+from itertools import chain, combinations
+
+
+# From https://stackoverflow.com/questions/1482308/how-to-get-all-subsets-of-a-set-powerset#answer-1482316
+def powerset(iterable):
+    "powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3,) (1,2,3)"
+    s = list(iterable)
+    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
+
+
+class QrackTorchNeuron(nn.Module):
+    """Torch wrapper for QrackNeuron
+
+    Attributes:
+        neuron(QrackNeuron): QrackNeuron backing this torch wrapper
+    """
+    def __init__(self, neuron: QrackNeuron) -> None:
+        super().__init__()
+        self.neuron = neuron
+
+    def forward(self, x):
+        neuron = self.neuron
+        neuron.predict(True, False)
+
+        return neuron.simulator.prob(neuron.target)
+
+
+class QrackNeuronFunction(Function if _IS_TORCH_AVAILABLE else object):
+    """Static forward/backward/apply functions for QrackTorchNeuron"""
+    @staticmethod
+    def forward(ctx, neuron: object):
+        # Save for backward
+        ctx.neuron = neuron
+
+        init_prob = neuron.simulator.prob(neuron.target)
+        neuron.predict(True, False)
+        final_prob = neuron.simulator.prob(neuron.target)
+        ctx.delta = final_prob - init_prob
+
+        return torch.tensor([ctx.delta], dtype=torch.float32) if _IS_TORCH_AVAILABLE else ctx.delta
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        neuron = ctx.neuron
+
+        pre_unpredict = neuron.simulator.prob(neuron.output_id)
+        neuron.unpredict()
+        post_unpredict = neuron.simulator.prob(neuron.output_id)
+        reverse_delta = pre_unpredict - post_unpredict
+
+        grad = reverse_delta - ctx.delta
+
+        return torch.tensor([grad], dtype=torch.float32) if _IS_TORCH_AVAILABLE else grad
+
+
+class QrackNeuronTorchLayer(nn.Module if _IS_TORCH_AVAILABLE else object):
+    """Torch layer wrapper for QrackNeuron (with power set of neurons between inputs and outputs)"""
+    def __init__(self, simulator: object, input_indices: list[int], output_indices: list[int],
+                 activation: int = int(NeuronActivationFn.Generalized_Logistic), parameters: list[float] = None):
+        """
+        Initialize a QrackNeuron layer for PyTorch with a power set of neurons connecting inputs to outputs.
+        The inputs and outputs must take the form of discrete, binary features (loaded manually into the backing QrackSimulator)
+
+        Args:
+            sim (QrackSimulator): Simulator into which predictor features are loaded
+            input_indices (list[int]): List of input bits
+            output_indices (list[int]): List of output bits
+            activation (int): Integer corresponding to choice of activation function from NeuronActivationFn
+            parameters (list[float]): (Optional) Flat list of initial neuron parameters, corresponding to little-endian basis states of power set of input indices, repeated for each output index (with empty set being constant bias)
+        """
+        super(QrackNeuronTorchLayer, self).__init__()
+        self.simulator = simulator
+        self.input_indices = input_indices
+        self.output_indices = output_indices
+        self.activation = NeuronActivationFn(activation)
+        self.fn = QrackNeuronFunction.apply if _IS_TORCH_AVAILABLE else lambda x: QrackNeuronFunction.forward(object(), x)
+
+        # Create neurons from all powerset input combinations, projecting to coherent output qubits
+        self.neurons = nn.ModuleList([
+            QrackTorchNeuron(QrackNeuron(simulator, list(input_subset), output_id, activation))
+            for input_subset in powerset(input_indices)
+            for output_id in output_indices
+        ])
+
+        # Set Qrack's internal parameters:
+        param_count = 0
+        for neuron_wrapper in self.neurons:
+            neuron = neuron_wrapper.neuron
+            p_count = 1 << len(neuron.controls)
+            neuron.set_angles(parameters[param_count:(param_count+p_count+1)] if parameters else ([0.0] * p_count))
+            param_count += p_count
+
+        self.weights = nn.ParameterList()
+        for pid in range(param_count):
+            self.weights.append(nn.Parameter(torch.tensor(parameters[pid] if parameters else 0.0)))
+
+    def forward(self, _):
+        # Assume quantum outputs should overwrite the simulator state
+        for output_id in self.output_indices:
+            if self.simulator.m(output_id):
+                self.simulator.x(output_id)
+            self.simulator.h(output_id)
+
+        # Set Qrack's internal parameters:
+        param_count = 0
+        for neuron_wrapper in self.neurons:
+            neuron = neuron_wrapper.neuron
+            p_count = 1 << len(neuron.controls)
+            angles = [w.item() for w in self.weights[param_count:(param_count+p_count)]]
+            neuron.set_angles(angles)
+            param_count += p_count
+
+        # Assume quantum inputs already loaded into simulator state
+        for neuron_wrapper in self.neurons:
+            self.fn(neuron_wrapper.neuron)
+
+        # These are classical views over quantum state; simulator still maintains full coherence
+        outputs = [
+            self.simulator.prob(output_id)
+            for output_id in self.output_indices
+        ]
+
+        return torch.tensor(outputs, dtype=torch.float32)
+

{pyqrack_cuda-1.40.3 → pyqrack_cuda-1.42.0}/pyqrack/qrack_simulator.py

@@ -1,4 +1,4 @@
-# (C) Daniel Strano and the Qrack contributors 2017-2023. All rights reserved.
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
 #
 # Use of this source code is governed by an MIT-style license that can be
 # found in the LICENSE file or at https://opensource.org/licenses/MIT.

{pyqrack_cuda-1.40.3 → pyqrack_cuda-1.42.0}/pyqrack/quimb_circuit_type.py

@@ -1,4 +1,4 @@
-# (C) Daniel Strano and the Qrack contributors 2017-2021. All rights reserved.
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
 #
 # Pauli operators are specified for "b" (or "basis") parameters.
 #

pyqrack_cuda-1.42.0/pyqrack/stats/__init__.py

@@ -0,0 +1,6 @@
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
+#
+# Use of this source code is governed by an MIT-style license that can be
+# found in the LICENSE file or at https://opensource.org/licenses/MIT.
+
+from .quantize_by_range import quantize_by_range

pyqrack_cuda-1.42.0/pyqrack/stats/load_quantized_data.py

@@ -0,0 +1,33 @@
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
+#
+# Load quantized data into a QrackSimulator
+#
+# Use of this source code is governed by an MIT-style license that can be
+# found in the LICENSE file or at https://opensource.org/licenses/MIT.
+
+
+def load_data(sim, index_bits, value_bits, data):
+    """
+    Take discretized features from quantize_by_range and load into a QrackSimulator
+
+    Args:
+        sim (QrackSimulator): Simulator into which to load data
+        index_bits (list[int]): List of index bits, least-to-most significant
+        value_bits (list[int]): List of value bits, least-to-most significant
+        data (list[list[bool]]): Data to load, row-major
+
+    Raises:
+        Value error: Length of value_bits does not match data feature column count!
+    """
+    if (len(data) > 0) and (len(value_bits) != len(data[0])):
+        raise ValueError("Length of value_bits does not match data feature column count!")
+
+    for i in range(index_bits):
+        if sim.m(i):
+            sim.x(i)
+        sim.h(i)
+
+    if len(data) == 0:
+        return
+
+    sim.lda(list(range(index_bits)), list(range(value_bits)), data)

pyqrack_cuda-1.42.0/pyqrack/stats/quantize_by_range.py

@@ -0,0 +1,51 @@
+# (C) Daniel Strano and the Qrack contributors 2017-2025. All rights reserved.
+#
+# Use of this source code is governed by an MIT-style license that can be
+# found in the LICENSE file or at https://opensource.org/licenses/MIT.
+
+try:
+    # Written by Elara (custom OpenAI GPT)
+    import numpy as np
+
+    def quantize_by_range(data: np.ndarray, feature_indices: list[int], bits: int) -> np.ndarray:
+        """
+        Discretize selected features of a dataset into binary variables using numpy.linspace binning.
+
+        Args:
+            data (np.ndarray): Input data of shape (n_samples, n_features).
+            feature_indices (list[int]): Indices of features to discretize.
+            bits (int): Number of bits to represent each discretized feature (e.g., 2 bits = 4 quantiles).
+
+        Returns:
+            np.ndarray: Transformed data with selected features replaced by binary bit columns.
+        """
+        n_samples, n_features = data.shape
+        n_bins = 2 ** bits
+
+        new_features = []
+        for i in range(n_features):
+            if i in feature_indices:
+                min_val, max_val = data[:, i].min(), data[:, i].max()
+                thresholds = np.linspace(min_val, max_val, n_bins + 1)[1:-1]
+                bins = np.digitize(data[:, i], bins=thresholds)
+                bin_bits = ((bins[:, None] & (1 << np.arange(bits)[::-1])) > 0).astype(int)
+                new_features.append(bin_bits)
+            else:
+                new_features.append(data[:, i][:, None])  # Keep original
+
+        return np.hstack(new_features)
+except ImportError:
+    def quantize_by_range(data, feature_indices: list[int], bits: int):
+        """
+        Discretize selected features of a dataset into binary variables using numpy.linspace binning.
+
+        Args:
+            data (np.ndarray): Input data of shape (n_samples, n_features).
+            feature_indices (list[int]): Indices of features to discretize.
+            bits (int): Number of bits to represent each discretized feature (e.g., 2 bits = 4 quantiles).
+
+        Returns:
+            np.ndarray: Transformed data with selected features replaced by binary bit columns.
+        """
+        raise NotImplementedError("You must have numpy installed to use quantize_by_percentile()!")
+

{pyqrack_cuda-1.40.3 → pyqrack_cuda-1.42.0/pyqrack_cuda.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqrack-cuda
-Version: 1.40.3
+Version: 1.42.0
 Summary: pyqrack - Pure Python vm6502q/qrack Wrapper
 Home-page: https://github.com/vm6502q/pyqrack
 Author: Daniel Strano

{pyqrack_cuda-1.40.3 → pyqrack_cuda-1.42.0}/pyqrack_cuda.egg-info/SOURCES.txt

@@ -9,10 +9,14 @@ pyqrack/neuron_activation_fn.py
 pyqrack/pauli.py
 pyqrack/qrack_circuit.py
 pyqrack/qrack_neuron.py
+pyqrack/qrack_neuron_torch_layer.py
 pyqrack/qrack_simulator.py
 pyqrack/quimb_circuit_type.py
 pyqrack/qrack_system/__init__.py
 pyqrack/qrack_system/qrack_system.py
+pyqrack/stats/__init__.py
+pyqrack/stats/load_quantized_data.py
+pyqrack/stats/quantize_by_range.py
 pyqrack_cuda.egg-info/PKG-INFO
 pyqrack_cuda.egg-info/SOURCES.txt
 pyqrack_cuda.egg-info/dependency_links.txt

{pyqrack_cuda-1.40.3 → pyqrack_cuda-1.42.0}/setup.py

@@ -7,7 +7,7 @@ from setuptools import setup
 from setuptools.command.build_py import build_py
 
 
-VERSION = "1.40.3"
+VERSION = "1.42.0"
 
 # Read long description from README.
 README_PATH = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'README.md')
@@ -27,7 +27,7 @@ class Build(build_py):
 setup(
     name='pyqrack-cuda',
     version=VERSION,
-    packages=['pyqrack', 'pyqrack.qrack_system'],
+    packages=['pyqrack', 'pyqrack.qrack_system', 'pyqrack.stats'],
     cmdclass={"build_py": Build},
     description="pyqrack - Pure Python vm6502q/qrack Wrapper",
     long_description=README,