Download runtime/cpu.py from guga-guga/GeoPOI: direct link, hf CLI and curl.
- Browser
- Download file 8.09 kB
-
https://huggingface.co/guga-guga/GeoPOI/resolve/main/runtime/cpu.py
- Command line
-
hf download hf://guga-guga/GeoPOI/runtime/cpu.py
-
curl -L -o cpu.py https://huggingface.co/guga-guga/GeoPOI/resolve/main/runtime/cpu.py
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() | |
| 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 | |