---
title: '1D-Justo-LiuNet: Compact Hyperspectral CNN'
url: https://www.emergentmind.com/topics/1d-justo-liunet
type: topic
---

# 1D-Justo-LiuNet: Compact Hyperspectral CNN

1D-Justo-LiuNet is a lightweight 1D convolutional neural network for per-pixel spectral classification and semantic segmentation in hyperspectral imagery. Proposed for sea–land–cloud segmentation in satellite data, it operates exclusively along the spectral dimension, ignores spatial context, and compresses the earlier LiuNet design into a four-block Conv1D/MaxPool pipeline with a three-class softmax head and 4,563 parameters on the canonical HYPSO-1 configuration [2310.16210]. Subsequent work treated it as the state-of-the-art baseline for spectral-only hyperspectral classification, and re-evaluated it under reduced-channel, limited-data, and class-imbalanced settings, including EO-1 Hyperion cloud segmentation and spectral classification benchmarks such as HyKo2, HSI-Drive, and HYPSO-1 [2403.08695] [2509.13809].

## 1. Origins and problem setting

1D-Justo-LiuNet was introduced in the context of semantic segmentation in satellite hyperspectral imagery for on-board inference on small satellites. The motivating HYPSO-1 application is rapid categorization of pixels into sea, land, and clouds so that the spacecraft can support autonomous decision-making in orbit, including data downlink prioritization and selective compression or discarding of non-essential pixels [2310.16210]. A later study characterizes the same model as a compact spectral-only baseline targeting deployment on resource-constrained platforms such as satellites to detect clouds and reduce downlink bandwidth requirements [2509.13809].

The model’s defining design choice is spectral-only processing. Rather than combining spatial and spectral context, it treats each pixel as a 1D spectral signature. On HYPSO-1, this was motivated by the finding that, for the mission’s modest spatial resolution, per-pixel spectral signatures contain enough discriminative information that 1D CNNs outperform 2D CNNs on sea–land–cloud segmentation [2310.16210]. In EO-1 Hyperion cloud segmentation, the same rationale appears in a different form: when many spectral channels are available, a 1D spectral CNN is appropriate because clouds exhibit characteristic absorption and reflectance features across VNIR–SWIR bands, and full spectral signatures per pixel enhance separability of cloud versus surface and atmosphere [2403.08695].

Architecturally, 1D-Justo-LiuNet is a refinement of LiuNet. The precursor LiuNet uses four 1D-convolution layers with widths 32, 32, 64, and 64, each followed by max pooling, before flattening and classification. Justo et al. reduce the widths to 6, 12, 18, and 24, and use kernel size 6 throughout, yielding a few thousand trainable parameters while maintaining strong performance [2509.13809]. In the original HYPSO-1 study, this compression is described as a reduction from Liuetal with 22,755 parameters to 1D-Justo-LiuNet with 4,563 parameters, alongside improved performance [2310.16210].

## 2. Canonical architecture

In its canonical HYPSO-1 form, 1D-Justo-LiuNet receives a per-pixel spectral vector of length 112 after preprocessing removes eight channels from the original 120-band input. The removed channels are the first four radiance channels at 388, 391, 395, and 399 nm, which were all zeros post-calibration, and four channels near the oxygen A-band at 758, 761, 765, and 768 nm. The resulting input is normalized by min–max normalization per channel and organized for 1D models as batch size × channels [2310.16210].

The network consists of four identical blocks, each comprising a 1D convolution with ReLU activation followed by 1D max pooling by 2. The numbers of filters are 6, 12, 18, and 24, and the kernel size is 6 in all four convolution layers. No batch normalization or dropout is reported for the original model. After the fourth pooling layer, the feature map is flattened and passed to a Dense layer with 3 units and Softmax, producing per-pixel class probabilities for sea, land, and cloud [2310.16210]. A later reimplementation summarizes the same pattern as a stack of 1D convolutional layers followed by max pooling, then flattening and a final fully connected classifier with softmax activations, noting that “typically, all models use a single fully connected layer with softmax activations as a classifier” [2509.13809].

The sequence-length evolution implied by the original parameter-count derivation uses valid padding and stride 1 for the convolutions, and stride 2 max pooling. Starting from length $L_0 = 112$, each Conv1D with kernel size 6 reduces the length by 5, producing the progression 112 $\rightarrow$ 107 $\rightarrow$ 53 $\rightarrow$ 48 $\rightarrow$ 24 $\rightarrow$ 19 $\rightarrow$ 9 $\rightarrow$ 4 $\rightarrow$ 2. The final feature map therefore has length 2 and 24 channels, yielding a flatten dimension of $2 \times 24 = 48$ [2310.16210].

The original paper gives the 1D convolution over the spectral dimension as
$$
y_{s}^{(k)} = \sum_{c=1}^{C_{\mathrm{in}}} \sum_{t=1}^{K} w_{t,c}^{(k)}\, x_{s+t-1,c} + b^{(k)}.
$$
For multi-class training, it reports categorical cross-entropy,
$$
\mathcal{L} = -\sum_{n} \sum_{c} y_{n,c}\,\log p_{n,c}.
$$
With this architecture, the exact parameter count is obtained as 42 for Conv1, 444 for Conv2, 1,314 for Conv3, 2,616 for Conv4, and 147 for the Dense layer, summing to 4,563 [2310.16210]. In a later spectral-classification study, the same model is described as having approximately 4,500 trainable parameters on the HYPSO-1 land–sea–cloud dataset, with the caveat that the count is dataset-dependent due to input dimensionality and pooling [2509.13809].

## 3. Data handling and training regimes

The original HYPSO-1 study uses 38 labeled scenes of size 956 × 684 pixels, with approximately 25 million labeled pixels in total. The train/validation/test split is 30 images (79%) for training, 3 images (8%) for validation, and 5 images (13%) for testing. The class proportions over the dataset are sea 37.01%, land 40.14%, and cloud 22.85%; in the test split, cloud is the minority class at 14.13%, with sea 39.01% and land 46.85% [2310.16210].

For training in that study, 1D-CNNs use Adam with default parameters, categorical cross-entropy loss, batch size 32 pixels, and 2 epochs; the small epoch count is explicitly motivated by reducing overfitting. Accuracy is the training metric, and the target validation accuracy is around 0.90. No class weighting, data augmentation, or custom initialization is reported [2310.16210].

Later work reimplemented 1D-Justo-LiuNet in PyTorch for spectral classification and adopted a substantially different optimization regime: batch size 4096 pixels, 10 epochs, AdamW without weight decay, and learning rate $10^{-3}$. The model checkpoint was selected by highest validation mIoU. For HYPSO-1, that study removed 8 bands during preprocessing and normalized spectra to $[0,1]$, using the same train/validation/test split as Justo et al. (30/3/5 images), while noting that one training image, ID 36, was unavailable, leaving 29 training images [2509.13809].

That later benchmark also formalized limited-data evaluation. The model was trained on shares $p = 5, 10, 25, 50, 75, 100\%$ of the original training sets, with full images sampled to preserve class imbalance. The authors present class-wise accuracy differences between 1D-Justo-LiuNet and MiniROCKET at each training share, plotted against the absolute number of class samples used for training [2509.13809]. This protocol became important because the model’s behavior changes materially once per-class sample counts become small.

Reduced-channel operation required additional modifications in later studies. In EO-1 Hyperion cloud segmentation, the network’s four pooling layers forced channel replication when only 1 or 6 PCA-selected channels were supplied: 1 channel was repeated 91 times and 6 channels were repeated 16 times so that the spectral length would not collapse through repeated pooling [2403.08695]. In the HyKo2 benchmark, which has only 15 bands, the authors removed the last convolutional layer of 1D-Justo-LiuNet because pooling four times on such short sequences caused problems [2509.13809].

## 4. Empirical performance across benchmarks

On the original HYPSO-1 sea–land–cloud task, 1D-Justo-LiuNet achieves macro-average accuracy 0.93 and Spearman’s coefficient 1.00, with 4,563 parameters and average inference time per hyperspectral image of 15,136 ms on an NVIDIA RTX A4000 [2310.16210]. Its reported false detection ratios are Cloud FPR $\approx 0.02$ and FNR $\approx 0.15$, Sea FNR $\approx 0.05$ and FPR $\approx 0.02$, and Land FNR $\approx 0.03$ and FPR $\approx 0.04$ [2310.16210]. In that study it outperformed multiple 2D CNN baselines, including 2D-Justo-UNet-Simple at accuracy 0.92 with 7,641 parameters and 2D-UNet FAUBAI at accuracy 0.88 with 26,534,211 parameters [2310.16210].

In EO-1 Hyperion cloud segmentation, performance depended strongly on the number of spectral channels retained after PCA. With $k=98$ channels, 1D-Justo-LiuNet achieved Test PA 82.2, Test DC 0.548, Test CA 98.0, and Test CF1 0.977, which were the highest Test PA, Test CA, and Test CF1 across all tested models and channel settings. With stronger reduction, performance degraded markedly: at $k=6$, Test PA was 74.0 and Test DC 0.443; at $k=1$, Test PA was 64.8 and Test DC 0.397 [2403.08695]. The same study notes that at $k=6$ or $k=1$, 2D CNNs outperform 1D-Justo-LiuNet in segmentation metrics, whereas at $k=98$ the 1D model achieves the highest accuracy-oriented metrics [2403.08695].

A later spectral-classification study used 1D-Justo-LiuNet as the state-of-the-art spectral-only baseline and compared it to MiniROCKET and HDC-MiniROCKET on HyKo2, HSI-Drive, and HYPSO-1 [2509.13809].

| Dataset | 1D-Justo-LiuNet results | Comparative note |
|---|---|---|
| HyKo2 | OA 66.50, AA 34.05, F 32.79, mIoU 25.78 | Leads MiniROCKET and HDC-MiniROCKET |
| HSI-Drive | OA 74.65, AA 22.58, F 22.31, mIoU 17.67 | Substantially outperforms MiniROCKET variants |
| HYPSO-1 | OA 72.90, AA 76.51, F 69.69, mIoU 56.37 | Slightly behind MiniROCKET |

Those comparisons are important because they qualify the model’s state-of-the-art status. In the general case with full training data, 1D-Justo-LiuNet remained strongest on HyKo2 and HSI-Drive, but on HYPSO-1 MiniROCKET slightly exceeded it in OA, AA, F, and mIoU [2509.13809]. Aggregated accuracy curves in the same study show that MiniROCKET and HDC-MiniROCKET dominate AA at low training shares and are generally on par in the general case, whereas 1D-Justo-LiuNet tends to do better in OA on imbalanced datasets, indicating stronger performance on majority classes but less balanced class coverage [2509.13809].

## 5. Computational footprint and deployment profile

The computational profile of 1D-Justo-LiuNet is defined by an unusual combination of extreme compactness and nontrivial runtime sensitivity to implementation and input format. In the original HYPSO-1 study, the model’s parameter count is 4,563, and the authors argue that this minimizes on-board memory and uplink payload for model deployment [2310.16210]. In EO-1 Hyperion experiments, the model size on disk is 0.097 MB and the in-memory footprint is 0.023 MB across all channel settings, confirming that the network is extremely compact [2403.08695].

Runtime results are more heterogeneous. On the EO-1 Hyperion study’s CPU platform, an Intel Core i5-12600, average per-tile inference times were 1.788 s for $k=1$, 1.860 s for $k=6$, and 1.998 s for $k=98$ [2403.08695]. On the original HYPSO-1 study’s NVIDIA RTX A4000 test setup, the average inference time per hyperspectral image was 15,136 ms [2310.16210]. The later MiniROCKET comparison found 1D-Justo-LiuNet to be approximately 40× faster than MiniROCKET in the authors’ implementations, while also noting that MiniROCKET’s implementation is more complex and may admit further optimization [2509.13809].

These measurements shaped deployment recommendations. For HYPSO-1, the on-board processing unit is a Zynq-7030/XC7Z030-1 FPGA SoC with ARM Cortex-A9, and the original study argues that lower-level CPU or FPGA implementations could reduce 1D inference times substantially; if needed, offloading heavy kernels to FPGA fabric is recommended [2310.16210]. In EO-1 Hyperion cloud detection, 1D-Justo-LiuNet is recommended for highest-accuracy in-orbit operation when extensive spectral channels are available and hardware acceleration can mitigate longer inference times, while 2D-Justo-UNet-Simple is recommended when balanced memory, timing, and precision are more important [2403.08695].

A practical implication is that compactness and deployability do not reduce to parameter count alone. The model’s memory footprint is exceptionally small, but its latency can still become the system bottleneck unless the hardware and software stack are matched to the spectral-only computation pattern. This suggests that deployment analyses must separate storage constraints from inference-throughput constraints.

## 6. Limitations, failure modes, and later reinterpretation

The first major limitation is sensitivity to spectral dimensionality. In the EO-1 Hyperion study, substantial channel reduction degraded performance sharply, and the authors attribute this to the network’s reliance on rich spectral features together with its four pooling layers, which reduce the feature length by $2^4$ and therefore require sufficiently large initial spectral length. Replicating a 1-channel or 6-channel input rescued sequence length but could not create new spectral information [2403.08695]. The same architectural issue appears in HyKo2, where the final convolutional layer had to be removed because four rounds of pooling on 15 bands were problematic [2509.13809].

The second limitation is sensitivity to limited labeled data and class imbalance. The later spectral-classification benchmark reports a broad threshold behavior: below roughly 100,000 training samples per class, MiniROCKET consistently outperforms 1D-Justo-LiuNet; between approximately 100,000 and 1,000,000 samples per class, MiniROCKET still tends to have an edge but some classes flip in favor of 1D-Justo-LiuNet; well above this, 1D-Justo-LiuNet generally wins [2509.13809]. The mechanism proposed there is that the model’s feature extractor is trainable and therefore requires sufficient labeled data to learn robust filters; in limited-data regimes, learned filters are underfit and unstable, hurting minority classes disproportionately [2509.13809]. This suggests that extreme parameter efficiency should not be conflated with data efficiency.

The third limitation is the absence of spatial context. In the original HYPSO-1 study, deployment-set visualizations showed acceptable segmentation and confidence maps, but class transitions were less smooth because the model infers each pixel from its spectral signature alone [2310.16210]. In EO-1 Hyperion cloud segmentation, 2D models with spatial context achieved better boundary delineation, and nnU-net obtained the best Dice coefficient at $k=6$, namely 0.607, exceeding 1D-Justo-LiuNet’s best Dice of 0.548 at $k=98$ [2403.08695]. Cross-sensor tests in that study also showed that all models, including 1D-Justo-LiuNet, misclassified snow-covered mountainous regions as clouds on Ziyuan-1 02 tiles [2403.08695].

These later results have shifted the interpretation of the model from a universally superior lightweight hyperspectral network to a more conditional instrument. When spectral dimensionality is high and class-wise sample counts are ample, 1D-Justo-LiuNet remains highly competitive or best-in-class for spectral-only processing. When channels are severely reduced, when positional or boundary information is critical, or when labeled data are scarce and imbalanced, alternative models can become preferable [2403.08695] [2509.13809].

Source: https://www.emergentmind.com/topics/1d-justo-liunet