globoptiml 0.1.0__tar.gz

globoptiml-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: globoptiml
+Version: 0.1.0
+Summary: Train neural networks via global mathematical optimisation (MINLP) instead of gradient descent.
+Author: Krzysztof
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pyomo
+Provides-Extra: pytorch
+Requires-Dist: torch; extra == "pytorch"
+Provides-Extra: all
+Requires-Dist: torch; extra == "all"
+Provides-Extra: dev
+Requires-Dist: torch; extra == "dev"
+Requires-Dist: scikit-learn; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+
+# OptiML
+
+Train neural networks via **global mathematical optimisation** (MINLP) instead of gradient descent.
+
+OptiML translates a neural network architecture into a system of constraints and decision variables,
+then uses a MINLP solver (e.g. Couenne, SCIP) to find the weights that *provably* minimise the
+training loss. After solving, the model can be exported to PyTorch for inference.
+
+## Installation
+
+```bash
+pip install -e .            # core (numpy + pyomo)
+pip install -e ".[pytorch]" # with PyTorch export support
+pip install -e ".[all]"     # everything
+```
+
+You also need a MINLP solver accessible to Pyomo, for example
+[Couenne](https://github.com/coin-or/Couenne) or [SCIP](https://www.scipopt.org/).
+
+## Quick start
+
+```python
+import optiml
+from optiml.losses import MSELoss
+
+# Ultra-small Edge AI classifier — only 9 parameters
+model = optiml.Sequential(
+    optiml.Linear(2, 2),
+    optiml.ReLU(M=10),
+    optiml.Linear(2, 1),
+)
+
+model.fit(X_train, y_train, loss=MSELoss(reduction='sum'), solver='couenne')
+
+# Export to PyTorch for inference / deployment
+pytorch_model = model.export('pytorch')
+```
+
+## Available layers
+
+| Layer | Description |
+|-------|-------------|
+| `Linear(in, out)` | Fully-connected layer |
+| `Conv1D(in_ch, out_ch, kernel)` | 1-D convolution |
+| `Conv2D(in_ch, out_ch, kernel)` | 2-D convolution |
+| `ReLU(M)` | ReLU via big-M formulation |
+| `AvgPool2D(kernel)` | 2-D average pooling |
+| `Flatten()` | Flatten spatial dimensions |
+
+## Available losses
+
+| Loss | Description |
+|------|-------------|
+| `MSELoss(reduction)` | Mean / sum of squared errors |
+| `SSELoss()` | Sum of squared errors |
+| `MAELoss(reduction)` | Mean / sum of absolute errors |
+| `HuberLoss(delta)` | Smooth L1 loss |
+
+## Export
+
+After fitting, call `model.export('pytorch')` to get a `torch.nn.Sequential`
+with the optimal weights loaded.
+
+## Example
+
+See `examples/binary_classification.py` for a full working example.
+It trains a 9-parameter Iris flower classifier (versicolor vs virginica
+from petal measurements) and compares OptiML with PyTorch + Adam:
+
+- **OptiML** finds the mathematically optimal weights in **~7 s**,
+  achieving **93.3 % test accuracy** on 90 unseen samples.
+- **PyTorch Adam** has a **30 % failure rate** (stuck at 50 % accuracy)
+  and even the best restart (selected by training loss) only reaches 91.1 %.

globoptiml-0.1.0/README.md

@@ -0,0 +1,73 @@
+# OptiML
+
+Train neural networks via **global mathematical optimisation** (MINLP) instead of gradient descent.
+
+OptiML translates a neural network architecture into a system of constraints and decision variables,
+then uses a MINLP solver (e.g. Couenne, SCIP) to find the weights that *provably* minimise the
+training loss. After solving, the model can be exported to PyTorch for inference.
+
+## Installation
+
+```bash
+pip install -e .            # core (numpy + pyomo)
+pip install -e ".[pytorch]" # with PyTorch export support
+pip install -e ".[all]"     # everything
+```
+
+You also need a MINLP solver accessible to Pyomo, for example
+[Couenne](https://github.com/coin-or/Couenne) or [SCIP](https://www.scipopt.org/).
+
+## Quick start
+
+```python
+import optiml
+from optiml.losses import MSELoss
+
+# Ultra-small Edge AI classifier — only 9 parameters
+model = optiml.Sequential(
+    optiml.Linear(2, 2),
+    optiml.ReLU(M=10),
+    optiml.Linear(2, 1),
+)
+
+model.fit(X_train, y_train, loss=MSELoss(reduction='sum'), solver='couenne')
+
+# Export to PyTorch for inference / deployment
+pytorch_model = model.export('pytorch')
+```
+
+## Available layers
+
+| Layer | Description |
+|-------|-------------|
+| `Linear(in, out)` | Fully-connected layer |
+| `Conv1D(in_ch, out_ch, kernel)` | 1-D convolution |
+| `Conv2D(in_ch, out_ch, kernel)` | 2-D convolution |
+| `ReLU(M)` | ReLU via big-M formulation |
+| `AvgPool2D(kernel)` | 2-D average pooling |
+| `Flatten()` | Flatten spatial dimensions |
+
+## Available losses
+
+| Loss | Description |
+|------|-------------|
+| `MSELoss(reduction)` | Mean / sum of squared errors |
+| `SSELoss()` | Sum of squared errors |
+| `MAELoss(reduction)` | Mean / sum of absolute errors |
+| `HuberLoss(delta)` | Smooth L1 loss |
+
+## Export
+
+After fitting, call `model.export('pytorch')` to get a `torch.nn.Sequential`
+with the optimal weights loaded.
+
+## Example
+
+See `examples/binary_classification.py` for a full working example.
+It trains a 9-parameter Iris flower classifier (versicolor vs virginica
+from petal measurements) and compares OptiML with PyTorch + Adam:
+
+- **OptiML** finds the mathematically optimal weights in **~7 s**,
+  achieving **93.3 % test accuracy** on 90 unseen samples.
+- **PyTorch Adam** has a **30 % failure rate** (stuck at 50 % accuracy)
+  and even the best restart (selected by training loss) only reaches 91.1 %.

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

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: globoptiml
+Version: 0.1.0
+Summary: Train neural networks via global mathematical optimisation (MINLP) instead of gradient descent.
+Author: Krzysztof
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: pyomo
+Provides-Extra: pytorch
+Requires-Dist: torch; extra == "pytorch"
+Provides-Extra: all
+Requires-Dist: torch; extra == "all"
+Provides-Extra: dev
+Requires-Dist: torch; extra == "dev"
+Requires-Dist: scikit-learn; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+
+# OptiML
+
+Train neural networks via **global mathematical optimisation** (MINLP) instead of gradient descent.
+
+OptiML translates a neural network architecture into a system of constraints and decision variables,
+then uses a MINLP solver (e.g. Couenne, SCIP) to find the weights that *provably* minimise the
+training loss. After solving, the model can be exported to PyTorch for inference.
+
+## Installation
+
+```bash
+pip install -e .            # core (numpy + pyomo)
+pip install -e ".[pytorch]" # with PyTorch export support
+pip install -e ".[all]"     # everything
+```
+
+You also need a MINLP solver accessible to Pyomo, for example
+[Couenne](https://github.com/coin-or/Couenne) or [SCIP](https://www.scipopt.org/).
+
+## Quick start
+
+```python
+import optiml
+from optiml.losses import MSELoss
+
+# Ultra-small Edge AI classifier — only 9 parameters
+model = optiml.Sequential(
+    optiml.Linear(2, 2),
+    optiml.ReLU(M=10),
+    optiml.Linear(2, 1),
+)
+
+model.fit(X_train, y_train, loss=MSELoss(reduction='sum'), solver='couenne')
+
+# Export to PyTorch for inference / deployment
+pytorch_model = model.export('pytorch')
+```
+
+## Available layers
+
+| Layer | Description |
+|-------|-------------|
+| `Linear(in, out)` | Fully-connected layer |
+| `Conv1D(in_ch, out_ch, kernel)` | 1-D convolution |
+| `Conv2D(in_ch, out_ch, kernel)` | 2-D convolution |
+| `ReLU(M)` | ReLU via big-M formulation |
+| `AvgPool2D(kernel)` | 2-D average pooling |
+| `Flatten()` | Flatten spatial dimensions |
+
+## Available losses
+
+| Loss | Description |
+|------|-------------|
+| `MSELoss(reduction)` | Mean / sum of squared errors |
+| `SSELoss()` | Sum of squared errors |
+| `MAELoss(reduction)` | Mean / sum of absolute errors |
+| `HuberLoss(delta)` | Smooth L1 loss |
+
+## Export
+
+After fitting, call `model.export('pytorch')` to get a `torch.nn.Sequential`
+with the optimal weights loaded.
+
+## Example
+
+See `examples/binary_classification.py` for a full working example.
+It trains a 9-parameter Iris flower classifier (versicolor vs virginica
+from petal measurements) and compares OptiML with PyTorch + Adam:
+
+- **OptiML** finds the mathematically optimal weights in **~7 s**,
+  achieving **93.3 % test accuracy** on 90 unseen samples.
+- **PyTorch Adam** has a **30 % failure rate** (stuck at 50 % accuracy)
+  and even the best restart (selected by training loss) only reaches 91.1 %.

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

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+globoptiml.egg-info/PKG-INFO
+globoptiml.egg-info/SOURCES.txt
+globoptiml.egg-info/dependency_links.txt
+globoptiml.egg-info/requires.txt
+globoptiml.egg-info/top_level.txt
+optiml/__init__.py
+optiml/layers.py
+optiml/losses.py
+optiml/model.py
+optiml/solver.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,13 @@
+numpy
+pyomo
+
+[all]
+torch
+
+[dev]
+torch
+scikit-learn
+pytest
+
+[pytorch]
+torch

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

@@ -0,0 +1 @@
+optiml

globoptiml-0.1.0/optiml/__init__.py

@@ -0,0 +1,30 @@
+"""OptiML — train neural networks via global mathematical optimisation."""
+
+__version__ = "0.1.0"
+
+from .layers import (
+    OptiModule,
+    Linear,
+    ReLU,
+    Conv1D,
+    Conv2D,
+    AvgPool2D,
+    Flatten,
+)
+from .model import Sequential
+from .solver import SolverVariable, SolverModel
+from . import losses
+
+__all__ = [
+    "OptiModule",
+    "Sequential",
+    "Linear",
+    "ReLU",
+    "Conv1D",
+    "Conv2D",
+    "AvgPool2D",
+    "Flatten",
+    "SolverVariable",
+    "SolverModel",
+    "losses",
+]

globoptiml-0.1.0/optiml/layers.py

@@ -0,0 +1,213 @@
+import numpy as np
+import pyomo.environ as pyo
+
+from .solver import SolverVariable
+
+
+class OptiModule:
+    """Base class for all OptiML layers."""
+
+    def __init__(self):
+        self._parameters = {}
+        self._weight_bounds = None
+
+    def get_parameter(self, name, shape, solver_model):
+        if name not in self._parameters:
+            unique_name = f"layer_{id(self)}_{name}"
+            self._parameters[name] = solver_model.create_variable(
+                shape, name=unique_name, bounds=self._weight_bounds,
+            )
+        return self._parameters[name]
+
+    def forward(self, x, solver_model):
+        raise NotImplementedError
+
+    def __call__(self, x, solver_model):
+        return self.forward(x, solver_model)
+
+    def _extract_weights(self, param_name):
+        param_solver_var = self._parameters[param_name]
+        arr = np.zeros(param_solver_var.shape)
+        for idx, var in np.ndenumerate(param_solver_var.data):
+            arr[idx] = pyo.value(var)
+        return arr
+
+    def to_pytorch(self):
+        raise NotImplementedError(
+            f"PyTorch export is not implemented for {self.__class__.__name__}"
+        )
+
+
+class Linear(OptiModule):
+    """Fully-connected layer: y = Wx + b."""
+
+    def __init__(self, in_features, out_features):
+        super().__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+
+    def forward(self, x, solver_model):
+        W = self.get_parameter('weight', (self.out_features, self.in_features), solver_model)
+        b = self.get_parameter('bias', (self.out_features,), solver_model)
+        out = solver_model.create_variable(shape=(self.out_features,))
+        solver_model.add_constraint(out == W @ x + b)
+        return out
+
+    def to_pytorch(self):
+        import torch
+        import torch.nn as nn
+        layer = nn.Linear(self.in_features, self.out_features)
+        layer.weight.data = torch.tensor(self._extract_weights('weight'), dtype=torch.float32)
+        layer.bias.data = torch.tensor(self._extract_weights('bias'), dtype=torch.float32)
+        return layer
+
+
+class ReLU(OptiModule):
+    """ReLU activation modelled via big-M with binary variables."""
+
+    def __init__(self, M=1000):
+        super().__init__()
+        self.M = M
+
+    def forward(self, x, solver_model):
+        shape = x.shape if hasattr(x, 'shape') else (1,)
+        y = solver_model.create_variable(shape=shape)
+        z = solver_model.create_variable(shape=shape, boolean=True)
+
+        solver_model.add_constraint(y >= 0)
+        solver_model.add_constraint(y >= x)
+        solver_model.add_constraint(y <= x + self.M * (1 - z))
+        solver_model.add_constraint(y <= self.M * z)
+        return y
+
+    def to_pytorch(self):
+        import torch.nn as nn
+        return nn.ReLU()
+
+
+class Conv1D(OptiModule):
+    """1-D convolution layer."""
+
+    def __init__(self, in_channels, out_channels, kernel_size, stride=1):
+        super().__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.kernel_size = kernel_size
+        self.stride = stride
+
+    def forward(self, x, solver_model):
+        W = self.get_parameter('weight', (self.out_channels, self.in_channels, self.kernel_size), solver_model)
+        b = self.get_parameter('bias', (self.out_channels,), solver_model)
+        in_channels, length = x.shape
+        out_length = (length - self.kernel_size) // self.stride + 1
+        out = solver_model.create_variable(shape=(self.out_channels, out_length))
+
+        for out_pos in range(out_length):
+            in_start = out_pos * self.stride
+            in_end = in_start + self.kernel_size
+            x_slice = x[:, in_start:in_end]
+            for oc in range(self.out_channels):
+                conv_sum = np.sum((W[oc, :, :] * x_slice).data) + b[oc].data
+                solver_model.add_constraint(out[oc, out_pos] == conv_sum)
+        return out
+
+    def to_pytorch(self):
+        import torch
+        import torch.nn as nn
+        layer = nn.Conv1d(self.in_channels, self.out_channels, self.kernel_size, stride=self.stride)
+        layer.weight.data = torch.tensor(self._extract_weights('weight'), dtype=torch.float32)
+        layer.bias.data = torch.tensor(self._extract_weights('bias'), dtype=torch.float32)
+        return layer
+
+
+class Conv2D(OptiModule):
+    """2-D convolution layer."""
+
+    def __init__(self, in_channels, out_channels, kernel_size, stride=1):
+        super().__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.kernel_size = kernel_size if isinstance(kernel_size, tuple) else (kernel_size, kernel_size)
+        self.stride = stride if isinstance(stride, tuple) else (stride, stride)
+
+    def forward(self, x, solver_model):
+        kh, kw = self.kernel_size
+        sh, sw = self.stride
+        W = self.get_parameter('weight', (self.out_channels, self.in_channels, kh, kw), solver_model)
+        b = self.get_parameter('bias', (self.out_channels,), solver_model)
+        in_channels, in_height, in_width = x.shape
+        out_height = (in_height - kh) // sh + 1
+        out_width = (in_width - kw) // sw + 1
+        out = solver_model.create_variable(shape=(self.out_channels, out_height, out_width))
+
+        for out_h in range(out_height):
+            for out_w in range(out_width):
+                h_start = out_h * sh
+                h_end = h_start + kh
+                w_start = out_w * sw
+                w_end = w_start + kw
+                x_slice = x[:, h_start:h_end, w_start:w_end]
+                for oc in range(self.out_channels):
+                    conv_sum = np.sum((W[oc, :, :, :] * x_slice).data) + b[oc].data
+                    solver_model.add_constraint(out[oc, out_h, out_w] == conv_sum)
+        return out
+
+    def to_pytorch(self):
+        import torch
+        import torch.nn as nn
+        layer = nn.Conv2d(self.in_channels, self.out_channels, self.kernel_size, stride=self.stride)
+        layer.weight.data = torch.tensor(self._extract_weights('weight'), dtype=torch.float32)
+        layer.bias.data = torch.tensor(self._extract_weights('bias'), dtype=torch.float32)
+        return layer
+
+
+class AvgPool2D(OptiModule):
+    """2-D average pooling layer."""
+
+    def __init__(self, kernel_size, stride=None):
+        super().__init__()
+        self.kernel_size = kernel_size if isinstance(kernel_size, tuple) else (kernel_size, kernel_size)
+        if stride is None:
+            self.stride = self.kernel_size
+        else:
+            self.stride = stride if isinstance(stride, tuple) else (stride, stride)
+
+    def forward(self, x, solver_model):
+        kh, kw = self.kernel_size
+        sh, sw = self.stride
+        channels, in_height, in_width = x.shape
+        out_height = (in_height - kh) // sh + 1
+        out_width = (in_width - kw) // sw + 1
+        out = solver_model.create_variable(shape=(channels, out_height, out_width))
+        pool_area = kh * kw
+
+        for c in range(channels):
+            for out_h in range(out_height):
+                for out_w in range(out_width):
+                    h_start = out_h * sh
+                    h_end = h_start + kh
+                    w_start = out_w * sw
+                    w_end = w_start + kw
+                    x_slice = x[c, h_start:h_end, w_start:w_end]
+                    avg_val = np.sum(x_slice.data) / pool_area
+                    solver_model.add_constraint(out[c, out_h, out_w] == avg_val)
+        return out
+
+    def to_pytorch(self):
+        import torch.nn as nn
+        return nn.AvgPool2d(self.kernel_size, stride=self.stride)
+
+
+class Flatten(OptiModule):
+    """Flatten all spatial dimensions into a single vector."""
+
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x, solver_model):
+        flat_data = x.data.flatten()
+        return SolverVariable(flat_data)
+
+    def to_pytorch(self):
+        import torch.nn as nn
+        return nn.Flatten(start_dim=1)

globoptiml-0.1.0/optiml/losses.py

@@ -0,0 +1,124 @@
+"""Loss functions expressible as Pyomo optimisation objectives.
+
+All losses support both scalar outputs (single-target regression /
+binary classification) and vector outputs (multi-target regression /
+multi-class classification with one-hot targets).
+"""
+
+import numpy as np
+
+
+class Loss:
+    """Base class for all OptiML losses."""
+
+    def __call__(self, y_pred, y_true, solver_model=None):
+        return self.compute(y_pred, y_true, solver_model)
+
+    def compute(self, y_pred, y_true, solver_model=None):
+        raise NotImplementedError
+
+
+def _squared_error_terms(predictions, targets):
+    """Yield (p - t)**2 for every scalar in every sample."""
+    for pred, target in zip(predictions, targets):
+        p_flat = pred.data.flatten()
+        t_flat = np.atleast_1d(target).flatten()
+        for p_val, t_val in zip(p_flat, t_flat):
+            yield (p_val - t_val) ** 2
+
+
+class MSELoss(Loss):
+    """Mean Squared Error: (1/n) * sum((y_pred - y_true)^2)."""
+
+    def __init__(self, reduction='mean'):
+        self.reduction = reduction
+
+    def compute(self, predictions, targets, solver_model=None):
+        total = sum(_squared_error_terms(predictions, targets))
+        if self.reduction == 'mean':
+            return total / len(predictions)
+        return total
+
+
+class SSELoss(Loss):
+    """Sum of Squared Errors: sum((y_pred - y_true)^2).
+
+    Equivalent to MSELoss(reduction='sum') but more explicit.
+    """
+
+    def compute(self, predictions, targets, solver_model=None):
+        return sum(_squared_error_terms(predictions, targets))
+
+
+class MAELoss(Loss):
+    """Mean Absolute Error modelled with auxiliary variables.
+
+    Introduces |e| = y_pred - y_true via:
+        t >= y_pred - y_true
+        t >= -(y_pred - y_true)
+    then minimises sum(t).
+    Requires solver_model to create auxiliary variables/constraints.
+    """
+
+    def __init__(self, reduction='mean'):
+        self.reduction = reduction
+
+    def compute(self, predictions, targets, solver_model=None):
+        if solver_model is None:
+            raise ValueError("MAELoss requires a solver_model to create auxiliary variables")
+
+        total_expr = 0
+        for pred, target in zip(predictions, targets):
+            p_flat = pred.data.flatten()
+            t_flat = np.atleast_1d(target).flatten()
+            for p_val, t_val in zip(p_flat, t_flat):
+                diff = p_val - t_val
+                t = solver_model.create_variable(shape=(1,))
+                solver_model.add_constraint(t >= diff)
+                solver_model.add_constraint(t >= -diff)
+                total_expr = total_expr + t.data.item()
+
+        if self.reduction == 'mean':
+            return total_expr / len(predictions)
+        return total_expr
+
+
+class HuberLoss(Loss):
+    """Huber loss (smooth L1) modelled with auxiliary variables.
+
+    For each scalar output element:
+        if |error| <= delta: loss = 0.5 * error^2
+        else:                loss = delta * (|error| - 0.5 * delta)
+
+    Requires solver_model to create auxiliary variables/constraints.
+    """
+
+    def __init__(self, delta=1.0, reduction='mean'):
+        self.delta = delta
+        self.reduction = reduction
+
+    def compute(self, predictions, targets, solver_model=None):
+        if solver_model is None:
+            raise ValueError("HuberLoss requires a solver_model to create auxiliary variables")
+
+        total_expr = 0
+        d = self.delta
+        for pred, target in zip(predictions, targets):
+            p_flat = pred.data.flatten()
+            t_flat = np.atleast_1d(target).flatten()
+            for p_val, t_val in zip(p_flat, t_flat):
+                diff = p_val - t_val
+                quad = 0.5 * diff ** 2
+                t_abs = solver_model.create_variable(shape=(1,))
+                solver_model.add_constraint(t_abs >= diff)
+                solver_model.add_constraint(t_abs >= -diff)
+                linear = d * t_abs.data.item() - 0.5 * d ** 2
+
+                h = solver_model.create_variable(shape=(1,))
+                solver_model.add_constraint(h >= quad)
+                solver_model.add_constraint(h >= linear)
+                total_expr = total_expr + h.data.item()
+
+        if self.reduction == 'mean':
+            return total_expr / len(predictions)
+        return total_expr

globoptiml-0.1.0/optiml/model.py

@@ -0,0 +1,194 @@
+"""High-level Sequential model that wraps layer definition, fitting, and export."""
+
+from collections import OrderedDict
+
+import numpy as np
+import pyomo.environ as pyo
+
+from .solver import SolverModel, SolverVariable
+from .layers import OptiModule
+from .losses import Loss, MSELoss
+
+
+class Sequential(OptiModule):
+    """An ordered container of OptiML layers with fit/export capabilities.
+
+    Usage::
+
+        import optiml
+
+        model = optiml.Sequential(
+            optiml.Linear(2, 2),
+            optiml.ReLU(M=10),
+            optiml.Linear(2, 1),
+        )
+
+        model.fit(X_train, y_train, solver='couenne')
+        pytorch_model = model.export('pytorch')
+    """
+
+    def __init__(self, *layers):
+        super().__init__()
+        self._layers = OrderedDict()
+        for i, layer in enumerate(layers):
+            name = f"{layer.__class__.__name__.lower()}_{i}"
+            self._layers[name] = layer
+            setattr(self, name, layer)
+
+        self._solver_model = None
+        self._fitted = False
+
+    def forward(self, x, solver_model):
+        out = x
+        for layer in self._layers.values():
+            out = layer(out, solver_model)
+        return out
+
+    def fit(
+        self,
+        X,
+        y,
+        loss=None,
+        solver='couenne',
+        weight_decay=0.0,
+        weight_bounds=None,
+        time_limit=None,
+        node_limit=None,
+        tee=True,
+        verbose=True,
+    ):
+        """Build the optimisation model from data and solve it.
+
+        Parameters
+        ----------
+        X : array-like, shape (n_samples, ...)
+            Training inputs (without batch dimension per sample).
+        y : array-like, shape (n_samples,) or (n_samples, n_outputs)
+            Training targets.
+        loss : Loss, optional
+            Loss function to minimise. Defaults to ``MSELoss(reduction='sum')``.
+        solver : str
+            Name of a Pyomo-compatible MINLP solver (e.g. ``'couenne'``, ``'scip'``).
+        weight_decay : float
+            L2 regularisation coefficient.  Adds ``weight_decay * sum(w²)``
+            to the objective.  Prevents over-fitting and encourages small
+            weights suitable for quantisation on micro-controllers.
+        weight_bounds : tuple[float, float] or None
+            If given, bound every trainable weight to ``(lo, hi)``.
+            Tightens the solver relaxation and prevents degenerate solutions.
+            Also useful for fixed-point quantisation on edge devices.
+        time_limit : float or None
+            Maximum solver wall-clock time in seconds.  The solver returns
+            the best feasible solution found within the time budget.
+        tee : bool
+            Whether to print solver output.
+        verbose : bool
+            Whether to print progress messages.
+
+        Returns
+        -------
+        results : SolverResults
+            Pyomo solver results object.
+        """
+        if loss is None:
+            loss = MSELoss(reduction='sum')
+
+        X = np.asarray(X)
+        y = np.asarray(y)
+
+        if weight_bounds is not None:
+            for layer in self._layers.values():
+                layer._weight_bounds = weight_bounds
+
+        self._solver_model = SolverModel()
+        sm = self._solver_model
+
+        if verbose:
+            print(f"[OptiML] Building constraints for {len(X)} samples...")
+
+        predictions = []
+        for i in range(len(X)):
+            x_input = X[i]
+            if not isinstance(x_input, SolverVariable):
+                x_input = SolverVariable(x_input)
+            y_pred = self.forward(x_input, sm)
+            predictions.append(y_pred)
+
+        if verbose:
+            n_vars = sm._var_counter
+            n_cons = len(sm.model.constraints)
+            print(f"[OptiML] Model has {n_vars} variable groups, {n_cons} constraints.")
+            print(f"[OptiML] Computing {loss.__class__.__name__}...")
+
+        objective_expr = loss(predictions, y, sm)
+
+        if weight_decay > 0:
+            reg = 0
+            for layer in self._layers.values():
+                for param_sv in layer._parameters.values():
+                    for val in param_sv.data.flatten():
+                        reg += val ** 2
+            objective_expr += weight_decay * reg
+            if verbose:
+                print(f"[OptiML] Added L2 regularisation (λ={weight_decay})")
+
+        sm.set_objective(objective_expr, minimize=True)
+
+        if verbose:
+            print(f"[OptiML] Solving with '{solver}'...")
+
+        results = sm.solve(solver_name=solver, tee=tee, time_limit=time_limit,
+                           node_limit=node_limit)
+        self._fitted = True
+
+        if verbose:
+            try:
+                obj_val = pyo.value(sm.model.obj)
+                print(f"[OptiML] Solved. Objective value: {obj_val:.8f}")
+            except Exception:
+                print("[OptiML] Solved. (could not read objective value)")
+
+        return results
+
+    @property
+    def objective_value(self):
+        """Return the objective value after fitting."""
+        if not self._fitted:
+            raise RuntimeError("Model has not been fitted yet. Call .fit() first.")
+        return pyo.value(self._solver_model.model.obj)
+
+    def export(self, backend='pytorch'):
+        """Export the fitted model to a deep-learning framework.
+
+        Parameters
+        ----------
+        backend : str
+            Target framework. Currently only ``'pytorch'`` is supported.
+
+        Returns
+        -------
+        model
+            A native model in the target framework with weights loaded
+            from the optimisation solution.
+        """
+        if not self._fitted:
+            raise RuntimeError("Model has not been fitted yet. Call .fit() first.")
+
+        if backend == 'pytorch':
+            return self._export_pytorch()
+        raise ValueError(f"Unknown backend '{backend}'. Supported: 'pytorch'")
+
+    def _export_pytorch(self):
+        import torch.nn as nn
+
+        pytorch_layers = []
+        for name, layer in self._layers.items():
+            pytorch_layers.append((name, layer.to_pytorch()))
+        return nn.Sequential(OrderedDict(pytorch_layers))
+
+    def __repr__(self):
+        lines = [f"Sequential("]
+        for name, layer in self._layers.items():
+            lines.append(f"  ({name}): {layer.__class__.__name__}()")
+        lines.append(")")
+        return "\n".join(lines)

globoptiml-0.1.0/optiml/solver.py

@@ -0,0 +1,121 @@
+import pyomo.environ as pyo
+import numpy as np
+import operator
+
+
+class SolverVariable:
+    """Array-like wrapper over Pyomo decision variables supporting arithmetic."""
+
+    def __init__(self, data):
+        self.data = np.array(data, dtype=object) if not isinstance(data, np.ndarray) else data
+        self.shape = self.data.shape
+
+    def __add__(self, other):
+        other_data = other.data if isinstance(other, SolverVariable) else other
+        return SolverVariable(self.data + other_data)
+
+    def __radd__(self, other):
+        return self.__add__(other)
+
+    def __sub__(self, other):
+        other_data = other.data if isinstance(other, SolverVariable) else other
+        return SolverVariable(self.data - other_data)
+
+    def __rsub__(self, other):
+        other_data = other.data if isinstance(other, SolverVariable) else other
+        return SolverVariable(other_data - self.data)
+
+    def __matmul__(self, other):
+        other_data = other.data if isinstance(other, SolverVariable) else other
+        return SolverVariable(np.dot(self.data, other_data))
+
+    def __mul__(self, other):
+        other_data = other.data if isinstance(other, SolverVariable) else other
+        return SolverVariable(self.data * other_data)
+
+    def __rmul__(self, other):
+        return self.__mul__(other)
+
+    def __pow__(self, power):
+        if isinstance(power, (int, float)):
+            flat = self.data.flatten()
+            result = np.empty(len(flat), dtype=object)
+            for i in range(len(flat)):
+                result[i] = flat[i] ** power
+            return SolverVariable(result.reshape(self.shape))
+        raise NotImplementedError("Only scalar powers are supported")
+
+    def _apply_relational(self, other, op):
+        other_data = other.data if isinstance(other, SolverVariable) else other
+        flat_self = self.data.flatten()
+        res_array = np.empty(len(flat_self), dtype=object)
+
+        if isinstance(other_data, np.ndarray):
+            flat_other = other_data.flatten()
+            for i in range(len(flat_self)):
+                res_array[i] = op(flat_self[i], flat_other[i])
+        else:
+            for i in range(len(flat_self)):
+                res_array[i] = op(flat_self[i], other_data)
+
+        return SolverVariable(res_array.reshape(self.shape))
+
+    def __eq__(self, other):
+        return self._apply_relational(other, operator.eq)
+
+    def __ge__(self, other):
+        return self._apply_relational(other, operator.ge)
+
+    def __le__(self, other):
+        return self._apply_relational(other, operator.le)
+
+    def __getitem__(self, key):
+        return SolverVariable(self.data[key])
+
+    def sum(self):
+        return np.sum(self.data)
+
+
+class SolverModel:
+    """Pyomo ConcreteModel wrapper for building optimisation problems."""
+
+    def __init__(self):
+        self.model = pyo.ConcreteModel()
+        self.model.constraints = pyo.ConstraintList()
+        self._var_counter = 0
+
+    def create_variable(self, shape, boolean=False, name=None, bounds=None):
+        if name is None:
+            name = f"var_{self._var_counter}"
+            self._var_counter += 1
+
+        domain = pyo.Binary if boolean else pyo.Reals
+        flat_size = int(np.prod(shape)) if isinstance(shape, tuple) and shape else 1
+
+        pyo_var = pyo.Var(range(flat_size), domain=domain, bounds=bounds)
+        setattr(self.model, name, pyo_var)
+
+        arr = np.array([pyo_var[i] for i in range(flat_size)], dtype=object).reshape(shape)
+        return SolverVariable(arr)
+
+    def add_constraint(self, condition):
+        cond_data = condition.data if isinstance(condition, SolverVariable) else condition
+        if isinstance(cond_data, np.ndarray):
+            for cond in cond_data.flatten():
+                self.model.constraints.add(cond)
+        else:
+            self.model.constraints.add(cond_data)
+
+    def set_objective(self, expr, minimize=True):
+        sense = pyo.minimize if minimize else pyo.maximize
+        self.model.obj = pyo.Objective(expr=expr, sense=sense)
+
+    def solve(self, solver_name='couenne', tee=True, time_limit=None,
+              node_limit=None):
+        solver = pyo.SolverFactory(solver_name)
+        if time_limit is not None:
+            solver.options['bonmin.time_limit'] = time_limit
+        if node_limit is not None:
+            solver.options['bonmin.node_limit'] = node_limit
+        results = solver.solve(self.model, tee=tee)
+        return results

globoptiml-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "globoptiml"
+version = "0.1.0"
+description = "Train neural networks via global mathematical optimisation (MINLP) instead of gradient descent."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    {name = "Krzysztof"},
+]
+
+dependencies = [
+    "numpy",
+    "pyomo",
+]
+
+[project.optional-dependencies]
+pytorch = ["torch"]
+all = ["torch"]
+dev = ["torch", "scikit-learn", "pytest"]
+
+[tool.setuptools.packages.find]
+include = ["optiml*"]

globoptiml-0.1.0/setup.cfg

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