Rhetorical Discourse Analysis Machine (rdam)

rdam runs several discourse and argumentation techniques on one source document, natively and side by side, and reports one explicit outcome per technique. It never collapses them into a common formalism, never generates or rewrites text, and reports the locally checked prerequisites separately from actual runtime success. It serves one person on one local machine.

  text / file / bytes → rdam.ingest → one complete inventory
                                          ↓
                                provider-specific projections
                                          ↓
                       RST · PDTB · SDRT · Toulmin · Walton
                                          ↓
  supplied structures → Dung · IBIS → separate native outcomes

Contents

• What is in the package
• Design principles
• Installation
• Using the machine
• Provider: RST (rdam.rst)
• Provider: Dung abstract argumentation (rdam.dung)
• Provider: IBIS (rdam.ibis)
• Repository layout
• Development, gates, and release
• Status and roadmap
• Provenance and licence
• Citation

What is in the package

One distribution, one import package, every technique a sub-package.

Sub-package	Technique	Provides	Availability requirement
rdam	the machine	Python API, unified rdam CLI, optional HTTP API, shared requests and native results	—
rdam.ingest	shared source preparation	complete inventory, provider requirements, projections, source anchors, and receipts	source-form dependencies
rdam.rst	RST	DMRST and UniRST discourse parsers, the RS3 viewer, and the machine adapter	configured parser
rdam.dung	Dung abstract argumentation	grounded, complete, preferred, and stable extensions of a supplied argument–attack framework, exact by construction	available
rdam.ibis	IBIS	issue–position–argument structures validated under the gIBIS link grammar and organised into a deliberation map	available
rdam.sdrt	SDRT	validated SDRS graphs	configured language model
rdam.toulmin	Toulmin	claims, grounds, warrants, backing, qualifiers and rebuttals	configured language model
rdam.walton	Walton	scheme instances and critical questions	configured language model
rdam.pdtb	PDTB	source-validated discourse relations and connective spans	configured language model

Design principles

• Native, side by side. Each technique keeps its own formalism, relation inventory, and result payload. The machine hands a provider's own outcome envelope back verbatim; it does not translate RST trees into argument graphs or vice versa.
• Analysis only. The machine describes discourse. It has no generation or rewriting path, by design and by contract.
• One outcome per technique, always. analyse() returns exactly one of ResultOutcome, UnavailableOutcome(reason), or FailedOutcome(failure) for every requested technique. A failure in one technique never hides a result in another; the machine never adds retries; internal bugs propagate instead of being relabelled. Native model boundaries retain their explicit bounded retry policies.
• Capabilities state what was checked. A provider is available when its local prerequisites resolve. No remote model probe is performed: credentials or a known model name do not prove a remote call will succeed. Otherwise it is unavailable with one of three stable reasons — not_implemented, model_unavailable, missing_structured_input — and never a stub.
• Structure in, structure out. Formal techniques (Dung, IBIS) take a supplied structure and never extract one from text. A text-only request for them is unavailable(missing_structured_input), not a guess.
• One person, one machine. No multi-user, distributed, or enterprise machinery. Pixi-managed, Apple-Silicon-first, MPS-aware, with a real test suite and CI.

Installation

In this checkout:

git clone https://github.com/Steve-Allison/Rhetorical_Discourse_Analysis_Machine.git
cd Rhetorical_Discourse_Analysis_Machine
pixi install -e production
pixi run -e production production-import-check

For another local project using Python 3.14, install the built wheel from this checkout (use its absolute path when working elsewhere):

pip install dist/6.1.0/rdam-6.1.0-py3-none-any.whl
pip install "dist/6.1.0/rdam-6.1.0-py3-none-any.whl[formats,http]"

The source archive is dist/6.1.0/rdam-6.1.0.tar.gz. The local package build uses an isolated local snapshot of the current package inputs; its packaged provenance names that snapshot commit, not the older main-repository tag. These are local artifacts; GitHub installation uses the remote commit, which may differ from this checkout. production-import-check checks the editable source, not the distributable wheel.

No model weight ships in the wheel. The machine defaults to the published gumrrg DMRST checkpoint at its pinned source commit, using the encoder it was trained with: xlm-roberta-large at a pinned revision. A manifest- and hash-validated local release can be selected explicitly when complete local component receipts are required. Known release identifiers include DMRST models (gumrrg-eb1d5745f3a1, rstdt-cc01afde1232) and UniRST models (unirst-9407970f1d9d). Their presence in a model store must be checked locally. Dung and IBIS need nothing beyond the package.

Development uses the default environment (pixi install, then pixi run test).

Using the machine

The primary entry point is production_machine(config=MachineConfig(...)). Python, rdam and optional rdam[http] all use this same engine. Configuration is explicit and immutable; per-technique model choices override the shared model. Discovery reports configuration without probing model availability on the network (model_probe: not_performed). Analysis supplies the runtime verdict.

from rdam import AggregateRequest, LlmSettings, MachineConfig, Technique, production_machine, serialize

machine = production_machine(config=MachineConfig(llm=LlmSettings(model="openai:gpt-5.6-sol")))
request = AggregateRequest.for_text("Because it rained, the match stopped.", (Technique.TOULMIN, Technique.WALTON))
analysis = machine.analyse(request)
json_bytes = serialize(analysis)

For immediate AI consumption, read status, requested_techniques, and the embedded reading_guide, then the corresponding complete native outcomes. Guides explain native meanings, source-evidence roles and limitations; they are not confidence or truth scores. Walton questions explicitly distinguish addressed, open and not_assessable. Toulmin warrants distinguish explicit, reconstructed and undetermined, with source evidence or a reason. Supporting text is not proof that an inference is correct. Retained upstream results are separate from requested outcomes and cannot improve completion status.

For custom provider composition:

from pathlib import Path

from rdam import AggregateRequest, Machine, ResultOutcome, StructuredInput, Technique
from rdam.dung import DungProvider
from rdam.ibis import IbisProvider
from rdam.rst.provider import RstProvider

machine = Machine(
    [
        RstProvider(store=Path("models/model-releases"), release_id="gumrrg-eb1d5745f3a1"),
        DungProvider(),
        IbisProvider(),
    ]
)

Capabilities are reported without loading model weights — one state per technique, including the techniques that have no provider. The example RST state below requires the named release to exist and validate in the configured store:

for item in machine.capabilities().techniques:
    print(item.technique.value, item.capability)
# rst    AvailableCapability(provider_id='rdam.rst/gumrrg-eb1d5745f3a1', ...)
# pdtb   UnavailableCapability(reason='not_implemented')
# ...
# dung   AvailableCapability(provider_id='rdam.dung/exhaustive-subset-v1', ...)
# ibis   AvailableCapability(provider_id='rdam.ibis/gibis-grammar-v1', ...)

Text in, one outcome per technique out:

aggregate = machine.analyse(AggregateRequest.for_text("Because it rained, the match stopped.", (Technique.RST, Technique.SDRT)))
for outcome in aggregate.outcomes:
    print(outcome)                      # ResultOutcome | UnavailableOutcome | FailedOutcome
rst = aggregate.outcome_for(Technique.RST)
if isinstance(rst, ResultOutcome):
    print(rst.result.payload["kind"])  # the RST provider's own outcome envelope, verbatim

Structure in, for the formal techniques:

framework = {"arguments": ["a", "b", "c"], "attacks": [["a", "b"], ["b", "c"]]}
request = AggregateRequest.for_structured(
    (StructuredInput(technique=Technique.DUNG, payload=framework),),
    techniques=(Technique.DUNG,),
)
dung = machine.analyse(request).outcome_for(Technique.DUNG)
if isinstance(dung, ResultOutcome):
    print(dung.result.payload["extensions"]["grounded"])  # ['a', 'c']

A malformed structure is a FailedOutcome with a stable code and a declared retryability (invalid_argumentation_framework, not_retryable); a text-only request for Dung or IBIS is UnavailableOutcome(reason='missing_structured_input'). Every AggregateAnalysis serializes to RFC 8785 canonical JSON with a self-checking semantic_digest.

Lineage, declared not inferred. If you built a framework from an earlier RST result, after checking isinstance(rst, ResultOutcome), carry that exact result in the request and name it from the structured input. The machine re-emits the upstream result untouched, the Dung payload records input_origin: explicitly_derived with the upstream identity, and the aggregate's lineage names both provider identities and the upstream artifact's digest. The machine never derives one technique's input from another's output itself.

from rdam import UpstreamResultReference

request = AggregateRequest(
    source=rst.result.source,
    text=None,
    techniques=(Technique.DUNG,),
    structured_inputs=(
        StructuredInput(
            technique=Technique.DUNG,
            payload=framework,
            derived_from=UpstreamResultReference(technique=Technique.RST, result_identity=rst.result.semantic_digest),
        ),
    ),
    upstream_results=(rst.result,),
)
print(machine.analyse(request).lineage)

Capability and provenance

Documents and provider projections

from pathlib import Path
from rdam import AggregateRequest, Technique, production_machine

machine = production_machine()
request = AggregateRequest.for_source(
    Path("tests/fixtures/pipeline/tabular-evidence.md"),
    (Technique.RST, Technique.TOULMIN, Technique.WALTON),
)
aggregate = machine.analyse(request)
assert aggregate.preparation is not None
print(len(aggregate.preparation.preparation.inventory))
print(len(aggregate.preparation.projections))

for_bytes(payload, source_form, source_name, techniques) accepts materialized bytes; for_text accepts a string. Construction identifies the exact bytes but does not inventory them or load a model. rdam.ingest.describe_capabilities() is the sole source-form authority, including optional-dependency availability.

Each aggregate inventories once and computes one projection per distinct provider requirement. Toulmin and Walton admit table evidence, with cell coordinates and explicit linearisation records; RST retains tables without admitting them to prose analysis. Speakers are resolved from source evidence or explicitly unresolved. Dung and IBIS receive supplied structures, never text projections. Native findings can carry source_alignment references to shared items and anchors without merging their formalisms.

Execution and caching

ExecutionPolicy(max_workers=4) is the default, bounded to one through seven in-process workers. Outcomes retain request order. Providers declaring concurrent safety are not locked; serialized providers share a lifetime-bounded lock across machine instances. Typed failures preserve other successes; programming errors propagate and no partial aggregate is returned.

Caching is opt-in through MachineConfig(execution=ExecutionSettings( cache_directory=Path("cache"))) for production_machine, or ExecutionPolicy(cache_directory=Path("cache")) for direct Machine composition. The key binds source, projection, provider, contract, model and instructions identities. Dirty source revisions bypass caching. Invalid cache entries are reported and recomputed. Native artifact_digest covers execution details too; semantic_digest excludes only execution fields declared by the provider, so run timing does not change aggregate analytical identity.

Provider availability

A technique is available when its checked local prerequisites resolve, and unavailable with a stable reason otherwise. Discovery does not certify remote service availability. There are exactly three reasons:

reason	meaning
not_implemented	no provider exists for this technique
model_unavailable	a provider exists but its configured model does not resolve
missing_structured_input	Dung or IBIS was asked without the structure it requires

rdam.dung and rdam.ibis are exact and deterministic, so they are available whenever imported. rdam.rst is available when the configured parser version is one the façade knows how to load, or when the named local model release validates; neither check loads a model or touches the network.

Every provider declares its own provenance to the machine — package, version, source digest, model identity where it has one, and the licence its code and weights carry — and that provenance travels on every native result. Releases such as gumrrg-eb1d5745f3a1 and unirst-9407970f1d9d provide production discourse tree parsing through RstProvider and Parser.

Provider: RST (rdam.rst)

Rhetorical Structure Theory parsing from raw text or exact pre-segmented EDUs. The production formalism is rst_tree. Extended RST is confined to the offline workbench for testing and evaluation.

Command line

# Canonical analysis of text, or of a Markdown / Docling JSON / DocLang / plain-text file
rdam analyse --text "Because it rained, the match stopped." --techniques rst
rdam analyse report.md --techniques rst,toulmin,walton --output analysis.json
rdam summary analysis.json                              # optional terminal inspection
rdam view analysis.json --techniques walton              # whole native result, no rerun
rdam prepare report.md                                  # complete inventory, no inference
rdam capabilities                                      # model-free discovery
rdam schema request                                    # machine-readable JSON Schema
rdam serve --port 8080                                  # requires rdam[http]
rdam version

Files or stdin (-) go in; canonical JSON goes to stdout and diagnostics to stderr. Analysis exits are 0 complete, 3 partial and 4 unsuccessful; operational failures exit 1, invalid input 2, interruption 130 and broken pipe 141. File output is atomic and refuses replacement unless --force is explicit; inputs can never be overwritten. Dung and IBIS take --structured dung=framework.json and --structured ibis=map.json, never inferred graphs.

serve binds only to 127.0.0.1 or ::1. Routes are POST /v1/prepare, /v1/analyse, /v1/view, /v1/summary and GET /v1/capabilities, /v1/version, /v1/schemas/{record}. JSON routes use the Python codecs. One POST is admitted at a time; discovery stays responsive. No model or source configuration is accepted from HTTP requests.

Python

from pathlib import Path

from rdam.rst import Parser, RstDocument
from rdam.rst.utils.analysis import tree_stats

# Load from an immutable model release:
parser = Parser.from_model_release(
    Path.home() / ".cache/isanlp_rst/model-releases",
    "gumrrg-eb1d5745f3a1",
    device="auto",  # CUDA if present, else MPS on Apple Silicon, else CPU
)
# Or initialize from published model weights:
# parser = Parser(hf_model_version="gumrrg", device="auto")

text = "On Saturday, Team India won against South Africa by seven runs. The final was played in Barbados."

tree = parser(text)["rst"][0]                      # DiscourseUnit tree, original-text character offsets
print(tree_stats(tree)["depth"], tree_stats(tree)["n_leaves"])

tree = parser.from_edus(["On Saturday, Team India won against South Africa by seven runs.", "The final was played in Barbados."])["rst"][0]

analysis = parser.parse_document(RstDocument.from_text(text, document_id="cricket"), output="rst_tree")
print(len(analysis.nodes), len(analysis.primary_edges))   # canonical RstAnalysis graph

Each DiscourseUnit node carries id, left, right, relation, nuclearity (NS / SN / NN), entropy, start, end, and text; leaves are EDUs. When holding many trees, tree.clear_textfields() drops the substrings and tree.fill_textfields(full_text) restores them.

device= accepts "auto", "cpu", "mps", "cuda", "cuda:N", or a torch.device. dtype= (bf16 / fp16 / fp32, or a torch.dtype) runs the forward pass under torch.autocast; the default is float32 everywhere. The dtype regression suite checks topology and segmentation on its fixtures; it does not prove universal equivalence. Relation labels on near-tied nodes can flip under reduced precision (tests/integration/test_integration.py).

Production source ingest

rdam.ingest is the one production boundary for real source material: plain text, exact pre-segmented EDUs, Markdown, DoclingDocument JSON, and DocLang XML or .dclx archives.

from pathlib import Path

from rdam.rst import Parser
from rdam.ingest import ProductionIngestor, SourceArtifact, describe_capabilities, serialize_contract

print(describe_capabilities().semantic.source_forms)   # all six forms and their availability, model-free

parser = Parser.from_model_release(Path.home() / ".cache/isanlp_rst/model-releases", "gumrrg-eb1d5745f3a1")
ingestor = ProductionIngestor(parser=parser)

outcome = ingestor.analyse(SourceArtifact.from_path(Path("report.md")), cache_directory=Path("cache"))
print(outcome.semantic.status)                 # analysed | empty_primary_discourse
analysis = outcome.semantic.analysis           # RstAnalysis, or None when nothing authored was found
preparation = outcome.semantic.preparation.semantic
print(preparation.inventory_coverage.covered_units == preparation.inventory_coverage.total_units)
assert outcome.semantic.validation is not None and outcome.semantic.validation.passed
canonical_bytes = serialize_contract(outcome)  # load_contract() reads it back identically

The source is inventoried completely first; the AUTHORED_PROSE_V1 policy then admits authored headings, prose, meaningful list items, and authored turns to primary RST analysis, and keeps tables, code, formulas, raw markup, pictures, metadata, fields, assets, machine-generated descriptions, notes, navigation, and furniture as receipted side channels. Source anchors survive into the analysis; long sources are subdivided at structure and parser-capacity boundaries and recombined into one anchored result; cache identity includes the complete pipeline fingerprint; failures are typed, staged, and private by default. Contract: docs/production-api-contract.md, docs/production-source-ingest.md.

Viewer, long documents, diagnostics

import rdam.rst as rst

tree.to_rs3("document.rs3")                 # RSTTool / rstWeb format
rst.render("document.rs3")                  # inline in Jupyter (colab=True in Colab)
rst.to_html("document.rs3", "document.html")
rst.to_png("document.rs3", "document.png")  # Playwright + Chromium: `playwright install chromium`
rst.to_pdf("document.rs3", "document.pdf")

• eRST is workbench-only. Signal detection, secondary-edge scoring and decoding, RS4 conversion, checkpoint handling and experimental contracts live in workbench/erst/. Production rejects erst_graph and has no eRST checkpoint option or automatic bundle loading. Passive saved-report data remains readable.
• Long documents: rdam.rst.hierarchical.HierarchicalSectionStitcher(parser).parse_hierarchical(document) parses each section, parses the macro relations across section roots, and stitches one globally consistent RstAnalysis.
• Diagnostics: pixi run rst-diag <paths> --model-store models/model-releases --release-id <id> reports prepared characters and segments, EDU and relation counts, the share of thin relations, tree skew, and every coverage ratio per source (--json for machine output).

Provider: Dung abstract argumentation (rdam.dung)

Formal evaluation of a supplied argumentation framework under the semantics Dung (1995) defines. Input is {"arguments": [...], "attacks": [[attacker, attacked], ...]}; the payload returned carries the framework as accepted, input_origin: supplied, the extensions under grounded, complete, preferred, and stable semantics, and the algorithm identity (exhaustive-subset v1, capacity 14 arguments).

Complete extensions are found by exhaustive enumeration of every candidate set under the declared capacity, so the result is exact by construction; grounded is computed independently by fixed-point iteration and checked against the enumerated complete extensions. A framework beyond capacity is refused with a typed failure (framework_exceeds_declared_capacity), never approximated. Invariants are tested exhaustively over all 512 three-argument frameworks and over seeded random frameworks (tests/dung). Semi-stable, ideal, and stage semantics, and larger frameworks, would be a new candidate with its own decision.

Provider: IBIS (rdam.ibis)

IBIS (Kunz & Rittel 1970) records deliberation as issues, positions, and arguments. The provider validates a supplied structure under the gIBIS link grammar (Conklin & Begeman 1988) and returns it organised, judging nothing:

relation	from	to
responds_to	position	issue
supports, objects_to	argument	position
generalizes, specializes, replaces	issue	issue
questions, is_suggested_by	issue	issue, position, argument

Every position responds to exactly one issue; every argument supports or objects to exactly one position; ids are unique; self-links are refused. Input is {"nodes": [{"id", "kind", "text"}], "links": [{"from", "relation", "to"}]}; the payload carries the structure as accepted, input_origin: supplied, extraction: None, the grammar id, and a map of each issue with its positions and their supporting and objecting arguments, plus the gaps (issues without positions, positions without arguments, isolated nodes). The type table is checked exhaustively for all 3 × 3 × 8 kind–kind–relation combinations (tests/ibis). Argument strength or acceptability is not assessed here. Dung computes formal acceptability under its supplied attack graph; neither provider measures real-world argument strength.

Repository layout

rdam/                        the distribution and import package — the machine
├── contracts.py, machine.py, composition.py, frameworks.py, serialization.py
├── resources/framework-identities.json   coe: identities projected from the vendored taxonomy
├── ingest/                  shared source inventory, projections, planning and anchors
├── cli.py, http.py           thin terminal and optional loopback interfaces
├── rst/                     RST provider: parser, converter, rstviewer, provider.py
├── pdtb/, sdrt/, toulmin/, walton/   independently validated model-backed techniques
├── dung/                    semantics.py, provider.py
└── ibis/                    grammar.py, provider.py
ontology/                    vendored Central distribution + the rdam LinkML profile (not shipped)
workbench/                   the one experimentation root: corpora, training, evaluation, research,
                             and the model-store release tooling
models/model-releases/       immutable local releases, each with its manifest and its
                             compatibility re-declaration sidecar
tools/production_boundary/   boundary inspection, reproducible build, artifact validation,
                             clean install, classified baseline comparison
tests/  specs/  docs/        verification, decision-closed feature records, documentation

Production code never imports workbench. The wheel has one Python import root, rdam/, plus distribution metadata; the sdist also includes the README, licenses and build configuration. pixi run production-boundary checks source ownership; pixi run validate-production-artifacts checks built archives. Each technique declares exactly one canonical framework identity from Central's coe:artifact/narrative/analytical_frameworks_taxonomy, referenced and never redefined (pixi run ontology-validate). Native discourse concept projections and retained Central snapshots also ship under rdam/resources/; Central_Configs remains the upstream authority, and mapping does not assert equivalence between formalisms.

Development, gates, and release

Every Python invocation goes through pixi; the task table in pyproject.toml is the authority (pixi task list).

pixi run lint && pixi run typecheck && pixi run test    # ruff, pyright strict, fast suite
pixi run mdlint                                         # markdownlint over the tracked Markdown
pixi run -e default production-boundary                 # import walk from rdam, ownership, dependencies
pixi run ontology-validate                              # LinkML profile, bindings, projection currency
pixi run smoke                                          # every stored release on every available device
pixi run test-all                                       # everything, including the slow model suites

For a clean committed source, build and check the package below. A tag is optional for building; when HEAD has a tag, it must match v<version> from pyproject.toml.

pixi run build-production                    # reproducible double build into ignored dist/<version>/
pixi run validate-production-artifacts       # RECORD, metadata, provenance, entry point, public surface
pixi run -e production production-clean-install \
  --model-store "$HOME/.cache/isanlp_rst/model-releases" \
  --release-id gumrrg-eb1d5745f3a1

Every release tool derives the distribution name and version from pyproject.toml; dist/ is never tracked, and the committed record is the evidence JSON under the feature that made the release. A stored model release runs under a later package line only through an evidence-backed, manifest-bound compatibility re-declaration (pixi run python -m workbench.promotion.compatibility --help), never by editing the immutable manifest. pixi run rst-baseline compare proves the RST public contract analytically equivalent across such changes, classifying every field-level difference before giving a verdict.

Status and roadmap

The active production scope is RST, PDTB, SDRT, Toulmin, Walton, Dung and IBIS, through Python, the unified rdam CLI and optional /v1/ HTTP routes. eRST is workbench-only following the owner's 2026-09-06 instruction. Its experimental implementation is excluded from the production distribution; no trained eRST accuracy or readiness is claimed.

The 2026-09-06 verification recorded 2,940 passing regression cases across two partitions, 14 distinct real-model scenarios, and four successful clean-install variants. These are dated results, not a promise that every model response will be analytically correct or that the project has demonstrated SOTA performance. See Feature 019 completion and limitations. The earlier 6.0.0 tag certification describes its original commit; it does not certify subsequent working-tree changes.

The current local five-text-technique Dvořák report is build/production-verification-2026-09-06/verified-production-report.json. Dung and IBIS were verified separately with supplied structures. The original build/real-document-reports/GUM_bio_dvorak.full-report.json remains historical. The remediation plan is build/real-document-reports/RDAM-remediation-plan.md. These ignored local files are not included in the distribution or a fresh clone. Analysis reports are canonical JSON for AI consumption; no companion text or HTML report is required.

The nested isanlp_rst.production contract writes 3.0.0 and reads historical 2.0.0 without rewriting its meaning. Machine record families have independent versions; use rdam version and rdam schema for the installed contracts. Persisted isanlp_rst identifiers are retained intentionally.

Documentation guide distinguishes current usage, approved requirements and historical evidence. Features 017–019 describe source preparation, shared runtime and unified interfaces; older feature records retain their dated results and must not be mistaken for current installation instructions.

Provenance and licence

This repository is Steve Allison's evolution of the IsaNLP RST Parser into the Rhetorical Discourse Analysis Machine. The original RST research code and the archived research model weights are by Elena Chistova; the MIT-licensed source carries her copyright. The machine, the Dung and IBIS providers, canonical source ingest, eRST completion, and the build and release tooling are Steve's own code.

• Source code: MIT — see LICENSE. Copyright Elena Chistova 2020 for the original parser; Steve Allison's contributions also under MIT.
• Production model weights (tchewik/isanlp_rst_v3 on HuggingFace, families rstdt, gumrrg, rstreebank, rrtrrg, unirst): CC BY-NC 4.0 — research and non-commercial use only, see LICENSE_MODELS. These models power PredictorDMRST and PredictorUniRST through Parser.
• Workbench research experiments: candidate architectures (e.g. ModernBERT) reside strictly under workbench/ and are evaluated against baselines before any production use.

Issues and pull requests: Steve-Allison/Rhetorical_Discourse_Analysis_Machine.

Citation

The archived research model weights are by Elena Chistova. If you use them in research, please cite:

For rstdt, gumrrg, and rstreebank:

@inproceedings{chistova-2024-bilingual,
 title = "Bilingual Rhetorical Structure Parsing with Large Parallel Annotations",
 author = "Chistova, Elena",
 booktitle = "Findings of the Association for Computational Linguistics ACL 2024",
 month = aug,
 year = "2024",
 address = "Bangkok, Thailand and virtual meeting",
 publisher = "Association for Computational Linguistics",
 url = "https://aclanthology.org/2024.findings-acl.577",
 pages = "9689--9706"
}

For unirst:

@inproceedings{chistova-2025-bridging,
  title = "Bridging Discourse Treebanks with a Unified Rhetorical Structure Parser",
  author = "Chistova, Elena",
  booktitle = "Proceedings of the 6th Workshop on Computational Approaches to Discourse, Context and Document-Level Inferences (CODI 2025)",
  month = nov,
  year = "2025",
  address = "Suzhou, China",
  publisher = "Association for Computational Linguistics",
  url = "https://aclanthology.org/2025.codi-1.17/",
  pages = "197--208"
}