Cutting Spontaneous Japanese Lectures Where No Dependencies Cross

Neural models with fixed input limits have to read long speech transcripts in pieces. The standard fixes are to cut at a fixed token count and either accept the damage at the edges or overlap neighbouring windows heavily. Fifty percent overlap, for example, means every token is processed twice. This proposal asks a narrower and more answerable question: in spontaneous Japanese lectures, can we choose cut points so that almost no grammatical links are severed? If so, near-disjoint windows could match the accuracy of heavy overlap at roughly half the compute. Japanese makes this plausible. Its grammar is organised around the bunsetsu, a short phrase made of a content word plus its particles, and nearly every bunsetsu attaches to a head somewhere to its right. At any gap between words we can therefore ask how many unresolved attachments are still "open" across it. The best places to cut are gaps where that count is near zero.

The Corpus of Spontaneous Japanese (CSJ) is the right testbed. It holds roughly 7 million words of unscripted academic and public-speaking monologues. Part of it carries gold annotation of word units, sentence boundaries, filler and disfluency tags, and bunsetsu dependencies. That last layer lets us measure exactly how many links each candidate cut destroys, and how much downstream accuracy that costs. Spontaneous speech is also where naive cuts hurt most, because punctuation is absent, sentences run on, and pauses often fall mid-phrase before fillers.

Core Claim

We claim that a cheap, local predictor of "dependency mass crossing this gap," combined with a dynamic program that places cuts under a length budget, gives bunsetsu parsing and disfluency tagging on CSJ lectures the accuracy of 50%-overlap sliding windows. It would do so while processing close to one pass over the input, and it would beat pause-based and sentence-boundary-based cutting at equal compute. Overlap stops being uniform. A small margin is added only at the few cuts the predictor flags as risky.

Let $p(h,d)$ be the model's probability that bunsetsu $d$ attaches to head $h$. The cost of cutting at gap $c$ is the expected number of attachments spanning it:

$$\mathrm{cost}(c)=\sum_{(h,d)} p(h,d)\,\mathbf{1}[\min(h,d)\le c<\max(h,d)].$$

We choose the set of cuts $C$ that minimises $\sum_{c\in C}\mathrm{cost}(c)$, subject to every segment being at most $L$ tokens long. A standard segmentation dynamic program solves this in $O(nL)$ time for a transcript of $n$ tokens.

There is an obvious circularity: we need dependencies to choose cuts, and cuts to get dependencies. We resolve it by never running the full parser to compute costs. Instead, a small tagger reads a local window of word, part-of-speech, pause, and clause-boundary features and predicts the crossing count directly. It is trained on counts computed from gold arcs. Two findings suggest this signal is learnable from local context. Bunsetsu boundaries are predictable from a four-word history with 91.27% accuracy on written Japanese (N-gram language modeling of Japanese using bunsetsu boundaries). Dependency probabilities and incoming-arc counts were among the most useful features for sentence boundary detection in CSJ (Dependency structure analysis and sentence boundary detection in spontaneous Japanese).

Relation to Prior Work

The proposal is motivated by evidence that cuts in spontaneous Japanese are costly, though nobody has optimised them for windowed neural processing. Kawahara et al. showed that sentence boundaries and dependency structure inform each other. In their system, predicted SVM boundaries raised CSJ dependency accuracy from 75.21% to 81.20%. They treated the boundary as a linguistic target, however, not as a compute-constrained window edge. Matsubara et al. relaxed head-final constraints for conversational Japanese and reached 87.0% overall parsing accuracy, yet links spanning utterance units reached only 6.5% precision (Robust dependency parsing of spontaneous Japanese speech and its evaluation; Stochastic Dependency Parsing of Spontaneous Japanese Spoken Language). This tells us cross-unit links are rare, which supports cheap cuts. It also tells us that the links which do cross are exactly what gets lost, which supports the adaptive margin. Their inverted, right-to-left dependencies also constrain the design: the cost must count arcs in both directions, as the equation above does.

Three segmentation methods supply the alternatives we compete with. Fixed 50% overlap is recommended as a cost-quality trade-off in code editing (InstructCoder). Fixed segments with left and right context frames plus a memory bank are used for streaming speech translation (Augmented Memory Transformer). A dynamic sliding window lets a summariser predict where its own next window should start (Dynamic Sliding Window for Meeting Summarization). All three place edges either blindly or from a generator's output. None uses an explicit measure of what a cut destroys, and none was tested on Japanese.

Two further papers bear on the cost of reading whole documents. Chunk-level processing beat full-document processing for transcript cleanup in Recording for Eyes, Not Echoing to Ears, with its chunks cut at fixed 1.5K tokens. That paper motivates segmentation over monolithic reading, and we test whether better-placed chunk edges help there too. The CSJ morphological work (Morphological Analysis of a Large Spontaneous Speech Corpus in Japanese) strips fillers before analysis and reinserts them afterwards. We do the opposite and keep fillers inside windows, because they are both targets and cues: hesitation pauses before fillers are precisely where pause-based cutting goes wrong.

Research Program

We would build three components and then analyse them. The first is a gold crossing-count table for the dependency-annotated CSJ talks, using the 178/15/10 train/held-out/test talk split of Kawahara et al. so results stay comparable. This table yields an oracle cost for every gap. It also yields a descriptive result of its own: how cross-cut dependency mass is distributed in spontaneous monologue, and how it differs between long pauses, clause boundaries, and sentence ends.

The second component is the crossing-count tagger described above, together with the dynamic program that places cuts.

The third is a set of downstream models. These are a Japanese pretrained transformer encoder fine-tuned for bunsetsu dependency parsing and for filler/disfluency tagging against CSJ's gold tags. They run with window length $L$ deliberately set below typical lecture length. Every segmentation method feeds the same downstream models.

The analysis then measures accuracy as a function of distance from the nearest cut, and accuracy against compute. We report compute as tokens processed per input token.

Baselines

The naive reference point is disjoint fixed-length windows of $L$ tokens with no overlap. That is one pass of compute. It sets the floor and shows how large the edge damage is.

The strongest generic competitor is fixed sliding windows with 50% overlap, keeping each token's prediction from the window where it sits farthest from an edge, in the style of InstructCoder. It costs about two passes and is the accuracy target. The file contains no reported number for this setting on CSJ. We run it ourselves with the same encoder, the same $L$, and the same fine-tuning budget, and we also sweep overlap at 12.5%, 25%, and 50% to trace a full compute-accuracy curve.

The linguistically informed competitors are cut placements chosen by other signals. One cuts at pauses over 500 ms, the threshold used in CSJ morphological work. One cuts at predicted sentence boundaries from a reimplemented boundary detector. The closest prior result on this detector is Kawahara et al.'s SVM, with sentence-boundary F-measure of 84.85% closed and 84.38% open, and dependency accuracy of 81.20% (closed) when its boundaries are fed to a maximum-entropy parser. That figure comes from a different parser and full-sentence input, so it serves as context, not as a target to beat directly.

We also adapt Liu and Chen's dynamic window. A head on the encoder predicts the start of the next window, trained to land after the last token whose head is resolved. Its only reported number is ROUGE-1 52.83 against 48.31 for truncation on English meetings (AMI). No reported result exists on Lacuna for it on CSJ.

Two ablations isolate our key ingredient. The first replaces predicted costs with gold crossing counts, which gives the oracle upper bound. The second removes the adaptive margin, using cut placement alone.

Our method beats the field if it reaches within the confidence interval of 50% overlap on dependency accuracy and filler F1 at no more than 1.15 passes of compute. It must also beat pause cuts and sentence-boundary cuts at matched compute, with talk-level bootstrap intervals that exclude zero.

Why not just…?

Why not just use 50% overlap and pay for it? For offline batch use, doubling compute may be acceptable, and that is the honest objection. The answer is the compute-accuracy curve. If overlap at 12.5% already matches 50%, cheap uniform overlap wins, and our contribution shrinks to a negative result about where cuts matter. We report that outcome if it happens. The case for cost-aware cutting rests on edge damage being concentrated at a few high-cost gaps. The oracle analysis measures this directly.

Why not just cut at long pauses or at predicted sentence ends? This is the real threat, because pauses are free and sentence ends are where crossing mass is lowest. Two pieces of evidence count against it. Kawahara et al. needed morphology, clause tags, and dependency features beyond pause to reach 84.85% boundary F-measure, so pause alone misplaces many boundaries. In lecture speech, hesitation pauses also cluster before fillers, in the middle of phrases. Even so, sentence-boundary cuts may capture most of the gain. The pause, sentence-end, and predicted-cost comparison at matched $L$ settles this. If sentence-end cutting is within noise of predicted-cost cutting, we would adopt it and redirect the work toward the adaptive margin alone.

Why not just feed whole lectures to a long-context model? Encoders fine-tuned for parsing have hard input limits. For generative cleanup, full-document input caused paragraph drift relative to 1.5K-token chunks in Recording for Eyes, Not Echoing to Ears. We include a secondary experiment that runs LLM spoken-to-written conversion on CSJ lectures in three ways: full document, fixed 1.5K chunks, and cost-aware chunks of the same mean size. We score faithfulness by alignment between source and output bunsetsu, and by retention of gold-tagged non-filler content.

Why not just use a memory bank as in the Augmented Memory Transformer? Summarised memory carries topic forward, but it cannot repair a severed attachment between two specific bunsetsu. We test a memory-augmented variant of the fixed-window baseline. If its accuracy near cuts matches ours, memory is the cheaper fix.

Decisive Checks

The first check decides whether the project is worth pursuing. Using gold crossing counts, oracle-placed disjoint cuts must recover most of the gap between disjoint fixed windows and 50% overlap on bunsetsu attachment accuracy within 32 tokens of a cut. If oracle cuts do not help, no predictor will, and we stop.

The second check asks whether the learned tagger keeps most of the oracle's gain. We measure this through the correlation between predicted and gold crossing counts, and through the downstream accuracy gap between predicted and oracle cuts.

The third check asks whether the gain survives against sentence-boundary cutting at equal compute, and whether it is concentrated, as predicted, on the rare cross-unit links where existing parsers reach only 6.5% precision.

All results are reported per talk, with bootstrap intervals over the 10 test talks. Because 10 talks is a small test set, we add a second evaluation by cross-validating over talks.