GeoPOI / runtime /cpu.py
Tiga233's picture
Release complete GeoPOI model with shared regional basis and 500-entity public catalog
49d63ea verified
Raw History Blame Contribute Delete
8.09 kB
"""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