Skip to content

Status: Needs Review

This page has not been reviewed for accuracy and completeness. Content may be outdated or contain errors.

Node Catalog

Complete reference of all 30+ built-in nodes in CUVIS.AI, organized by category for easy navigation.

Overview

Nodes are the building blocks of CUVIS.AI pipelines. Each node performs a specific operation (data loading, preprocessing, detection, visualization) and connects to other nodes via typed ports.

What You'll Find Here: - 📚 Complete catalog of all built-in nodes - 🔍 Quick reference tables for finding the right node - 📖 Usage examples and configuration patterns - 🔗 Links to tutorials demonstrating each node

Node Categories

  • Data Nodes

    Data loading and dataset management nodes

    Nodes: LentilsAnomalyDataNode (1)

  • Preprocessing

    Data transformation and preprocessing nodes

    Nodes: MinMaxNormalizer, ZScoreNormalizer, PerPixelUnitNorm, and more (7)

  • Selectors

    Channel and feature selection nodes

    Nodes: SoftChannelSelector, BaselineFalseRGBSelector, SupervisedSelectors (8)

  • Statistical

    Statistical analysis and anomaly detection nodes

    Nodes: RXGlobal, ScoreToLogit (2)

  • Deep Learning

    Neural network and gradient-based training nodes

    Nodes: DeepSVDD*, TrainablePCA, LearnableChannelMixer, ConcreteBandSelector (8)

  • Loss & Metrics

    Loss functions and evaluation metrics

    Nodes: AnomalyBCEWithLogits, DeepSVDDSoftBoundaryLoss, AnomalyDetectionMetrics (7)

  • Visualization

    Results visualization and monitoring nodes

    Nodes: AnomalyMask, CubeRGBVisualizer, ScoreHeatmapVisualizer, TensorBoardMonitor (4)

  • Utility Nodes

    Helper nodes for decisions and transformations

    Nodes: BinaryDecider, QuantileBinaryDecider, BinaryAnomalyLabelMapper (4)

Quick Reference Table

All Built-in Nodes at a Glance:

Node Category Statistical Init Trainable Primary Use Case
LentilsAnomalyDataNode Data ❌ ❌ Load hyperspectral data with anomaly labels
BandpassByWavelength Preprocessing ❌ ❌ Filter channels by wavelength range
MinMaxNormalizer Preprocessing ✅ ❌ Min-max scaling with running statistics
ZScoreNormalizer Preprocessing ❌ ❌ Z-score normalization
ZScoreNormalizerGlobal Preprocessing/DL ✅ ✅ Learnable z-score encoder for Deep SVDD
PerPixelUnitNorm Preprocessing ❌ ❌ Per-pixel L2 normalization
SigmoidNormalizer Preprocessing ❌ ❌ Median-centered sigmoid squashing
IdentityNormalizer Preprocessing ❌ ❌ Pass-through (no-op)
SoftChannelSelector Selectors ✅ ✅ Learnable soft channel selection (Gumbel-Softmax)
TopKIndices Selectors ❌ ❌ Extract top-k channel indices from weights
BaselineFalseRGBSelector Selectors ❌ ❌ Fixed RGB wavelength selection
CIRFalseColorSelector Selectors ❌ ❌ Color Infrared false color
HighContrastBandSelector Selectors ❌ ❌ Data-driven high-contrast selection
SupervisedCIRBandSelector Selectors ✅ ❌ Supervised NIR/Red/Green selection with mRMR
SupervisedWindowedFalseRGBSelector Selectors ✅ ❌ Supervised RGB selection with windowing
SupervisedFullSpectrumBandSelector Selectors ✅ ❌ Supervised global band selection
RXGlobal Statistical ✅ ❌ Reed-Xiaoli anomaly detector
ScoreToLogit Utility ❌ ✅ Transform RX scores to logits
DeepSVDDProjection Deep Learning ❌ ✅ Deep SVDD projection network
DeepSVDDCenterTracker Deep Learning ✅ ✅ Track hypersphere center with EMA
DeepSVDDScores Deep Learning ❌ ❌ Compute distance-based anomaly scores
TrainablePCA Deep Learning ✅ ✅ PCA with optional gradient training
LearnableChannelMixer Deep Learning ✅ ✅ DRCNN-style 1x1 convolution mixer
ConcreteBandSelector Deep Learning ❌ ✅ Concrete/Gumbel-Softmax discrete selector
AnomalyBCEWithLogits Loss ❌ ❌ Binary cross-entropy loss
DeepSVDDSoftBoundaryLoss Loss ❌ ❌ Soft boundary loss for Deep SVDD
OrthogonalityLoss Loss ❌ ❌ Orthogonality regularization for PCA
SelectorEntropyRegularizer Loss ❌ ❌ Entropy regularization for selectors
SelectorDiversityRegularizer Loss ❌ ❌ Diversity regularization for selectors
AnomalyDetectionMetrics Metrics ❌ ❌ IoU, precision, recall, F1, AP
ExplainedVarianceMetric Metrics ❌ ❌ Track PCA explained variance
AnomalyMask Visualization ❌ ❌ Visualize anomaly masks
CubeRGBVisualizer Visualization ❌ ❌ False-color RGB from selected channels
PCAVisualization Visualization ❌ ❌ Visualize PCA projections
ScoreHeatmapVisualizer Visualization ❌ ❌ Anomaly score heatmaps
TensorBoardMonitorNode Visualization ❌ ❌ TensorBoard logging (sink node)
BinaryDecider Utility ❌ ❌ Fixed threshold binary decisions
QuantileBinaryDecider Utility ❌ ❌ Quantile-based binary decisions
BinaryAnomalyLabelMapper Utility ❌ ❌ Convert multi-class to binary anomaly labels

Finding the Right Node

By Task

Anomaly Detection: - Statistical: RXGlobal - Fast, interpretable baseline - Deep Learning: DeepSVDD* - One-class learning with neural networks

Band/Channel Selection: - Fixed Selection: BaselineFalseRGBSelector, CIRFalseColorSelector - Learnable Selection: SoftChannelSelector, ConcreteBandSelector - Supervised Selection: SupervisedCIRBandSelector, SupervisedWindowedFalseRGBSelector

Preprocessing: - Normalization: MinMaxNormalizer, ZScoreNormalizer - Wavelength Filtering: BandpassByWavelength - Per-Pixel Operations: PerPixelUnitNorm

Dimensionality Reduction: - PCA: TrainablePCA - Channel Mixing: LearnableChannelMixer

Visualization & Monitoring: - TensorBoard: TensorBoardMonitorNode - Anomaly Masks: AnomalyMask - Score Heatmaps: ScoreHeatmapVisualizer

By Training Paradigm

Statistical-Only (No Gradients): - RXGlobal - MinMaxNormalizer (with use_running_stats=True) - SupervisedCIRBandSelector - SupervisedWindowedFalseRGBSelector

Two-Phase (Statistical → Gradient): - SoftChannelSelector - TrainablePCA - LearnableChannelMixer - DeepSVDD* nodes

Gradient-Only: - ConcreteBandSelector - DeepSVDDProjection

No Training Required: - ZScoreNormalizer - BandpassByWavelength - BinaryDecider - All visualization nodes

By Data Type

Hyperspectral Data: - LentilsAnomalyDataNode - BandpassByWavelength - SoftChannelSelector - RXGlobal

RGB/False-Color: - BaselineFalseRGBSelector - CIRFalseColorSelector - CubeRGBVisualizer

Feature Embeddings: - DeepSVDDProjection - DeepSVDDCenterTracker - DeepSVDDScores

Common Pipeline Patterns

Pattern 1: Statistical Detection Pipeline

Use Case: Fast baseline anomaly detection with RX

graph LR
    A[LentilsAnomalyDataNode] -->|cube| B[MinMaxNormalizer]
    B -->|normalized| C[RXGlobal]
    C -->|scores| D[ScoreToLogit]
    D -->|logits| E[BinaryDecider]
    E -->|decisions| F[AnomalyDetectionMetrics]
    A -->|mask| F
    F -->|metrics| G[TensorBoard]

Training: Statistical-only (Phase 1) Tutorial: RX Statistical Detection

Pattern 2: Two-Phase Training with Channel Selection

Use Case: Learnable channel selection with gradient optimization

graph LR
    A[Data] -->|cube| B[MinMaxNormalizer]
    B -->|normalized| C[SoftChannelSelector]
    C -->|selected| D[RXGlobal]
    D -->|scores| E[ScoreToLogit]
    E -->|logits| F[BCELoss]
    E -->|logits| G[BinaryDecider]
    G -->|decisions| H[Metrics]
    C -->|weights| I[EntropyLoss]

Training: Phase 1 (Statistical) → Phase 2 (Unfreeze selector + RX) → Phase 3 (Gradient) Tutorial: Channel Selector

Pattern 3: Deep Learning Pipeline (Deep SVDD)

Use Case: Deep one-class anomaly detection

graph LR
    A[Data] -->|cube| B[BandpassByWavelength]
    B -->|filtered| C[PerPixelUnitNorm]
    C -->|normalized| D[ZScoreNormalizerGlobal]
    D -->|encoded| E[DeepSVDDProjection]
    E -->|embeddings| F[CenterTracker]
    F -->|center| G[DeepSVDDScores]
    E -->|embeddings| G
    G -->|scores| H[QuantileDecider]
    H -->|decisions| I[Metrics]

Training: Phase 1 (Statistical encoder init) → Phase 2 (Unfreeze encoder) → Phase 3 (Gradient) Tutorial: Deep SVDD Gradient

Pattern 4: Plugin-Based Pipeline

Use Case: Using external plugin nodes (e.g., AdaCLIP)

graph LR
    A[Data] -->|cube| B[MinMaxNormalizer]
    B -->|normalized| C[LearnableChannelMixer]
    C -->|rgb 3ch| D[AdaCLIPDetector Plugin]
    D -->|scores| E[QuantileDecider]
    E -->|decisions| F[Metrics]

Training: Phase 1 (Statistical) → Phase 2 (Unfreeze mixer) → Phase 3 (Gradient with IoU loss) Tutorial: AdaCLIP Workflow

Plugin Nodes

CUVIS.AI supports plugin nodes loaded from external repositories. Plugin nodes extend the built-in catalog with specialized functionality.

Key Difference: - Built-in nodes: Included in cuvis-ai package - Plugin nodes: Loaded dynamically from Git repositories

Example Plugin: cuvis-ai-adaclip - AdaCLIPDetector: CLIP-based anomaly detection for hyperspectral data - Repository: https://github.com/cubert-hyperspectral/cuvis-ai-adaclip

Learn More: - Plugin System Overview - Architecture and concepts - Plugin Usage - How to use plugin nodes - Plugin Development - Create your own plugins

Node Development

Want to create custom nodes?

  1. For built-in nodes: Follow the Add Built-in Node guide
  2. For external plugins: See Plugin Development

Resources: - Node System Deep Dive - Node architecture and lifecycle - Port System - Typed I/O connections - API Reference - Node base classes and utilities

Concepts: - Node System Deep Dive - Understanding nodes and their lifecycle - Port System Deep Dive - Typed port connections - Two-Phase Training - Training strategies for learnable nodes

Tutorials: - RX Statistical Detection - Statistical-only pipeline - Channel Selector - Two-phase training example - Deep SVDD Gradient - Deep learning pipeline

API Reference: - Node API - Base node classes - Port API - Port specifications - Pipeline API - Pipeline construction

Next Steps: Browse the category pages above to explore detailed documentation for each node, including port specifications, parameters, usage examples, and configuration patterns.