Pith. sign in

REVIEW 3 major objections 5 minor 29 references

SequenceLayers: Sequence Processing and Streaming Neural Networks Made Easy

T0 review · 3 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read SequenceLayers is a layer API that makes streaming sequence models correct by default by requiring every steppable layer to produce identical outputs whether run layer-wise or step-wise.

desk verdict A genuinely useful library paper with a real API design contribution; the correctness claims are tested but not proven, and the 'identical outputs' wording overstates the floating-point tolerance check. read the letter →

arxiv 2507.23292 v1 pith:B3T7LLY3 submitted 2025-07-31 cs.LG cs.CLcs.PLcs.SEeess.AS

RJ Skerry-Ryan , Julian Salazar , Soroosh Mariooryad , David Kao , Daisy Stanton , Eric Battenberg , Matt Shannon , Ron J. Weiss
show 3 more authors
Robin Scheibler Jonas Rothfuss Tom Bagby
This is my paper · ORCID
classification cs.LGcs.CLcs.PLcs.SEeess.AS
keywords sequencemodelingstreaminginferencelayer-stepequivalenceexplicitstateKVcachemaskedsequencescomposablelayerAPIautoregressivesampling
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper aims to remove the gap between offline and streaming sequence models. It proposes a layer API in which every time-dependent layer declares an explicit state, such as a Transformer KV cache, a convolution buffer, or an RNN hidden state, and a step method that advances that state. It elevates a consistency requirement into a contract: a steppable layer must produce the same output whether the input is processed all at once by the layer method or in blocks by the step method. If that contract holds, models composed from such layers are streamable as soon as they are built, with no separate inference implementation to maintain. A reader should care because this directly targets the recurring cost of reimplementing trained models for autoregressive or real-time serving.

What carries the argument

The central object is the SequenceLayer type, a class with two routes through the computation, layer, which processes a whole sequence, and step, which processes one block of inputs plus explicit state, joined by the invariant that the routes agree. It is supported by the Sequence object, a pair of values and a boolean mask that travels everywhere with the data, and by layer metadata the contract exposes, including output ratio, block size, input and output latency, and receptive field, which let combinator layers compute aggregate properties of a composition. The explicit per-layer State, such as a KV cache, convolution buffer, or RNN cell state, is what makes the step route possible, and the verify_contract test utility is the enforcement mechanism that checks the equivalence property on randomly generated inputs, including gradient checks, batching and padding invariance, and metadata consistency.

What would settle it

Find a SequenceLayer that passes verify_contract on its random inputs but produces different outputs in layer-wise versus step-wise execution on some other input, such as an input with all positions invalid, a single-timestep block, or extreme values, or find a composition of contract-valid layers that violates the equivalence on any input; either would show the contract does not make streaming correct by default.

Watch

Extended reading notes

Core claim

The central claim is that a single design contract can make streaming inference a derived property of a sequence model rather than a parallel implementation. A SequenceLayer defines layer, get_initial_state, and step, and the contract states that for any input sequence and equivalent starting state, step-by-step execution over blocks of block_size timesteps must produce identical values and masks as layer-wise execution, up to floating-point tolerance and with equivalent RNG state. State is always explicit arrays, never hidden inside the layer, so combinators can wrap and unwrap sublayer states mechanically. The paper argues that this layer/step equivalence, together with Sequence objects that bind data to masks, makes padding invariance, batching invariance, causal masking, and streaming/offline mismatch into testable properties of each layer, and that the whole design is framework-agnostic.

Load-bearing premise

The entire 'correct by default' claim rests on randomized unit tests, called verify_contract, rather than on a proof or exhaustive check, so the guarantee is only as strong as the test coverage.

Editorial extensions

If this is right

  • Any model assembled from contract-valid SequenceLayers is immediately streamable: the sampling loop can call get_initial_state and step without writing a separate inference path.
  • Combinators propagate the contract automatically, so a Transformer block defined in a few declarative lines exposes working state and step methods for free.
  • Padding and batching bugs largely disappear as a class, because Sequence objects carry their masks and layers must be padding- and batching-invariant to satisfy the contract.
  • Deployment can use the exposed metadata, including output ratio, block size, latency, and receptive field, to allocate buffers and schedule streaming computation before the model is run.
  • Serving infrastructure can accept any SequenceLayer model directly, eliminating most of the research-to-production tax for streaming use cases.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • A formal equivalence proof, or exhaustive enumeration over small inputs for finite-state layers, would strengthen the 'correct by default' claim from empirical to guaranteed, which the randomized test suite alone does not provide.
  • Because the contract is framework-agnostic, porting SequenceLayers to another backend should preserve the same guarantees, provided the verification utility is ported along with it.
  • The exposed metadata could feed streaming schedulers and mobile deployment tools that choose block sizes and flush latencies automatically, a use the paper leaves implicit.
  • Shared-state designs such as cross-block KV cache sharing require redrawing the layer boundary, which the paper acknowledges, and this suggests an extension where combinators explicitly manage shared state.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper introduces SequenceLayers, a neural network layer API and library (implemented in JAX and TensorFlow 2) designed to make sequence models immediately streamable. The core idea is that every steppable layer defines an explicit state and a step method that must produce outputs identical to a layer-wise invocation. The paper specifies a contract (Section 2.2) enforced by a verify_contract utility, describes composable combinators (Serial, Residual, Repeat, Blockwise, etc.), and reports that the library has been used internally at Google across many tasks. The central claims are that streamability comes 'for free', that the design is 'correct by default' making whole bug classes impossible, and that it eliminates the 'research-to-production tax'.

Significance. If the layer/step equivalence guarantee is reliable, the design is a genuinely useful abstraction for sequence modeling: it decouples architecture from autoregressive inference, makes composed models immediately streamable, and mitigates a practical class of training/serving-skew bugs. The paper is clearly written, the open-source implementations are a concrete artifact, and the verify_contract test suite is a reproducible mechanism for checking the contract. However, the evidence falls short of the strong claims made: the guarantee is validated only by randomized tests up to an unspecified floating-point tolerance, not by a formal proof or exhaustive verification, and no empirical data support the claimed reduction in development time or elimination of the research-to-production tax. The significance of the work is real but currently asserted rather than demonstrated.

major comments (3)
  1. [Section 2.2] The contract states that 'layer and step methods must produce identical results' and the paper's value proposition rests on 'identical outputs' and 'correct by default'. Yet verify_contract checks equivalence only 'up to floating point tolerance' without specifying the tolerance or analyzing how rounding differences propagate through composed layers, repeated steps, and long autoregressive rollouts. For a sampling loop, per-step ulp-level differences can accumulate and eventually change discrete token choices, so the claim of eliminating training/serving skew is stronger than the evidence. The authors should either demonstrate that all current layer implementations are bitwise identical between layer and step (and enforce this in tests), or replace the 'identical' language with a bounded-divergence guarantee and provide an error-accumulation analysis for the included layers and combinators.
  2. [Section 1, Section 2.2] The claims that SequenceLayers is 'correct by default' and makes entire classes of bugs 'impossible' are not supported by the presented evidence. verify_contract applies randomized tests on finite inputs; it does not provide a formal proof of the contract, exhaustive state-space exploration, or a demonstrated link between passing these tests and the absence of bugs in real deployments. No benchmark or case study quantifies reduced bug rates, development time, or maintenance cost. These claims should be softened to 'mitigates' or 'reduces the likelihood of' unless the authors add a formal correctness argument or empirical evidence.
  3. [Section 5.1] The assertion that SequenceLayers 'eliminates the research-to-production tax' at Google is central to the paper's motivation, but it is supported only by a general statement of internal usage. No concrete evidence is provided: no measurements of deployment time, no comparison of handwritten serving implementations versus SequenceLayers-based ones, no code-size or latency data. Without such evidence, this is an anecdotal claim. The authors should either provide a representative case study with quantitative results or substantially temper the claim to 'reduces' rather than 'eliminates'.
minor comments (5)
  1. [Section 2.1.1, Table 1] The table entry for 'Conv1DTranspose stride = 2' reads 'Fraction(2, )' which is in incomplete representation; it should be 'Fraction(2, 1)'.
  2. [Figure 3 and Figure 4] These figures use np.testing.assert_array_equal, which checks exact equality, while Section 2.2 says the contract tests check 'up to floating point tolerance'. These two representations of the guarantee should be reconciled so readers understand whether the shipped tests are exact or tolerant.
  3. [Section 2.1.4] The definitions of output latency and input latency are given in prose. A small illustrative example or an algorithmic definition would make the concepts easier to apply when users implement their own layers.
  4. [Section 2.3.5] The Bidirectional combinator is described as 'not steppable'. This is consistent with the contract's conditional 'If step-wise operation is supported', but the paper could make that connection explicit to avoid confusion for readers who expect all SequenceLayers to be steppable.
  5. [Section 4.1] The paper states that the code is available on GitHub and PyPI, but it does not mention the license or version. For a reproducibility-oriented paper, stating the license (e.g., Apache 2.0) and a specific version would be helpful.

Circularity Check

1 steps flagged · score 1.0 of 10

Trace-level self-definitionality only: the 'correct by default' guarantee restates the contract that defines correctness; no fitted predictions, no load-bearing self-citations, no imported uniqueness results.

  1. self definitional [Section 1 (Introduction, 'Correct' bullet) and Section 2.2 ('Correct: The SequenceLayer Contract')]
    "Correct. SequenceLayers is correct by default, making entire classes of bugs impossible, e.g., those due to masking, upsampling, downsampling, causality, and padding-invariance. This comes from enforcing layer vs. step equivalence (Section 2.2) ... the SequenceLayer contract, which is the set of requirements a SequenceLayer must implement to be considered correct."

    The central guarantee 'correct by default' is not derived from an independent premise; it is the enforcement of the contract, and Section 2.2 defines 'correct' as satisfying exactly that contract: 'the set of requirements a SequenceLayer must implement to be considered correct.' Likewise, 'a steppable SequenceLayer must produce identical outputs regardless of whether the layer or step API is used' (Section 2.1) is constitutive: a step implementation is by definition valid only if it reproduces the layer output, so 'steppable implies identical outputs' holds by construction of the definition rather than by argument.

full rationale

Walking the paper's claims: (1) there are no fitted parameters, empirical predictions, or data-driven results anywhere, so the 'fitted input called prediction' pattern is absent; (2) the only self-citations (Section 4.2: Gemma 3n, DolphinGemma, Battenberg et al. 2025, Scheibler et al. 2025, etc.) are usage examples, not load-bearing premises for the correctness guarantee; (3) no uniqueness theorems are imported from prior author work, and no ansatz is smuggled in via citation; (4) the output-ratio, block-size, latency, and receptive-field properties are defined quantities, and the verify_contract receptive-field check compares a hand-computed formula against an independent gradient-based calculation, which is self-consistency testing rather than circularity. The single definitional reduction is the equivalence guarantee itself: Section 2.2 states the contract is 'the set of requirements a SequenceLayer must implement to be considered correct,' so 'correct' means contract compliance, and the claim that streaming is correct by default restates that definition plus the empirically tested assertion that shipped layers comply. The skeptic's floating-point-tolerance and test-coverage objections concern the strength of the evidence, not circular reasoning, and per the analysis rules they belong to correctness risk rather than to this score. Because the paper is self-contained, its claims are externally falsifiable by running verify_contract on the released code, and no derivation reduces to its own inputs in a damaging way, the circularity score is 1.

Assumptions & free parameters 0 free parameters · 2 assumptions · 0 invented entities

The paper introduces no fitted parameters or new physical entities. Its central claims rest on the correctness of the testing approach and on the fixed-shape compilation constraint of deep learning frameworks.

assumptions (2)
  • domain assumption Layer-step equivalence can be sufficiently verified by randomized tests
    The paper's correctness story depends on verify_contract, which uses random inputs and parameters, not exhaustive or formal verification (Section 2.2).
  • domain assumption Compiled JAX/TensorFlow programs require fixed input/output shapes
    This motivates the constant output ratio and block size requirements (Section 2.1.1).

how reviews work

0 comments
Cite this review

Pith. "Pith review of SequenceLayers: Sequence Processing and Streaming Neural Networks Made Easy." pith.science (2026). https://pith.science/paper/B3T7LLY3

@misc{pith2026250723292,
  author       = {Pith},
  title        = {Pith review of: SequenceLayers: Sequence Processing and Streaming Neural Networks Made Easy},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/B3T7LLY3}},
  note         = {Machine review of arXiv:2507.23292}
}
read the original abstract

We introduce a neural network layer API and library for sequence modeling, designed for easy creation of sequence models that can be executed both layer-by-layer (e.g., teacher-forced training) and step-by-step (e.g., autoregressive sampling). To achieve this, layers define an explicit representation of their state over time (e.g., a Transformer KV cache, a convolution buffer, an RNN hidden state), and a step method that evolves that state, tested to give identical results to a stateless layer-wise invocation. This and other aspects of the SequenceLayers contract enables complex models to be immediately streamable, mitigates a wide range of common bugs arising in both streaming and parallel sequence processing, and can be implemented in any deep learning library. A composable and declarative API, along with a comprehensive suite of layers and combinators, streamlines the construction of production-scale models from simple streamable components while preserving strong correctness guarantees. Our current implementations of SequenceLayers (JAX, TensorFlow 2) are available at https://github.com/google/sequence-layers.

Figures

Figures reproduced from arXiv: 2507.23292 by the authors.

Figure 1
Figure 1. Imperative forward pass definition of a Transformer block in Flax, versus a declarative definition in [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Example demonstrating the Sequence and MaskedSequence primitives. 2.1 Streamable: The SequenceLayer Type SequenceLayer is a Python class which defines the basic API and functionality required to achieve the goals of the library. The fundamental methods of the API are: • layer: Sequence -> Sequence: Process a sequence x layer-wise and return a new sequence y. • get_initial_state: State: Returns a pytree of state arra… view at source ↗
Figure 3
Figure 3. Example demonstrating layer-wise and step-wise execution of a [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: Demonstration of layer / step equivalence when the [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]
Figure 5
Figure 5. Figure 5: Demonstration of the receptive_field property for various layers. • A step-wise application with 2 × block_size produces identical outputs to the layer-wise output. • The layer’s behavior is consistent with its metadata (get_output_spec, input_latency, output_latency, …
Figure 6
Figure 6. Figure 6: The Serial combinator. 2.3.2 The Parallel Combinator The Parallel combinator enables processing an input sequence in parallel by two or more SequenceLayers, combining the result at the end according to a fixed number of broadcasted combination strategies (for exam￾ple,…
Figure 7
Figure 7. Figure 7: The Repeat combinator. 2.3.5 The Bidirectional Combinator The Bidirectional combinator processes its input in the forward direction with a forward layer, and in the backward direction with a backward layer, and then combines the resulting forward and backward sequences…
Figure 8
Figure 8. Figure 8: The Blockwise combinator. • The latency (delay or lookahead) in sequence time (not wallclock time) induced by the module. • The receptive field of the module; the causal relationship between inputs and outputs of the layer. • The compute profile (the wallclock processi…
Figure 9
Figure 9. Figure 9: The configuration dataclass pattern in JAX SequenceLayers. [PITH_FULL_IMAGE:figures/full_fig_p014_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

29 extracted references · 22 canonical work pages

  1. [1]

    Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng

    Mart \' n Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek Gordon Murray, Benoit Steiner, Paul A. Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. Tensor F low: A syst...

    work page 2016

  2. [2]

    Neural machine translation by jointly learning to align and translate

    Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In ICLR , 2015

    work page 2015

  3. [3]

    Eric Battenberg, R. J. Skerry - Ryan, Daisy Stanton, Soroosh Mariooryad, Matt Shannon, Julian Salazar, and David Kao. Robust and unbounded length generalization in autoregressive transformer-based text-to-speech. In NAACL (Long Papers) , pp.\ 11789--11806. Association for Computational Linguistics, 2025

    work page 2025

  4. [4]

    Keras: The P ython deep learning library

    Fran c ois Chollet et al. Keras: The P ython deep learning library. Astrophysics source code library, pp.\ ascl--1806, 2018

    work page 2018

  5. [5]

    Carbonell, Quoc Viet Le, and Ruslan Salakhutdinov

    Zihang Dai, Zhilin Yang, Yiming Yang, Jaime G. Carbonell, Quoc Viet Le, and Ruslan Salakhutdinov. Transformer- XL : Attentive language models beyond a fixed-length context. In ACL (1) , pp.\ 2978--2988. Association for Computational Linguistics, 2019

    work page 2019

  6. [6]

    Protocol buffers, 2008

    Jeff Dean, Sanjay Ghemawat, et al. Protocol buffers, 2008

    work page 2008

  7. [7]

    Compiling machine learning programs via high-level tracing

    Roy Frostig, Matthew James Johnson, and Chris Leary. Compiling machine learning programs via high-level tracing. Systems for Machine Learning, 4 0 (9), 2018

    work page 2018

  8. [8]

    MLX : Efficient and flexible machine learning on A pple silicon, 2023

    Awni Hannun, Jagrit Digani, Angelos Katharopoulos, and Ronan Collobert. MLX : Efficient and flexible machine learning on A pple silicon, 2023. URL https://github.com/ml-explore

    work page 2023

Show all 29 references
  1. [9]

    Deep residual learning for image recognition

    Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR , pp.\ 770--778. IEEE Computer Society, 2016

    2016

  2. [10]

    F lax: A neural network library and ecosystem for JAX , 2024

    Jonathan Heek, Anselm Levskaya, Avital Oliver, Marvin Ritter, Bertrand Rondepierre, Andreas Steiner, and Marc van Z ee. F lax: A neural network library and ecosystem for JAX , 2024. URL http://github.com/google/flax

    2024

  3. [11]

    Mediapipe: A framework for building perception pipelines

    Camillo Lugaresi, Jiuqiang Tang, Hadon Nash, Chris McClanahan, Esha Uboweja, Michael Hays, Fan Zhang, Chuo - Ling Chang, Ming Guang Yong, Juhyun Lee, Wan - Teh Chang, Wei Hua, Manfred Georg, and Matthias Grundmann. Mediapipe: A framework for building perception pipelines. CoRR...

    1906 arXiv

  4. [12]

    Soroosh Mariooryad, Matt Shannon, Siyuan Ma, Tom Bagby, David Kao, Daisy Stanton, Eric Battenberg, and R. J. Skerry - Ryan. Learning the joint distribution of two sequences using little or no paired data. CoRR, abs/2212.03232, 2022

    2022 arXiv

  5. [13]

    Trax — deep learning with clear code and speed, 2019

    Afroz Mohiuddin et al. Trax — deep learning with clear code and speed, 2019. URL https://github.com/google/trax

    2019

  6. [14]

    Tensor F low- S erving: Flexible, high-performance ML serving

    Christopher Olston, Fangwei Li, Jeremiah Harmsen, Jordan Soyke, Kiril Gorovoy, Li Lao, Noah Fiedel, Sukriti Ramesh, and Vinu Rajashekhar. Tensor F low- S erving: Flexible, high-performance ML serving. In Workshop on ML Systems at NIPS 2017, 2017

    2017

  7. [15]

    Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala

    Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas K \" o pf, Edward Z. Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Stei...

    2019

  8. [16]

    Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. J. Mach. Learn. Res., 21: 0 140:1--140:67, 2020

    2020

  9. [17]

    Adam Roberts, Hyung Won Chung, Gaurav Mishra, Anselm Levskaya, James Bradbury, Daniel Andor, Sharan Narang, Brian Lester, Colin Gaffney, Afroz Mohiuddin, Curtis Hawthorne, Aitor Lewkowycz, Alex Salcianu, Marc van Zee, Jacob Austin, Sebastian Goodman, Livio Baldini Soares, Hait...

    2023

  10. [18]

    XLA : Compiling machine learning for peak performance, 2020

    Amit Sabne. XLA : Compiling machine learning for peak performance, 2020

    2020

  11. [19]

    Hershey, Arnaud Doucet, and Henry Li

    Robin Scheibler, John R. Hershey, Arnaud Doucet, and Henry Li. Source separation by flow matching. CoRR, abs/2505.16119, 2025

    2025 arXiv

  12. [20]

    Self-attention with relative position representations

    Peter Shaw, Jakob Uszkoreit, and Ashish Vaswani. Self-attention with relative position representations. In NAACL-HLT (2) , pp.\ 464--468. Association for Computational Linguistics, 2018

    2018

  13. [21]

    Jonathan Shen, Patrick Nguyen, Yonghui Wu, Zhifeng Chen, Mia Xu Chen, Ye Jia, Anjuli Kannan, Tara N. Sainath, Yuan Cao, Chung - Cheng Chiu, Yanzhang He, Jan Chorowski, Smit Hinsu, Stella Laurenzo, James Qin, Orhan Firat, Wolfgang Macherey, Suyog Gupta, Ankur Bapna, Shuyuan Zha...

    1902 arXiv

  14. [22]

    Daisy Stanton, Matt Shannon, Soroosh Mariooryad, R. J. Skerry - Ryan, Eric Battenberg, Tom Bagby, and David Kao. Speaker generation. In ICASSP , pp.\ 7897--7901. IEEE , 2022

    2022

  15. [23]

    You only cache once: Decoder-decoder architectures for language models

    Yutao Sun, Li Dong, Yi Zhu, Shaohan Huang, Wenhui Wang, Shuming Ma, Quanlu Zhang, Jianyong Wang, and Furu Wei. You only cache once: Decoder-decoder architectures for language models. In NeurIPS, 2024

    2024

  16. [24]

    Gomez, Lukasz Kaiser, and Illia Polosukhin

    Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NIPS , pp.\ 5998--6008, 2017

    2017

  17. [25]

    Yuxuan Wang, R. J. Skerry - Ryan, Daisy Stanton, Yonghui Wu, Ron J. Weiss, Navdeep Jaitly, Zongheng Yang, Ying Xiao, Zhifeng Chen, Samy Bengio, Quoc V. Le, Yannis Agiomyrgiannakis, Rob Clark, and Rif A. Saurous. Tacotron: Towards end-to-end speech synthesis. In INTERSPEECH , p...

  18. [26]

    Yuxuan Wang, Daisy Stanton, Yu Zhang, R. J. Skerry - Ryan, Eric Battenberg, Joel Shor, Ying Xiao, Ye Jia, Fei Ren, and Rif A. Saurous. Style tokens: Unsupervised style modeling, control and transfer in end-to-end speech synthesis. In ICML , volume 80 of Proceedings of Machine ...

    2018

  19. [27]

    Weiss, R

    Ron J. Weiss, R. J. Skerry - Ryan, Eric Battenberg, Soroosh Mariooryad, and Diederik P. Kingma. Wave- T acotron: Spectrogram-free end-to-end text-to-speech synthesis. In ICASSP , pp.\ 5679--5683. IEEE , 2021

    2021

  20. [28]

    Hugging F ace's T ransformers: State-of-the-art natural language processing

    Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, R \' e mi Louf, Morgan Funtowicz, and Jamie Brew. Hugging F ace's T ransformers: State-of-the-art natural language processing. CoRR, abs/1910.03771, 2019

    1910 arXiv

  21. [29]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.