Release Cronformer v0.1.0

MANIFEST.json

@@ -0,0 +1,76 @@
+{
+  "repo_id": "impalasys/cronformer",
+  "release": "v0.1.0",
+  "updated_unix": 1784267466,
+  "source_checkpoint": "/Users/shukant/Library/CloudStorage/GoogleDrive-sukantk3.4@gmail.com/My Drive/Checkpoints/Codex/Cronformer/passes/pass322-full-broad-failure-repair-v1/checkpoint/num_steps-12000",
+  "validation": {
+    "command": "bazel run //uncommonstash/cronformer:validate_hf_cronformer_release -- --hf-dir <release-dir> --local-files-only --json",
+    "status": "passed",
+    "prompt": "every night at 5pm on tuesdays and wednesdays",
+    "prediction": "0 17 * * 2,3"
+  },
+  "files": [
+    {
+      "name": "README.md",
+      "bytes": 5106,
+      "sha256": "3de7475af8f43e5d374d6b776c6d14e8b6c4e443b4c884f3fb00c457aa96c8ed"
+    },
+    {
+      "name": "RELEASE.json",
+      "bytes": 1129,
+      "sha256": "5212b2ba852f574983b0b244f21a0103f6a31b2121299981f37ceb3e3d794aaa"
+    },
+    {
+      "name": "__init__.py",
+      "bytes": 184,
+      "sha256": "19733b3b4e6d0cd824750e90f0be36a42d97e7a9a0b181510cf5badb9725625f"
+    },
+    {
+      "name": "config.json",
+      "bytes": 1413,
+      "sha256": "423c81858035bedd95eb7a369ddfc9259c0ab52dd592b45e23aca4c0b1378888"
+    },
+    {
+      "name": "configuration_cronformer.py",
+      "bytes": 2417,
+      "sha256": "8f000d55b8884023f4fae72cca2a75b96fd6fd5e0ffe940d1a14de4b7ab98ccd"
+    },
+    {
+      "name": "cron.py",
+      "bytes": 31551,
+      "sha256": "b4ec73e1899daa8d92216d590a52eef09d8fe8e9cb3ca73103170ca70d265f61"
+    },
+    {
+      "name": "model.safetensors",
+      "bytes": 25368616,
+      "sha256": "6c9b7a57b49c10b35fd74b21719dc593b7c262c4e4293fde3d7471853704025f"
+    },
+    {
+      "name": "modeling_cronformer.py",
+      "bytes": 15600,
+      "sha256": "75337ab548d435066676128fa4c48e73650d1e61a3f76bf7261a348525c41fd7"
+    },
+    {
+      "name": "special_tokens_map.json",
+      "bytes": 125,
+      "sha256": "b6d346be366a7d1d48332dbc9fdf3bf8960b5d879522b7799ddba59e76237ee3"
+    },
+    {
+      "name": "tokenizer_config.json",
+      "bytes": 370,
+      "sha256": "56043ee5aa67cf0ac3c364ac8f677ef33cd1be78081e5e3eff4a8e596daacac7"
+    },
+    {
+      "name": "vocab.txt",
+      "bytes": 231508,
+      "sha256": "07eced375cec144d27c900241f3e339478dec958f92fddbc551f295c992038a3"
+    }
+  ],
+  "model": {
+    "parameters": 6334826,
+    "model_safetensors_bytes": 25368616,
+    "model_safetensors_mib": 24.19,
+    "tensor_bytes": 25339304,
+    "tensor_mib": 24.17
+  }
+}

README.md

@@ -1,3 +1,175 @@
 ---
+language:
+- en
 license: agpl-3.0
+library_name: transformers
+base_model: google/bert_uncased_L-2_H-128_A-2
+tags:
+- cron
+- schedules
+- text-to-cron
+- structured-prediction
+- custom-code
+model-index:
+- name: Cronformer
+  results:
+  - task:
+      type: text-to-cron
+      name: Natural Language to Cron
+    dataset:
+      type: cronformer-broad-fixture
+      name: Cronformer broad schedule fixture
+    metrics:
+    - type: accuracy
+      name: Full broad top-1 accuracy
+      value: 0.9961
+    - type: accuracy
+      name: Full broad top-2 accuracy
+      value: 0.9981
+    - type: accuracy
+      name: Full broad top-3 accuracy
+      value: 0.9981
 ---
+
+# Cronformer
+
+Cronformer is a compact model for converting short English schedule requests
+into standard five-field cron expressions:
+
+```text
+every night at 5pm on tuesdays and wednesdays -> 0 17 * * 2,3
+```
+
+The model is not a text generator. It uses a small BERT encoder and a structured
+decoder that predicts the cron fields directly: minute, hour, day-of-month,
+month, and day-of-week.
+
+## Quick Start
+
+This repository contains custom Transformers model code. Loading the model
+requires `trust_remote_code=True`.
+
+```python
+import importlib.util
+
+import torch
+from huggingface_hub import hf_hub_download
+from transformers import AutoModel, AutoTokenizer
+
+repo_id = "impalasys/cronformer"
+
+model = AutoModel.from_pretrained(repo_id, trust_remote_code=True)
+tokenizer = AutoTokenizer.from_pretrained(repo_id)
+
+cron_py = hf_hub_download(repo_id, "cron.py")
+spec = importlib.util.spec_from_file_location("cronformer_release_cron", cron_py)
+cron_module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(cron_module)
+
+inputs = tokenizer(
+    "every night at 5pm on tuesdays and wednesdays",
+    return_tensors="pt",
+    max_length=128,
+    truncation=True,
+    padding="max_length",
+)
+
+with torch.no_grad():
+    output = model(**inputs)
+
+cron = cron_module.logits_to_cron(output)[0].to_vixie_cron()
+print(cron)
+```
+
+Expected output:
+
+```text
+0 17 * * 2,3
+```
+
+## Architecture
+
+Cronformer is an encoder-only structured prediction model for cron expressions.
+It does not decode cron as text. Instead, it predicts the cron schema directly.
+
+The model has three main parts:
+
+1. A compact BERT encoder, `google/bert_uncased_L-2_H-128_A-2`, encodes the
+   input prompt.
+2. Five learned field queries attend over the prompt representation, one for
+   each cron field: minute, hour, day-of-month, month, and day-of-week.
+3. Learned slot queries specialize each field state into cron decisions such as
+   wildcard/value/list/range/step pattern, selected values, ranges, step sizes,
+   nth weekday, and last-day offsets.
+
+The output is a structured `CronOutput` object. The bundled `cron.py` helper
+turns those logits into a five-field Vixie-style cron string:
+
+```text
+minute hour day-of-month month day-of-week
+```
+
+Cronformer does not predict seconds, years, timezone rules, holiday calendars,
+or execution history.
+
+## Version
+
+This is the initial public Cronformer release.
+
+- Version: `v0.1.0`
+- Architecture: field-query Cronformer
+- Base encoder: `google/bert_uncased_L-2_H-128_A-2`
+- Parameters: 6,334,826
+- Weight file size: 25,368,616 bytes (24.19 MiB)
+- Maximum input length: 128 tokens
+- License: AGPL-3.0
+
+## Evaluation
+
+The released checkpoint was selected from internal Cronformer development as the
+best current all-around checkpoint for this architecture. The evaluation suites
+below are project-specific schedule fixtures, not public benchmark datasets.
+
+| Suite | Top-1 | Top-2 | Top-3 |
+| --- | ---: | ---: | ---: |
+| Sampled broad schedule fixture | 99.50% | 100.00% | 100.00% |
+| Hard language fixture | 100.00% | 100.00% | 100.00% |
+| Human-authored JSONL fixture | 100.00% | 100.00% | 100.00% |
+| Manual smoke prompts | 100.00% | 100.00% | 100.00% |
+| Full broad schedule fixture | 99.61% | 99.81% | 99.81% |
+
+Known top-1 misses on the full broad fixture:
+
+- `late evening at 11 PM daily`
+- `every 30 minutes from 9 to 5 on Monday through Friday`
+
+For ambiguous business-hour language, showing top-k candidates or confirming the
+cron expression with the user is recommended.
+
+## Intended Use
+
+Cronformer is intended for schedule-authoring interfaces, developer tools, and
+automation products that need a small local model to propose cron expressions
+from concise English prompts.
+
+Good fits:
+
+- Suggesting cron expressions in a UI.
+- Ranking or displaying multiple candidate schedules.
+- Local/offline cron assistance where a large LLM is unnecessary.
+
+Poor fits:
+
+- Legal, medical, financial, or safety-critical scheduling without review.
+- Calendar-aware scheduling involving holidays, timezones, daylight saving time,
+  or business-specific blackout windows.
+- Natural-language requests that require external state or temporal context.
+
+## Limitations
+
+- English-only training/evaluation.
+- Five-field cron only.
+- Ambiguous prompts may have multiple valid cron interpretations.
+- The model can produce syntactically valid but semantically wrong cron strings.
+- Evaluation was performed on internal Cronformer fixtures.
+

RELEASE.json

@@ -0,0 +1,28 @@
+{
+  "repo_id": "impalasys/cronformer",
+  "release": "v0.1.0",
+  "source_checkpoint": "/Users/shukant/Library/CloudStorage/GoogleDrive-sukantk3.4@gmail.com/My Drive/Checkpoints/Codex/Cronformer/passes/pass322-full-broad-failure-repair-v1/checkpoint/num_steps-12000",
+  "release_dir": "/Users/shukant/Library/CloudStorage/GoogleDrive-sukantk3.4@gmail.com/My Drive/Checkpoints/Cronformer/hf_releases/impalasys-cronformer-v0.1.0",
+  "checkpoint_pass": "pass322-full-broad-failure-repair-v1",
+  "checkpoint_step": "num_steps-12000",
+  "files_expected": [
+    "MANIFEST.json",
+    "README.md",
+    "RELEASE.json",
+    "SHA256SUMS",
+    "__init__.py",
+    "config.json",
+    "configuration_cronformer.py",
+    "cron.py",
+    "model.safetensors",
+    "modeling_cronformer.py",
+    "special_tokens_map.json",
+    "tokenizer_config.json",
+    "vocab.txt"
+  ],
+  "validation_status": "passed",
+  "validation_command": "bazel run //uncommonstash/cronformer:validate_hf_cronformer_release -- --hf-dir <release-dir> --local-files-only --json",
+  "parameters": 6334826,
+  "model_safetensors_bytes": 25368616,
+  "model_safetensors_mib": 24.19
+}

SHA256SUMS

@@ -0,0 +1,11 @@
+3de7475af8f43e5d374d6b776c6d14e8b6c4e443b4c884f3fb00c457aa96c8ed  README.md
+5212b2ba852f574983b0b244f21a0103f6a31b2121299981f37ceb3e3d794aaa  RELEASE.json
+19733b3b4e6d0cd824750e90f0be36a42d97e7a9a0b181510cf5badb9725625f  __init__.py
+423c81858035bedd95eb7a369ddfc9259c0ab52dd592b45e23aca4c0b1378888  config.json
+8f000d55b8884023f4fae72cca2a75b96fd6fd5e0ffe940d1a14de4b7ab98ccd  configuration_cronformer.py
+b4ec73e1899daa8d92216d590a52eef09d8fe8e9cb3ca73103170ca70d265f61  cron.py
+6c9b7a57b49c10b35fd74b21719dc593b7c262c4e4293fde3d7471853704025f  model.safetensors
+75337ab548d435066676128fa4c48e73650d1e61a3f76bf7261a348525c41fd7  modeling_cronformer.py
+b6d346be366a7d1d48332dbc9fdf3bf8960b5d879522b7799ddba59e76237ee3  special_tokens_map.json
+56043ee5aa67cf0ac3c364ac8f677ef33cd1be78081e5e3eff4a8e596daacac7  tokenizer_config.json
+07eced375cec144d27c900241f3e339478dec958f92fddbc551f295c992038a3  vocab.txt

__init__.py

@@ -0,0 +1,5 @@
+# Copyright 2026 Impala Systems, Inc.
+# SPDX-License-Identifier: AGPL-3.0-only
+
+from .configuration_cronformer import CronformerConfig
+from .modeling_cronformer import CronformerModel

config.json

@@ -0,0 +1,55 @@
+{
+  "architectures": [
+    "CronformerModel"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_cronformer.CronformerConfig",
+    "AutoModel": "modeling_cronformer.CronformerModel"
+  },
+  "base_model": "google/bert_uncased_L-2_H-128_A-2",
+  "dropout": 0.1,
+  "dtype": "float32",
+  "encoder_config": {
+    "attention_probs_dropout_prob": 0.1,
+    "hidden_act": "gelu",
+    "hidden_dropout_prob": 0.1,
+    "hidden_size": 128,
+    "initializer_range": 0.02,
+    "intermediate_size": 512,
+    "layer_norm_eps": 1e-12,
+    "max_position_embeddings": 512,
+    "model_type": "bert",
+    "num_attention_heads": 2,
+    "num_hidden_layers": 2,
+    "pad_token_id": 0,
+    "type_vocab_size": 2,
+    "vocab_size": 30522
+  },
+  "encoder_model": "google/bert_uncased_L-2_H-128_A-2",
+  "hidden_size": 256,
+  "input_sequence_length": 128,
+  "lang_tokenizer": "google/bert_uncased_L-2_H-128_A-2",
+  "library_name": "transformers",
+  "list_item_components": null,
+  "list_item_score_scale": 1.0,
+  "model_type": "cronformer",
+  "num_attention_heads": 4,
+  "num_field_layers": 1,
+  "token_value_decoding_components": [
+    0,
+    1
+  ],
+  "transformers_version": "4.57.1",
+  "use_list_item_decoding": false,
+  "use_list_item_scoring": false,
+  "use_path_score_decoding": false,
+  "use_token_value_decoding": false,
+  "use_value_count_decoding": true,
+  "value_count_decoding_components": [
+    0,
+    1,
+    2,
+    3,
+    4
+  ]
+}

configuration_cronformer.py

@@ -0,0 +1,55 @@
+# Copyright 2026 Impala Systems, Inc.
+# SPDX-License-Identifier: AGPL-3.0-only
+
+from transformers import AutoConfig, PretrainedConfig
+
+
+class CronformerConfig(PretrainedConfig):
+    model_type = "cronformer"
+
+    def __init__(
+        self,
+        encoder_model: str = "google/bert_uncased_L-2_H-128_A-2",
+        hidden_size: int = 256,
+        lang_tokenizer: str | None = None,
+        input_sequence_length: int = 128,
+        num_attention_heads: int = 4,
+        num_field_layers: int = 1,
+        dropout: float = 0.1,
+        use_value_count_decoding: bool = False,
+        value_count_decoding_components: list[int] | None = None,
+        use_token_value_decoding: bool = False,
+        token_value_decoding_components: list[int] | None = None,
+        use_path_score_decoding: bool = False,
+        use_list_item_decoding: bool = False,
+        use_list_item_scoring: bool = False,
+        list_item_score_scale: float = 1.0,
+        list_item_components: list[int] | None = None,
+        encoder_config: dict | None = None,
+        **kwargs,
+    ):
+        self.encoder_model = encoder_model
+        self.hidden_size = hidden_size
+        self.lang_tokenizer = lang_tokenizer or encoder_model
+        self.input_sequence_length = input_sequence_length
+        self.num_attention_heads = num_attention_heads
+        self.num_field_layers = num_field_layers
+        self.dropout = dropout
+        self.use_value_count_decoding = use_value_count_decoding
+        self.value_count_decoding_components = value_count_decoding_components or [0, 1]
+        self.use_token_value_decoding = use_token_value_decoding
+        self.token_value_decoding_components = token_value_decoding_components or [0, 1]
+        self.use_path_score_decoding = use_path_score_decoding
+        self.use_list_item_decoding = use_list_item_decoding
+        self.use_list_item_scoring = use_list_item_scoring
+        self.list_item_score_scale = list_item_score_scale
+        self.list_item_components = list_item_components
+        self.encoder_config = encoder_config
+        super().__init__(**kwargs)
+
+    def to_encoder_config(self):
+        if self.encoder_config is not None:
+            encoder_config = dict(self.encoder_config)
+            model_type = encoder_config.pop("model_type", "bert")
+            return AutoConfig.for_model(model_type, **encoder_config)
+        return AutoConfig.from_pretrained(self.encoder_model)

cron.py

@@ -0,0 +1,786 @@
+# Copyright 2026 Impala Systems, Inc.
+# SPDX-License-Identifier: AGPL-3.0-only
+
+from enum import Enum
+from dataclasses import dataclass, field, is_dataclass
+from typing import List, Optional, Dict, Any, TypedDict
+import torch
+
+class CronPatternType(Enum):
+    WILDCARD = 0
+    VALUE = 1
+    LIST = 2
+    RANGE = 3
+    STEP = 4
+    NTH_WEEKDAY = 5
+    LAST = 6
+    NEAREST = 7
+
+
+@dataclass
+class CronComponentOutput:
+    """Raw logits for a single component from the model."""
+    pattern_logits: torch.Tensor
+    values_logits: torch.Tensor
+    range_start_logits: torch.Tensor
+    range_end_logits: torch.Tensor
+    step_start_logits: torch.Tensor
+    step_size_logits: torch.Tensor
+    nth_logits: torch.Tensor
+    last_offset_logits: torch.Tensor
+    token_values_logits: Optional[torch.Tensor] = None
+    token_step_size_logits: Optional[torch.Tensor] = None
+    token_pattern_logits: Optional[torch.Tensor] = None
+    value_count_logits: Optional[torch.Tensor] = None
+    list_values_logits: Optional[torch.Tensor] = None
+    list_item_logits: Optional[torch.Tensor] = None
+    residual_adapter_selector_logits: Optional[torch.Tensor] = None
+    constrained_field_logits: Optional[torch.Tensor] = None
+    interval_scope_selector_logits: Optional[torch.Tensor] = None
+    use_value_count_decoding: bool = False
+    use_token_value_decoding: bool = False
+    use_path_score_decoding: bool = False
+    use_list_item_decoding: bool = False
+    use_list_item_scoring: bool = False
+    list_item_score_scale: float = 1.0
+
+
+@dataclass
+class CronOutput:
+    """Complete model output containing component outputs."""
+    minute: CronComponentOutput
+    hour: CronComponentOutput
+    dom: CronComponentOutput
+    month: CronComponentOutput
+    dow: CronComponentOutput
+    dom_dow_intersect_logits: torch.Tensor
+    semantic_binding_logits: Optional[torch.Tensor] = None
+
+    def get_component(self, name: str) -> CronComponentOutput:
+        return getattr(self, name)
+
+
+class CronComponentDict(TypedDict):
+    pattern_output_ids: torch.Tensor
+    values_output_ids: torch.Tensor
+    range_start_output_ids: torch.Tensor
+    range_end_output_ids: torch.Tensor
+    step_start_output_ids: torch.Tensor
+    step_size_output_ids: torch.Tensor
+    nth_output_ids: torch.Tensor
+    last_offset_output_ids: torch.Tensor
+
+class CronDict(TypedDict):
+    minute: CronComponentDict
+    hour: CronComponentDict
+    dom: CronComponentDict
+    month: CronComponentDict
+    dow: CronComponentDict
+    dom_dow_intersect_output_ids: torch.Tensor
+
+
+@dataclass
+class CronComponent:
+    type: CronPatternType
+    values: List[int] = field(default_factory=list)
+    items: List["CronComponent"] = field(default_factory=list)
+    step_start: Optional[int] = None
+    step_size: Optional[int] = None
+    nth: Optional[int] = None
+    range_start: Optional[int] = None
+    range_end: Optional[int] = None
+    last_offset: Optional[int] = None
+
+    def to_string(self, component_index: int) -> str:
+        if self.type == CronPatternType.WILDCARD:
+            return "*"
+        elif self.type == CronPatternType.VALUE:
+            if not self.values:
+                return "*" # Fallback
+            return str(self.values[0])
+        elif self.type == CronPatternType.LIST:
+            if self.items:
+                return ",".join(item.to_string(component_index) for item in self.items)
+            if not self.values:
+                return "*" # Fallback
+            return ",".join(map(str, sorted(self.values)))
+        elif self.type == CronPatternType.RANGE:
+            start = self.range_start if self.range_start is not None else 0
+            end = self.range_end if self.range_end is not None else self.range_start
+            return f"{start}-{end}"
+        elif self.type == CronPatternType.STEP:
+            step_size = self.step_size if self.step_size is not None else 1
+            if step_size == 1 and (self.step_start is None or self.step_start == 0):
+                # Typically */1
+                return "*"
+            elif self.step_start is None or self.step_start == 0:
+                # Typically */step
+                base = "*"
+            else:
+                base = str(self.step_start)
+            return f"{base}/{step_size}"
+        elif self.type == CronPatternType.NTH_WEEKDAY:
+            # e.g. 2#2 (Tuesday#2nd)
+            if not self.values:
+                return "*"
+            dow = self.values[0]
+            nth = self.nth if self.nth is not None else 1
+            return f"{dow}#{nth}"
+        elif self.type == CronPatternType.LAST:
+             # L or 5L
+            if self.last_offset:
+                return f"L-{self.last_offset}"
+            if not self.values:
+                return "L"
+            return f"{self.values[0]}L"
+        elif self.type == CronPatternType.NEAREST:
+            # 15W
+            if not self.values:
+                return "1W" # Fallback
+            return f"{self.values[0]}W"
+        return "*"
+
+@dataclass
+class Cron:
+    minute: CronComponent
+    hour: CronComponent
+    dom: CronComponent
+    month: CronComponent
+    dow: CronComponent
+    dom_dow_intersect: bool = True
+
+    def to_vixie_cron(self) -> str:
+        # TODO: Handle dom_dow_intersect
+        parts = [
+            self.minute.to_string(0),
+            self.hour.to_string(1),
+            self.dom.to_string(2),
+            self.month.to_string(3),
+            self.dow.to_string(4),
+        ]
+        return " ".join(parts)
+
+# Pre-defined dimensions for each component
+# Minute: 0-59 (60)
+# Hour: 0-23 (24)
+# DoM: 1-31 (32, 0 is unused/padding)
+# Month: 1-12 (13, 0 is unused/padding)
+# DoW: 0-6 (7)
+COMPONENT_DIMS = [60, 24, 32, 13, 7]
+COMPONENT_NAMES = ["minute", "hour", "dom", "month", "dow"]
+MAX_LIST_ITEMS = 4
+SEMANTIC_BINDING_NAMES = [
+    "weekday_interval_all_day",
+    "workday_dow_required",
+    "month_end_last_dom",
+    "office_hours_end_17",
+    "office_hours_end_18",
+    "hour_window_required",
+    "hour_window_absent",
+]
+
+def _component_from_path_score(comp_output: CronComponentOutput, component_index: int, batch_index: int) -> CronComponent:
+    pattern_logits = comp_output.pattern_logits[batch_index]
+    values_logits = comp_output.values_logits[batch_index]
+    if comp_output.use_token_value_decoding and comp_output.token_values_logits is not None:
+        values_logits = comp_output.token_values_logits[batch_index].amax(dim=0)
+    list_values_logits = (
+        comp_output.list_values_logits[batch_index]
+        if comp_output.list_values_logits is not None
+        else values_logits
+    )
+    range_start_logits = comp_output.range_start_logits[batch_index]
+    range_end_logits = comp_output.range_end_logits[batch_index]
+    step_start_logits = comp_output.step_start_logits[batch_index]
+    step_size_logits = comp_output.step_size_logits[batch_index]
+    nth_logits = comp_output.nth_logits[batch_index]
+    last_offset_logits = comp_output.last_offset_logits[batch_index]
+    value_count_logits = (
+        comp_output.value_count_logits[batch_index]
+        if comp_output.value_count_logits is not None
+        else None
+    )
+
+    def list_item_score(indices: list[int]) -> torch.Tensor:
+        if (
+            not comp_output.use_list_item_scoring
+            or comp_output.list_item_logits is None
+            or not indices
+        ):
+            return torch.tensor(0.0, dtype=list_values_logits.dtype, device=list_values_logits.device)
+        item_logits = comp_output.list_item_logits[batch_index]
+        score = torch.tensor(0.0, dtype=item_logits.dtype, device=item_logits.device)
+        for slot, value in enumerate(sorted(indices)[: item_logits.shape[0]]):
+            if 0 <= value < item_logits.shape[-1]:
+                score = score + item_logits[slot, value]
+        return score * comp_output.list_item_score_scale
+
+    def list_item_indices() -> list[int]:
+        if not comp_output.use_list_item_decoding or comp_output.list_item_logits is None:
+            return []
+        return scoreable_list_item_indices()
+
+    def scoreable_list_item_indices() -> list[int]:
+        if comp_output.list_item_logits is None:
+            return []
+        item_logits = comp_output.list_item_logits[batch_index]
+        if comp_output.use_value_count_decoding and value_count_logits is not None:
+            value_count = int(torch.argmax(value_count_logits).item())
+        else:
+            value_count = int(torch.clamp(torch.round(torch.sigmoid(list_values_logits).sum()), min=1).item())
+        value_count = max(1, min(value_count, item_logits.shape[0]))
+        indices: list[int] = []
+        for slot in range(value_count):
+            ranked = torch.argsort(item_logits[slot], descending=True).flatten().tolist()
+            selected = next((int(value) for value in ranked if int(value) not in indices), int(ranked[0]))
+            indices.append(selected)
+        return indices
+
+    def value_component(pattern_type: CronPatternType) -> tuple[float, CronComponent]:
+        value_index = int(torch.argmax(values_logits).item())
+        return (
+            float((pattern_logits[pattern_type.value] + values_logits[value_index]).item()),
+            CronComponent(type=pattern_type, values=[value_index]),
+        )
+
+    argmax_pattern = CronPatternType(int(torch.argmax(pattern_logits).item()))
+    candidates: list[tuple[float, CronPatternType, CronComponent]] = [
+        (
+            float(pattern_logits[CronPatternType.WILDCARD.value].item()),
+            CronPatternType.WILDCARD,
+            CronComponent(type=CronPatternType.WILDCARD),
+        ),
+    ]
+    value_score, value_cron = value_component(CronPatternType.VALUE)
+    candidates.append((value_score, CronPatternType.VALUE, value_cron))
+
+    item_decoded_indices = list_item_indices()
+    if item_decoded_indices:
+        list_indices = item_decoded_indices
+    elif comp_output.use_value_count_decoding and value_count_logits is not None:
+        value_count = int(torch.argmax(value_count_logits).item())
+        value_count = max(1, min(value_count, list_values_logits.numel()))
+        list_indices = torch.topk(list_values_logits, value_count).indices.flatten().tolist()
+    else:
+        list_indices = (list_values_logits > 0.0).nonzero().flatten().tolist()
+        if not list_indices:
+            list_indices = [int(torch.argmax(list_values_logits).item())]
+    list_score = (
+        pattern_logits[CronPatternType.LIST.value]
+        + list_values_logits[list_indices].sum()
+        + list_item_score([int(value) for value in list_indices])
+    )
+    list_component = CronComponent(type=CronPatternType.LIST, values=[int(value) for value in list_indices])
+    last_offset_idx = int(torch.argmax(last_offset_logits).item())
+    if component_index == 2 and last_offset_idx == 0:
+        list_component.items = [
+            CronComponent(CronPatternType.VALUE, values=[value])
+            for value in sorted(list_component.values)
+        ]
+        list_component.items.append(CronComponent(CronPatternType.LAST))
+    candidates.append((float(list_score.item()), CronPatternType.LIST, list_component))
+    if comp_output.use_list_item_scoring and not comp_output.use_list_item_decoding:
+        scored_item_indices = scoreable_list_item_indices()
+        if scored_item_indices and sorted(scored_item_indices) != sorted([int(value) for value in list_indices]):
+            scored_item_list_score = (
+                pattern_logits[CronPatternType.LIST.value]
+                + list_values_logits[scored_item_indices].sum()
+                + list_item_score([int(value) for value in scored_item_indices])
+            )
+            candidates.append(
+                (
+                    float(scored_item_list_score.item()),
+                    CronPatternType.LIST,
+                    CronComponent(
+                        type=CronPatternType.LIST,
+                        values=[int(value) for value in scored_item_indices],
+                    ),
+                )
+            )
+
+    range_start = int(torch.argmax(range_start_logits).item())
+    range_end = int(torch.argmax(range_end_logits).item())
+    candidates.append(
+        (
+            float(
+                (
+                    pattern_logits[CronPatternType.RANGE.value]
+                    + range_start_logits[range_start]
+                    + range_end_logits[range_end]
+                ).item()
+            ),
+            CronPatternType.RANGE,
+            CronComponent(type=CronPatternType.RANGE, range_start=range_start, range_end=range_end),
+        )
+    )
+
+    step_start = int(torch.argmax(step_start_logits).item())
+    step_size = int(torch.argmax(step_size_logits).item())
+    candidates.append(
+        (
+            float(
+                (
+                    pattern_logits[CronPatternType.STEP.value]
+                    + step_start_logits[step_start]
+                    + step_size_logits[step_size]
+                ).item()
+            ),
+            CronPatternType.STEP,
+            CronComponent(type=CronPatternType.STEP, step_start=step_start, step_size=step_size),
+        )
+    )
+
+    nth_value = int(torch.argmax(values_logits).item())
+    nth = int(torch.argmax(nth_logits).item())
+    candidates.append(
+        (
+            float(
+                (
+                    pattern_logits[CronPatternType.NTH_WEEKDAY.value]
+                    + values_logits[nth_value]
+                    + nth_logits[nth]
+                ).item()
+            ),
+            CronPatternType.NTH_WEEKDAY,
+            CronComponent(type=CronPatternType.NTH_WEEKDAY, values=[nth_value], nth=nth),
+        )
+    )
+
+    last_values = (values_logits > 0.0).nonzero().flatten().tolist()
+    last_value_score = torch.tensor(0.0, dtype=values_logits.dtype, device=values_logits.device)
+    last_component = CronComponent(type=CronPatternType.LAST)
+    if component_index != 2 and last_values:
+        last_value = int(torch.argmax(values_logits).item())
+        last_component.values = [last_value]
+        last_value_score = values_logits[last_value]
+    if last_offset_idx > 0:
+        last_component.last_offset = last_offset_idx
+    candidates.append(
+        (
+            float(
+                (
+                    pattern_logits[CronPatternType.LAST.value]
+                    + last_value_score
+                    + last_offset_logits[last_offset_idx]
+                ).item()
+            ),
+            CronPatternType.LAST,
+            last_component,
+        )
+    )
+
+    nearest_value = int(torch.argmax(values_logits).item())
+    candidates.append(
+        (
+            float(
+                (
+                    pattern_logits[CronPatternType.NEAREST.value]
+                    + values_logits[nearest_value]
+                ).item()
+            ),
+            CronPatternType.NEAREST,
+            CronComponent(type=CronPatternType.NEAREST, values=[nearest_value]),
+        )
+    )
+
+    candidate_by_pattern = {pattern: (score, component) for score, pattern, component in candidates}
+    if argmax_pattern != CronPatternType.WILDCARD:
+        return candidate_by_pattern[argmax_pattern][1]
+
+    wildcard_score = candidate_by_pattern[CronPatternType.WILDCARD][0]
+    eligible = [candidate_by_pattern[CronPatternType.WILDCARD]]
+    range_score, range_component = candidate_by_pattern[CronPatternType.RANGE]
+    range_margin = 10.0
+    if component_index != 4 and range_score - wildcard_score >= range_margin:
+        eligible.append((range_score, range_component))
+    if component_index == 2:
+        last_score, last_component = candidate_by_pattern[CronPatternType.LAST]
+        if last_score - wildcard_score >= 6.0:
+            eligible.append((last_score, last_component))
+
+    return max(eligible, key=lambda item: item[0])[1]
+
+
+def logits_to_cron(output: CronOutput) -> List[Cron]:
+    """
+    Converts structured CronOutput into a list of Cron objects.
+    """
+    # Assuming batch size is consistent across all tensors in output
+    batch_size = output.minute.pattern_logits.size(0)
+    crons = []
+    
+    # Store component data for each item in batch
+    batch_components = [[] for _ in range(batch_size)]
+    
+    for component_index, comp_name in enumerate(COMPONENT_NAMES):
+        comp_output = output.get_component(comp_name)
+        
+        # Now process each item in the batch for this component
+        for b in range(batch_size):
+            if comp_output.use_path_score_decoding:
+                batch_components[b].append(_component_from_path_score(comp_output, component_index, b))
+                continue
+
+            # Extract
+            pattern_logits = comp_output.pattern_logits[b]
+            values_logits = comp_output.values_logits[b]
+            if comp_output.use_token_value_decoding and comp_output.token_values_logits is not None:
+                values_logits = comp_output.token_values_logits[b].amax(dim=0)
+            list_values_logits = (
+                comp_output.list_values_logits[b]
+                if comp_output.list_values_logits is not None
+                else values_logits
+            )
+            rs_logits = comp_output.range_start_logits[b]
+            re_logits = comp_output.range_end_logits[b]
+            step_start_logits = comp_output.step_start_logits[b]
+            step_size_logits = comp_output.step_size_logits[b]
+            nth_logits = comp_output.nth_logits[b]
+            value_count_logits = comp_output.value_count_logits[b] if comp_output.value_count_logits is not None else None
+            
+            pattern_idx = torch.argmax(pattern_logits).item()
+            pattern_type = CronPatternType(pattern_idx)
+            
+            # Values (Sigmoid)
+            values_indices = (values_logits > 0.0).nonzero().flatten().tolist()
+            
+            rs_idx = torch.argmax(rs_logits).item()
+            re_idx = torch.argmax(re_logits).item()
+            step_start_idx = torch.argmax(step_start_logits).item()
+            step_size_idx = torch.argmax(step_size_logits).item()
+            nth_idx = torch.argmax(nth_logits).item()
+            last_offset_idx = torch.argmax(comp_output.last_offset_logits[b]).item()
+            
+            # Construct Component
+            comp = CronComponent(type=pattern_type)
+            
+            if pattern_type == CronPatternType.WILDCARD:
+                pass
+            elif pattern_type == CronPatternType.VALUE:
+                if not values_indices:
+                    comp.values = [torch.argmax(values_logits).item()]
+                else:
+                    # Pick the highest probability value among the candidates
+                    best_idx = max(values_indices, key=lambda i: values_logits[i].item())
+                    comp.values = [best_idx]
+            elif pattern_type == CronPatternType.LIST:
+                values_logits = list_values_logits
+                values_indices = (values_logits > 0.0).nonzero().flatten().tolist()
+                if comp_output.use_list_item_decoding and comp_output.list_item_logits is not None:
+                    item_logits = comp_output.list_item_logits[b]
+                    if comp_output.use_value_count_decoding and value_count_logits is not None:
+                        value_count = int(torch.argmax(value_count_logits).item())
+                    else:
+                        value_count = int(torch.clamp(torch.round(torch.sigmoid(values_logits).sum()), min=1).item())
+                    value_count = max(1, min(value_count, item_logits.shape[0]))
+                    values_indices = []
+                    for slot in range(value_count):
+                        ranked = torch.argsort(item_logits[slot], descending=True).flatten().tolist()
+                        selected = next((int(value) for value in ranked if int(value) not in values_indices), int(ranked[0]))
+                        values_indices.append(selected)
+                elif comp_output.use_value_count_decoding and value_count_logits is not None:
+                    value_count = int(torch.argmax(value_count_logits).item())
+                    value_count = max(1, min(value_count, values_logits.numel()))
+                    values_indices = torch.topk(values_logits, value_count).indices.flatten().tolist()
+                elif not values_indices:
+                    values_indices = [torch.argmax(values_logits).item()]
+                comp.values = values_indices
+                if component_index == 2 and last_offset_idx == 0:
+                    comp.items = [CronComponent(CronPatternType.VALUE, values=[value]) for value in sorted(values_indices)]
+                    comp.items.append(CronComponent(CronPatternType.LAST))
+            elif pattern_type == CronPatternType.RANGE:
+                comp.range_start = rs_idx
+                comp.range_end = re_idx
+            elif pattern_type == CronPatternType.STEP:
+                comp.step_start = step_start_idx
+                comp.step_size = step_size_idx
+            elif pattern_type == CronPatternType.NTH_WEEKDAY:
+                comp.values = [torch.argmax(values_logits).item()]
+                comp.nth = nth_idx
+            elif pattern_type == CronPatternType.LAST:
+                 if component_index != 2 and values_indices:
+                     comp.values = [torch.argmax(values_logits).item()]
+                 if last_offset_idx > 0:
+                     comp.last_offset = last_offset_idx
+            elif pattern_type == CronPatternType.NEAREST:
+                 comp.values = [torch.argmax(values_logits).item()]
+
+            batch_components[b].append(comp)
+
+    # Assemble Cron objects
+    for b in range(batch_size):
+        comps = batch_components[b] # Order matches loop above
+        
+        dom_dow_logits = output.dom_dow_intersect_logits[b]
+        dom_dow_val = torch.argmax(dom_dow_logits).item() == 1
+        
+        crons.append(Cron(
+            minute=comps[0],
+            hour=comps[1],
+            dom=comps[2],
+            month=comps[3],
+            dow=comps[4],
+            dom_dow_intersect=dom_dow_val
+        ))
+        
+    return crons
+
+
+
+def cron_string_to_cron(cron_str: str) -> Cron:
+    """
+    Parses a Vixie Cron string into a Cron object.
+    Simplistic parser for training demo.
+    """
+    parts = cron_str.split()
+    if len(parts) != 5:
+        parts = ["*", "*", "*", "*", "*"]
+        
+    components_data = [
+        (parts[0], 0, 59),   # minute
+        (parts[1], 0, 23),   # hour
+        (parts[2], 1, 31),   # dom
+        (parts[3], 1, 12),   # month
+        (parts[4], 0, 6),    # dow
+    ]
+    
+    cron_components = []
+
+    for i, (expr, min_val, max_val) in enumerate(components_data):
+        comp = CronComponent(type=CronPatternType.VALUE) # Default
+        
+        if expr == "*":
+            comp.type = CronPatternType.WILDCARD
+        elif "," in expr:
+            comp.type = CronPatternType.LIST
+            values = []
+            for val in expr.split(","):
+                try:
+                    v = int(val)
+                    values.append(v)
+                except: pass
+            comp.values = values
+        elif "/" in expr:
+            comp.type = CronPatternType.STEP
+            try:
+                base, step = expr.split("/")
+                if base != "*":
+                    try:
+                        v = int(base)
+                        comp.step_start = v
+                    except: pass
+                else:
+                    comp.step_start = 0
+                comp.step_size = int(step)
+            except: pass
+        elif "#" in expr:
+            comp.type = CronPatternType.NTH_WEEKDAY
+            try:
+                dow, nth = map(int, expr.split("#"))
+                comp.values = [dow]
+                comp.nth = nth
+            except: pass
+        elif "L" in expr:
+            comp.type = CronPatternType.LAST
+            if expr.startswith("L-"):
+                try:
+                    comp.last_offset = int(expr[2:])
+                except: pass
+            elif expr != "L":
+                try:
+                    val = int(expr.replace("L", ""))
+                    comp.values = [val]
+                except: pass
+        elif "-" in expr:
+            comp.type = CronPatternType.RANGE
+            try:
+                s, e = map(int, expr.split("-"))
+                comp.range_start = s
+                comp.range_end = e
+            except: pass
+        elif "W" in expr:
+            comp.type = CronPatternType.NEAREST
+            try:
+                val = int(expr.replace("W", ""))
+                comp.values = [val]
+            except: pass
+        else:
+            comp.type = CronPatternType.VALUE
+            try:
+                v = int(expr)
+                comp.values = [v]
+            except: pass
+            
+        cron_components.append(comp)
+
+    return Cron(
+        minute=cron_components[0],
+        hour=cron_components[1],
+        dom=cron_components[2],
+        month=cron_components[3],
+        dow=cron_components[4],
+        dom_dow_intersect=True # heuristic
+    )
+
+def cron_to_dict(cron: Cron) -> CronDict:
+    """
+    Converts a Cron object into a structured dictionary of tensors.
+    """
+    # Order: Minute, Hour, DoM, Month, DoW
+    components = [cron.minute, cron.hour, cron.dom, cron.month, cron.dow]
+    target_dict = {}
+    
+    for i, comp in enumerate(components):
+        dim_size = COMPONENT_DIMS[i]
+        comp_name = COMPONENT_NAMES[i]
+        
+        pattern_idx = comp.type.value
+        values_hot = [0.0] * dim_size
+        range_start_idx = -100
+        range_end_idx = -100
+        step_start_idx = -100
+        step_size_idx = -100
+        nth_idx = -100
+        last_offset_idx = -100
+        
+        # Values
+        if comp.values:
+            for v in comp.values:
+                if 0 <= v < dim_size:
+                    values_hot[v] = 1.0
+        # Range
+        if comp.type == CronPatternType.RANGE:
+             if comp.range_start is not None: range_start_idx = comp.range_start
+             if comp.range_end is not None: range_end_idx = comp.range_end
+        
+        # Step
+        if comp.type == CronPatternType.STEP:
+             if comp.step_start is not None: step_start_idx = comp.step_start
+             if comp.step_size is not None: step_size_idx = comp.step_size
+        
+        # Nth
+        if comp.type == CronPatternType.NTH_WEEKDAY:
+             if comp.nth is not None: nth_idx = comp.nth
+
+        # Last offset. 0 is an explicit "plain L / no offset" class for LAST.
+        if comp.type == CronPatternType.LAST:
+            last_offset_idx = comp.last_offset if comp.last_offset is not None else 0
+        elif comp.type == CronPatternType.LIST:
+            has_last_item = any(item.type == CronPatternType.LAST for item in comp.items)
+            if has_last_item:
+                last_offset_idx = 0
+            else:
+                last_offset_idx = dim_size - 1
+             
+        # Create Component Dict
+        target_dict[comp_name] = {
+            "pattern_output_ids": torch.tensor(pattern_idx, dtype=torch.long),
+            "values_output_ids": torch.tensor(values_hot, dtype=torch.float),
+            "range_start_output_ids": torch.tensor(range_start_idx, dtype=torch.long),
+            "range_end_output_ids": torch.tensor(range_end_idx, dtype=torch.long),
+            "step_start_output_ids": torch.tensor(step_start_idx, dtype=torch.long),
+            "step_size_output_ids": torch.tensor(step_size_idx, dtype=torch.long),
+            "nth_output_ids": torch.tensor(nth_idx, dtype=torch.long),
+            "last_offset_output_ids": torch.tensor(last_offset_idx, dtype=torch.long),
+        }
+
+    dd_idx = 1 if cron.dom_dow_intersect else 0
+    target_dict["dom_dow_intersect_output_ids"] = torch.tensor(dd_idx, dtype=torch.long)
+    
+    return target_dict
+
+def parse_cron_string(cron_str: str) -> CronDict:
+    """
+    Wrapper to return target dict.
+    """
+    cron = cron_string_to_cron(cron_str)
+    return cron_to_dict(cron)
+
+
+def parse_cron_schema(cron_schema: Dict[str, Any] | str) -> CronDict:
+    """
+    Converts a Cronformer proto JSON CronExpression into target tensors.
+    """
+    if isinstance(cron_schema, str):
+        return parse_cron_string(cron_schema)
+
+    field_keys = ["minute", "hour", "dayOfMonth", "month", "dayOfWeek"]
+
+    def kind_name(value: Any) -> str:
+        if isinstance(value, int):
+            return CronPatternType(value - 1).name if value > 0 else "WILDCARD"
+        return str(value).replace("CRON_FIELD_KIND_", "")
+
+    def component_from_field(field: Dict[str, Any]) -> CronComponent:
+        kind = kind_name(field.get("kind", "CRON_FIELD_KIND_WILDCARD"))
+        values = [int(v) for v in field.get("values", [])]
+
+        if kind == "WILDCARD":
+            return CronComponent(type=CronPatternType.WILDCARD)
+        if kind == "VALUE":
+            return CronComponent(type=CronPatternType.VALUE, values=values)
+        if kind == "LIST":
+            if field.get("items"):
+                items = [component_from_field(item) for item in field["items"]]
+                numeric_values = []
+                for item in items:
+                    if item.type == CronPatternType.VALUE:
+                        numeric_values.extend(item.values)
+                return CronComponent(type=CronPatternType.LIST, values=numeric_values, items=items)
+            return CronComponent(type=CronPatternType.LIST, values=values)
+        if kind == "RANGE":
+            return CronComponent(
+                type=CronPatternType.RANGE,
+                range_start=int(field.get("rangeStart", 0)),
+                range_end=int(field.get("rangeEnd", 0)),
+            )
+        if kind == "STEP":
+            return CronComponent(
+                type=CronPatternType.STEP,
+                step_start=int(field.get("stepStart", 0)),
+                step_size=int(field.get("stepSize", 1)),
+            )
+        if kind == "NTH_WEEKDAY":
+            return CronComponent(
+                type=CronPatternType.NTH_WEEKDAY,
+                values=values,
+                nth=int(field.get("nth", 1)),
+            )
+        if kind == "LAST":
+            return CronComponent(
+                type=CronPatternType.LAST,
+                values=values,
+                last_offset=int(field["lastOffset"]) if "lastOffset" in field else None,
+            )
+        if kind == "NEAREST_WEEKDAY":
+            return CronComponent(type=CronPatternType.NEAREST, values=values)
+        raise ValueError(f"Unsupported cron field kind: {kind}")
+
+    components = [component_from_field(cron_schema[key]) for key in field_keys]
+    semantics = cron_schema.get("domDowSemantics", "DOM_DOW_SEMANTICS_OR")
+    return cron_to_dict(
+        Cron(
+            minute=components[0],
+            hour=components[1],
+            dom=components[2],
+            month=components[3],
+            dow=components[4],
+            dom_dow_intersect=semantics == "DOM_DOW_SEMANTICS_AND",
+        )
+    )
+
+
+def recursive_to_device(data, device):
+    """
+    Recursively moves data (Dict, List, or Tensor) to the specified device.
+    """
+    if isinstance(data, dict):
+        return {k: recursive_to_device(v, device) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [recursive_to_device(v, device) for v in data]
+    elif isinstance(data, torch.Tensor):
+        return data.to(device)
+    elif is_dataclass(data) and not isinstance(data, type):
+        values = {field_name: recursive_to_device(getattr(data, field_name), device) for field_name in data.__dataclass_fields__}
+        return data.__class__(**values)
+    return data

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c9b7a57b49c10b35fd74b21719dc593b7c262c4e4293fde3d7471853704025f
+size 25368616

modeling_cronformer.py

@@ -0,0 +1,349 @@
+# Copyright 2026 Impala Systems, Inc.
+# SPDX-License-Identifier: AGPL-3.0-only
+
+from __future__ import annotations
+
+"""Canonical Cronformer model.
+
+Cronformer is an encoder-only structured decoder: it reads a natural-language
+schedule request and emits logits for the five cron fields rather than rendering
+cron text token by token. The decoder uses learned field queries and learned
+slot queries so each output decision has an explicit place in the model.
+"""
+
+import math
+
+import torch
+from torch import nn
+from transformers import AutoConfig, AutoModel, AutoModelForCausalLM, PreTrainedModel
+
+from .configuration_cronformer import CronformerConfig
+from .cron import (
+    COMPONENT_DIMS,
+    COMPONENT_NAMES,
+    MAX_LIST_ITEMS,
+    CronComponentOutput,
+    CronOutput,
+    CronPatternType,
+)
+
+
+SLOT_NAMES = [
+    "pattern",
+    "values",
+    "list_values",
+    "list_items",
+    "range_start",
+    "range_end",
+    "step_start",
+    "step_size",
+    "nth",
+    "last_offset",
+    "field_presence",
+]
+
+
+class FieldSlotDecoder(nn.Module):
+    """Prediction heads for one cron field after field/slot attention.
+
+    The field-slot states carry global semantic context for this field, while
+    token-level heads preserve copy-like access to numbers and pattern words
+    that appear directly in the prompt.
+    """
+
+    def __init__(self, hidden_size: int, output_dim: int):
+        super().__init__()
+        self.output_dim = output_dim
+        self.token_value_norm = nn.LayerNorm(hidden_size)
+        self.token_step_size_norm = nn.LayerNorm(hidden_size)
+        self.token_pattern_norm = nn.LayerNorm(hidden_size)
+        self.pattern_head = nn.Linear(hidden_size, len(CronPatternType))
+        self.values_head = nn.Linear(hidden_size, output_dim)
+        self.list_values_head = nn.Linear(hidden_size, output_dim)
+        self.range_start_head = nn.Linear(hidden_size, output_dim)
+        self.range_end_head = nn.Linear(hidden_size, output_dim)
+        self.step_start_head = nn.Linear(hidden_size, output_dim)
+        self.step_size_head = nn.Linear(hidden_size, output_dim)
+        self.nth_head = nn.Linear(hidden_size, 6)
+        self.last_offset_head = nn.Linear(hidden_size, output_dim)
+        self.value_count_head = nn.Linear(hidden_size, output_dim + 1)
+        self.list_item_head = nn.Linear(hidden_size, output_dim)
+        self.field_presence_head = nn.Linear(hidden_size, 1)
+        self.token_values_head = nn.Linear(hidden_size, output_dim)
+        self.token_step_size_head = nn.Linear(hidden_size, output_dim)
+        self.token_pattern_head = nn.Linear(hidden_size, len(CronPatternType))
+        self.value_fusion_gate = nn.Linear(hidden_size, output_dim)
+        self.list_value_fusion_gate = nn.Linear(hidden_size, output_dim)
+        self.step_size_fusion_gate = nn.Linear(hidden_size, output_dim)
+
+    @staticmethod
+    def _slot(states: torch.Tensor, name: str) -> torch.Tensor:
+        return states[:, SLOT_NAMES.index(name), :]
+
+    @staticmethod
+    def _masked_token_pool(token_logits: torch.Tensor, attention_mask: torch.Tensor | None) -> torch.Tensor:
+        # Max pooling keeps a strong local token signal for numbers without
+        # forcing the structured slot state to memorize every literal value.
+        if attention_mask is None:
+            return token_logits.amax(dim=1)
+        mask = attention_mask.bool().unsqueeze(-1)
+        return token_logits.masked_fill(~mask, -1.0e4).amax(dim=1)
+
+    def forward(
+        self,
+        slot_states: torch.Tensor,
+        token_states: torch.Tensor,
+        attention_mask: torch.Tensor | None,
+    ) -> CronComponentOutput:
+        value_slot = self._slot(slot_states, "values")
+        list_value_slot = self._slot(slot_states, "list_values")
+        step_size_slot = self._slot(slot_states, "step_size")
+        token_values_logits = self.token_values_head(
+            self.token_value_norm(token_states + value_slot.unsqueeze(1))
+        )
+        token_step_size_logits = self.token_step_size_head(
+            self.token_step_size_norm(token_states + step_size_slot.unsqueeze(1))
+        )
+        token_pattern_logits = self.token_pattern_head(
+            self.token_pattern_norm(token_states + self._slot(slot_states, "pattern").unsqueeze(1))
+        )
+        pooled_token_values = self._masked_token_pool(token_values_logits, attention_mask)
+        pooled_token_step_size = self._masked_token_pool(token_step_size_logits, attention_mask)
+
+        # Fuse slot-level classification with token-local evidence. The gate is
+        # learned per output value, which lets the model decide when prompt
+        # literals should dominate over the semantic field representation.
+        value_logits = self.values_head(value_slot) + torch.sigmoid(self.value_fusion_gate(value_slot)) * pooled_token_values
+        list_values_logits = self.list_values_head(list_value_slot) + torch.sigmoid(
+            self.list_value_fusion_gate(list_value_slot)
+        ) * pooled_token_values
+        step_size_logits = self.step_size_head(step_size_slot) + torch.sigmoid(
+            self.step_size_fusion_gate(step_size_slot)
+        ) * pooled_token_step_size
+
+        list_item_state = self._slot(slot_states, "list_items")
+        list_item_logits = self.list_item_head(list_item_state).unsqueeze(1).expand(
+            -1,
+            MAX_LIST_ITEMS,
+            -1,
+        )
+        return CronComponentOutput(
+            pattern_logits=self.pattern_head(self._slot(slot_states, "pattern")),
+            values_logits=value_logits,
+            range_start_logits=self.range_start_head(self._slot(slot_states, "range_start")),
+            range_end_logits=self.range_end_head(self._slot(slot_states, "range_end")),
+            step_start_logits=self.step_start_head(self._slot(slot_states, "step_start")),
+            step_size_logits=step_size_logits,
+            nth_logits=self.nth_head(self._slot(slot_states, "nth")),
+            last_offset_logits=self.last_offset_head(self._slot(slot_states, "last_offset")),
+            token_values_logits=token_values_logits,
+            token_step_size_logits=token_step_size_logits,
+            token_pattern_logits=token_pattern_logits,
+            value_count_logits=self.value_count_head(value_slot),
+            list_values_logits=list_values_logits,
+            list_item_logits=list_item_logits,
+            constrained_field_logits=self.field_presence_head(self._slot(slot_states, "field_presence")),
+        )
+
+
+class CronformerModel(PreTrainedModel):
+    """Field-query Cronformer.
+
+    Forward flow:
+    1. Encode prompt tokens with a small Hugging Face encoder.
+    2. Cross-attend five learned field queries over token states.
+    3. Run field self-attention so minute/hour/dom/month/dow can coordinate.
+    4. For each field, cross-attend learned slot queries over token states.
+    5. Decode slot states into the CronOutput contract used by training/eval.
+    """
+
+    config_class = CronformerConfig
+
+    def __init__(self, config: CronformerConfig):
+        super().__init__(config)
+        self.config = config
+        self.encoder = AutoModel.from_config(config.to_encoder_config())
+        encoder_dim = self.encoder.config.hidden_size
+        hidden_size = config.hidden_size
+        self.token_projection = nn.Sequential(
+            nn.Linear(encoder_dim, hidden_size),
+            nn.GELU(),
+            nn.LayerNorm(hidden_size),
+        )
+        self.field_queries = nn.Parameter(torch.empty(len(COMPONENT_NAMES), hidden_size))
+        self.slot_queries = nn.Parameter(torch.empty(len(SLOT_NAMES), hidden_size))
+        self.field_attention = nn.MultiheadAttention(
+            hidden_size,
+            config.num_attention_heads,
+            dropout=config.dropout,
+            batch_first=True,
+        )
+        field_layer = nn.TransformerEncoderLayer(
+            d_model=hidden_size,
+            nhead=config.num_attention_heads,
+            dim_feedforward=hidden_size * 4,
+            dropout=config.dropout,
+            activation="gelu",
+            batch_first=True,
+            norm_first=True,
+        )
+        self.field_interaction = nn.TransformerEncoder(
+            field_layer,
+            num_layers=config.num_field_layers,
+        )
+        self.slot_attention = nn.MultiheadAttention(
+            hidden_size,
+            config.num_attention_heads,
+            dropout=config.dropout,
+            batch_first=True,
+        )
+        self.slot_norm = nn.LayerNorm(hidden_size)
+        self.heads = nn.ModuleDict(
+            {
+                name: FieldSlotDecoder(hidden_size, output_dim)
+                for name, output_dim in zip(COMPONENT_NAMES, COMPONENT_DIMS)
+            }
+        )
+        self.dom_dow_pool = nn.Sequential(
+            nn.Linear(hidden_size, hidden_size),
+            nn.GELU(),
+            nn.LayerNorm(hidden_size),
+        )
+        self.dom_dow_intersect_head = nn.Linear(hidden_size, 2)
+        self.post_init()
+        nn.init.normal_(self.field_queries, mean=0.0, std=0.02)
+        nn.init.normal_(self.slot_queries, mean=0.0, std=0.02)
+
+    def _init_weights(self, module: nn.Module):
+        if isinstance(module, nn.Linear):
+            module.weight.data.normal_(mean=0.0, std=0.02)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.LayerNorm):
+            module.bias.data.zero_()
+            module.weight.data.fill_(1.0)
+
+    def _key_padding_mask(self, attention_mask: torch.Tensor | None) -> torch.Tensor | None:
+        if attention_mask is None:
+            return None
+        return ~attention_mask.bool()
+
+    def _token_states(
+        self,
+        input_ids: torch.LongTensor,
+        attention_mask: torch.Tensor | None,
+    ) -> torch.Tensor:
+        encoder_output = self.encoder(input_ids=input_ids, attention_mask=attention_mask)
+        return self.token_projection(encoder_output.last_hidden_state)
+
+    def _field_states(
+        self,
+        token_states: torch.Tensor,
+        attention_mask: torch.Tensor | None,
+    ) -> torch.Tensor:
+        batch_size = token_states.shape[0]
+        queries = self.field_queries.unsqueeze(0).expand(batch_size, -1, -1)
+        # Each learned field query asks the token sequence for the evidence
+        # relevant to one cron field. This is the Direct+V2 merge point: output
+        # remains structured, but field semantics are learned by attention.
+        field_states, _ = self.field_attention(
+            queries,
+            token_states,
+            token_states,
+            key_padding_mask=self._key_padding_mask(attention_mask),
+            need_weights=False,
+        )
+        # Field interaction is the only learned global coordination layer. It
+        # replaces hand-coded semantic corrections while still allowing fields
+        # such as day-of-month and day-of-week to influence each other.
+        return self.field_interaction(field_states)
+
+    def _slot_states(
+        self,
+        field_states: torch.Tensor,
+        token_states: torch.Tensor,
+        attention_mask: torch.Tensor | None,
+    ) -> dict[str, torch.Tensor]:
+        slot_states = {}
+        slot_offsets = self.slot_queries.unsqueeze(0)
+        key_padding_mask = self._key_padding_mask(attention_mask)
+        for index, name in enumerate(COMPONENT_NAMES):
+            # Slot queries specialize a field state into concrete decisions:
+            # pattern, values, ranges, steps, list items, and field presence.
+            queries = field_states[:, index : index + 1, :] + slot_offsets
+            attended, _ = self.slot_attention(
+                queries,
+                token_states,
+                token_states,
+                key_padding_mask=key_padding_mask,
+                need_weights=False,
+            )
+            slot_states[name] = self.slot_norm(attended + queries)
+        return slot_states
+
+    def forward(
+        self,
+        input_ids: torch.LongTensor,
+        attention_mask: torch.Tensor | None = None,
+        token_type_ids: torch.Tensor | None = None,
+        **_: object,
+    ) -> CronOutput:
+        token_states = self._token_states(input_ids, attention_mask)
+        field_states = self._field_states(token_states, attention_mask)
+        slot_states = self._slot_states(field_states, token_states, attention_mask)
+        component_outputs = {}
+        count_decode_components = set(getattr(self.config, "value_count_decoding_components", [0, 1]))
+        token_decode_components = set(getattr(self.config, "token_value_decoding_components", [0, 1]))
+        list_item_components = getattr(self.config, "list_item_components", None)
+        list_item_component_set = None if list_item_components is None else set(list_item_components)
+        for component_index, name in enumerate(COMPONENT_NAMES):
+            output = self.heads[name](slot_states[name], token_states, attention_mask)
+            # These flags are decoder policy switches consumed by cron.py. The
+            # model always emits the full CronComponentOutput; configs choose
+            # which learned logits participate in final cron reconstruction.
+            output.use_value_count_decoding = (
+                self.config.use_value_count_decoding and component_index in count_decode_components
+            )
+            output.use_token_value_decoding = (
+                self.config.use_token_value_decoding and component_index in token_decode_components
+            )
+            output.use_path_score_decoding = self.config.use_path_score_decoding
+            output.use_list_item_decoding = self.config.use_list_item_decoding and (
+                list_item_component_set is None or component_index in list_item_component_set
+            )
+            output.use_list_item_scoring = self.config.use_list_item_scoring and (
+                list_item_component_set is None or component_index in list_item_component_set
+            )
+            output.list_item_score_scale = self.config.list_item_score_scale
+            component_outputs[name] = output
+
+        pooled_fields = field_states.mean(dim=1)
+        dom_dow_logits = self.dom_dow_intersect_head(self.dom_dow_pool(pooled_fields))
+        return CronOutput(
+            minute=component_outputs["minute"],
+            hour=component_outputs["hour"],
+            dom=component_outputs["dom"],
+            month=component_outputs["month"],
+            dow=component_outputs["dow"],
+            dom_dow_intersect_logits=dom_dow_logits,
+        )
+
+    @classmethod
+    def from_encoder(cls, encoder_model: str = "google/bert_uncased_L-2_H-128_A-2") -> "CronformerModel":
+        config = CronformerConfig(encoder_model=encoder_model)
+        model = cls(config)
+        encoder_config = AutoConfig.from_pretrained(encoder_model)
+        architectures = getattr(encoder_config, "architectures", None) or []
+        # Some small language models expose their reusable token backbone behind
+        # AutoModelForCausalLM rather than AutoModel. Keep this loader narrow:
+        # Cronformer still uses hidden states as an encoder, never generation.
+        if any(str(architecture).endswith("ForCausalLM") for architecture in architectures):
+            causal_lm = AutoModelForCausalLM.from_pretrained(encoder_model)
+            if not hasattr(causal_lm, "model"):
+                raise ValueError(
+                    f"{encoder_model} advertises a CausalLM architecture but does not expose a .model backbone"
+                )
+            model.encoder = causal_lm.model
+        else:
+            model.encoder = AutoModel.from_pretrained(encoder_model)
+        return model

special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

tokenizer_config.json

@@ -0,0 +1,15 @@
+{
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "mask_token": "[MASK]",
+  "model_max_length": 128,
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizerFast",
+  "unk_token": "[UNK]"
+}