eizen-nsga 1.0.0__py3-none-any.whl

eizen_nsga-1.0.0.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: eizen-nsga
+Version: 1.0.0
+Summary: Simple inference package for NSGA-Net trained models
+Home-page: https://github.com/eizen-ai/nsga-net
+Author: Eizen.ai Team
+Author-email: "Eizen.ai Team" <support@eizen.ai>
+License: MIT
+Project-URL: Homepage, https://eizen.ai
+Project-URL: Repository, https://github.com/eizen-ai/nsga-net
+Project-URL: Issues, https://github.com/eizen-ai/nsga-net/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=1.9.0
+Requires-Dist: torchvision>=0.10.0
+Requires-Dist: numpy>=1.19.0
+Requires-Dist: pillow>=8.0.0
+Provides-Extra: sota
+Requires-Dist: ultralytics>=8.0.0; extra == "sota"
+Provides-Extra: nn
+Requires-Dist: pandas>=1.0.0; extra == "nn"
+Requires-Dist: scikit-learn>=0.24.0; extra == "nn"
+Provides-Extra: transformer
+Requires-Dist: transformers>=4.0.0; extra == "transformer"
+Requires-Dist: tokenizers>=0.10.0; extra == "transformer"
+Provides-Extra: all
+Requires-Dist: ultralytics>=8.0.0; extra == "all"
+Requires-Dist: pandas>=1.0.0; extra == "all"
+Requires-Dist: scikit-learn>=0.24.0; extra == "all"
+Requires-Dist: transformers>=4.0.0; extra == "all"
+Requires-Dist: tokenizers>=0.10.0; extra == "all"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# eizen-nsga
+
+**Standalone** inference package for NSGA-Net trained models. Works just like ultralytics YOLO.
+
+✅ **Fully independent** - no external dependencies on NSGA-Net codebase
+✅ **Simple API** - load model from ZIP or URL, run inference
+✅ **PyPI ready** - publish and use anywhere
+✅ **Supports URLs** - load models from HTTP, S3, GCS, and more
+
+## Installation
+
+```bash
+# For SOTA (computer vision) models
+pip install eizen-nsga[sota]
+
+# For NN (tabular) models
+pip install eizen-nsga[nn]
+
+# For Transformer (LLM) models
+pip install eizen-nsga[transformer]
+
+# Install all dependencies
+pip install eizen-nsga[all]
+```
+
+## Quick Start
+
+```python
+from eizen_nsga import NASModel
+
+# Load model from local ZIP file
+model = NASModel("trained_model.zip")
+
+# Or load from URL (HTTP, HTTPS, S3, GCS, etc.)
+model = NASModel("https://example.com/models/model.zip")
+model = NASModel("s3://mybucket/models/model.zip")
+
+# Run inference (accepts file path, PIL Image, or numpy array)
+result = model.predict("image.jpg")
+
+# Classification results
+print(f"Top class: {result['class']}")
+print(f"Confidence: {result['confidence']:.2%}")
+print(f"Top 5 predictions: {result['predictions']}")
+
+# Or call directly like YOLO
+result = model("image.jpg")
+```
+
+## Detection Models
+
+```python
+from nsga_inference import NASModel
+
+# Load detection model
+model = NASModel("detector.zip")
+
+# Run detection
+result = model.predict("image.jpg", conf_threshold=0.3, iou_threshold=0.45)
+
+# Detection results
+print(f"Found {result['count']} objects")
+for det in result['detections']:
+    print(f"  Box: {det['box']}, Class: {det['class']}, Conf: {det['confidence']}")
+```
+
+## Model Info
+
+```python
+# Get model information
+info = model.info()
+print(f"Category: {info['category']}")
+print(f"Task: {info['task']}")
+print(f"Backbone: {info['backbone']}")
+print(f"Classes: {info['num_classes']}")
+```
+
+## Device Selection
+
+```python
+# Auto-detect device (default)
+model = NASModel("model.zip")
+
+# Specify device
+model = NASModel("model.zip", device="cuda")
+model = NASModel("model.zip", device="cpu")
+
+# Move to different device
+model.to("cuda")
+```
+
+## How It Works
+
+1. **Extract**: Automatically extracts model ZIP file
+2. **Parse**: Reads `log.txt` to get model configuration (genome, backbone, etc.)
+3. **Build**: Constructs model architecture from genome encoding
+4. **Load**: Loads trained weights from `weights.pt`
+5. **Predict**: Runs inference on your images
+
+## Supported Model Categories
+
+- **SOTA**: Computer vision models (YOLOv8, ResNet, EfficientNet backbones) ✅
+- **NN**: Tabular data models (coming soon)
+- **Transformer**: LLM models (coming soon)
+
+## Model ZIP Structure
+
+Your trained model ZIP should contain:
+```
+model.zip
+├── weights.pt       # Trained model weights
+└── log.txt          # Model configuration (genome, backbone, etc.)
+```
+
+## Package is Fully Standalone
+
+This package includes all necessary SOTA modules internally:
+- Model builders (micro/macro architectures)
+- Genome encoders/decoders
+- Neural operations
+- Backbone registry
+- Detection heads
+
+No need to have the NSGA-Net training codebase installed!
+
+## Requirements
+
+**Core dependencies:**
+- torch >= 1.9.0
+- torchvision >= 0.10.0
+- numpy >= 1.19.0
+- pillow >= 8.0.0
+
+**Optional (for SOTA models):**
+- ultralytics >= 8.0.0
+
+## License
+
+MIT License - Copyright (c) 2024 Eizen.ai Team
+
+## Links
+
+- Homepage: https://eizen.ai
+- GitHub: https://github.com/eizen-ai/nsga-net
+- Issues: https://github.com/eizen-ai/nsga-net/issues

eizen_nsga-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+eizen_nsga-1.0.0.dist-info/licenses/LICENSE,sha256=_HF_TY-jv6lFXR4QcG1iTnMYgDC3MfslE5S0OvUGlQA,1091
+sota/__init__.py,sha256=3hyX_CR86TvV2RYQaES0FhZdtklUBu3DB7HAv1Z0yGo,525
+sota/detection_heads.py,sha256=Tx7qgqc0_BBtaIenxNHg_dIwbDHyOQz3QsamNEa9gX0,11206
+sota/macro_encoding.py,sha256=lwV8Nptwt014UWW-2rAmivYqS-5Jfs3g8DCmzhRzHsA,3037
+sota/macro_models.py,sha256=okitzfXyaRPjGb5lAh9BNwqUVjTaUqaj7jwypKKVVm0,12254
+sota/micro_encoding.py,sha256=LrhgzhgnGMP2Up7Uqy0zT5nedzefqDXl2HJ8YL2TOVM,4820
+sota/micro_models.py,sha256=piLM6jt4LEiiQuox6AL6I-K0W0XcGLcL2qHWZgPbpvA,22062
+sota/micro_operations.py,sha256=3E2JL1eSzWYmtI4X9omBkocWcAoZslXdkIj8CS1h4dQ,8702
+sota/model_registry.py,sha256=lQQKUKCVWEQEql5mDZrlwRJEIVaqdokNWEEN4SWrnA0,17750
+eizen_nsga-1.0.0.dist-info/METADATA,sha256=uQP38LPaimMrKbFtdFhUXuBaOsIMaQntO1oJRvjDLK4,5268
+eizen_nsga-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+eizen_nsga-1.0.0.dist-info/top_level.txt,sha256=pPnDGDIcVIcY4aYyBjID0_x2rcMP9_Q3G-ZHKSZGwQI,5
+eizen_nsga-1.0.0.dist-info/RECORD,,

eizen_nsga-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

eizen_nsga-1.0.0.dist-info/licenses/LICENSE

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

eizen_nsga-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+sota

sota/__init__.py

@@ -0,0 +1,22 @@
+"""
+SOTA module for NSGA-Net inference package
+Contains model builders, encoders, and operations for neural architecture search
+"""
+
+from . import micro_models
+from . import macro_models
+from . import micro_encoding
+from . import macro_encoding
+from . import micro_operations
+from . import model_registry
+from . import detection_heads
+
+__all__ = [
+    'micro_models',
+    'macro_models',
+    'micro_encoding',
+    'macro_encoding',
+    'micro_operations',
+    'model_registry',
+    'detection_heads',
+]

sota/detection_heads.py

@@ -0,0 +1,312 @@
+"""
+Detection heads for object detection tasks.
+Implements YOLO-style detection head that works with adapter networks.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class YOLODetectionHead(nn.Module):
+    """
+    YOLO-style detection head for object detection.
+
+    Predicts bounding boxes, objectness scores, and class probabilities on a grid.
+    Each grid cell can predict multiple anchors.
+
+    Output format: [batch, num_anchors * (5 + num_classes), H, W]
+    where 5 = (x, y, w, h, objectness)
+    """
+
+    def __init__(self, in_channels, num_classes, num_anchors=3, grid_size=7):
+        """
+        Args:
+            in_channels: Number of input channels from backbone/adapter
+            num_classes: Number of object classes
+            num_anchors: Number of anchor boxes per grid cell
+            grid_size: Size of prediction grid (e.g., 7 means 7x7 grid)
+        """
+        super(YOLODetectionHead, self).__init__()
+
+        self.in_channels = in_channels
+        self.num_classes = num_classes
+        self.num_anchors = num_anchors
+        self.grid_size = grid_size
+
+        # Number of predictions per anchor: 4 (bbox) + 1 (objectness) + num_classes
+        self.num_predictions = 5 + num_classes
+
+        # Detection layers
+        # Reduce channels first for efficiency
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(in_channels, 512, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(512),
+            nn.LeakyReLU(0.1, inplace=True)
+        )
+
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(512, 256, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(256),
+            nn.LeakyReLU(0.1, inplace=True)
+        )
+
+        # Final prediction layer
+        self.pred_conv = nn.Conv2d(
+            256,
+            num_anchors * self.num_predictions,
+            kernel_size=1
+        )
+
+        # Adaptive pooling to ensure output is correct grid size
+        self.adaptive_pool = nn.AdaptiveAvgPool2d((grid_size, grid_size))
+
+        self._initialize_weights()
+
+        logger.info(f"YOLODetectionHead initialized: {num_anchors} anchors, "
+                   f"{num_classes} classes, {grid_size}x{grid_size} grid")
+
+    def _initialize_weights(self):
+        """Initialize weights for detection head."""
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+    def forward(self, x):
+        """
+        Args:
+            x: Input features of shape (batch, in_channels, H, W)
+
+        Returns:
+            predictions: Tensor of shape (batch, num_anchors, grid_size, grid_size, 5 + num_classes)
+                where last dim is [x, y, w, h, objectness, class_probs...]
+        """
+        # Apply detection layers
+        x = self.conv1(x)
+        x = self.conv2(x)
+
+        # Ensure correct spatial size
+        if x.size(2) != self.grid_size or x.size(3) != self.grid_size:
+            x = F.interpolate(x, size=(self.grid_size, self.grid_size),
+                            mode='bilinear', align_corners=False)
+
+        # Prediction layer
+        predictions = self.pred_conv(x)
+
+        # Reshape: [batch, num_anchors * predictions, H, W]
+        #       -> [batch, num_anchors, predictions, H, W]
+        #       -> [batch, num_anchors, H, W, predictions]
+        batch_size = predictions.size(0)
+        predictions = predictions.view(
+            batch_size,
+            self.num_anchors,
+            self.num_predictions,
+            self.grid_size,
+            self.grid_size
+        )
+        predictions = predictions.permute(0, 1, 3, 4, 2).contiguous()
+
+        # predictions shape: [batch, num_anchors, grid_size, grid_size, 5 + num_classes]
+        return predictions
+
+
+class MultiScaleDetectionHead(nn.Module):
+    """
+    Multi-scale detection head with predictions at multiple resolutions.
+    Similar to YOLOv3/v4 multi-scale approach.
+    """
+
+    def __init__(self, in_channels, num_classes, num_anchors=3, grid_sizes=[7, 14]):
+        """
+        Args:
+            in_channels: Number of input channels from backbone/adapter
+            num_classes: Number of object classes
+            num_anchors: Number of anchor boxes per grid cell
+            grid_sizes: List of grid sizes for multi-scale predictions
+        """
+        super(MultiScaleDetectionHead, self).__init__()
+
+        self.in_channels = in_channels
+        self.num_classes = num_classes
+        self.num_anchors = num_anchors
+        self.grid_sizes = grid_sizes
+
+        # Create detection head for each scale
+        self.detection_heads = nn.ModuleList([
+            YOLODetectionHead(in_channels, num_classes, num_anchors, grid_size)
+            for grid_size in grid_sizes
+        ])
+
+        logger.info(f"MultiScaleDetectionHead initialized with scales: {grid_sizes}")
+
+    def forward(self, x):
+        """
+        Args:
+            x: Input features of shape (batch, in_channels, H, W)
+
+        Returns:
+            predictions: List of tensors, one per scale
+                Each tensor has shape [batch, num_anchors, grid_size, grid_size, 5 + num_classes]
+        """
+        predictions = []
+        for head in self.detection_heads:
+            pred = head(x)
+            predictions.append(pred)
+
+        return predictions
+
+
+def decode_predictions(predictions, conf_threshold=0.5, grid_size=7):
+    """
+    Decode raw predictions to actual bounding boxes.
+
+    Args:
+        predictions: Tensor of shape [batch, num_anchors, grid_size, grid_size, 5 + num_classes]
+        conf_threshold: Confidence threshold for filtering predictions
+        grid_size: Size of the prediction grid
+
+    Returns:
+        boxes: List of tensors, one per image in batch
+            Each tensor has shape [N, 4] with boxes in format [x_center, y_center, w, h] (normalized)
+        scores: List of tensors, one per image
+            Each tensor has shape [N] with objectness * class_prob scores
+        labels: List of tensors, one per image
+            Each tensor has shape [N] with predicted class indices
+    """
+    batch_size = predictions.size(0)
+    num_anchors = predictions.size(1)
+
+    # Apply sigmoid to objectness and class predictions
+    # predictions[..., :4] are bbox coords (will apply sigmoid)
+    # predictions[..., 4] is objectness
+    # predictions[..., 5:] are class logits
+
+    pred_boxes = torch.sigmoid(predictions[..., :4])  # [batch, anchors, H, W, 4]
+    pred_obj = torch.sigmoid(predictions[..., 4])     # [batch, anchors, H, W]
+    pred_cls = predictions[..., 5:]                    # [batch, anchors, H, W, num_classes]
+
+    # Apply softmax to class predictions
+    pred_cls = F.softmax(pred_cls, dim=-1)
+
+    # Get class scores and labels
+    class_scores, class_labels = torch.max(pred_cls, dim=-1)  # [batch, anchors, H, W]
+
+    # Combine objectness and class confidence
+    confidence = pred_obj * class_scores  # [batch, anchors, H, W]
+
+    # Decode boxes for each image in batch
+    batch_boxes = []
+    batch_scores = []
+    batch_labels = []
+
+    for b in range(batch_size):
+        # Get predictions above threshold
+        mask = confidence[b] > conf_threshold
+
+        if mask.sum() == 0:
+            # No detections
+            batch_boxes.append(torch.zeros((0, 4), device=predictions.device))
+            batch_scores.append(torch.zeros((0,), device=predictions.device))
+            batch_labels.append(torch.zeros((0,), dtype=torch.long, device=predictions.device))
+            continue
+
+        # Get valid predictions
+        valid_boxes = pred_boxes[b][mask]  # [N, 4]
+        valid_scores = confidence[b][mask]  # [N]
+        valid_labels = class_labels[b][mask]  # [N]
+
+        # Convert grid-relative coordinates to image-relative
+        # Note: pred_boxes are already in [0, 1] range due to sigmoid
+        # They represent offsets within grid cells, so we need to adjust
+
+        batch_boxes.append(valid_boxes)
+        batch_scores.append(valid_scores)
+        batch_labels.append(valid_labels)
+
+    return batch_boxes, batch_scores, batch_labels
+
+
+def non_max_suppression(boxes, scores, labels, iou_threshold=0.4):
+    """
+    Apply Non-Maximum Suppression to remove duplicate detections.
+
+    Args:
+        boxes: Tensor of shape [N, 4] in format [x_center, y_center, w, h]
+        scores: Tensor of shape [N]
+        labels: Tensor of shape [N]
+        iou_threshold: IoU threshold for NMS
+
+    Returns:
+        keep_indices: Tensor of indices to keep
+    """
+    if len(boxes) == 0:
+        return torch.tensor([], dtype=torch.long, device=boxes.device)
+
+    # Convert center format to corner format for NMS
+    # [x_center, y_center, w, h] -> [x1, y1, x2, y2]
+    x_center, y_center, w, h = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
+    x1 = x_center - w / 2
+    y1 = y_center - h / 2
+    x2 = x_center + w / 2
+    y2 = y_center + h / 2
+    boxes_corners = torch.stack([x1, y1, x2, y2], dim=1)
+
+    # Apply NMS per class
+    keep_indices = []
+    unique_labels = labels.unique()
+
+    for label in unique_labels:
+        label_mask = labels == label
+        label_boxes = boxes_corners[label_mask]
+        label_scores = scores[label_mask]
+        label_indices = torch.where(label_mask)[0]
+
+        # Use torchvision NMS
+        keep = torch.ops.torchvision.nms(label_boxes, label_scores, iou_threshold)
+        keep_indices.append(label_indices[keep])
+
+    if len(keep_indices) > 0:
+        keep_indices = torch.cat(keep_indices)
+    else:
+        keep_indices = torch.tensor([], dtype=torch.long, device=boxes.device)
+
+    return keep_indices
+
+
+def build_detection_head(head_type, in_channels, num_classes, **kwargs):
+    """
+    Factory function to build detection head.
+
+    Args:
+        head_type: Type of detection head ('yolo' or 'multiscale')
+        in_channels: Number of input channels
+        num_classes: Number of object classes
+        **kwargs: Additional arguments for the head
+
+    Returns:
+        Detection head module
+    """
+    if head_type == 'yolo':
+        return YOLODetectionHead(
+            in_channels=in_channels,
+            num_classes=num_classes,
+            num_anchors=kwargs.get('num_anchors', 3),
+            grid_size=kwargs.get('grid_size', 7)
+        )
+    elif head_type == 'multiscale':
+        return MultiScaleDetectionHead(
+            in_channels=in_channels,
+            num_classes=num_classes,
+            num_anchors=kwargs.get('num_anchors', 3),
+            grid_sizes=kwargs.get('grid_sizes', [7, 14])
+        )
+    else:
+        raise ValueError(f"Unknown detection head type: {head_type}")

sota/macro_encoding.py

@@ -0,0 +1,100 @@
+# Macro Search Space Encoding for YOLO Adapter
+# Search for connectivity pattern in phases (Genetic CNN style)
+# Based on NSGA-Net reference implementation
+
+import numpy as np
+from collections import namedtuple
+
+# MacroGenotype: List of DAG matrices per phase
+MacroGenotype = namedtuple('MacroGenotype', 'ops')
+
+def phase_dencode(phase_bit_string):
+    """
+    Convert flat connectivity bits to adjacency structure.
+    Returns a list of lists where genome[i] contains connections for node i.
+    """
+    # Calculate number of nodes from bit length
+    # Length L = n*(n+1)/2 + 1
+    # 2*L = n^2 + n + 2
+    # n^2 + n + (2 - 2L) = 0
+    # n = (-1 + sqrt(1 - 4(2-2L)))/2 = (-1 + sqrt(8L - 7))/2
+    # This formula from reference: n = int(np.sqrt(2 * len(phase_bit_string) - 7/4) - 1/2) 
+    # seems to correspond to L = n(n+1)/2 + 1.
+    
+    n = int(np.sqrt(2 * len(phase_bit_string) - 7/4) - 1/2)
+    genome = []
+    
+    # For each node i (0 to n-1)
+    for i in range(n):
+        operator = []
+        # Check connections from all previous nodes 0 to i
+        # Triangular number indexing
+        for j in range(i + 1):
+            idx = int(i * (i + 1) / 2 + j)
+            operator.append(phase_bit_string[idx])
+        genome.append(operator)
+        
+    # Last bit is residual skip for the whole phase
+    genome.append([phase_bit_string[-1]])
+    return genome
+
+
+def convert(bit_string, n_phases=3):
+    """
+    Convert flat integer array to list of phase bit-strings
+    """
+    # Assumes bit_string is a np array
+    if bit_string.shape[0] % n_phases != 0:
+        # If mismatch (e.g. during initialization before bound setup fix), try to infer
+        n_phases = len(bit_string) // (len(bit_string) // n_phases)
+        
+    phase_length = bit_string.shape[0] // n_phases
+    genome = []
+    for i in range(0, bit_string.shape[0], phase_length):
+        sub_genome = bit_string[i:i+phase_length]
+        genome.append(sub_genome.tolist())
+
+    return genome
+
+
+def decode(genome):
+    """
+    Decode list of phase bit-strings into Genotype structure (adjacency lists)
+    """
+    genotype = []
+    for gene in genome:
+        genotype.append(phase_dencode(gene))
+
+    return MacroGenotype(ops=genotype)
+
+
+def get_search_space_bounds(n_nodes=4, n_phases=3):
+    """
+    Get bounds for macro search space (Binary encoding)
+    
+    Args:
+        n_nodes: number of nodes inside each phase
+        n_phases: number of phases to stack
+        
+    Returns:
+        n_var: number of bits
+        lb: lower bounds (all 0)
+        ub: upper bounds (all 1)
+    """
+    # Calculate bits per phase
+    # n_nodes nodes. 
+    # Node 1 inputs: 1 bit (from Input)
+    # Node 2 inputs: 2 bits (from Input, Node 1)
+    # ...
+    # Node n inputs: n bits
+    # Total connection bits = n*(n+1)/2
+    # Plus 1 bit for global skip connection
+    
+    bits_per_phase = int(n_nodes * (n_nodes + 1) / 2 + 1)
+    n_var = bits_per_phase * n_phases
+    
+    lb = np.zeros(n_var)
+    ub = np.ones(n_var) # Binary encoding
+    
+    return n_var, lb, ub
+