cs.LGOct 13, 2026

Sea-Net: A Small and Inherently Interpretable Neural Network for Time Series Classification

Authors: Ubaid Ur Rehman, Tanmoy Mondal

Organizations: FOX Team, Centre de Recherche en Informatique, Signal et Automatique de Lille (CRIStAL) University of Lille, CNRS, Centrale Lille, UMR 9189 F-59000 Lille, France

Read PDF
Ask AI
Cite

Copy citation

DOINot available for this paper

Abstract

Traditional time-series classification methods often operate as black boxes, providing a class prediction without indicating which time point or time interval within the series led to that prediction. To improve temporal interpretability, MILLET (Multiple Instance Learning with Temporal Explanation), which combines an InceptionTime encoder with Conjunctive Pooling, provides both classification and temporal explanations. However, MILLET contains approximately 424 K parameters, making it unsuitable for deployment on resource-constrained micro-controllers, and it achieves an overall time-series accuracy of 0.888 and an explanation score of 0.681 NDCG@n. We therefore propose SEA-Net, a lightweight architecture using small multi-scale depthwise-separable convolutional TSC encoders and improved Multiple Instance Learning (MIL) pooling heads. Our SEA-Net bottleneck encoder with Top-k pooling achieves 0.931 accuracy and 0.765 NDCG@n with only 41 K parameters. Another variant, using a gated encoder with Top-k pooling, achieves 0.955 accuracy and 0.750 NDCG@n with 62 K parameters. These results demonstrate that lightweight architectures can maintain strong classification performance and temporal explanations while substantially reducing model size. The proposed variants address specific limitations of the pooling strategy used by MILLET, providing a practical direction for interpretable time-series classification on resource-constrained edge devices.

Figures & tables

Figure 1: The same WebTraffic series classified by three models. Each panel shows the predicted class and, its right side provides the explanation or interpretation of the prediction, given by the model. The red marks provide the evidence, supporting the predicted class at each time step. The “green shaded window” is the original ground truth of the time steps and was never used during training. MILLET (top) predicts the same class with 71 % confidence and does explain itself, but needs 424 K parameters. SEA-Net (bottom) is more confident, produces a sharper explanation, and uses 41 K parameters.
Appendix figures & tables51 assets

Supplementary material from the paper’s appendix.

Appendix

Figure 3: The MIL view of a time series, read from left to right. The series XiX_{i} is the bag and each time point is one instance. The encoder gives one embedding zijz_{i}^{j} per instance; the pooling head weights those embeddings and combines them into the prediction Y^i\hat{Y}_{i} (right). The same weighted contributions, kept instead of discarded, are the interpretation I^i\hat{I}_{i} drawn on the series below, where red pushes towards the predicted class and blue pushes away from it. The two grey boxes are interchangeable, which is what lets any encoder of Appendix B be paired with any head of Appendix C .
Figure 4: One multi-scale separable block. The three depth wise convolutions read the same input at the kernel sizes 55 , 1111 and 2323 , their outputs are summed, and the point-wise 1×11\times 1 convolution PP mixes the channels; BatchNorm, ReLU and dropout close the unit U\mathcal{U} of Equation 1 . The dashed box is what is applied twice, and the arrow over the top is the residual connection of Equation 2 .
Figure 5: The effect of the dilation, drawn with the same five taps of the k=5k=5 filter in both rows. Widening the region that the filter sees costs no extra weight, which is why the receptive field of the encoder can be grown without paying for it in parameters.
StageLayerOutputParams
Inputz-normalised seriesb×1×tb\times 1\times t–
StemConv1d 1→641\to 64 , kernel 7b×64×tb\times 64\times t512
Block 1 (dilation 1), 2×2\times unit:depthwise Conv1d ×3\times 3 (kernels 5, 11, 23), summedb×64×tb\times 64\times t2,688
 pointwise Conv1d 64→1664\to 16 (reduce)b×16×tb\times 16\times t1,040
 pointwise Conv1d 16→6416\to 64 (expand)b×64×tb\times 64\times t1,088
 BatchNorm ++ ReLU ++ dropoutb×64×tb\times 64\times t128
Appendix
Table 3: The SEA-Net bottleneck encoder ( d=64d=64 , 4 blocks, kernels 5/11/23, dilations 1/2/4/8), layer by layer, with the output shape and the number of parameters, built from top/top_bottleneck_topk for WebTraffic ( c=10c=10 ). The point-wise convolution of every unit is factorised as d→d/4→dd\to d/4\to d , which is where the parameter saving comes from. Every layer keeps the series length tt , so the head sees one embedding per time point. Depthwise = one filter per channel (groups =d=d ).
StageLayerOutputParams
Inputz-normalised seriesb×1×tb\times 1\times t–
StemConv1d 1→641\to 64 , kernel 7b×64×tb\times 64\times t512
Block 1 (dilation 1), 2×2\times unit:depthwise Conv1d ×3\times 3 (kernels 5, 11, 23), summedb×64×tb\times 64\times t2,688
 pointwise Conv1d 64→6464\to 64b×64×tb\times 64\times t4,160
 BatchNorm ++ ReLU ++ dropoutb×64×tb\times 64\times t128
 after both units: residual add ++ ReLUb×64×tb\times 64\times tblock total 13,952
Appendix
Table 4: The SEA-Net base encoder ( d=64d=64 , 4 blocks, kernels 5/11/23, dilations 1/2/4/8), layer by layer, with the output shape and the number of parameters, built from seanet/seanet_slim_topk for WebTraffic ( c=10c=10 ). It has the same skeleton with the plain d→dd\to d point-wise convolution, for comparison. Every layer keeps the series length tt , so the head sees one embedding per time point. Depthwise = one filter per channel (groups =d=d ).
Figure 6: Conjunctive pooling, the MILLET baseline of Equation 7 . Read from left to right: the time point embeddings feed an attention head and a classifier, their product is the evidence at each time point, which is also the interpretation, and aggregating that evidence over time gives the prediction for the series. The classifier is the same in every head; only the two blue boxes, the attention head and the aggregation, change from one head to the next, so Figure 7 to Figure 13 are best read against this figure.
Figure 7: Class-wise conjunctive pooling. Against Figure 6 , only the attention head changes: widening its last layer to CC outputs costs (C−1)(da+1)(C-1)(d_{a}+1) weights and makes the evidence, and therefore the interpretation, class-specific.
Figure 8: Soft-Max conjunctive pooling. Both blue boxes change compared with Figure 6 : the attention is normalized over time, and the aggregation is a weighted sum rather than a mean. The single extra weight is the sharpness τ=exp⁡(ρ)\tau=\exp(\rho) .
Figure 9: Top- kk conjunctive pooling. The attention head is the one of Figure 7 , and only the aggregation moves: the mean runs over the mm largest evidence values of the class instead of over all tt . It adds no weight, because κ\kappa is a hyperparameter.
Figure 10: Adaptive class-wise pooling ( Equation 16 ). The attention head is the one of Figure 7 ; the aggregation slides between the mean and the maximum according to one learned number per class.
Figure 11: Attention-max pooling ( Equation 17 ), the hard counterpart of Figure 10 : one learned number per class blends the mean with the maximum directly.
Figure 12: Per-class gated attention ( Equation 18 and Equation 19 ). The attention head has two layers instead of one, and the second of them decides which attention features are admitted.
Figure 13: Dual-stream conjunctive pooling ( Equation 20 and Equation 21 ). A second stream, built around the most supporting time point of each class, is blended into the class-wise stream of Figure 7 by one learned scalar.
#HeadAttentionReduction over timeReduces atTargets
1Conjunctive (baseline)shared gatemean——
2Class-wise conjunctiveper-class gatemeanai j,k=aija_{i}^{\,j,k}=a_{i}^{j}L1
3Soft-Max conjunctiveper-class scoresoftmax, learnable τ\tauτ→∞\tau\to\inftyL2
4Top- kk conjunctiveper-class gatemean of the mm largestκ=1\kappa=1L3
5Adaptive class-wiseper-class gatesoft-argmax, learnable βk\beta_{k}βk→0\beta_{k}\to 0L3
6Attention-maxper-class gateblend of mean and maxλk→0\lambda_{k}\to 0L3
Appendix
Table 5: The eight heads as two separate choices. Reduces at gives the setting at which the head becomes conjunctive pooling exactly, and Targets gives the limitations of Section C.1 that it addresses.
ProcessLayerInputOutput
InputPositional encoding ++ dropoutb×t×db\times t\times db×t×db\times t\times d (time-point embs.)
AttentionLinear ++ tanhb×t×db\times t\times db×t×ab\times t\times a
 Linear ++ sigmoidb×t×ab\times t\times ab×t×1b\times t\times 1 (attention scores)
ClassifierLinearb×t×db\times t\times db×t×cb\times t\times c (time-point logits)
PoolingAttention weightingb×t×cb\times t\times cb×t×cb\times t\times c (interpretation)
 Mean over ttb×t×cb\times t\times cb×cb\times c (series logits)
Appendix
Table 6: Conjunctive pooling, the MILLET baseline head (their Table A.5; d=128d=128 ). One scalar gate per time point, shared by every class. Registered as mil_conjunctive .
ProcessLayerInputOutput
InputPositional encoding ++ dropoutb×t×db\times t\times db×t×db\times t\times d (time-point embs.)
AttentionLinear ++ tanhb×t×db\times t\times db×t×ab\times t\times a
 Linear ++ sigmoidb×t×ab\times t\times ab×t×cb\times t\times c (one gate per class)
ClassifierLinearb×t×db\times t\times db×t×cb\times t\times c (time-point logits)
EvidenceGate ×\times logit (element-wise)b×t×cb\times t\times cb×t×cb\times t\times c (interpretation)
PoolingMean over ttb×t×cb\times t\times cb×cb\times c (series logits)
Appendix
Table 7: Class-wise conjunctive pooling: conjunctive pooling with one gate per class instead of one shared gate. Registered as sea_classwise_conjunctive .
ProcessLayerInputOutput
InputPositional encoding ++ dropoutb×t×db\times t\times db×t×db\times t\times d (time-point embs.)
AttentionLinear ++ tanhb×t×db\times t\times db×t×ab\times t\times a
 Linear ++ sigmoidb×t×ab\times t\times ab×t×cb\times t\times c (one gate per class)
ClassifierLinearb×t×db\times t\times db×t×cb\times t\times c (time-point logits)
EvidenceGate ×\times logit (element-wise)b×t×cb\times t\times cb×t×cb\times t\times c (interpretation)
PoolingTop- kk over tt (per class)b×t×cb\times t\times cb×k×cb\times k\times c
Appendix
Table 8: Top- kk conjunctive pooling, the head of every short-listed model: class-wise conjunctive pooling, but the series logit averages only the k=⌈κt⌉k=\lceil\kappa t\rceil largest evidence values of each class ( κ=0.1\kappa=0.1 ). The interpretation is the full evidence map, so it is exactly zero wherever no evidence was used. Registered as sea_topk_conjunctive .
ProcessLayerInputOutput
InputPositional encoding ++ dropoutb×t×db\times t\times db×t×db\times t\times d (time-point embs.)
AttentionLinear ++ tanhb×t×db\times t\times db×t×ab\times t\times a
 Linear (raw scores)b×t×ab\times t\times ab×t×cb\times t\times c
 ÷ τ\div\,\tau , softmax over ttb×t×cb\times t\times cb×t×cb\times t\times c (weights, sum to 1)
ClassifierLinearb×t×db\times t\times db×t×cb\times t\times c (time-point logits)
PoolingWeight ×\times logit (element-wise)b×t×cb\times t\times cb×t×cb\times t\times c (interpretation)
Appendix
Table 9: Soft-Max conjunctive pooling: the attention is a distribution over time (a softmax with one learned temperature τ\tau ), so the series logit is a true weighted average and long and short series are on one scale. Registered as sea_softmax_conjunctive .
ProcessLayerInputOutput
InputPositional encoding ++ dropoutb×t×db\times t\times db×t×db\times t\times d (time-point embs.)
AttentionLinear ++ tanhb×t×db\times t\times db×t×ab\times t\times a
 Linear ++ sigmoidb×t×ab\times t\times ab×t×cb\times t\times c (one gate per class)
ClassifierLinearb×t×db\times t\times db×t×cb\times t\times c (time-point logits)
EvidenceGate ×\times logit (element-wise)b×t×cb\times t\times cb×t×cb\times t\times c (interpretation)
Poolingsoftmax over tt of βk⋅\beta_{k}\cdot evidenceb×t×cb\times t\times cb×t×cb\times t\times c (weights)
Appendix
Table 10: Adaptive class-wise pooling: class-wise conjunctive pooling with a learned mean-to-max aggregator, i.e. a soft-argmax with one sharpness βk=softplus(θk)≥0\beta_{k}=\mathrm{softplus}(\theta_{k})\geq 0 per class ( cc extra parameters; β→0\beta\to 0 gives the mean and β→∞\beta\to\infty the max). Registered as sea_adaptive_classwise .
ProcessLayerInputOutput
InputPositional encoding ++ dropoutb×t×db\times t\times db×t×db\times t\times d (time-point embs.)
AttentionLinear ++ tanhb×t×db\times t\times db×t×ab\times t\times a
 Linear ++ sigmoidb×t×ab\times t\times ab×t×cb\times t\times c (one gate per class)
ClassifierLinearb×t×db\times t\times db×t×cb\times t\times c (time-point logits)
EvidenceGate ×\times logit (element-wise)b×t×cb\times t\times cb×t×cb\times t\times c (interpretation)
PoolingMean over ttb×t×cb\times t\times cb×cb\times c
Appendix
Table 11: Attention-max pooling: class-wise conjunctive pooling with a learned per-class blend λk=σ(θk)\lambda_{k}=\sigma(\theta_{k}) of the mean and the max over time ( cc extra parameters). Registered as sea_attention_max .
ProcessLayerInputOutput
InputPositional encoding ++ dropoutb×t×db\times t\times db×t×db\times t\times d (time-point embs.)
AttentionLinear ++ tanh ( VV )b×t×db\times t\times db×t×ab\times t\times a
 Linear ++ sigmoid ( UU )b×t×db\times t\times db×t×ab\times t\times a
 Element-wise productb×t×ab\times t\times ab×t×ab\times t\times a (gated features)
 Linear (scores), softmax over ttb×t×ab\times t\times ab×t×cb\times t\times c (weights, sum to 1)
ClassifierLinearb×t×db\times t\times db×t×cb\times t\times c (time-point logits)
Appendix
Table 12: Per-class gated attention pooling ( Ilse et al. 2018 , made class-specific): a tanh branch multiplied by a sigmoid branch scores every time point, and a softmax over time turns the scores into weights. Registered as sea_gated_attention .
ProcessLayerInputOutput
InputPositional encoding ++ dropoutb×t×db\times t\times db×t×db\times t\times d (time-point embs.)
AttentionLinear ++ tanhb×t×db\times t\times db×t×ab\times t\times a
 Linear ++ sigmoidb×t×ab\times t\times ab×t×cb\times t\times c (one gate per class)
ClassifierLinearb×t×db\times t\times db×t×cb\times t\times c (time-point logits)
EvidenceGate ×\times logit (element-wise)b×t×cb\times t\times cb×t×cb\times t\times c (interpretation)
Stream AMean over ttb×t×cb\times t\times cb×cb\times c
Appendix
Table 13: Dual-stream conjunctive pooling (DSMIL, Li et al. 2021 , wrapped around class-wise conjunctive pooling): stream A is the plain mean, and stream B re-weights the time points by their similarity to the most supporting one (the critical time point) of each class; a learned scalar λ=σ(θ)\lambda=\sigma(\theta) blends the two and starts near stream A. Registered as sea_dualstream_conjunctive .
Figure 14: One example of each class of the WebTraffic dataset. Each series is a daily seasonal signal with a weekly trend and noise, and the signature that defines the class is injected inside a single window, shown shaded; the exception is class 00 (None), which has no signature. These windows are the per-time-point ground truth against which NDCG@ nn is scored, and they are never used during training.
#DatasetTrainTestLengthClassesImbalance
 WebTraffic5005001,008101.00
1Adiac390391176373.75
2ArrowHead3617525131.00
3Beef303047051.00
4BeetleFly202051221.00
5BirdChicken202051221.00
Appendix
Table 14: The datasets: WebTraffic (the only one with per-time-point labels, hence the only one with NDCG@ nn ) and the 85 UCR datasets that MILLET publishes, in the order of MILLET. Imbalance is the largest training-class share divided by the smallest (1.00 = balanced). The sizes are the original train / test splits; our training holds out 20 % of the training set for validation when it has at least 100 series.
SettingValue
Encoder size (every SEA-Net model)width d=64d=64 , 4 blocks; 41,324–69,768 parameters
OptimizerAdam ( Kingma & Ba, 2015 ) , lr =1.25×10−3=1.25\times 10^{-3} , weight decay =1.2×10−4=1.2\times 10^{-4}
Epochs / early stoppingmax 400 epochs; stop after 60 epochs with no improvement
Batch sizemin⁡(⌊ntrain/10⌋,16)\min(\lfloor n_{\text{train}}/10\rfloor,16) , floor of 2
Validation splitstratified 80/20 when ntrain≥100n_{\text{train}}\geq 100 ; else train-loss early stopping
Label smoothing0.13
Appendix
Table 15: Training configuration, identical for every model of this study. The complete hyperparameter list, including the head-specific initial values, is given in Table 16 .
ParameterSEA-Net bottleneck ++ Top- kk (the paper’s model)SEA-Net gated (mean) ++ Top- kkMILLET, our recipe
Training
max epochs400400400
early-stopping patience606060
batch size (max)161616
learning rate0.001250.001250.00125
weight decay0.000120.000120.00012
Appendix
Table 16: Every hyperparameter, read from the configuration files under configs/models/ . The two SEA-Net columns and MILLET (our recipe) share one training block, so any difference between them is the architecture. – = not applicable (the InceptionTime backbone is the code of MILLET with its published defaults, so it has no settings here).
#Encoder \\backslash headclass-wise conj.Top- kk conj.softmax conj.adaptive cw.attn-maxgated attn.dual-streamconj. Madditive Mattention M
1bottleneck (shallow)–21,548––––––––
2multi-scale pyramid (bottleneck base, over channels)–28,441––––––––
3bottleneck41,32441,324 (+0.00%)41,325 (+0.00%)41,334 (+0.02%)41,334 (+0.02%)41,844 (+1.26%)41,845 (+1.26%)–––
4multi-scale pyramid (bottleneck base)–42,365––––––––
5multi-scale channels (bottleneck base, lean)–43,576––––––––
6multi-scale channels (bottleneck base)–47,176––––––––
Appendix
Table 17: Number of parameters of every encoder ×\times pooling head pair that was trained, measured on WebTraffic (10 classes; the size of a head grows with the number of classes). The percentages give the change relative to the same encoder with class-wise conjunctive pooling, in the manner of Table A.13 of MILLET: every attention head costs well under 1 % of the encoder, so the size of a model is set by its encoder. The bottom rows are the baseline encoders with the conjunctive head of MILLET.
Figure 15: Head-to-head comparison of the explanations of MILLET (published recipe) and of our SEA-Net bottleneck ++ Top- kk model on four WebTraffic classes. The panels show, left to right, the series with its true signature window, the interpretation heatmap for the true class, and the perturbation curves under each model’s own deletion order (solid) against a random one (dotted). The vertical axis is the change as a fraction of the original logit, because the two models produce logits on very different scales ( Section E.6 ). The AOPCR of each panel is the area between the two curves; MILLET wins it on three of the four classes while our heatmaps are the more concentrated — the difference between the two metrics is analysed in Section 4.1 .
#EncoderPooling headAcc.AUROCNLLAOPCRNDCG@ nnParamsEpochs run / bestTrain (s)
1bottleneckTop- kk conjunctive (paper model, re-run)0.9420.9960.2942.9510.78641,324180 / 12054
2bottleneckTop- kk conjunctive, thresholded0.9300.9960.3302.6030.74441,324172 / 11252
3bottlenecksoftmax conjunctive, per-class τ\tau0.9140.9910.3772.0760.73241,334151 / 9165
4bottleneckdeviation-max (MLP form)0.9120.9900.3692.3940.74242,544164 / 104276
5bottleneckDSMIL (batched rewrite)0.9000.9910.4771.4620.66771,956379 / 319611
6InceptionTimeconjunctive (MILLET, our recipe)0.8900.9850.5312.1200.692423,707184 / 124443
Appendix
Table 18: The 2026-09 pooling-head round on WebTraffic (results/top_results, one seed each): every new head is trained on the bottleneck encoder (one on the gated encoder), so row 1 (the model of the paper, trained again) is the number to beat. The MILLET row is the baseline retrained with our recipe. Epochs run / best gives the epoch at which early stopping fired and the epoch whose weights were kept; the voting heads that fail to fit are visible in their NLL.
#Encoder \\backslash headclass-wise conj.Top- kk conj.softmax conj.adaptive cw.attn-maxgated attn.dual-streamconj. Madditive Mattention M
1gated (mean)0.9020.9550.9120.8600.832–––––
2base (wide, d=128d=128 )0.946–0.8800.918–––0.9540.942–
3gated (max)0.9440.9520.9140.9060.886–––––
4spike/trend0.9040.9500.8780.9340.8540.9300.556–––
5multi-scale channels (input-gated base)–0.948––––––––
6multi-scale channels (gated base)–0.948––––––––
Appendix
Table 19: WebTraffic accuracy for every encoder ×\times pooling head pair that was trained (71-model sweep; the κ\kappa / λ\lambda ablation copies are left out). – = pair not trained; a superscript count means that several configurations share the cell and the most accurate one is shown. M = a MILLET head. The best value of each column is in bold.
#Encoder \\backslash headclass-wise conj.Top- kk conj.softmax conj.adaptive cw.attn-maxgated attn.dual-streamconj. Madditive Mattention M
1gated (mean)2.49 / 0.7142.23 / 0.7502.09 / 0.7652.24 / 0.7311.67 / 0.704–––––
2base (wide, d=128d=128 )1.72 / 0.686–1.02 / 0.6051.61 / 0.619–––1.50 / 0.6981.58 / 0.729–
3gated (max)1.89 / 0.5922.27 / 0.7191.88 / 0.7762.07 / 0.7291.12 / 0.575–––––
4spike/trend2.15 / 0.6992.32 / 0.7561.43 / 0.6651.91 / 0.7471.65 / 0.6441.59 / 0.7211.64 / 0.510–––
5multi-scale channels (input-gated base)–2.32 / 0.757––––––––
6multi-scale channels (gated base)–2.22 / 0.717––––––––
Appendix
Table 20: WebTraffic AOPCR / NDCG@ nn for every encoder ×\times pooling head pair that was trained (71-model sweep; the κ\kappa / λ\lambda ablation copies are left out). – = pair not trained; a superscript count means that several configurations share the cell and the most accurate one is shown. M = a MILLET head. AOPCR is unnormalised (the same recipe is used everywhere here).
#EncoderPooling headAcc.NLLAOPCRNDCG@ nnParamsUCR-85 acc.
Accuracy ≥0.94\geq 0.94
1gated (mean)Top- kk conj. ∗0.9550.2542.2250.75061,7400.8083
2base (wide, d=128d=128 )conj. M0.9540.2621.5020.698269,0830.8238
3gated (max)Top- kk conj.0.9520.3082.2680.71961,7400.8108
4bottleneckTop- kk conj. ( λfocus=0\lambda_{\text{focus}}{=}0 )0.9500.2632.3030.76541,324–
5spike/trendTop- kk conj.0.9500.2882.3160.75667,0200.8089
Appendix
Table 21: The complete WebTraffic leaderboard of the 71-model sweep (results/old_results), ranked by accuracy and grouped into accuracy bands. ∗ marks the mean over three seeds (seeds 0–2, the runs of Table 28 ); every other row is a single run with seed 0, so a comparison between a ∗ row and an unmarked row sets a three-run mean against one run. UCR-85 acc. is the mean accuracy over the 85 UCR datasets for the models that completed the archive, and – for the models that were only screened on WebTraffic. Encoder drops the SEA-Net prefix (MS = multi-scale); wide is the d=128d=128 encoder; M = a MILLET head. AUROC is given in the csv file next to this table.
Figure 16: Compute cost of one prediction, in millions of floating point operations, for our SEA-Net bottleneck ++ Top- kk model and for the MILLET baseline ( InceptionTime ++ Conjunctive ). Left: as the length of the series grows, at 1010 classes. Right: as the number of classes grows, at length 463463 . The dashed lines mark the mean series length and the mean number of classes over the 8585 UCR datasets.
#Pooling headReal multiplicationsScale w.r.t. ttScale w.r.t. ccAt WebTraffic (M)
1conjunctive Mdtc+dta+(a+2c) tdtc+dta+(a+2c)\,tdc+da+a+2cdc+da+a+2cdt+2tdt+2t2.351 ( d=128d=128 )
2class-wise conjunctivedtc+dta+(ac+2c) tdtc+dta+(ac+2c)\,tdc+da+ac+2cdc+da+ac+2cdt+at+2tdt+at+2t1.262 ( d=64d=64 )
3Top- kk conjunctivedtc+dta+(ac+c) t+ckdtc+dta+(ac+c)\,t+ckdc+da+ac+c+cκdc+da+ac+c+c\kappadt+at+t+kdt+at+t+k1.253 ( d=64d=64 )
4softmax conjunctivedtc+dta+(ac+3c) tdtc+dta+(ac+3c)\,tdc+da+ac+3cdc+da+ac+3cdt+at+3tdt+at+3t1.272 ( d=64d=64 )
5adaptive class-wisedtc+dta+(ac+4c) tdtc+dta+(ac+4c)\,tdc+da+ac+4cdc+da+ac+4cdt+at+4tdt+at+4t1.282 ( d=64d=64 )
6attention-maxdtc+dta+(ac+2c) t+2cdtc+dta+(ac+2c)\,t+2cdc+da+ac+2cdc+da+ac+2cdt+at+2t+2dt+at+2t+21.262 ( d=64d=64 )
Appendix
Table 23: Time complexity of the pooling heads as the number of real multiplications, counted from the code (matrix products only, as in Table A.15 of MILLET; additions, comparisons, the exponential of a softmax and the gather of the critical time point are not counted). tt = series length, cc = classes, dd = embedding size, aa = attention width, k=⌈κt⌉k=\lceil\kappa t\rceil . The last column evaluates the formula for WebTraffic ( t=1008t=1008 , c=10c=10 , a=8a=8 , κ=0.1\kappa=0.1 , so k=101k=101 ) with the own dd of each head: the SEA-Net heads read d=64d=64 embeddings and the MILLET head d=128d=128 , so every SEA-Net head is cheaper than the baseline head in absolute terms, although its formula has more terms. M = MILLET.
#Pooling headMean acc.Mean AOPCRMean NDCG@ nnnnBest pairing (acc.)
SEA-Net heads
1class-wise conjunctive0.9212.3220.692100.946 ( seanet_classwise )
2gated attention0.9181.8690.73340.930 ( seanet_bottleneck_gatedattn )
3adaptive class-wise0.9122.2100.73290.946 ( seanet_recon_adaptive )
4softmax conjunctive0.9071.6900.71290.940 ( seanet_bottleneck_softmax )
5Top- kk conjunctive0.9032.2600.712160.955 ( seanet_gated_mean_topk )
Appendix
Table 24: Effect of the pooling head: WebTraffic accuracy, AOPCR and NDCG@ nn averaged over every encoder that each head was paired with in the 71-model sweep ( nn = number of pairings; the κ\kappa / λ\lambda ablation copies are excluded, so that no pairing is counted twice). The last column is the best single pairing of that head. A head paired once ( n=1n=1 ) is not comparable with one averaged over ten.
#EncoderMean acc.Mean AOPCRMean NDCG@ nnnnBest pairing (acc.)
SEA-Net encoders ( †\dagger = a wrapper around another encoder)
1SEA-Net multi-scale channels †0.9362.3850.74740.948 ( seanet_inputgate_mschan )
2SEA-Net reconstruction-residual0.9242.3150.71950.946 ( seanet_recon_adaptive )
3SEA-Net input-gated0.9032.3450.71850.946 ( seanet_inputgate_topk )
4SEA-Net gated0.9022.0560.710190.955 ( seanet_gated_mean_topk )
5SEA-Net base0.8981.9330.693120.954 ( seanet_conjunctive )
Appendix
Table 25: Effect of the encoder: WebTraffic accuracy, AOPCR and NDCG@ nn averaged over every pooling head that each encoder was paired with ( nn = number of pairings, with the same exclusions as in Table 24 ). The gated encoder has the largest nn because it was paired with the most heads, which pulls its mean towards the weak heads; the last column shows what each encoder reaches with its best head.
#κ\kappakk at t=1008t=1008AccuracyNLLAOPCRNDCG@ nn
10.05510.8880.4012.2880.715
20.10 (default)1010.8880.3912.4090.755
30.252520.9400.2772.6480.733
40.505040.8820.4183.1140.732
51.00 (= class-wise conjunctive)10080.9080.3952.4360.722
 0.10, mean ±\pm std over 3 runs1010.931±0.0320.931\pm 0.0320.312±0.0630.312\pm 0.0632.498±0.1492.498\pm 0.1490.765±0.0130.765\pm 0.013
Appendix
Table 26: Top- kk fraction ablation on WebTraffic: the bottleneck ++ Top- kk model trained five times with only κ\kappa changed (seed 0 everywhere, so the κ=0.10\kappa=0.10 row is the seed-0 run of that model, and the last row is its mean over every run). k=⌈κt⌉k=\lceil\kappa t\rceil is the number of time points that the series logit averages; κ=1\kappa=1 recovers class-wise conjunctive pooling exactly. The best single-seed value of each column is in bold.
λfocus\lambda_{\text{focus}}AccuracyNLLAOPCRNDCG@ nn
0.01 (on, the default)0.8880.3912.4090.755
0.00 (off)0.9500.2632.3030.765
Appendix
Table 27: The attention-entropy term of the loss, switched on and off, on WebTraffic (seed 0): the bottleneck ++ Top- kk model with only λfocus\lambda_{\text{focus}} changed. This is one matched pair on one seed, so it indicates a direction rather than an effect size.
Figure 17: SEA-Net bottleneck ++ Top- kk (ours). Wrong predictions on the hardest WebTraffic class, i.e. the class with the lowest accuracy. Top: the series with its true signature window in yellow. Middle: the interpretation for the class that the model predicted. Bottom: the interpretation for the true class, with its NDCG@ nn .
Figure 18: MILLET (published recipe). Wrong predictions on the hardest WebTraffic class, i.e. the class with the lowest accuracy. Top: the series with its true signature window in yellow. Middle: the interpretation for the class that the model predicted. Bottom: the interpretation for the true class, with its NDCG@ nn .
#ModelMetricRun 1Run 2Run 3Run 4Mean ±\pm std
1SEA-Net gated (mean) + Top- kk conjunctiveaccuracy0.9540.9580.952–0.955±0.0020.955\pm 0.002
  AOPCR2.2932.0742.308–2.225±0.1072.225\pm 0.107
  NDCG@ nn0.7720.7490.728–0.750±0.0180.750\pm 0.018
  runarchive, seed 0archive, seed 1archive, seed 2  
2SEA-Net bottleneck + Top- kk conjunctiveaccuracy0.8880.9380.966–0.931±0.0320.931\pm 0.032
  AOPCR2.4092.7082.378–2.498±0.1492.498\pm 0.149
Appendix
Table 28: Every WebTraffic run of the models that were trained more than once, run by run ( archive = the 71-model sweep in results/old_results, 2026-09 = results/top_results; a seed run in both folders is two different trainings). These are the numbers behind every ±\pm in the main tables. The spread on AOPCR is far larger than on accuracy for every model, which is why AOPCR differences of a few tenths are not read as wins.
Figure 19: Model variance over the 8585 UCR datasets, in the style of Early et al. (2024) . For each dataset and each seed, the balanced accuracy minus the median balanced accuracy of that model on that dataset, pooled over the datasets; the models are ordered from left to right by their total variance, which is printed under each of them. Our SEA-Net model is the least stable of the four and has a long lower tail, i.e. on a few datasets one seed falls far below the other two, which is the same effect that Table 28 shows on WebTraffic.
ModelParamsAcc.Mean rankW/T/L
MILLET, published ( Early et al., 2024 )423,7070.8445——
SEA-Net wide ++ class-wise conjunctive269,1640.829211.5326/19/39
SEA-Net wide ++ MILLET additive269,0830.829811.9823/19/42
SEA-Net wide ++ MILLET conjunctive269,0830.823812.4322/20/42
MILLET, matched budget423,7070.8274 ‡12.6013/25/46
ResNet ++ conjunctive506,3310.814613.5425/11/49
Appendix
Table 29: UCR-85 accuracy and mean rank. Mean rank is over the 84 datasets finished by all 28 models we ran on the archive; lower is better. Win/tie/loss is counted per dataset against MILLET’s published accuracies. ‡ 84 of 85 datasets finished.
Figure 20: Direct comparison of our SEA-Net bottleneck ++ Top- kk model against the published MILLET accuracies on the 8585 UCR datasets, one point per dataset. The points above the diagonal are the datasets where our model is the more accurate one. The title gives the number of wins / ties / losses (15 / 17 / 52, where a tie is a difference below 0.0050.005 ), and the datasets with the largest positive and negative differences are named.
Figure 21: The effect of the class imbalance, on the UCR datasets whose training set is imbalanced (normalized class entropy below one). Top: the balanced accuracy of our model and of MILLET measured three ways, i.e. published, re-trained with the published recipe, and re-trained with the configuration of Table 15 . Bottom: the difference, ours minus MILLET, where green means that our model is the better one. Each title gives the wins / ties / losses and the mean gain. The imbalance does not hurt the smaller model more than the baseline: the differences are small on both sides, and they do not grow with the imbalance.
Figure 22: Average accuracy rank ( 1=1= best, lower is better) of our model and of the three MILLET measurements, binned by two properties of the dataset: the length of the series ( left ) and the number of training series ( right ). The bin edges are chosen to give bins of roughly equal size, and nn is the number of datasets in each bin. The ranking is stable across the bins, i.e. our SEA-Net model does not fall further behind on the long series or on the small training sets.
#ModelnnAcc.Bal. acc.AUROCNLLAOPCRParams
1SEA-Net base (wide, d=128d=128 ) + additive (MILLET)850.82980.80770.92950.50880.551269,083
2SEA-Net base (wide, d=128d=128 ) + class-wise conjunctive850.82920.80390.92550.51130.564269,164
3MILLET (InceptionTime + conjunctive), our recipe840.82740.79970.92750.52970.812423,707
4SEA-Net base (wide, d=128d=128 ) + conjunctive (MILLET)850.82380.79930.92810.51800.626269,083
5SEA-Net gated (max) + class-wise conjunctive850.82370.79790.92880.52140.61961,740
6SEA-Net input-gated + adaptive class-wise850.81530.79050.92080.55450.96458,102
Appendix
Table 30: The 85 UCR datasets: every model that completed the archive, sorted by mean accuracy ( nn = number of datasets finished, out of the 85 that MILLET publishes). The means are over the datasets that each model finished; the win / tie / loss counts of the same rows are given in Table 31 . AOPCR is unnormalised: the rows trained with our recipe can be compared with each other, whereas the † row (the published numbers of MILLET) is on another scale. The best value of each column is in bold (the † row is excluded for AOPCR).
#ModelW/T/L acc.W/T/L NLLW/T/L AOPCR
1SEA-Net base (wide, d=128d=128 ) + additive (MILLET)24/19/4260/2/233/0/82
2SEA-Net base (wide, d=128d=128 ) + class-wise conjunctive27/19/3960/1/243/0/82
3MILLET (InceptionTime + conjunctive), our recipe13/25/4656/2/263/0/81
4SEA-Net base (wide, d=128d=128 ) + conjunctive (MILLET)23/20/4257/5/234/0/81
5SEA-Net gated (max) + class-wise conjunctive20/17/4861/0/244/0/81
6SEA-Net input-gated + adaptive class-wise20/15/5060/0/254/0/81
Appendix
Table 31: Wins / ties / losses (W/T/L) of the models of Table 30 , with the same rows and the same numbering, against the published per-dataset numbers of MILLET, with tie bands of 0.005 (accuracy), 0.01 (NLL) and 0.1 (AOPCR). The published AOPCR values come from MILLET’s recipe and are on another scale, which is why every model “loses” the AOPCR W/T/L against them.
#DatasetMILLET pub.bottleneckgated (mean)input-gatedspike/trendMILLET (ours)ResNetFCN
1Adiac0.8320.7330.7880.7490.7720.8120.7850.788
2ArrowHead0.8380.8510.8290.8400.8690.8270.8860.840
3Beef0.8470.8220.8670.8330.7670.8000.8000.733
4BeetleFly0.9200.8670.7500.8500.9000.8830.8500.700
5BirdChicken0.9400.8500.8000.9500.8500.9831.0000.900
6Car0.9200.8670.8830.9170.8830.9110.9330.883
Appendix
Table 32: Per-dataset accuracy on the 85 UCR datasets that MILLET publishes. MILLET pub. is the published mean of 5 seeds of MILLET; the next four columns are SEA-Net encoders with the Top- kk conjunctive head (the model of the paper is bottleneck ); MILLET (ours) , ResNet and FCN are the baselines re-trained under our recipe, each with conjunctive pooling. The best value of each row is in bold (the published column included).
#DatasetMILLET pub. †bottleneckgated (mean)input-gatedspike/trendMILLET (ours)ResNetFCN
1Adiac15.89-0.83-0.02-0.27-0.641.60-2.051.73
2ArrowHead3.200.240.451.370.670.600.841.31
3Beef5.491.331.950.80-0.301.342.071.63
4BeetleFly1.240.582.351.181.590.242.291.35
5BirdChicken3.371.962.771.301.580.961.151.36
6Car6.620.401.81-0.032.801.022.553.66
Appendix
Table 33: Per-dataset AOPCR on the 85 UCR datasets that MILLET publishes. MILLET pub. is the published mean of 5 seeds of MILLET; the next four columns are SEA-Net encoders with the Top- kk conjunctive head (the model of the paper is bottleneck ); MILLET (ours) , ResNet and FCN are the baselines re-trained under our recipe, each with conjunctive pooling. The best value of each row is in bold among the columns trained with our recipe; the published column ( † ) was trained with MILLET’s recipe and its AOPCR is on another scale, so it is shown but not compared.
   WebTrafficUCR-85 mean
#How the number was obtainedRunsAcc.AOPCRNDCG@ nnAcc.AOPCR
1Published, mean of 5 seeds50.92412.768 †0.6740.84454.553 †
2Published, 5-model ensemble10.94011.100 †0.694––
3Re-trained here, our recipe (400 epochs, label smoothing, early stopping): the baseline of every comparison40.8880.888 ±0.007\pm 0.0072.4572.457 ±0.655\pm 0.6550.6810.681 ±0.013\pm 0.0130.8274 (84)0.812
Appendix
Table 34: The MILLET baseline (InceptionTime ++ conjunctive pooling): the published numbers of Early et al. (2024) and our retrained baseline. The WebTraffic columns are means ( ±\pm std) over the runs in both results folders, and the UCR columns are means over the 85 published datasets (the number in brackets if fewer were finished). Only the last row is used in the main comparisons. † : the published AOPCR comes from MILLET’s own recipe and is on another scale, so AOPCR must only be compared within one recipe.
More in this topic

Interpretable Time-Series Classification

See all 16 papers

Explore similar work

CardsList

  1. AnchorMoE: Interpretable Time Series Classification via Anchor-Routed MoE

    Jun 2, 2026Tao Xie, Zexi Tan, Haoyi Xiao +5Explainable Time Series ForecastingMultivariate Time Series Classification

    Guangdong University of Technology · Guangzhou, China · Shenzhen University +7

  2. SPaRSe-TIME: Saliency-Projected Low-Rank Temporal Modeling for Efficient and Interpretable Time Series Prediction

    Apr 19, 2026K. A. ShahriarTime Series ForecastingTime Series Decomposition

    Department of Electrical and Electronic Engineering Bangladesh University of Engineering and Technology Dhaka-1205, Bangladesh

  3. Fast, Interpretable, and Deterministic Time Series Classification With a Bag-of-Receptive-Fields

    Nov 29, 2023Francesco Spinnato, Riccardo Guidotti, Anna Monreale +1Time Series ClassificationInterpretable ML

    Scuola Normale Superiore, Pisa, Italy · University of Pisa, Pisa, Italy · ISTI-CNR, Pisa, Italy