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