RepGen: Generative Inference & Applications

• RepGen is a collection of generative modeling frameworks that utilize latent variable and probabilistic methods to infer high-dimensional representations.
• Each system in RepGen targets distinct domains—immunogenetics, event-based vision, and deep learning bug reproduction—demonstrating robust performance and actionable insights.
• RepGen methodologies leverage self-supervised learning, HMM inference, and LLM orchestration to enhance model accuracy, interpretability, and reproducibility.

RepGen denotes a family of specialized methodologies and toolkits for generative modeling and inference in diverse domains, including immune receptor diversity estimation, event-based computer vision, classification-driven image generation, diffusion model acceleration, and automated software bug reproduction. While distinct in technical specifics and fields of application, these systems share a focus on inferring, refining, or leveraging high-dimensional generative representations—often by harnessing latent structures, probabilistic modeling, or self-supervised learning. The following sections detail major RepGen systems as presented in arXiv-indexed literature.

1. RepGenHMM: Probabilistic Inference of Immune Receptor Generation Rules

RepGenHMM is a computational framework for inferring the probabilistic rules governing immune receptor sequence generation, focusing on the stochastic assembly process (V(D)J recombination) that underpins T-cell and B-cell receptor diversity. The generative model explicitly represents the choice of germline segments, segment-specific base deletion, and random nucleotide insertion, parameterizing the full rearrangement scenario for both α/light (V, J) and β/heavy (V, D, J) chain receptors. The underlying model factorizes scenario probability:

• For α or light chains: $$r = (V, J, \text{del}\,V, \text{del}\,J, \text{ins})$$

$$P_{\rm rearr}(r) = P(V,J) \cdot P(\text{del}\,V|V) \cdot P(\text{del}\,J|J) \cdot P(\text{ins})$$

• For β or heavy chains: $$r = (V, D, J, \text{del}\,V, \text{del}\,Dl, \text{del}\,Dr, \text{ins}\,VD, \text{ins}\,DJ)$$

$$P_{\rm rearr}(r) = P(V,D,J)\cdot P(\text{del}\,V|V)\cdot P(\text{del}\,Dl,\text{del}\,Dr|D)\cdot P(\text{ins}\,VD)\cdot P(\text{ins}\,DJ)\cdot P(\text{del}\,J|J)$$

RepGenHMM employs a hidden Markov model formulation, constructing state graphs for each V(D)J combination with templated states, insertion emission states, and non-emitting “ghost” states to enforce state-transition sparsity. The inference of the model parameters relies on Baum–Welch expectation–maximization, efficiently marginalizing over plausible rearrangement paths per sequence.

Key outputs include generation probability $P_{\text{gen}}(s)$ for any sequence, Shannon entropy-based diversity estimates (e.g., total TCR α+β diversity ≈ $10^{23}$), synthetic sequence generation, and parameter profiles (segment usage, deletion, insertion). Rigorous evaluation on both synthetic and empirical T-cell data demonstrates robust parameter recovery and alignment with known biological constraints (Elhanati et al., 2015).

2. RepGen in Event-Based Vision: Learned Self-Supervised Representation Enhancement

In the domain of event-based camera data processing, RepGen refers to a representation generator trained via self-supervised learning to transform "EvRep" (a 3-channel spatial-temporal event statistic) into a higher quality, 5-channel representation ("EvRepSL"). The EvRep tensor comprises:

• Event count ($\mathcal{E}_C(x,y)$)
• Signed event polarity integral ($\mathcal{E}_I(x,y)$)
• Standard deviation of inter-event intervals ($\mathcal{E}_T(x,y)$)

Building on a derived log-intensity frame-event relation, RepGen implements a W-shaped neural architecture with a shared encoder, two decoders (predicting refined polarity and per-pixel contrast threshold), and a frame-event mapping module constrained during training via a mean absolute error on frame reconstruction. Once trained (frozen), RepGen supplies, for each event patch, two additional channels—learned refined integral and threshold—substantially improving downstream classification and optical flow tasks.

Empirical validation shows that RepGen-based EvRepSL consistently outperforms prior SOTA on event-based classification (e.g., +20.7% top-1 accuracy on N-Caltech101, 0.94M parameters) and dense flow estimation (20–30% relative improvement). Computationally, EvRepSL incurs ≈4.4 ms latency per 100 ms event window, suitable for real-time use. Channel ablations confirm each additional learned channel monotonically improves downstream accuracy, indicating the method’s efficacy as a generic plug-in event representation enhancer (Qu et al., 2024).

3. RepGen for Deep Learning Bug Reproduction

RepGen in software engineering denotes an LLM-driven, automated system for reproducing deep learning bugs in codebases. The architecture comprises a modular pipeline:

• Project Context Builder: Hybrid BM25 and ANN-based code snippet retrieval, cross-encoder reranking, dependency resolution, and module-level context extraction.
• Bug Report Restructurer: LLM parses raw issue reports into structured summaries.
• Plan Generator: LLM creates stepwise reproduction plans aligned to code context and bug specification.
• Reproduction Agent: Iterative generate–validate–refine loop that produces, checks, and incrementally fixes candidate scripts; validation integrates static analysis (AST check, PyLint), relevance scoring, and LLM-based symptom simulation.

This multi-stage agent yields a verified reproduction if the script matches compile and error/symptom conditions, runtime errors, and similarity to the reported bug. In a benchmark of 106 real-world DL bugs, RepGen achieves an 80.19% reproduction rate (19.81% absolute gain over the best baseline), with ablation studies demonstrating the necessity of each module (removal of context, planning, or validation steps leads to >40% reduction in success). Developer studies quantify a 23.35% increase in bug reproduction rate and >50% reduction in reproduction time, with significant cognitive load decreases (Shah et al., 17 Dec 2025).

4. Comparison with Related Gen*-Class Tools

The RepGen nomenclature has parallels and points of contrast with related generative modeling approaches such as ReGene (Gopalakrishnan et al., 2020) (classification-latent space exploitation for controlled image generation) and representation entanglement frameworks for diffusion models (e.g., REG (Wu et al., 2 Jul 2025)). While ReGene constructs new samples using convex combinations of supervised latent codes within a discriminatively trained classifier’s region (offering theoretical guarantees of label preservation via linear separability), RepGenHMM and RepGen for event-based vision emphasize latent variable modeling and self-supervised estimation of transformation parameters. In the software engineering context, RepGen embodies an agentified LLM orchestration pipeline rather than a pure statistical model.

5. Applications and Impact

RepGen systems are foundational in several domains:

• Immunogenetics: Accurate quantification of immune repertoire diversity and sequence generation, synthetic dataset production, and hypothesis testing on receptor evolution and selection pressures (Elhanati et al., 2015).
• Computer Vision: Event-based representation learning and vision tasks (classification, optical flow) with broad camera and domain coverage (Qu et al., 2024).
• Software Engineering: Automated bug reproduction for deep learning pipelines, with integration into developer workflows and benchmarks for tool evaluation (Shah et al., 17 Dec 2025).

These systems deliver SOTA or near-SOTA performance and serve as baselines for evaluating selection pressures or downstream learning tasks. In research and applied settings, the formalization and automation of generative inference patterns via RepGen represent significant advances in efficiency, reproducibility, and model interpretability.

6. Limitations and Prospects

RepGen-based toolkits inherit domain-specific limitations:

• In immunogenetics, coverage is bounded by the model expressivity (e.g., maximum deletions/insertions, fixed error rates) and available germline templates.
• Event-based vision RepGen requires paired event-frame data for training but is agnostic to camera type and downstream network architecture.
• Software RepGen depends on LLM coverage of API/version subtleties, struggles with true environment-dependent/data-dependent bugs, and relies on correct extraction of context and relevance from large codebases.

Future directions include integrating containerized environment control for dealing with infra bugs, expanding event-based RepGen to multi-modal or cross-domain tasks, and hybridizing statistical modeling with generative neural architectures. These developments will further automate and refine generative inference, representation, and diagnosis across computational biology, machine perception, and program synthesis.