"""The trained acoustic candidate chain and original V8 literal decisions.""" import numpy as np import torch from components.neural import load_neural_heads from components.policy import load as load_policy from .span_proposal import propose_spans from .retrieval_math import bounded_shortlist, reader_scores, select_names from .catalog import PublicCatalog, CANONICAL_KEYS, digest from .frontend import LocalFrontend from . import causal from .literal_policy import RequestPolicy from .pre_adapter_gate import PreAdapterGate, RawPartial, GateFeatures class CountedPolicy: def __init__(self, heads): self.heads = heads self.theta = heads.theta self.reset() def reset(self): self.calls = {name: 0 for name in ('Entry', 'benefit', 'harm', 'gain', 'Hcal3', 'B49cost3')} def score_entry(self, features): if len(features): self.calls['Entry'] += 1 return self.heads.score_entry(features) def entry_pass(self, probabilities): return self.heads.entry_pass(probabilities) def score_actions(self, features): if len(features): for name in ('benefit', 'harm', 'gain', 'Hcal3', 'B49cost3'): self.calls[name] += 1 return self.heads.score_actions(features) class CompleteCPU: def __init__(self, root): self.catalog = PublicCatalog(root) self.models = load_neural_heads(root / 'components', 'cpu') self.policy = CountedPolicy(load_policy(root / 'components')) if list(self.policy.heads.feature_names_Entry) != causal.ENTRY_NAMES or list(self.policy.heads.feature_names_Gate) != causal.GATE_NAMES: raise ValueError('Trained decision feature ordering differs') self.frontend = LocalFrontend(root) self.reset() def reset(self): self.calls = dict(reader=0, span=0, retriever=0, ranker=0) if hasattr(self, 'policy'): self.policy.reset() @torch.inference_mode() def evidence(self, frames, pool, pool_ref): if not len(pool['surface_ids']): return None frames = frames.detach().to(device='cpu', dtype=torch.float32).contiguous() mask = torch.ones(len(frames), dtype=torch.bool) reader, span, retriever, ranker = [self.models[k] for k in ('reader', 'span', 'retriever', 'ranker')] audio = reader(frames).cpu() empty = torch.zeros((1, 4, len(mask))) pred = span(frames[None], mask[None], empty) weights, bounds = propose_spans(pred['frame'][0].sigmoid(), mask, max_spans=4, return_bounds=True) pred = span(frames[None], mask[None], weights[None]) queries, valid = retriever(audio[None], mask[None], weights[None]) budget = 512 if len(set(pool['surface_ids'])) >= 8192 else 256 shortlist = bounded_shortlist(queries[0], valid[0], pool['embeddings'], pool['surface_ids'], 4, total_k=budget) for row in shortlist: i = row['index']; row['cell'] = pool['candidate_cells'][i] for plural, singular in [('variant_ids', 'variant_id'), ('candidate_ids', 'candidate_id'), ('lexical_ids', 'lexical_id'), ('lexical_entity_ids', 'lexical_entity_id'), ('decoder_token_ids', 'decoder_token_ids'), ('canonical_names', 'canonical')]: row[singular] = pool[plural][i] ix = [row['index'] for row in shortlist] embeddings = pool['embeddings'][ix].float() acoustic = reader_scores(audio, mask, embeddings, 0.2, 0.1) scores, none, reference = ranker(audio[None], mask[None], embeddings[None], torch.tensor([[row['coarse'] for row in shortlist]]), acoustic[None], queries, valid, pred['semantic'], local_query_count=torch.tensor(4)) chosen = select_names(scores[0], none[0], [row['surface_id'] for row in shortlist], top_k=10, margin=-0.5) records = [] for i, row in enumerate(shortlist): candidate = dict(row, acoustic_score=float(acoustic[i]), ranker_score=float(scores[0][i])) identity = {key: candidate[key] for key in CANONICAL_KEYS} candidate['candidate_identity_sha256'] = digest(identity) candidate['candidate_binding_sha256'] = digest(dict(original_pool=pool_ref, original_pool_row=candidate['index'], identity=identity)) records.append(candidate) self.calls['reader'] += 1; self.calls['span'] += 2 self.calls['retriever'] += 1; self.calls['ranker'] += 1 return dict(all_original_shortlist=records, selected=[records[i] for i in chosen], selected_shortlist_indices=chosen, ranker_none=float(none[0]), shortlist_budget=budget, reader_pool_max=float(acoustic.max()) if len(acoustic) else None, span_core_bounds=bounds.tolist(), valid_span_count=int(valid[0, :4].sum()), query_count=int(queries.shape[1]), valid_frame_count=len(mask), whole_selected_list_preserved=True, text_or_target_input=False) def session(self, cells): return DecisionSession(self, cells) def close(self): self.frontend.close() class DecisionSession: def __init__(self, backend, cells): self.backend = backend self.permissions = PreAdapterGate(backend.policy) self.request = 'current'; self.context = 'observed' self.permissions.begin_request(self.request, context_key=self.context, allowed_cells=cells) self.feature_state = causal.CaseFeatureState() self.literal = RequestPolicy(backend.policy, causal) self.trace = [] def begin_input(self, sequence, evidence, region_to_id): records = [] if evidence is None else evidence['all_original_shortlist'] value = self.permissions.begin_input(self.request, context_key=self.context, segment_id=sequence, current_shortlist=records, route_builder=lambda rows: self.backend.catalog.route(rows, region_to_id)) return value def partial(self, sequence, raw_text, audio_us, eof, cells, pool_ref, metadata, evidence): snapshot = dict(is_final=False, eos_observed=bool(eof), observed_version=sequence, audio_time_us=audio_us, received_audio_time_us=audio_us) case = dict(geography=dict(cells=list(cells)), pool=pool_ref) value = None if evidence is None else dict(evidence=evidence, original_pool=pool_ref) entry, gate, actions, receipt = causal.propose_snapshot(case, snapshot, raw_text, value, {}, metadata, self.feature_state, self.backend.frontend) if not eof: partial = RawPartial(self.request, self.context, sequence, sequence, raw_text, audio_us, audio_us) features = GateFeatures.from_original_snapshot(partial, entry, gate, actions) permission = self.permissions.observe_partial(partial, lambda _: features) next_allowed = permission.allow_adapter_next_input else: next_allowed = False raw = causal.RawSnapshot(sequence, audio_us, raw_text, bool(eof), False) result = self.literal.on_raw_partial(raw, received_audio_time_us=audio_us, entry_features_F32=np.asarray([entry], dtype=np.float32), gate_features_F32=np.asarray(gate, dtype=np.float32).reshape((-1, 46)), actions=actions) self.trace.append(dict(sequence=sequence, source_audio_eof=bool(eof), action_count=len(actions), adapter_allowed_next_input=bool(next_allowed), Entry_admitted=result['policy_trace']['Entry_admitted'], Gate_pass_count=len(result['policy_trace']['Gate_passing_action_indices']), literal_accepted_count=sum(bool(v['accepted']) for v in result['policy_trace']['action_eligibility_audit']))) def done(self, version, raw_text, audio_us): raw = causal.RawSnapshot(version, audio_us, raw_text, True, True) result = self.literal.on_done(raw, received_audio_time_us=audio_us) self.permissions.end_request(self.request, context_key=self.context) return result