Learning Efficient Representations of Neutrino Telescope Events

## Abstract

Abstract Neutrino telescopes detect rare interactions of particles produced in some of the most extreme environments in the Universe.
This is accomplished by instrumenting a cubic-kilometer volume of naturally occurring transparent medium with light sensors.
Given their substantial size and the high frequency of background interactions, these telescopes amass an enormous quantity of large variance, high-dimensional data.
These attributes create substantial challenges for analyzing and reconstructing interactions, particularly when utilizing machine learning (ML) techniques.
In this paper, we present a novel approach, called om2vec , that employs transformer-based variational autoencoders to efficiently represent neutrino telescope events by learning compact and descriptive latent representations.
We demonstrate that these latent representations offer enhanced flexibility and improved computational efficiency, thereby facilitating downstream tasks in data analysis.

## 1 Introduction

Neutrino telescopes search for rare interactions caused by neutrinos, an elusive particle central to many open questions in the Standard Model of particle physics, such as the origin of their masses and the matter anti-matter asymmetry of the universe.
The leading detector in operation today, the IceCube Neutrino Observatory, comprises 5,160 optical modules (OMs) arranged on strings deep within the clear ice of the Antarctic glacier (see Aartsen et al. ()).
Each OM is designed to precisely record the arrival times of photons, forming a photon arrival time distribution (PATD).
The data gathered by IceCube are archived as “events,” which are triggered when a specific number of coincident light detections occur between OMs in neighboring strings, signaling the presence of a charged particle.
Figure 1 is an artistic representation of the photons produced in a neutrino interaction and their subsequent detection in the OMs.

Figure: Figure 1: An artistic rendition of a cascade-like event, showcasing how photon arrival time distributions (PATDs) are recorded in neutrino telescopes. A neutrino interaction producing photons occurs in the detector medium, where it is surrounded by photon-detecting optical modules (OMs). The photon arrival times are recorded and counted, as shown in the histograms in the above figure. The amount of photons a particular OM sees is highly variable and generally depends on its proximity to the interaction point. The main goal of om2vec is to convert the PATD on each OM in the event into a fixed-size latent representation.
Refer to caption: x1.png

A neutrino telescope typically classifies events into categories based on the morphology of the light detected: cascade-like events, identifiable by their approximately spherical spatial distribution; and track-like events, characterized by their elongated, linear spatial morphology.
In IceCube, events are recorded at an approximate rate of 3000 per second, constituting a large data rate.
Moreover, comparable or even larger optical neutrino telescopes are either under construction or planned, such as KM3NeT (Aiello et al., ), Baikal-GVD (Avrorin et al., ), P-ONE (Agostini et al., ), IceCube-Gen2 (Aartsen et al., ), TRIDENT (Ye et al., ), and HUNT (Huang et al., ), signalling a need to develop methods for efficiently handling neutrino telescope data.

The accurate reconstruction and prediction of the interacting particle’s physical properties—including its energy, direction, and type— from the PATDs recorded by each OM, is essential for informing and facilitating downstream physics analyses.
ML techniques have successfully been applied to this task in recent years, notably in neutrino telescopes like IceCube (Choma et al., ; Abbasi et al., ; Huennefeld et al., ; Abbasi et al., ; Yu et al., ; Eller, ; Jin et al., ; Zhu et al., ) and KM3NeT (De Sio, ; Aiello et al., ; Reck et al., ; Guderian, ; Mauro & de Wasseige, ).
Nevertheless, a significant challenge in ML-based reconstruction techniques remains: the incorporation of the full-timing information provided by the PATDs of the OMs, which are characterized by high dimensionality and variable lengths.
Interaction events may last several $\mu s$, yet ns-scale timing resolution is needed on the PATDs for most downstream physics analyses.
Furthermore, as illustrated by OM#1 in Figure 1, some OMs near the interaction point can detect up to tens of thousands of photons in the highest-energy and brightest events.
On the other hand, many further OMs record only a few photons, resulting in highly irregular events; illustrated in the OM#2 distribution on the same figure.

To address the challenges of working with this data, previous studies have employed summary statistics (Abbasi et al., ), using key variables that summarize the PATD of a given OM.
This approach yields greater efficiency and flexibility, as each OM has a fixed-size description of the timing distribution, allowing events to be formatted as 2D images with multiple features per pixel.
However, the summary statistics lose a substantial amount of information present in the original PATD.
An alternative method involves parameterizing the PATD by fitting an asymmetric Gaussian mixture model (AGMM).
In this study, we implemented a basic AGMM to serve as a comparison, drawing inspiration from Huennefeld et al. ().
While this retains significantly more information than summary statistics, the optimization process can be slow and prone to failure, with a strong dependence on hyperparameters, e.g., the number of Gaussian components.
In this paper, we take a deep learning approach for the first time by introducing a transformer-based variational autoencoder (VAE), termed om2vec, which converts PATDs into a fixed-size compact latent representation.
om2vec is trained to reconstruct the input PATD as readout by OMs, using only the information from its learned latent space.
Our approach provides a number of significant benefits over previous methods:

- •
om2vec generally retains more information compared to the AGMM approach, giving it greater flexibility in representing more complex PATDs.
- •
om2vec demonstrates greater reliability by avoiding optimization failures.
- •
om2vec is orders of magnitude faster than the AGMM, especially when scaling to larger latent dimensions.
It can also benefit more from GPU acceleration and parallel processing.
- •
om2vec is less dependent on hyperparameters.

We argue that these advantages make this the first “one-size-fits-all” neutrino event representation learner, making it suitable for deployment at the earliest stages of experimental data collection.
With a robust latent representation of each OM’s PATD, neutrino events can easily be arranged into image-like data.
This will serve to circumvent the challenges inherent in raw neutrino telescope data, and facilitate the rapid adoption of more sophisticated ML techniques from the image-processing community into the neutrino physics field.
Source code, datasets, and pre-trained checkpoints can be found on [GitHub](https://github.com/felixyu7/om2vec).

## 2 Architecture

Figure: Figure 2: Model architecture of om2vec. Input embeddings are generated from the binned PATDs. Each encoder (decoder) block operates on both the feature and sequence dimensions, where feedforward layers are used to downsample (upsample) the length of the distributions. In the decoder, a memory embedding is learned to keep the decoder independent of the encoder.
Refer to caption: x2.png

Since their inception, VAEs have been extensively utilized for learning effective data representations and generative modeling (Kingma & Welling, ).
More recently, transformers have demonstrated exceptional performance in handling sequential data (Vaswani et al., ).
Given the time series nature of our dataset, we incorporate transformer layers to enhance feature learning capabilities.
Our model employs the standard encoder-decoder structure, as illustrated in Figure 2.
We assume a Gaussian prior for the latent space and train the encoder to learn the parameters $\mu$ and $\sigma$, with some added random noise $\epsilon$.
The re-parameterization trick is utilized to construct the latent representation $z$, a vector of user-defined length referred to as the latent dimension.
This technique guarantees that the latent space remains continuous, and that similar representations within this space reconstruct to similar PATDs.

The input data PATDs are formatted as one-dimensional time series sequences of equal length, with each element corresponding to a specific time in sequence.
Each element features a single attribute: the number of photon hits occurring during that particular time window.
We first expand the feature space with an input embedding layer.
The encoder and decoder are constructed by stacking blocks.
Importantly, we employ a hybrid approach that operates across both the feature and sequence dimensions.
Transformer layers process the feature dimension, followed by a feed-forward network that down-samples or up-samples the sequence length in the encoder and decoder, respectively.
Linear layers are then used to flatten the feature dimension into latent representations, as well as to generate output logits after the decoder.
We opted for a learnable memory embedding for the transformer decoder layers, ensuring that the decoder portion of the architecture remains entirely independent of the encoder.
This design allows for future utilization directly on latent representations without requiring outputs from the encoder or the input PATDs themselves.

## 3 Dataset and Training Details

Simulations play a key role in neutrino physics experiments, facilitating preliminary testing that informs experiment development and subsequent physics analyses.
As such, the field has developed sophisticated simulation tools capable of generating events for incorporation into our training datasets.
In this paper, we present results trained and tested on simulated events, but emphasize that the methodology can be readily applied to real detector data.
We employ the open-source simulation toolkit Prometheus (Lazar et al., ) to emulate an IceCube-like array of OMs within Antarctic ice.
We generate four datasets of events based on the different neutrino interaction types, corresponding to the distinct flavors of the neutrino, $\nu$.
Specifically, these interactions are the charged-current electron neutrino ($\nu_{e}$ CC), muon neutrino ($\nu_{\mu}$ CC), and tau neutrino ($\nu_{\tau}$ CC) interactions, alongside the neutral-current ($\nu$ NC) interactions.
Notably, the $\nu_{e}$ CC, $\nu_{\tau}$ CC, and $\nu$ NC interactions produce predominantly spherical cascade-like events, while the $\nu_{\mu}$ CC interactions result in long track-like events.
Additionally, as further detailed in Section 4, the PATDs generated by $\nu_{\tau}$ CC interactions are of particular interest to physicists due to their potential to exhibit a smoking-gun “double-bang” signature of astrophysical neutrinos.

Events are simulated, and all OMs detecting at least one photon hit are included in the overall training dataset.
We extract five million PATDs from both $\nu_{e}$ CC and $\nu$ NC interactions, as their signals are quite similar.
Additionally, 7.5 million PATDs are sourced from $\nu_{\mu}$ CC events, and 3.25 million PATDs from $\nu_{\tau}$ CC interactions, totaling approximately 20 million PATDs for the training dataset.
An additional 4.5 million distributions are reserved for the test dataset, mixed roughly equally from each interaction type.
The majority of OMs registering light detect only a few photon hits.
For an illustration of this distribution, see the bottom panel in Figure 3.
Notably, photon yields from interactions increase significantly at higher energies.
The simulated events span a wide range of energies to encompass all types of PATDs that may occur in neutrino telescopes.

**Table 1: Model and training hyperparameters.**
| PARAMETER | VALUE |
| --- | --- |
| Input Sequence Length | 6400 |
| Latent Dimension | [32, 64, 128] |
| Embedding Feature Size | 32 |
| No. Trainable Parameters | 15M |
| Batch Size | 1024 |

As previously mentioned, each PATD in the datasets is pre-processed into a fixed-length vector by binning photon hits over time.
A total of 6400 bins, each 1 ns wide, represent the first 6.4 $\mu s$ of hits—a readout time frame consistent with IceCube’s OMs (Aartsen et al., ).
The choice of binning and time window can be adapted to suit the specifications of other neutrino telescopes.
Any remaining hits are accumulated in a final overflow bin.
The hit counts in each bin are then log-normalized, as they can be extremely large for high-energy neutrino interactions.
A table of model and training hyperparameters can be found in Table 1.

The training loss combines reconstruction loss and a KL divergence regularization loss on the latent space.
The reconstruction loss is computed as the Poisson negative log-likelihood based on the input PATD.
Thus, the network is trained to predict the underlying probability density function that generates the input PATD.
The KL divergence loss term is scaled by a $\beta$ factor that follows a cyclic cosine function during training, peaking at a hyperparameter value set at $10^{-5}$.

## 4 Results

In this section, we present the performance and efficiency results of om2vec across several benchmarks.
In several cases, we also compare to the more traditional AGMM method for encoding PATDs.
The AGMM operates by fitting multiple asymmetric Gaussians defined by the equation

$$ $AG(t\mid\mu,\sigma,r)=\frac{2}{\sqrt{2\pi}*\sigma(r+1)}*\begin{cases}\exp({- \frac{(t-\mu)^{2}}{2\sigma^{2}}}),&x\leq\mu\\ \exp({-\frac{(t-\mu)^{2}}{2(r\sigma)^{2}}}),&\text{otherwise}\end{cases}$ $$

where $\mu$ and $\sigma$ are the mean and standard deviation and $r$ is the asymmetry parameter, as introduced in (Huennefeld et al., ).
Each asymmetric Gaussian is assigned a weighting factor, $w$, and then summed.
Consequently, each component of the mixture model introduces four parameters: $\mu$, $\sigma$, $r$, and $w$.
The mixture model is initially fit using $k$-means clustering to obtain the starting parameters, followed by solving a bounded-constrained optimization problem that minimizes the negative log-likelihood. However, the fit is only performed when the number of photon hits (the length of $x$) is greater than the number of Gaussian components. Otherwise, the true photon hit times are stored.

### 4.1 Timing Distribution Reproducibility

Figure: Figure 3: JS distance between the true input PATD and the reconstructed PATD across different methods, plotted as a function of the number of detected photons in the input PATD. Greater values of the JS distance implies a worse fit. In the AGMM methods, the sudden jump is caused by the fit only being performed when the number of photon hits is greater than the number of Gaussian components. The lower panel illustrates the percentage of PATDs in each number of photons bin, relative to the total dataset.
Refer to caption: x3.png

We now evaluate the ability of om2vec to retain information in its latent representation by measuring how accurately it can reconstruct the input PATD.
We train three separate models, each with a different latent dimension size (32, 64, and 128).
For comparison, we also present results from our AGMM implementation, using the same total number of parameters (8, 16, and 32 components, with 4 parameters per component).

To assess the reconstruction capability, we employ the Jensen-Shannon (JS) distance (Lin, ; Nielsen, ), which is derived from the KL divergence and is defined as follows:

$$ $D_{JS}(P\mid Q)=\sqrt{\frac{1}{2}D_{KL}(P\mid\frac{P+Q}{2})+\frac{1}{2}D_{KL}( Q\mid\frac{P+Q}{2})},$ $$

given the distributions $P$ and $Q$, and where $D_{KL}$ is the KL divergence.
The JS distance provides a similarity score between 0 and 1, where 0 indicates identical distributions and 1 indicates maximum difference.
In Figure 3, we present the median JS distance curves for both om2vec and AGMM approaches, across the three different latent dimension sizes.
We plot the JS distance as a function of the number of photons recorded in the PATD, scaling up to a thousand photons.
While some PATDs observe significantly more photons from the highest-energy events, the statistics are sparse (i.e., there are few PATDs) at those higher photon counts.

Figure: Figure 4: Failure percentage ($>0.99$ JS distance) as a function of the number of photons on the input PATD. om2vec is always at 0% in this figure.
Refer to caption: x4.png

Notable characteristics of these curves include well-reconstructed distributions on the left, where the number of photons is low enough for the representations to “memorize” the distribution.
This is followed by a sharp upward trend, peaking in a regime where there are too many photons for memorization, but insufficient statistics to generate a well-formed PATD.
We then observe the JS distance decreasing as the number of photons increases, allowing for enough statistical information to effectively reconstruct the PATD.
We also observe that increasing the latent dimension size for om2vec noticeably enhances the performance of representation learning, a trend not reflected in the AGMM method.
Further insights into this phenomenon can be gained by examining the failure rate in Figure 4, where we define “failures” as PATDs reconstructed with a JS distance greater than 0.99.
Notably, the VAE is never above this threshold for all PATDs.
In contrast, a substantial percentage of PATDs from the AGMM method are mis-reconstructed due to optimization failures, with this failure rate increasing as more parameters and components are added.

Figure: Figure 5: An example PATD of a “double-bang” signature, characterized by two distinct peaks. om2vec is able to reconstruct both peaks, while the AGMM is noticeably less accurate.
Refer to caption: x5.png

In order to give a more intuitive sense of the performance of om2vec, we examine individual PATDs and their reconstructed PDFs.
This is especially interesting for exotic cases such as the “double-bang” signature produced by $\nu_{\tau}$ interactions, as mentioned earlier.
Figure 5 illustrates an example of this type of PATD, distinguished by its two distinct peaks. It is evident that om2vec reconstructs the bimodal structure of the timing distribution with greater precision than the AGMM method, despite the overall JS distance difference between the two methods being minor.
As this is an extremely large PATD ($\sim$100,000 photons), this is likely due to the dominant statistics contained in the first peak.
However, from a physics perspective, retaining information about both peaks is crucial for downstream tasks that attempt to isolate $\nu_{\tau}$ interactions, a smoking-gun indication of astrophysical neutrinos.

### 4.2 Reconstruction with Representations v.s. Full Information

Figure: Figure 6: Angular resolution as a function of the true neutrino energy. The models trained using the latent representations from om2vec are able to perform just as well when compared to using the full timing information.
Refer to caption: x6.png

We now evaluate whether downstream physics analysis tasks suffer any performance loss when using the latent representations.
One of the most critical downstream analysis tasks is angular reconstruction, i.e. predicting the direction of the incoming particle based on the photons recorded across the OMs.
We test three different separately trained ML models for angular reconstruction on track-like events.

- •
SSCNN (Full): a sparse submanifold convolutional neural network (SSCNN) that utilizes full timing information in a 4D CNN, as described in Yu et al. ().
- •
SSCNN (om2vec): another 3D (reducing the timing dimension) SSCNN that leverages the latent representations from om2vec.
- •
CNN (om2vec): a traditional 2D ResNet CNN, where each neutrino event is encoded into a 2D image representation.
These image representations are created by pixelizing the detector geometry along the strings and the OMs per string, then concatenating the latent representation and spatial position information at each pixel for the feature dimension.

In Figure 6, we show the neutrino angular resolution (the angular difference between the true and predicted neutrino direction), as a function of the true neutrino energy.
We find that the SSCNN models using the full timing information and the latent representations perform similarly, though as expected, the full 4D model is able to achieve a slightly better resolution.
Notably, SSCNN sacrifices some performance to remain computationally feasible on higher-dimensional sparse data (Graham & van der Maaten, ).
Thus, we observe that the dense CNN approach with latent representations performs just as well or slightly better than the SSCNN with full-timing information, depending on the true neutrino energy.
This CNN approach is made possible by the fixed-length latent representations.
Importantly, we note that this new flexibility allows for the easy adaptation of more powerful models, such as vision transformers (Dosovitskiy et al., ), for angular reconstruction.

### 4.3 Runtime Efficiency

**Table 2: Average per-PATD runtime of encoding methods.**
| METHOD | CPU RUNTIME (s) | GPU RUNTIME (s) |
| --- | --- | --- |
| AGMM (dim=32) | 0.142 | - |
| AGMM (dim=64) | 0.557 | - |
| AGMM (dim=128) | 1.408 | - |
| om2vec (dim=32) | 0.0207 | 0.00184 |
| om2vec (dim=64) | 0.0204 | 0.00185 |
| om2vec (dim=128) | 0.0330 | 0.00193 |

In terms of forward pass encoding runtime, om2vec proves to be an efficient method, particularly when compared to classical approaches like the AGMM.
Table 2 presents the average per-PATD runtime for various encoding methods alongside their latent dimensionalities.
om2vec also significantly benefits from GPU acceleration, unlike the AGMM.
Even when running on a CPU, om2vec is an order of magnitude faster.
This is particularly important when running in resource-constrained environments such as IceCube’s lab at the South Pole.
With GPU acceleration, this speed advantage increases to two orders of magnitude.
It is also worth noting that PATDs can be batched and processed in parallel on the GPU, which would further speedup the average runtime.
Additionally, om2vec scales well with increasing latent dimensionality, allowing users to expand the latent space with minimal runtime impact.

We also observe runtime improvements when running angular reconstruction algorithms on events using om2vec-represented PATDs instead of full-timing information.
SSCNN (Full) took approximately 8.5s to process 20,000 events.
In contrast, SSCNN (om2vec) took only 2.1s for the same number of events, representing a significant speedup.
All GPU runtime tests were conducted on an NVIDIA A100 80GB.

## 5 Conclusions and Future Directions

This work introduces om2vec, a novel approach utilizing transformer-based VAEs to efficiently represent neutrino telescope events.
Our method addresses the significant challenges posed by the large size, high dimensionality, and variance of data in neutrino telescopes.
By learning compact and descriptive latent representations, om2vec offers several advantages for downstream analysis tasks.

We have demonstrated that these learned latent representations not only preserve critical information from the original PATDs but also provide enhanced flexibility and substantial computational benefits.
Our experiments show that models trained on these latent representations can achieve comparable performance to those using full-timing information in crucial tasks such as angular reconstruction.
The enhanced efficiency and adaptability of om2vec encoding for neutrino telescope events paves the way for more sophisticated ML algorithms to be applied to neutrino telescope events.
In particular, employing image-based algorithms in neutrino telescopes becomes straightforward by encoding the data using om2vec.

Another future direction could involve exploring data throughput rate reduction through latent representations.
In existing active telescopes like IceCube, OM readouts are restricted by data throughput rate limits imposed by various physical and networking factors.
Considering that high-energy events can result in tens of thousands of photons hits on a single OM, utilizing latent representations could decrease the throughput rate, enabling experiments such as IceCube to store higher-resolution timing information than is currently feasible.

By bridging the gap between the complex, high-dimensional data of neutrino telescopes and efficient ML techniques, om2vec represents an important step forward in our ability to sharpen our view of the neutrino sky.
As our telescopes grow larger and data rates increase, our capability to efficiently process events will play an increasingly crucial role in pushing the boundaries of neutrino astronomy.

Availability: Source code, datasets, and pre-trained checkpoints for om2vec on Prometheus events is made available on [GitHub](https://github.com/felixyu7/om2vec).
Additionally, as an immediate next step, om2vec is being integrated into GraphNeT (Søgaard et al., ), an open-source deep learning pipeline widely utilized by various collaborations in the neutrino telescope community.

#### Acknowledgments

FY was supported by the National Science Foundation (NSF) AI Institute for Artificial Intelligence and Fundamental Interactions (IAIFI).
NK is supported by the David & Lucile Packard Foundation and the NSF IAIFI.
CAA are supported by the Faculty of Arts and Sciences of Harvard University, NSF, NSF IAIFI, the Research Corporation for Science Advancement, and the David & Lucile Packard Foundation.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 3
presentation: 1
questions: * In Fig. 2, the “autoencoder” outputs some probabilities through the softmax activation. This is a confusing design. How is the reconstruction loss applied in this case? 
* In section 4.2, the training methodology for the three models and the utilization of om2vec are unclear. Can you provide a more detailed explanation of the training process and how om2vec is incorporated?
* Are there any additional physics features that could be included in the time series data, beyond the current single feature of photon hits?
* In lines 179-180, the authors wrote “We opted for a learnable memory embedding for the transformer decoder layers, ensuring that the decoder portion of the architecture remains entirely independent of the encoder”. Please elaborate on the memory embedding block about its design.
* The model and training details in Table 1 are incomplete and unclear. Can you provide a more comprehensive description of the model architecture, including the number of encoder and decoder layers used?
soundness: 2
strengths: The application of machine learning techniques in scientific research is a vital and rapidly evolving field. We are delighted to see submissions in this area and encourage researchers to share their relevant work.
summary: This article presents an approach to learning representations of neutrino events by leveraging a transformer-based variational autoencoder. The model is trained to capture the photon arrival time distribution, and the learned representations are evaluated using the Jensen-Shannon divergence to assess reconstruction quality. Furthermore, the authors explore the applicability of these representations in a downstream task – angular reconstruction.
weaknesses: This article requires significant improvements in its writing and technical accuracy. Numerous technical details are either unclear, incorrect, or require further clarification (see Questions for specific concerns). As it stands, the article's technical clarity is compromised, which may lead to confusion and misinterpretation. A thorough revision is necessary to ensure the article's technical details are accurate, clear, and concise.

---

confidence: 4
contribution: 4
initial_rating: 8
presentation: 4
questions: 1. How does the model’s performance vary with different encoder/decoder block architectures or deeper networks?
2. Can the approach be adapted or extended to handle data from other types of particle physics experiments with different signal characteristics?
3. Have real-world data tests been considered, and if so, what were the challenges and results?
4. Is there potential for this method to contribute to real-time data processing in neutrino observatories under field conditions?
soundness: 4
strengths: - Originality: Applying transformer-based VAEs to neutrino event data is novel and demonstrates a creative extension of ML techniques to physical sciences.
- Quality: Comprehensive evaluation of the model against AGMMs, showing significant improvements in reconstruction accuracy, computational efficiency, and robustness.
- Clarity: The architectural details, data processing steps, and experimental methods are described with clarity, making the paper accessible to readers familiar with ML and neutrino physics.
- Significance: The ability to improve data processing and enable better downstream analyses has substantial implications for neutrino research and potentially for other high-dimensional physics datasets.
summary: This paper presents om2vec, a novel approach leveraging transformer-based variational autoencoders (VAEs) to create compact, descriptive latent representations of photon arrival time distributions (PATDs) from neutrino telescope events. The proposed model is designed to handle the high-dimensional, variable-length data typical of neutrino observatories like IceCube. om2vec aims to outperform conventional approaches, such as asymmetric Gaussian mixture models (AGMMs), by improving reconstruction accuracy, runtime efficiency, and reliability while being less dependent on hyperparameters. The paper details the architecture, training, and testing with simulated datasets, comparing the method’s performance with traditional AGMMs and exploring its utility for downstream tasks like angular reconstruction.
weaknesses: - Generalizability: While the results are promising, it would be helpful to see a more extensive discussion on how the method might generalize across different types of neutrino observatories or non-simulated real-world data.
- Comparison Baseline: Although om2vec is compared with AGMMs, additional comparisons with other potential ML approaches (e.g., deep CNNs or LSTMs) for PATD representation might strengthen the case for its use.
- Hyperparameter Sensitivity: While the model claims reduced dependence on hyperparameters, an exploration of performance variability with different encoder/decoder block configurations or latent dimension sizes would provide deeper insights into its stability.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: Not at the moment, will see other reviewers' comments.
soundness: 2
strengths: The application is certainly interesting and compelling. I also like the rationale of the work. There's a clear scientific motivation for these problems.
summary: This develops a variational autoencoder to create a generative model for data produced by neutrino telescopes. The architecture is based on transformers, and results in a flexible representation and improved computation.
weaknesses: Several aspects. First, this is an ML focused conference so I would have appreciated greater details on the encoder and decoder without having to dig through the source code. Why transformers as opposed to a simpler architecture? Is there some kind transformation of the features that would allow for an MLP. Even if not, I would appreciate these as baselines as opposed to a traditional statistical model when comparing performance.

Also having worked with these a lot, I'm willing to bet that there was a substantial amount of tweaking required for learning rate and architecture parameters. If not, I'm certain performance can be improved dramatically by taking these steps. Another example, the runtime isn't really compelling to me. This is a feed-forward network, clearly it's going to be quicker than the alternatives. Should be supplementary, which would make more space for the fitting details I discussed.

Overall, this seems written for a scientific audience rather than an ML audience. I very much appreciate the application and clear motivation so I hope it's resubmitted. It just seems like some of the details we find interesting were glossed over and need to be improved for this to be accepted.

---

confidence: 4
contribution: 1
initial_rating: 1
presentation: 1
questions: The paper is somewhat limited as it presents results solely based on training and testing with simulated events, which may not accurately reflect real-world measurement data. Given that the approach uses a VAE-based transformer, it may perform better with simulated data that follows known distributions. Do you have access to any existing real-world datasets? If so, I would appreciate your feedback on this aspect.
soundness: 2
strengths: - The use of a transformer-based variational autoencoder (VAE), called om2vec, represents an innovative approach for neutrino event data analysis, which has traditionally relied on more conventional statistical methods or simple summary statistics. 
- The paper pushes the boundaries of machine learning applications within high-energy physics, specifically neutrino detection. 
- By applying a VAE with transformer components to a unique scientific data source, the paper contributes to bridging techniques between disciplines, such as physics, machine learning, and data science. This could encourage further cross-disciplinary research and adaptation of machine learning models to complex scientific problems.
summary: The paper titled "Learning Efficient Representations of Neutrino Telescope Events" introduces a novel approach called om2vec, which utilizes transformer-based variational autoencoders (VAEs) to effectively represent neutrino telescope events. The study addresses the challenges posed by high-dimensional, variable-length Photon arrival time distributions (PATDs) recorded by optical modules in neutrino telescopes, particularly focusing on the IceCube Neutrino Observatory.
weaknesses: - The paper lacks a clear structure and does not adequately address related work. If this is indeed the first study applying deep learning techniques to the domain of neutrino telescopes, it is essential to include a dedicated **Related Works** section to provide context for this research.

- The figures in the paper are oversized. I recommend the authors resize them to a more standard dimension to enhance the overall presentation quality. The current size does not meet the standards expected for conference presentations.

- There are several typographical errors throughout the paper (e.g., lines 127, 484, etc.), which detract from its readability and should be addressed to improve clarity.

- The objective function is unclear, and the problem is not well-defined. The paper jumps directly to the results, with only a brief discussion of the classical $KL$ divergence. A significant improvement is needed in presenting a comprehensive **Proposed Methods** section that clearly defines the final objective function, rather than merely referring to it in the **Results section** (lines 228 to 230).

- Some statements in the paper are ambiguous or inaccurate. For example, the assertion in lines 223 to 232 that "the re-parameterization trick is utilized to construct the latent representation $z$, a vector of user-defined length referred to as the latent dimension. This technique guarantees that the latent space remains continuous and that similar representations within this space reconstruct to similar PATDs" is misleading and not entirely accurate.  However, the reparameterization trick separates the randomness of sampling (handled by $\epsilon$) from the parameters $\mu$ and $\sigma$, which allows to compute gradients with respect to these parameters. I recommend that the authors deepen their understanding of this concept from this paper [1].

I would be willing to consider increasing my rating, but only if these issues are adequately addressed. As it stands, the current version of the paper is not ready for publication.

**Refrences:**

[1] Kingma, Diederik P., and Max Welling. "An introduction to variational autoencoders." Foundations and Trends® in Machine Learning 12.4 (2019): 307-392

Meta-review: This is a very interesting submission, focused primarily on an application of representing neutrino events.  The submission is presented from a fairly informal level, with a very large amount of space devoted to the relatively non-technical Figure 1.  Reviewers were generally quite positive about the topic of the contribution, but nevertheless had significant reservations regarding its acceptance to ICLR in its current form.  Quoting from a review: "This article requires significant improvements in its writing and technical accuracy. Numerous technical details are either unclear, incorrect, or require further clarification...."

Decision: Reject