File size: 8,088 Bytes
49d63ea | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 | """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
|