PaperlayerView exact revision on arXiv

Source-linked AI summary

ELF: Embedded Language Flows

Keya Hu, Linlu Qiu, Yiyang Lu, Hanhong Zhao, Tianhong Li, Yoon Kim, Jacob Andreas, Kaiming He

arXiv:2605.10938v2cs.CLcs.AIcs.LG

TL;DR

Diffusion language models have largely focused on discrete tokens, leaving effective continuous modeling as an open direction. ELF uses Flow Matching in continuous embedding space and outperforms leading discrete and continuous models with fewer sampling steps and training tokens.

  • Problem

    Diffusion language models use either continuous representations or discrete tokens, while effective continuous language modeling remains a promising open direction.

  • Method

    ELF denoises continuously in embedding space with continuous-time Flow Matching and discretizes only at the final step.

  • Results

    ELF achieves better generation quality with fewer sampling steps and fewer training tokens than leading discrete and continuous diffusion language models.

  • Takeaways & Limitations

    These results suggest that continuous diffusion language models are a promising direction for diffusion-based language modeling.

  • Takeaways & Limitations

    The study does not report validation perplexity because likelihood evaluation for flow-based models may require additional likelihood-specific training.

Abstract

from arXiv · show

Diffusion and flow-based models have become the de facto approaches for generating continuous data, e.g., in domains such as images and videos. Their success has attracted growing interest in applying them to language modeling. Unlike their image-domain counterparts, today's leading diffusion language models (DLMs) primarily operate over discrete tokens. In this paper, we show that continuous DLMs can be made effective with minimal adaptation to the discrete domain. We propose Embedded Language Flows (ELF), a class of diffusion models in continuous embedding space based on continuous-time Flow Matching. Unlike existing DLMs, ELF predominantly stays within the continuous embedding space until the final time step, where it maps to discrete tokens using a shared-weight network. This formulation makes it straightforward to adapt established techniques from image-domain diffusion models, e.g., classifier-free guidance (CFG). Experiments show that ELF substantially outperforms leading discrete and continuous DLMs, achieving better generation quality with fewer sampling steps. These results suggest that ELF offers a promising path toward effective continuous DLMs.

1 Introduction

ELF is a continuous diffusion language model that performs Flow Matching directly in embedding space and discretizes only at the final time step. It achieves better generation quality than leading discrete and continuous DLMs with fewer sampling steps, 10× fewer training tokens, and no distillation.

  • Empirical results: 10× fewer training tokens and no distillation accompany ELF’s stronger generation quality and fewer sampling steps than prior DLMs.Figure 1 reports this comparison for 105M-parameter ELF and 170M-parameter baselines on OWT.
  • ELF formulation: ELF applies continuous-time Flow Matching to denoise continuous token embeddings, postponing discretization until the final time step.This design defines the velocity field through the time derivative and enables adaptation of Flow Matching advances from image and video generation.
  • ELF formulation: ELF uses a shared-weight network to map final continuous embeddings back to discrete tokens without a separate decoder.Its embedding space can use a pretrained, jointly trained, or randomly initialized frozen encoder.
  • Design rationale: Unlike methods with per-step discretization losses, ELF performs denoising in continuous embedding space at nearly all steps, maximizing flexibility for flow dynamics.The minimalist design targets the interface between continuous and discrete spaces.
  • Empirical results: ELF achieves better generation quality with fewer sampling steps than leading discrete DLMs such as MDLM and Duo and continuous DLMs such as FLM and LangFlow.The comparison follows evaluation protocols established in prior works.

2 Background & Related Work

Prior diffusion and flow-based language models operate either directly in discrete token space or in continuous representations that often remain tied to tokens. ELF instead performs denoising predominantly in continuous embedding space and decodes back to discrete tokens only at the final step.

  • Diffusion-/Flow-based models: Diffusion and flow-based models transform noise into data through ordinary or stochastic differential equations, with discrete variants using categorical transitions and continuous variants using score or noise prediction.DDPM-style formulations define generation through transitions between successive states, which may be discrete or continuous.
  • Continuous diffusion language models: Continuous DLMs denoise token representations in continuous spaces, including embedding-space methods using Gaussian noise and FlowSeq using Flow Matching.Related approaches also use simplex-based, manifold-based, or analogbit representations as continuous relaxations of tokens.
  • Continuous diffusion language models: ELF encodes tokens as clean embeddings, corrupts them, predicts clean embeddings during training, and switches to discrete decoding only after iterative denoising from Gaussian noise.Training uses either denoising loss LMSE or token-wise cross-entropy loss LCE, while final decoding uses an unembedding layer.
  • Continuous diffusion language models: Unlike many continuous relaxations, ELF denoises entirely in continuous embedding space without per-step mechanisms that keep trajectories tied to discrete tokens.The contrasting methods use simplex constraints, token-aligned bit encodings, or token-level cross-entropy objectives.
  • Continuous diffusion language models: Other continuous flow-based language models apply token-level cross-entropy supervision along the trajectory, use varied continuous state spaces, and sometimes add distillation for few-step generation.ELF differs by keeping the denoising trajectory entirely in continuous embedding space.
  • Discrete diffusion language models: Discrete diffusion language models define categorical corruption processes or masked absorbing states and generate through iterative unmasking, with later work targeting sampling and efficiency.Examples include D3PMs and MDLMs, alongside remasking, adaptive inference, and semi-autoregressive approaches.

3 Embedded Language Flows

ELF performs language denoising primarily in continuous embedding space using Flow Matching, then converts clean embeddings into discrete tokens only at the final step. Its continuous formulation supports image-domain techniques such as classifier-free guidance, including training-time implementations.

  • Continuous formulation: ELF maps discrete token sequences into continuous embeddings and defines a Flow Matching path from noise to data using linear interpolation.The noisy latent is z_t = tx + (1 − t)ε, with x drawn from the embedding distribution and ε from a noise distribution.
  • Continuous formulation: ELF predicts clean embeddings x rather than velocity v, enabling effective Flow Matching on high-dimensional representations and aligning training with final token prediction.The approach uses x_θ = net_θ(z_t, t) and trains through an MSE objective on the corresponding predicted velocity.
  • Continuous-to-discrete decoding: At t = 1, ELF uses the shared denoiser network to map corrupted inputs to clean embeddings, projects them with a learnable unembedding matrix, and applies token-level cross-entropy.During inference, unembedding and argmax produce discrete tokens, so ELF requires no separate decoder.
  • Inference: During inference, ELF numerically solves the ODE from Gaussian noise to clean embeddings before decoding at the final time step, while also supporting an SDE-inspired noisy sampler.The ODE is d z_t/dt = v_θ(z_t, t), approximated with a numerical solver such as Euler.
  • Classifier-free guidance: Because classifier-free guidance is naturally defined for continuous velocity fields, ELF combines self-conditioned conditional and unconditional predictions and supports training-time CFG with a single network pass.Training-time CFG models the guided prediction directly, avoiding the two forward passes required by the original inference-time formulation.

4 Experiments

Experiments evaluate ELF on unconditional and conditional generation using established datasets and task-specific metrics. Ablations and comparisons show that guidance, embedding choices, sampling, scaling, and ELF’s training efficiency contribute to strong performance.

  • Dataset and evaluation: Unconditional evaluation trains on OpenWebText and reports generative perplexity plus average unigram entropy from 1,000 generated samples.Conditional evaluation uses WMT14 German-to-English with BLEU and XSum with ROUGE-1, ROUGE-2, and ROUGE-L.
  • Classifier-free guidance: Increasing classifier-free guidance lowers generative perplexity but reduces entropy, revealing a quality–diversity trade-off.ELF’s continuous flow formulation is naturally compatible with classifier-free guidance.
  • Embedding choices: Pretrained contextual embeddings achieve the best generative perplexity–entropy trade-off among contextual, non-contextual, frozen, and learnable alternatives.The embedding ablation varies contextuality and whether embeddings are fixed or learnable.
  • Decoding strategies: The shared-weight decoding strategy reaches lower generative perplexity than the two-stage alternative while avoiding an extra training stage.Both decoding strategies achieve similar trade-offs overall.
  • Samplers and model scales: SDE sampling achieves substantially lower generative perplexity than ODE sampling in the few-step regime, while larger models consistently improve the generative perplexity–entropy frontier.The scaling comparison covers ELF-B (105M), ELF-M (342M), and ELF-L (652M).
  • Comparisons and efficiency: 45B estimated training tokens power ELF versus prior DLMs’ typical use of over 500B, while ELF outperforms distilled baselines in the few-step regime.ELF-B has 105M parameters compared with approximately 170M for the main baselines, and ELF-B achieves the best performance across both conditional tasks.

5 Conclusion

The paper introduces ELF, a continuous diffusion language model that performs language generation in continuous embedding space with continuous-time Flow Matching. By discretizing only at the final step, ELF adapts continuous diffusion techniques straightforwardly and achieves a strong quality–efficiency trade-off against discrete and continuous DLMs.

  • Conclusion: ELF formulates language generation in continuous embedding space using continuous-time Flow Matching.It is presented as a continuous diffusion language model.
  • Conclusion: ELF keeps the denoising trajectory continuous and applies discretization only at the final step.This design enables straightforward adaptation of techniques from continuous diffusion models.
  • Conclusion: ELF achieves a strong quality–efficiency trade-off against leading discrete and existing continuous DLMs across language generation tasks.It attains lower generative perplexity with fewer sampling steps and fewer training tokens.

A Continuous Diffusion Language Model Survey · B Progressive Distillation of ELF for Few-Step Language Generation · B.1 Method

The survey positions ELF as a continuous-time embedding-space model that delays discretization until final decoding, unlike methods using intermediate token-level supervision. Progressive distillation then compresses ELF’s sampling trajectory toward few-step generation while retaining its shared denoiser-decoder setup.

  • A Continuous Diffusion Language Model Survey: The survey compares continuous diffusion and flow-based language models by process, denoising state, intermediate discretization, and decoder requirements.These axes organize how models denoise continuous states and map them back to text.
  • A Continuous Diffusion Language Model Survey: Intermediate discretization distinguishes training-time token supervision from inference-time conversion of denoising states into token predictions.Training-time discretization provides vocabulary-level guidance but couples intermediate states to categorical predictions.
  • A Continuous Diffusion Language Model Survey: ELF performs continuous-time Flow Matching in a frozen contextual embedding space and discretizes the trajectory only at the final decoding step.A single shared-weight network handles intermediate denoising and final token recovery through the unembedding layer, without a separate decoder.
  • B Progressive Distillation of ELF for Few-Step Language Generation: ELF achieves strong performance with 8–32 sampling steps, but performance degrades further as sampling steps decrease, leaving one-/few-step generation challenging.Progressive distillation is introduced because it can reduce sampling steps while preserving generation quality.
  • B.1 Method: Progressive distillation compresses K teacher sampling steps over [t, r] into one student step by converting the teacher’s numerical-solver displacement into a new target.The teacher moves the noisy embedding from z_t to z_r before target construction.
  • B.1 Method: The method retains ELF’s two-branch training, shared-weight denoiser, and decoder, replacing denoising MSE with distillation loss while preserving decoding cross-entropy.This keeps the original decoding objective while changing the denoising objective for distillation.
  • B.1 Method: Distillation halves student steps each round for five rounds, using a fixed 64-step ELF teacher and initializing each student from the preceding model.The first 16-step student starts from the teacher; subsequent rounds continue halving the student’s step count.

B.2 Experimental Setup

The experiments use OpenWebText and ELF’s original training settings, including training-time classifier-free guidance with self-conditioning. Inference uses an SDE-inspired sampler with step-dependent noise reinjection and guidance scales, while targeted sweeps control γ and exclude degenerate outputs by entropy.

  • Training Setup: Training uses OpenWebText, one epoch per distillation round, ELF’s original hyperparameters, 0.1 warmup epoch, and shared self-conditioning CFG scales for teacher and student.The same logit-normal schedule is used to sample t_i.
  • Inference Setup: Inference uses an SDE-inspired sampler with the training-time logit-normal schedule; 1–8 steps use γ = 1.5 and CFG scale 2.5, while 16–32 steps use γ = 2.0 and CFG scale 2.0.The noise reinjection and self-conditioning CFG settings vary with the generation-step regime.
  • Ablation Setup: The self-conditioning CFG sweep varies the scale from 0.5 to 3.0 with γ = 1.5 and reports only configurations with entropy greater than 5.0.The entropy filter excludes degenerate, repetitive text.
  • Ablation Setup: Curriculum-distillation experiments fix γ = 1.5 and the self-conditioning CFG scale to 2.5.These settings are used for the analysis in Tab. 5.

B.3 Results · C Method Details

ELF+PD outperforms distilled discrete and continuous language-model baselines across sampling budgets while requiring substantially fewer training tokens. Progressive distillation improves few-step generation, with later-round students avoiding the collapse seen in early rounds.

  • B.3 Results: ELF+PD achieves the lowest generative perplexity at every sampling budget while maintaining reasonable entropy on OpenWebText.The comparison includes distilled MDLM+SDTT, Duo+DCD, and FMLM baselines.
  • B.3 Results: Each progressive-distillation round halves student steps while retaining a fixed 64-step teacher, so an N-step student matches 64/N teacher substeps.The five-round curriculum progressively distills the teacher into a one-step student.
  • B.3 Results: 90B tokens, or 2.0× base-model training, are used by ELF+PD versus 550–577B tokens, or 12×+, for other baselines.These estimates are reported for OpenWebText few-step generation.
  • B.3 Results: ELF+PD has comparable generative perplexity–entropy trade-offs across 8–32 sampling steps, but fewer than 8 steps degrade performance.Exact few-step results are reported in Table 4.
  • B.3 Results: Early-round students perform well only at larger sampling budgets and collapse to degenerate outputs at smaller budgets.Degenerate results are defined as entropy below 5.0.
  • B.3 Results: Later-round students substantially improve 1–4-step generation compared with early-round students.Table 5 reports performance across progressive-distillation rounds and sampling steps.

C.1 Training · C.2 Inference

ELF trains a shared-weight network to denoise corrupted embeddings and decode them into tokens, using self-conditioning, in-context control tokens, and training-time CFG. At inference, it integrates the denoising flow over a logit-normal time grid, supports ODE or stochastic SDE-inspired sampling, and controls guidance through an input scale.

  • C.1 Training: ELF’s training pipeline encodes tokens into clean embeddings, applies corruption and self-conditioning, prepends control tokens, and uses shared weights for denoising and decoding.The denoising branch predicts clean embeddings with LMSE, while the decoding branch unembeds predicted embeddings and supervises token recovery.
  • C.1 Training: Embedding corruption uses z_t = t x + (1 − t)ϵ after normalizing clean embeddings, with noise schedules differing across training modes.ϵ is Gaussian noise, and the clean embeddings are normalized using estimated OWT mean and standard deviation.
  • C.1 Training: Self-conditioning concatenates either a stopped-gradient previous prediction or zeros with noisy embeddings, projects back to the original dimension, and is used with 50% probability in denoising.The decoding branch always uses zero self-conditioning.
  • C.1 Training: In-context conditioning prepends control-token embeddings, preserves conditioning embeddings uncorrupted, and drops the condition with 10% probability for conditional generation.The model performs bidirectional self-attention over the conditioning and target sequences.
  • C.2 Inference: The inference loop self-conditions on the previous prediction, decodes at t = 1 through the shared network and unembedding layer, and uses argmax token selection.Changing the CFG scale w requires no additional inference pass because w is supplied through in-context conditioning; conditional CFG combines conditional and unconditional predictions.
  • C.2 Inference: Inference discretizes t ∈ [0, 1] with a logit-normal schedule matching training, using smaller intervals near t = 0 and larger intervals near t = 1.The schedule uses Pmean = −1.5 and Pstd = 0.8, with endpoints fixed at t = 0 and t = 1.
  • C.2 Inference: ELF supports deterministic ODE sampling and an SDE-inspired sampler that re-injects Gaussian noise with scale γ while shifting the state toward the noise regime.The denoiser is evaluated on the perturbed state before advancing the flow.

D Additional Ablations … D.5 Optimizers

The ablations identify stable prediction targets, moderate bottlenecks, balanced denoising supervision, in-context conditioning, and Muon optimization as important design choices for ELF. Across ODE and SDE sampling, these choices improve the generative perplexity–entropy trade-off, while both optimizers still outperform other baselines.

  • D Additional Ablations: The ablations evaluate ELF using 64-step ODE or SDE samplers and the generative perplexity–entropy trade-off, with entropy below 5.0 or perplexity above 300 indicating poor quality.The trade-off is varied through the self-conditioning CFG scale.
  • D.1 Prediction Targets: x-prediction remains the most stable as embedding dimension increases, whereas v-prediction degrades at higher dimensions and ϵ-prediction collapses across dimensions.The comparison uses T5-small, T5-base, and T5-large encoders with dimensions 512, 768, and 1024.
  • D.2 Bottleneck: A bottleneck dimension of 128 provides the best generative perplexity–entropy trade-off, while smaller bottlenecks reduce diversity and larger ones hurt generative perplexity.The study compares bottleneck dimensions 32, 128, and 512 under ODE and SDE sampling.
  • D.3 Denoising Mode Probability: A denoising-mode probability of 0.8 achieves the best overall generative perplexity–entropy trade-off across both ODE and SDE samplers.Lower probabilities consistently degrade the trade-off, especially under SDE sampling, so 0.8 is used by default.
  • D.4 Conditioning Strategies: In-context conditioning slightly improves performance while substantially reducing model parameters compared with adaLN-Zero conditioning.The model prepends time step, CFG scale, and model mode as condition tokens and processes them with full attention.
  • D.5 Optimizers: Muon achieves lower training loss within the same number of steps and a better generative perplexity–entropy trade-off than AdamW under both ODE and SDE sampling.Muon uses a learning rate of 2 × 10−3, while AdamW uses 1 × 10−4 with β1 = 0.9 and β2 = 0.95.
  • D.5 Optimizers: Muon’s improvement is especially significant under SDE sampling, where it achieves lower generative perplexity at the same entropy level.Models trained with both Muon and AdamW still outperform other baselines, so ELF’s performance is not attributed to the optimizer alone.

D.6 Sampling Methods … E.2 Hyperparameters

The paper improves sampling efficiency and generation quality through logit-normal schedules, stochastic noise reinjection, and calibrated CFG, while documenting architecture and hyperparameter choices for reproducibility and system-level comparisons.

  • D.6 Sampling Methods: Logit-normal time scheduling consistently lowers generative perplexity versus uniform scheduling, especially when using few denoising steps.The schedule is used by default during inference.
  • D.6 Sampling Methods: The SDE noise scale γ controls the perplexity–entropy trade-off: moderate increases lower generative perplexity while slightly reducing entropy.γ = 0 corresponds to deterministic ODE sampling.
  • D.6 Sampling Methods: γ = 1.0 is the default SDE setting because noise reinjection may correct early denoising errors and balances generative perplexity with entropy.The hypothesis contrasts stochastic correction with deterministic amplification of imperfect ODE trajectories.
  • D.7 CFG on Conditional Generation: CFG scale 2 is the default: increasing the scale from 1 to 2 substantially improves WMT14 De-En and XSum, whereas stronger guidance gradually hurts performance.The result suggests that stronger conditioning initially improves source following but can become excessive.
  • E.1 Model Architecture: ELF uses a standard Diffusion Transformer with SwiGLU, RMSNorm, RoPE, and qk-norm, while in-context conditioning reduces ELF-B from 148M to 105M parameters.The architecture configurations are summarized across different model sizes.
  • E.2 Hyperparameters: The ELF pipeline hyperparameters cover architecture, diffusion, conditioning and guidance, and optimization, with a default configuration used unless otherwise noted.These settings are provided to support reproducibility.
  • E.2 Hyperparameters: System-level comparisons use SDE sampling with enabled time schedules; CFG scale is 3 for 8-, 16-, and 32-step generation, with γ = 2 for 8 and 16 steps and γ = 1.5 for 32 steps.Longer denoising trajectories use less stochastic correction.
  • E.2 Hyperparameters: 45.2B effective training tokens are used by ELF under the default 5-epoch schedule on OWT, estimated from roughly 9.04B dataset tokens.The passage states that ELF requires roughly an order of magnitude fewer effective training tokens, but the comparison is truncated.

E.3 Ablation Studies Setting

The ablation setting evaluates multiple embedding representations for ELF and also tests two-stage training with a separate decoder, while keeping other settings at the default unless specified. Variants differ in whether embeddings are scratch-trained, pretrained, Gaussian-initialized, or jointly learnable, with distinct normalization and decoder procedures.

  • E.3 Ablation Studies Setting: ELF ablations compare scratch-trained, pretrained, Gaussian, and learnable embedding representations, plus a separate-decoder two-stage training setting.Other settings remain identical to the default ELF configuration unless specified.
  • E.3 Ablation Studies Setting: The scratch encoder is trained on OpenWebText for 5 epochs with a 1 × 10−3 learning rate, cosine schedule, 0.4 epoch warmup, and batch size 512.Channel-wise normalization is applied to encoder outputs during ELF training.
  • E.3 Ablation Studies Setting: The pretrained variant freezes and normalizes the T5-small encoder embedding table, while training the unembedding layer separately.The embedding table serves as the token embedding layer.
  • E.3 Ablation Studies Setting: The Gaussian variant freezes token-wise embeddings initialized with mean 0 and standard deviation 1, whereas the learnable variant jointly trains embeddings with the denoiser and decoder.The learnable variant ties unembedding to embedding and normalizes the unembedding matrix at every step.
  • E.3 Ablation Studies Setting: The separate-decoder setting mirrors the T5-small encoder, keeps it fixed, masks 20% of inputs, and trains for 3 epochs at 3×10−4 with logit-normal noise.It uses Pmean = 0.5, Pstd = 1.0, cosine scheduling, and relative noise scale 5.0.

E.4 Reported Numbers … ELF-B XSum

ELF’s reported results show robust system-level gains, CFG-dependent scaling, progressive denoising into grammatical text, and fluent outputs across unconditional, translation, and summarization examples.

  • E.4 Reported Numbers: Across 6 independent evaluation seeds, ELF’s gains remain robust to random-seed variation, with standard error decreasing as sampling steps increase from 8 to 32.The reported system-level results are summarized as mean ± standard error over seeds 0–5.
  • E.4 Reported Numbers: Larger CFG scales improve generation quality by reducing Gen. PPL within a certain range, but the effect reverses beyond 3; only ELF-L benefits from scaling from 3 to 4.The default setup uses 64 sampling steps, and most ablations therefore consider CFG scales from 0.5 to 3.
  • E.5 Conditional Generation: ELF’s conditional-generation comparisons reproduce AR, MDLM, E2D2, and Duo using configurations intended to match their original implementations as closely as possible.Reported WMT14 results for several baselines come from their original papers, while reproduced baselines use the E2D2 or Duo codebases.
  • F.1 Denoising Trajectory: During denoising, repetitive tokens at t = 0 progressively become semantically meaningful, grammatical, and better-worded text as t approaches 1.The trajectory transforms noisy embeddings that decode to gibberish into clean embeddings that decode to grammatical sentences.
  • F.2 Unconditional Generation Examples on OpenWebText: ELF-B unconditional OpenWebText samples are described as fluent, syntactically coherent, and topically consistent across diverse domains.Reported examples include Entropy: 5.36 Gen. PPL: 21.04, Entropy: 5.27 Gen. PPL: 21.29, and Entropy: 5.17 Gen. PPL: 21.80.
  • ELF-B OWT: The ELF-B OpenWebText examples contain fluent-looking passages but also exhibit repetition, malformed wording, and factual inconsistencies.Examples include repeated phrases such as “youth assistance” and unusual constructions such as “turningping off their fingers.”
  • F.3 Conditional Generation Examples: On WMT14 De-En, ELF generally produces fluent and globally coherent translations, including examples that preserve the source meaning while varying in wording.The examples include translations concerning elections and responsibility for conducting elections.
  • ELF-B XSum: On XSum, ELF generally produces fluent and concise summaries that capture source-document content, though some examples diverge from the references in details.The examples summarize a cricket injury and a Labour leadership contest, with competing outputs showing both accurate and inaccurate details.

F.4 Unconditional Generation Examples of ELF+PD on OpenWebTex

The section presents unconditional OpenWebTex samples from ELF+PD across sampling steps, reporting each sample’s entropy and generative perplexity. The examples span technology, gaming, sports, and education-related text, with substantial variation in reported Gen. PPL.

  • Reported samples: ELF+PD examples report Entropy: 5.28 and Gen. PPL: 132.89 for a technology-focused continuation mentioning Bloomberg, Samsung, and Apple.The sample contains highly repetitive and fragmented phrasing about laptops, smartphones, and websites.
  • Reported samples: A gaming-company continuation is reported with Entropy: 5.47 and Gen. PPL: 64.76.The text discusses accessibility, gaming companies, software development, and portable programs.
  • Reported samples: A sports-related continuation is reported with Entropy: 5.32 and Gen. PPL: 30.76.The sample describes a player’s performance, experience, team, and role as a winger or striker.
  • Reported samples: An education-related continuation is reported with Entropy: 5.24 and Gen. PPL: 19.22.The text discusses declining basic education, low-income people, and limited resources.
Loading 2605.10938v2…