Text Classification
Transformers
Safetensors
English
basedecision_dyno
feature-extraction
decision-model
system-one
decision-index
multiple-choice
calibration
read-twice
custom-code
lora-merged
custom_code
Instructions to use onlyaady/BaseDecision-Dyno with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use onlyaady/BaseDecision-Dyno with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("text-classification", model="onlyaady/BaseDecision-Dyno", trust_remote_code=True)# pip install -U transformers accelerate # Load model directly from transformers import AutoModel model = AutoModel.from_pretrained("onlyaady/BaseDecision-Dyno", trust_remote_code=True, device_map="auto") - Notebooks
- Google Colab
- Kaggle
Download modeling_dyno.py from onlyaady/BaseDecision-Dyno: direct link, hf CLI and curl.
- Browser
- Download file 7.35 kB
-
https://huggingface.co/onlyaady/BaseDecision-Dyno/resolve/main/modeling_dyno.py
- Command line
-
hf download hf://onlyaady/BaseDecision-Dyno/modeling_dyno.py
-
curl -L -o modeling_dyno.py https://huggingface.co/onlyaady/BaseDecision-Dyno/resolve/main/modeling_dyno.py
7.35 kB
| """Text-only Dyno backbone and decision readout, with mandatory default repetition.""" | |
| import math | |
| from pathlib import Path | |
| import torch | |
| from torch import nn | |
| from transformers import AutoProcessor, PreTrainedModel | |
| from transformers.models.qwen3_5.configuration_qwen3_5 import Qwen3_5TextConfig | |
| from transformers.models.qwen3_5.modeling_qwen3_5 import Qwen3_5TextModel | |
| from .configuration_dyno import DynoConfig | |
| from .protocol_dyno import encode | |
| from .boundary_dyno import BoundaryProcessor | |
| class DynoModel(PreTrainedModel): | |
| config_class = DynoConfig | |
| base_model_prefix = 'backbone' | |
| _supports_sdpa = True | |
| _keep_in_fp32_modules = ['readout', 'lora_A', 'lora_B'] | |
| _no_split_modules = ['Qwen3_5DecoderLayer'] | |
| def __init__(self, config): | |
| super().__init__(config) | |
| self._keep_in_fp32_modules = list(config.fp32_modules) | |
| text = Qwen3_5TextConfig(**config.text_config) | |
| text._attn_implementation = 'sdpa'; text.use_cache = False | |
| self.backbone = Qwen3_5TextModel(text) | |
| if config.native_lora: | |
| from peft import LoraConfig, inject_adapter_in_model | |
| inject_adapter_in_model(LoraConfig(**config.native_lora), self.backbone) | |
| self._lora_float() | |
| for m in self.backbone.modules(): | |
| if type(m).__name__ == 'Qwen3_5Attention': m.is_causal = False | |
| self.readout = nn.Linear(text.hidden_size, len(config.label_ids), | |
| bias=config.readout_bias, dtype=torch.float32) | |
| self._processor = None; self._buckets = (); self._compiled = False | |
| self.post_init() | |
| def _lora_float(self): | |
| for module in self.backbone.modules(): | |
| if hasattr(module, 'lora_A'): | |
| module.lora_A.float(); module.lora_B.float() | |
| def from_pretrained(cls, pretrained_model_name_or_path, *args, **kwargs): | |
| obj = super().from_pretrained(pretrained_model_name_or_path, *args, **kwargs) | |
| # Device-map dispatch remains HF-owned; never silently CPU-offload a fast profile. | |
| obj._artifact_path = str(pretrained_model_name_or_path) | |
| obj._artifact_revision = getattr(obj.config, '_commit_hash', None) or kwargs.get('revision') | |
| obj._local_only = kwargs.get('local_files_only', False) | |
| obj._lora_float() | |
| obj.readout.float() | |
| return obj | |
| def get_input_embeddings(self): return self.backbone.embed_tokens | |
| def set_input_embeddings(self, value): self.backbone.embed_tokens = value | |
| def processor(self): | |
| if self._processor is None: | |
| self._processor = AutoProcessor.from_pretrained(self._artifact_path, | |
| local_files_only=getattr(self, '_local_only', True), | |
| revision=getattr(self, '_artifact_revision', None), trust_remote_code=True) | |
| self._processor.tokenizer.padding_side = 'left' | |
| if self._processor.tokenizer.pad_token_id is None: | |
| self._processor.tokenizer.pad_token_id = self._processor.tokenizer.eos_token_id | |
| self._boundary_processor = BoundaryProcessor(self._processor, self.config.labels) | |
| return self._processor | |
| def prepare_request(self, request, mode='default'): | |
| _ = self.processor | |
| return encode(self._boundary_processor, self.config.labels, self.config.label_ids, | |
| request, mode, self.config.max_length) | |
| def optimize(self, compile_mode='layer', buckets=(256, 512, 1024, 2048, 4096, 8192, 16384)): | |
| """Explicit opt-in. Run parity and latency checks before adopting this profile.""" | |
| if compile_mode not in ('none', 'layer'): raise ValueError('compile_mode must be none or layer') | |
| if any(x <= 0 or x > self.config.max_length for x in buckets): raise ValueError('Invalid bucket') | |
| if self._compiled: raise ValueError('Optimize only once on a fresh model instance') | |
| self._buckets = tuple(sorted(set(buckets))) | |
| if compile_mode == 'layer': | |
| if self.device.type != 'cuda': raise ValueError('CUDA layer compilation requested without CUDA') | |
| for layer in self.backbone.layers: | |
| layer.forward = torch.compile(layer.forward, backend='inductor', dynamic=False, | |
| options={'triton.cudagraphs': False}) | |
| self._compiled = True | |
| return self | |
| def _logits(self, items, bucket=True): | |
| """Private numerical core. Public forward/decide accept structured requests only.""" | |
| if not items: return [] | |
| width = max(len(r['ids']) for r in items) | |
| if width > self.config.max_length: raise ValueError('Internal sequence exceeds context limit') | |
| if bucket and self._buckets: | |
| width = next((n for n in self._buckets if n >= width), width) | |
| pad = self.processor.tokenizer.pad_token_id | |
| ids = torch.full((len(items), width), pad, dtype=torch.long, device=self.device) | |
| mask = torch.zeros_like(ids, dtype=torch.bool) | |
| for i, r in enumerate(items): | |
| n = len(r['ids']); ids[i, -n:] = torch.tensor(r['ids'], device=self.device); mask[i, -n:] = True | |
| # Host-known lengths choose the mask; no bool(CUDA_tensor) synchronization. | |
| padded = any(len(r['ids']) != width for r in items) | |
| mapping = {'full_attention': mask[:, None, None, :] if padded else None, | |
| 'linear_attention': mask if padded else None} | |
| with torch.autocast(self.device.type, dtype=torch.bfloat16, enabled=self.device.type == 'cuda'): | |
| hidden = self.backbone(input_ids=ids, attention_mask=mapping, | |
| use_cache=False).last_hidden_state[:, -1] | |
| # Keep the tiny head and softmax outside mixed-precision autocast. | |
| with torch.autocast(self.device.type, enabled=False): | |
| n = max(len(r['keys']) for r in items) | |
| logits = torch.nn.functional.linear(hidden.float(), self.readout.weight[:n], | |
| None if self.readout.bias is None else self.readout.bias[:n]) | |
| return [z[:len(r['keys'])] for z, r in zip(logits, items)] | |
| def decide(self, request, mode='default'): | |
| temperature = float(self.config.temperatures.get(mode, float('nan'))) | |
| if not math.isfinite(temperature) or temperature <= 0: raise ValueError('Invalid mode/temperature') | |
| items = self.prepare_request(request, mode) | |
| # One sequence per question preserves the trained protocol. No generation. | |
| answers = {}; usage = [] | |
| for item in items: | |
| z = self._logits([item])[0] | |
| probabilities = (z.float()/temperature).softmax(-1).cpu().tolist() | |
| p = dict(zip(item['keys'], probabilities)); selected = max(p, key=p.get) | |
| answers[item['qid']] = {'choice': selected, 'probabilities': p} | |
| usage.append(len(item['ids'])) | |
| return {'answers': answers, 'mode': mode, 'read_twice': mode == 'default', | |
| 'sequence_tokens': usage, 'calibrated': self.config.calibrated, | |
| 'release_id': self.config.release_id} | |
| def forward(self, request=None, mode='default', **kwargs): | |
| if kwargs: raise ValueError('Use structured request input; raw input_ids/generation bypasses are not the public API') | |
| return self.decide(request, mode) | |