neurofixer 0.1.0__tar.gz

neurofixer-0.1.0/LICENSE

@@ -0,0 +1,37 @@
+NeuroFixer Research Preview License
+
+Copyright (c) 2026 Serdar Erişen
+
+This repository is released as a public research preview and demonstration
+implementation of NeuroFuser-inspired, backbone-agnostic attention-fusion modules.
+
+Permission is granted to view, clone, run, and evaluate this repository for
+personal, academic, and non-commercial research purposes.
+
+The following uses are not permitted without prior written permission from the
+copyright holder:
+
+1. Commercial use, including integration into commercial products or services.
+2. Redistribution of modified or unmodified copies as a competing library.
+3. Repackaging, relicensing, sublicensing, or selling the software.
+4. Use of the repository name, NeuroFixer, NeuroFuser, or related project names
+   to imply endorsement, official collaboration, or authorship.
+5. Uploading trained weights, private experimental assets, unpublished datasets,
+   or journal-specific confidential material derived from the author's research
+   without permission.
+
+Academic citation and attribution are required when this repository, its modules,
+or its design ideas are used in research, prototypes, demonstrations, derivative
+works, reports, or publications.
+
+This repository 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 non-infringement. In no event shall the copyright
+holder be liable for any claim, damages, or other liability arising from the use
+of this repository.
+
+For commercial licensing, collaboration, or permission requests, please contact:
+
+Serdar Erişen
+GitHub: https://github.com/serdarch
+Repository: https://github.com/serdarch/NeuroFixer

neurofixer-0.1.0/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: neurofixer
+Version: 0.1.0
+Summary: Backbone-agnostic build and support tools for NeuroFuser-style attention fusion.
+Author: Serdar Erişen
+Project-URL: Homepage, https://github.com/serdarch/NeuroFixer
+Project-URL: Repository, https://github.com/serdarch/NeuroFixer
+Project-URL: Paper, https://doi.org/10.1016/j.patcog.2026.114167
+Keywords: semantic segmentation,attention,neurofuser,cnn,vit,computer vision
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0
+Dynamic: license-file
+
+# NeuroFixer
+
+**NeuroFixer** is the public companion demo and library-oriented repository for the Pattern Recognition article:
+
+**NeuroFuser: Resource-Aware Neuromodulation of Multi-scale Fusion Attention for Domain Adaptive Segmentation**
+Serdar Erişen and André Borrmann
+*Pattern Recognition*, 2026
+DOI: **10.1016/j.patcog.2026.114167**
+
+NeuroFixer provides a lightweight, backbone-agnostic PyTorch implementation path for NeuroFuser-style attention-fusion modules. It is designed as a public-demo safe repository that can grow toward a future installable package:
+
+```bash
+pip install neurofixer
+```
+
+The current version provides dependency-light PyTorch implementations of the core NeuroFuser-inspired modules:
+
+* `EncodingGate` — per-location/channel gated feature calibration with residual flow.
+* `EncodingModule` — latent-grid alignment with grouped dilation modulation.
+* `FusionBridge` — branch-normalized multi-scale fusion for decoder/skip pathways.
+* `NeuromodulationController` — differentiable resource-aware controls for gates, heads, dilations, and fusion weights.
+* Buildable CNN and ViT demo networks without custom dependencies.
+
+## Relation to the paper
+
+The published NeuroFuser paper introduces resource-aware neuromodulation of multi-scale fusion attention for domain-adaptive semantic segmentation. NeuroFixer is a public-facing, lightweight implementation and experimentation repository inspired by the paper’s main design principles: backbone-agnostic fusion, controllable attention modulation, CNN/ViT compatibility, and dependency-light modularity.
+
+This repository is intentionally released as a public demo and development base. It does not include private training assets, pretrained weights, full experimental pipelines, journal submission files, or confidential reviewer-related material.
+
+## Design principles
+
+1. **Backbone-agnostic:** CNN feature maps and ViT token grids can both use the same EG/EM/FBr interfaces.
+2. **Minimal dependencies:** PyTorch is the only required runtime dependency.
+3. **Public-demo safe:** no pretrained weights, no private backbones, and no journal-specific experimental assets are included.
+4. **Research extensible:** the modules are intentionally modular so user feedback can guide future additions.
+5. **Future package-ready:** the repository structure is prepared for gradual development toward an installable `neurofixer` package.
+
+## Quick start from source
+
+```bash
+pip install -e .
+python -m neurofixer.demo.run_demo --backbone cnn
+python -m neurofixer.demo.run_demo --backbone vit
+```
+
+Expected output:
+
+```python
+{'backbone': 'cnn', 'input_shape': (1, 3, 128, 128), 'output_shape': (1, 19, 128, 128)}
+```
+
+## Python usage
+
+```python
+import torch
+from neurofixer import build_cnn_neurofixer, build_vit_neurofixer
+
+x = torch.randn(1, 3, 128, 128)
+
+model = build_cnn_neurofixer(num_classes=19)
+logits = model(x)
+print(logits.shape)
+
+vit_model = build_vit_neurofixer(num_classes=19, patch_size=8)
+vit_logits = vit_model(x)
+print(vit_logits.shape)
+```
+
+## Repository layout
+
+```text
+neurofixer/
+  modules/       # EG, EM, FBr, neuromodulation controller
+  build/         # CNN and ViT demo builders
+  demo/          # CLI demo and smoke-test helpers
+  utils/         # token/grid helpers for CNN-ViT interoperability
+
+functions/       # compatibility wrappers for the early folder plan
+build/           # compatibility build entry points
+neurofuser_demo/ # compatibility demo wrappers
+tests/           # smoke tests
+```
+
+
+## Model families
+
+NeuroFixer is organized as a lightweight library for reusable attention-fusion modules and model-family demos. The first model family is:
+
+```text
+neurofixer.models.neurofuser_demo
+```
+
+This folder contains lightweight CNN and ViT demonstration networks that use the NeuroFuser-inspired `EncodingGate`, `EncodingModule`, `FusionBridge`, and `NeuromodulationController` components. Future attention projects can be added under `neurofixer/models/` as separate model families without changing the core module API.
+
+Example imports:
+
+```python
+from neurofixer.models.neurofuser_demo import build_cnn_neurofixer
+from neurofixer.models.neurofuser_demo import build_vit_neurofixer
+from neurofixer.models.registry import list_models, build_model
+```
+
+## Development roadmap
+
+* Add config dataclasses for larger CNN/ViT variants.
+* Add optional FlashAttention/xFormers adapters only as optional extras, never as required dependencies.
+* Add palette-alignment utilities for training-free domain transfer.
+* Add public examples for Cityscapes-like and ADE20K-like class counts without releasing private weights.
+* Add GitHub Actions smoke tests for CPU-only import and demo execution.
+* Prepare future package metadata for `pip install neurofixer`.
+
+## Citation
+
+If you use NeuroFixer, NeuroFuser-inspired modules, or the design ideas in this repository, please cite the associated Pattern Recognition article:
+
+```bibtex
+@article{erisen2026neurofuser,
+  title   = {NeuroFuser: Resource-Aware Neuromodulation of Multi-scale Fusion Attention for Domain Adaptive Segmentation},
+  author  = {Eri{\c{s}}en, Serdar and Borrmann, Andr{\'e}},
+  journal = {Pattern Recognition},
+  year    = {2026},
+  doi     = {10.1016/j.patcog.2026.114167}
+}
+```
+
+## License and rights
+
+Copyright © Serdar Erişen, 2026. All rights reserved.
+
+NeuroFixer is released under a custom **Research Preview License**.
+
+You may view, clone, run, and evaluate the repository for personal, academic, and non-commercial research purposes. Commercial use, redistribution as a competing library, relicensing, sublicensing, or use of the project names to imply endorsement require prior written permission from the copyright holder.
+
+See [LICENSE](LICENSE) for the full terms.
+
+## Contact
+
+For academic collaboration, licensing, or repository-related questions, please contact the repository owner through GitHub:
+
+**GitHub:** `@serdarch`
+**Repository:** `serdarch/NeuroFixer`

neurofixer-0.1.0/README.md

@@ -0,0 +1,141 @@
+# NeuroFixer
+
+**NeuroFixer** is the public companion demo and library-oriented repository for the Pattern Recognition article:
+
+**NeuroFuser: Resource-Aware Neuromodulation of Multi-scale Fusion Attention for Domain Adaptive Segmentation**
+Serdar Erişen and André Borrmann
+*Pattern Recognition*, 2026
+DOI: **10.1016/j.patcog.2026.114167**
+
+NeuroFixer provides a lightweight, backbone-agnostic PyTorch implementation path for NeuroFuser-style attention-fusion modules. It is designed as a public-demo safe repository that can grow toward a future installable package:
+
+```bash
+pip install neurofixer
+```
+
+The current version provides dependency-light PyTorch implementations of the core NeuroFuser-inspired modules:
+
+* `EncodingGate` — per-location/channel gated feature calibration with residual flow.
+* `EncodingModule` — latent-grid alignment with grouped dilation modulation.
+* `FusionBridge` — branch-normalized multi-scale fusion for decoder/skip pathways.
+* `NeuromodulationController` — differentiable resource-aware controls for gates, heads, dilations, and fusion weights.
+* Buildable CNN and ViT demo networks without custom dependencies.
+
+## Relation to the paper
+
+The published NeuroFuser paper introduces resource-aware neuromodulation of multi-scale fusion attention for domain-adaptive semantic segmentation. NeuroFixer is a public-facing, lightweight implementation and experimentation repository inspired by the paper’s main design principles: backbone-agnostic fusion, controllable attention modulation, CNN/ViT compatibility, and dependency-light modularity.
+
+This repository is intentionally released as a public demo and development base. It does not include private training assets, pretrained weights, full experimental pipelines, journal submission files, or confidential reviewer-related material.
+
+## Design principles
+
+1. **Backbone-agnostic:** CNN feature maps and ViT token grids can both use the same EG/EM/FBr interfaces.
+2. **Minimal dependencies:** PyTorch is the only required runtime dependency.
+3. **Public-demo safe:** no pretrained weights, no private backbones, and no journal-specific experimental assets are included.
+4. **Research extensible:** the modules are intentionally modular so user feedback can guide future additions.
+5. **Future package-ready:** the repository structure is prepared for gradual development toward an installable `neurofixer` package.
+
+## Quick start from source
+
+```bash
+pip install -e .
+python -m neurofixer.demo.run_demo --backbone cnn
+python -m neurofixer.demo.run_demo --backbone vit
+```
+
+Expected output:
+
+```python
+{'backbone': 'cnn', 'input_shape': (1, 3, 128, 128), 'output_shape': (1, 19, 128, 128)}
+```
+
+## Python usage
+
+```python
+import torch
+from neurofixer import build_cnn_neurofixer, build_vit_neurofixer
+
+x = torch.randn(1, 3, 128, 128)
+
+model = build_cnn_neurofixer(num_classes=19)
+logits = model(x)
+print(logits.shape)
+
+vit_model = build_vit_neurofixer(num_classes=19, patch_size=8)
+vit_logits = vit_model(x)
+print(vit_logits.shape)
+```
+
+## Repository layout
+
+```text
+neurofixer/
+  modules/       # EG, EM, FBr, neuromodulation controller
+  build/         # CNN and ViT demo builders
+  demo/          # CLI demo and smoke-test helpers
+  utils/         # token/grid helpers for CNN-ViT interoperability
+
+functions/       # compatibility wrappers for the early folder plan
+build/           # compatibility build entry points
+neurofuser_demo/ # compatibility demo wrappers
+tests/           # smoke tests
+```
+
+
+## Model families
+
+NeuroFixer is organized as a lightweight library for reusable attention-fusion modules and model-family demos. The first model family is:
+
+```text
+neurofixer.models.neurofuser_demo
+```
+
+This folder contains lightweight CNN and ViT demonstration networks that use the NeuroFuser-inspired `EncodingGate`, `EncodingModule`, `FusionBridge`, and `NeuromodulationController` components. Future attention projects can be added under `neurofixer/models/` as separate model families without changing the core module API.
+
+Example imports:
+
+```python
+from neurofixer.models.neurofuser_demo import build_cnn_neurofixer
+from neurofixer.models.neurofuser_demo import build_vit_neurofixer
+from neurofixer.models.registry import list_models, build_model
+```
+
+## Development roadmap
+
+* Add config dataclasses for larger CNN/ViT variants.
+* Add optional FlashAttention/xFormers adapters only as optional extras, never as required dependencies.
+* Add palette-alignment utilities for training-free domain transfer.
+* Add public examples for Cityscapes-like and ADE20K-like class counts without releasing private weights.
+* Add GitHub Actions smoke tests for CPU-only import and demo execution.
+* Prepare future package metadata for `pip install neurofixer`.
+
+## Citation
+
+If you use NeuroFixer, NeuroFuser-inspired modules, or the design ideas in this repository, please cite the associated Pattern Recognition article:
+
+```bibtex
+@article{erisen2026neurofuser,
+  title   = {NeuroFuser: Resource-Aware Neuromodulation of Multi-scale Fusion Attention for Domain Adaptive Segmentation},
+  author  = {Eri{\c{s}}en, Serdar and Borrmann, Andr{\'e}},
+  journal = {Pattern Recognition},
+  year    = {2026},
+  doi     = {10.1016/j.patcog.2026.114167}
+}
+```
+
+## License and rights
+
+Copyright © Serdar Erişen, 2026. All rights reserved.
+
+NeuroFixer is released under a custom **Research Preview License**.
+
+You may view, clone, run, and evaluate the repository for personal, academic, and non-commercial research purposes. Commercial use, redistribution as a competing library, relicensing, sublicensing, or use of the project names to imply endorsement require prior written permission from the copyright holder.
+
+See [LICENSE](LICENSE) for the full terms.
+
+## Contact
+
+For academic collaboration, licensing, or repository-related questions, please contact the repository owner through GitHub:
+
+**GitHub:** `@serdarch`
+**Repository:** `serdarch/NeuroFixer`

neurofixer-0.1.0/neurofixer/__init__.py

@@ -0,0 +1,24 @@
+"""NeuroFixer: lightweight attention-fusion modules and model-family demos."""
+
+from neurofixer.modules import (
+    EncodingGate,
+    EncodingModule,
+    FusionBridge,
+    NeuromodulationController,
+)
+
+from neurofixer.models.neurofuser_demo import (
+    build_cnn_neurofixer,
+    build_vit_neurofixer,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "EncodingGate",
+    "EncodingModule",
+    "FusionBridge",
+    "NeuromodulationController",
+    "build_cnn_neurofixer",
+    "build_vit_neurofixer",
+]

neurofixer-0.1.0/neurofixer/build/__init__.py

@@ -0,0 +1,11 @@
+from .cnn import CNNNeuroFuserDemo, SimpleCNNEncoder, build_cnn_neurofixer
+from .vit import SimpleViTGridEncoder, ViTNeuroFuserDemo, build_vit_neurofixer
+
+__all__ = [
+    "CNNNeuroFuserDemo",
+    "SimpleCNNEncoder",
+    "build_cnn_neurofixer",
+    "SimpleViTGridEncoder",
+    "ViTNeuroFuserDemo",
+    "build_vit_neurofixer",
+]

neurofixer-0.1.0/neurofixer/build/cnn.py

@@ -0,0 +1,69 @@
+"""Small CNN demo backbone and NeuroFuser-style decoder."""
+from __future__ import annotations
+
+from typing import List, Sequence
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+from neurofixer.modules import EncodingGate, EncodingModule, FusionBridge
+
+
+class SimpleCNNEncoder(nn.Module):
+    """Dependency-free CNN encoder for public demos and smoke tests."""
+
+    def __init__(self, in_channels: int = 3, channels: Sequence[int] = (32, 64, 128, 256)) -> None:
+        super().__init__()
+        layers = []
+        prev = in_channels
+        for i, c in enumerate(channels):
+            stride = 1 if i == 0 else 2
+            layers.append(nn.Sequential(
+                nn.Conv2d(prev, c, 3, stride=stride, padding=1, bias=False),
+                nn.BatchNorm2d(c),
+                nn.GELU(),
+                nn.Conv2d(c, c, 3, padding=1, bias=False),
+                nn.BatchNorm2d(c),
+                nn.GELU(),
+            ))
+            prev = c
+        self.stages = nn.ModuleList(layers)
+        self.channels = tuple(channels)
+
+    def forward(self, x: torch.Tensor) -> List[torch.Tensor]:
+        feats = []
+        for stage in self.stages:
+            x = stage(x)
+            feats.append(x)
+        return feats
+
+
+class CNNNeuroFuserDemo(nn.Module):
+    """Buildable CNN NeuroFixer demo using EG, EM, and FBr."""
+
+    def __init__(self, num_classes: int = 19, in_channels: int = 3, latent_dim: int = 128) -> None:
+        super().__init__()
+        self.encoder = SimpleCNNEncoder(in_channels=in_channels)
+        ch = self.encoder.channels
+        self.gates = nn.ModuleList([EncodingGate(c, num_classes=None) for c in ch])
+        self.align = nn.ModuleList([EncodingModule(c, latent_dim=latent_dim) for c in ch])
+        self.fuse43 = FusionBridge([latent_dim, latent_dim], latent_dim)
+        self.fuse32 = FusionBridge([latent_dim, latent_dim], latent_dim)
+        self.fuse21 = FusionBridge([latent_dim, latent_dim], latent_dim)
+        self.head = nn.Conv2d(latent_dim, num_classes, 1)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        image_size = x.shape[-2:]
+        feats = [gate(f) for gate, f in zip(self.gates, self.encoder(x))]
+        latent = [em(f) for em, f in zip(self.align, feats)]
+        y = latent[-1]
+        y = self.fuse43([F.interpolate(y, size=latent[-2].shape[-2:], mode="bilinear", align_corners=False), latent[-2]])
+        y = self.fuse32([F.interpolate(y, size=latent[-3].shape[-2:], mode="bilinear", align_corners=False), latent[-3]])
+        y = self.fuse21([F.interpolate(y, size=latent[-4].shape[-2:], mode="bilinear", align_corners=False), latent[-4]])
+        logits = self.head(y)
+        return F.interpolate(logits, size=image_size, mode="bilinear", align_corners=False)
+
+
+def build_cnn_neurofixer(num_classes: int = 19, in_channels: int = 3, latent_dim: int = 128) -> CNNNeuroFuserDemo:
+    return CNNNeuroFuserDemo(num_classes=num_classes, in_channels=in_channels, latent_dim=latent_dim)

neurofixer-0.1.0/neurofixer/build/vit.py

@@ -0,0 +1,82 @@
+"""Small ViT-style demo backbone and NeuroFuser-style decoder."""
+from __future__ import annotations
+
+from typing import List, Sequence, Tuple
+
+import torch
+from torch import nn
+import torch.nn.functional as F
+
+from neurofixer.modules import EncodingGate, EncodingModule, FusionBridge
+
+
+class PatchEmbed(nn.Module):
+    def __init__(self, in_channels: int = 3, embed_dim: int = 128, patch_size: int = 8) -> None:
+        super().__init__()
+        self.patch_size = patch_size
+        self.proj = nn.Conv2d(in_channels, embed_dim, patch_size, stride=patch_size)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.proj(x)
+
+
+class SimpleViTGridEncoder(nn.Module):
+    """Grid-preserving ViT-like encoder using PyTorch Transformer blocks.
+
+    It keeps the demo installable without timm or HuggingFace dependencies.
+    """
+
+    def __init__(self, in_channels: int = 3, embed_dim: int = 128, patch_size: int = 8, depth: int = 4, heads: int = 4) -> None:
+        super().__init__()
+        self.patch = PatchEmbed(in_channels, embed_dim, patch_size)
+        self.blocks = nn.ModuleList([
+            nn.TransformerEncoderLayer(
+                d_model=embed_dim,
+                nhead=heads,
+                dim_feedforward=embed_dim * 4,
+                batch_first=True,
+                activation="gelu",
+                norm_first=True,
+            )
+            for _ in range(depth)
+        ])
+        self.norms = nn.ModuleList([nn.LayerNorm(embed_dim) for _ in range(depth)])
+        self.channels = tuple([embed_dim] * depth)
+
+    def forward(self, x: torch.Tensor) -> List[torch.Tensor]:
+        grid = self.patch(x)
+        b, c, h, w = grid.shape
+        tokens = grid.flatten(2).transpose(1, 2)
+        feats = []
+        for block, norm in zip(self.blocks, self.norms):
+            tokens = block(tokens)
+            z = norm(tokens).transpose(1, 2).reshape(b, c, h, w).contiguous()
+            feats.append(z)
+        return feats
+
+
+class ViTNeuroFuserDemo(nn.Module):
+    """Buildable ViT NeuroFixer demo using EG, EM, and FBr."""
+
+    def __init__(self, num_classes: int = 19, in_channels: int = 3, latent_dim: int = 128, patch_size: int = 8) -> None:
+        super().__init__()
+        self.encoder = SimpleViTGridEncoder(in_channels=in_channels, embed_dim=latent_dim, patch_size=patch_size)
+        ch = self.encoder.channels
+        self.gates = nn.ModuleList([EncodingGate(c, num_classes=None) for c in ch])
+        self.align = nn.ModuleList([EncodingModule(c, latent_dim=latent_dim) for c in ch])
+        self.fuse = nn.ModuleList([FusionBridge([latent_dim, latent_dim], latent_dim) for _ in range(len(ch) - 1)])
+        self.head = nn.Conv2d(latent_dim, num_classes, 1)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        image_size = x.shape[-2:]
+        feats = [gate(f) for gate, f in zip(self.gates, self.encoder(x))]
+        latent = [em(f) for em, f in zip(self.align, feats)]
+        y = latent[-1]
+        for skip, fuse in zip(reversed(latent[:-1]), self.fuse):
+            y = fuse([y, skip])
+        logits = self.head(y)
+        return F.interpolate(logits, size=image_size, mode="bilinear", align_corners=False)
+
+
+def build_vit_neurofixer(num_classes: int = 19, in_channels: int = 3, latent_dim: int = 128, patch_size: int = 8) -> ViTNeuroFuserDemo:
+    return ViTNeuroFuserDemo(num_classes=num_classes, in_channels=in_channels, latent_dim=latent_dim, patch_size=patch_size)

neurofixer-0.1.0/neurofixer/demo/__init__.py

@@ -0,0 +1,4 @@
+from .functions import build_demo_model, run_smoke_demo
+from .parameters import DemoParameters
+
+__all__ = ["DemoParameters", "build_demo_model", "run_smoke_demo"]

neurofixer-0.1.0/neurofixer/demo/arguments.py

@@ -0,0 +1,15 @@
+"""Command-line arguments for NeuroFixer demos."""
+from __future__ import annotations
+
+import argparse
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Run a NeuroFixer CNN/ViT smoke demo.")
+    parser.add_argument("--backbone", choices=["cnn", "vit"], default="cnn")
+    parser.add_argument("--num-classes", type=int, default=19)
+    parser.add_argument("--latent-dim", type=int, default=128)
+    parser.add_argument("--image-size", type=int, default=128)
+    parser.add_argument("--patch-size", type=int, default=8)
+    parser.add_argument("--device", default="cpu")
+    return parser

neurofixer-0.1.0/neurofixer/demo/functions.py

@@ -0,0 +1,23 @@
+"""Demo helpers."""
+from __future__ import annotations
+
+import torch
+
+from neurofixer.build import build_cnn_neurofixer, build_vit_neurofixer
+
+
+def build_demo_model(backbone: str = "cnn", num_classes: int = 19, latent_dim: int = 128, patch_size: int = 8):
+    if backbone == "cnn":
+        return build_cnn_neurofixer(num_classes=num_classes, latent_dim=latent_dim)
+    if backbone == "vit":
+        return build_vit_neurofixer(num_classes=num_classes, latent_dim=latent_dim, patch_size=patch_size)
+    raise ValueError("backbone must be 'cnn' or 'vit'")
+
+
+@torch.no_grad()
+def run_smoke_demo(backbone: str = "cnn", num_classes: int = 19, latent_dim: int = 128, image_size: int = 128, patch_size: int = 8, device: str = "cpu"):
+    model = build_demo_model(backbone, num_classes=num_classes, latent_dim=latent_dim, patch_size=patch_size).to(device)
+    model.eval()
+    x = torch.randn(1, 3, image_size, image_size, device=device)
+    y = model(x)
+    return {"backbone": backbone, "input_shape": tuple(x.shape), "output_shape": tuple(y.shape)}

neurofixer-0.1.0/neurofixer/demo/parameters.py

@@ -0,0 +1,14 @@
+"""Default demo parameters."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class DemoParameters:
+    backbone: str = "cnn"  # "cnn" or "vit"
+    num_classes: int = 19
+    in_channels: int = 3
+    latent_dim: int = 128
+    image_size: int = 128
+    patch_size: int = 8

neurofixer-0.1.0/neurofixer/demo/run_demo.py

@@ -0,0 +1,22 @@
+"""Executable smoke demo: python -m neurofixer.demo.run_demo --backbone cnn"""
+from __future__ import annotations
+
+from .arguments import build_parser
+from .functions import run_smoke_demo
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+    result = run_smoke_demo(
+        backbone=args.backbone,
+        num_classes=args.num_classes,
+        latent_dim=args.latent_dim,
+        image_size=args.image_size,
+        patch_size=args.patch_size,
+        device=args.device,
+    )
+    print(result)
+
+
+if __name__ == "__main__":
+    main()

neurofixer-0.1.0/neurofixer/models/__init__.py

@@ -0,0 +1,11 @@
+"""Model families available in NeuroFixer."""
+
+from neurofixer.models.neurofuser_demo import (
+    build_cnn_neurofixer,
+    build_vit_neurofixer,
+)
+
+__all__ = [
+    "build_cnn_neurofixer",
+    "build_vit_neurofixer",
+]

neurofixer-0.1.0/neurofixer/models/neurofuser_demo/__init__.py

@@ -0,0 +1,17 @@
+"""NeuroFuser-style public demo models for NeuroFixer."""
+
+from neurofixer.models.neurofuser_demo.cnn import (
+    CNNNeuroFuserDemo,
+    build_cnn_neurofixer,
+)
+from neurofixer.models.neurofuser_demo.vit import (
+    ViTNeuroFuserDemo,
+    build_vit_neurofixer,
+)
+
+__all__ = [
+    "CNNNeuroFuserDemo",
+    "ViTNeuroFuserDemo",
+    "build_cnn_neurofixer",
+    "build_vit_neurofixer",
+]