Chart Parsers¶

@classmethod
def from_schema(
    cls,
    schema: RuleSchema,
    category_system: CategorySystem,
    n_terminals: int,
    start: str | Category = "S",
    semiring: ChartSemiring | None = None,
    learnable_rule_weights: bool = True,
) -> ChartParser:
    """Create a chart parser from a rule schema and category system.

    Parameters
    ----------
    schema : RuleSchema
        The composable rule schema (e.g. ``CCG``, ``LAMBEK``).
    category_system : CategorySystem
        The category inventory.
    n_terminals : int
        Vocabulary size.
    start : str or Category
        The start category.
    semiring : ChartSemiring or None
        Scoring algebra.
    learnable_rule_weights : bool
        Whether rule weights are learnable.

    Returns
    -------
    ChartParser
        A new parser instance.
    """
    rule_system = schema(category_system)

    return cls.from_category_system(
        category_system,
        rule_system,
        n_terminals,
        start,
        semiring,
        learnable_rule_weights,
    )

@classmethod
def from_category_system(
    cls,
    category_system: CategorySystem,
    rule_system: RuleSystem,
    n_terminals: int,
    start: str | Category = "S",
    semiring: ChartSemiring | None = None,
    learnable_rule_weights: bool = True,
) -> ChartParser:
    """Create a chart parser from a category system and rules.

    Parameters
    ----------
    category_system : CategorySystem
        The category inventory.
    rule_system : RuleSystem
        The structural rules.
    n_terminals : int
        Vocabulary size.
    start : str or Category
        The start category.
    semiring : ChartSemiring or None
        Scoring algebra.
    learnable_rule_weights : bool
        Whether rule weights are learnable.

    Returns
    -------
    ChartParser
        A new parser instance.
    """
    if isinstance(start, str):
        start = AtomicCategory(name=start)

    if start not in category_system:
        raise ValueError(f"start category {start!r} not in category system")

    return cls(
        rule_system=rule_system,
        n_terminals=n_terminals,
        start_idx=category_system.index(start),
        category_system=category_system,
        semiring=semiring,
        learnable_rule_weights=learnable_rule_weights,
    )

def forward(self, input: torch.Tensor) -> torch.Tensor:
    """Compute sentence scores via CKY chart parsing.

    Parameters
    ----------
    input : torch.Tensor
        Integer tensor of terminal indices. Shape
        ``(batch, seq_len)`` or ``(seq_len,)`` for a single
        sentence.

    Returns
    -------
    torch.Tensor
        Score of each sentence under the grammar.
    """
    squeeze = False

    if input.dim() == 1:
        input = input.unsqueeze(0)
        squeeze = True

    if input.shape[1] == 0:
        raise ValueError("cannot parse empty sentences")

    result = super().forward(input)

    if squeeze:
        return result.squeeze(0)

    return result

def inside_chart(self, tokens: torch.Tensor) -> torch.Tensor:
    """Compute the full inside chart (for analysis/debugging).

    Parameters
    ----------
    tokens : torch.Tensor
        Integer tensor of terminal indices.

    Returns
    -------
    torch.Tensor
        Full chart of shape ``(batch, N, seq_len, seq_len+1)``.
    """
    squeeze = False

    if tokens.dim() == 1:
        tokens = tokens.unsqueeze(0)
        squeeze = True

    if tokens.shape[1] == 0:
        raise ValueError("cannot parse empty sentences")

    # run axiom + schedule but skip goal extraction
    chart = self.axiom(tokens, self._semiring)
    chart = self._schedule.run(chart, self.deductions, self._semiring)

    if squeeze:
        return chart.squeeze(0)

    return chart