Files
ays953andClaude Opus 5.5 c8b3c4ae6f AI candidate selection on Windows and Linux
Python port of the reranker: core/lm.py runs the same CKIP gpt2-tiny-chinese
model with numpy (batched per candidate length, scores match the Swift and
reference implementations), Converter.kbest, core/reranker.py (modes, time
budget, pause after overruns, cache), core/system_monitor.py (Windows: CPU usage
and battery saver; Linux: load average, thermal zones, low-power profile and low
battery) and core/ai.py (settings.json, background model loading, status line).

Windows: numpy wheels for PIME's 32-bit Python 3.8 (PIME 1.3) and 3.15 (PIME 2)
are bundled under autozhuyin/vendor and picked by Python version; a settings menu
on the taskbar IME icon and the language bar (left click on the icon toggles
English mode). Linux: install.sh uses the system numpy or downloads the matching
wheel from PyPI (tools/fetch_numpy.py, SHA-256 checked); an IBus settings menu.
Without numpy or the model the input method works as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 16:51:41 +08:00

103 lines
3.6 KiB
Python

""""AI 選字": reranks the converter's best paths with a language model. Port of Reranker.swift.
score = lexicon score (log10 → ln) + λ · LM log-probability
Typing is never blocked for long: a rerank that runs over its time budget counts as an
overrun, and three in a row pause AI for a minute. `system_state` lets the shell pause
or reduce it when the machine is busy, hot or saving power.
"""
import math
import time
OFF, SAVER, STANDARD, QUALITY = "off", "saver", "standard", "quality"
MODES = (OFF, SAVER, STANDARD, QUALITY)
# Paths reranked, and the time budget (seconds) of one rerank. numpy is slower than
# the Mac's Accelerate code, so the budgets are larger than in Reranker.swift.
K = {SAVER: 3, STANDARD: 10, QUALITY: 30}
BUDGET = {SAVER: 0.04, STANDARD: 0.08, QUALITY: 0.2}
NORMAL, REDUCED, PAUSED = "normal", "reduced", "paused" # system states
ST_OFF, ST_LOADING, ST_ACTIVE, ST_BUSY, ST_SLOW = "off", "loading", "active", "paused-busy", "paused-slow"
PAUSE_AFTER_OVERRUNS = 3
SLOW_PAUSE = 60.0
CACHE_LIMIT = 512
class Reranker:
def __init__(self, mode=STANDARD, model=None, now=time.monotonic):
self._mode = mode
self._model = model
self.lam = 0.6
self.system_state = lambda: NORMAL
self.now = now
self.status = ST_OFF
self._overruns = 0
self._paused_until = float("-inf")
self._cache = {}
@property
def mode(self):
return self._mode
@mode.setter
def mode(self, value):
self._mode = value
self._cache.clear()
@property
def model(self):
return self._model
@model.setter
def model(self, value):
self._model = value
self._cache.clear()
def effective_mode(self):
"""The mode used now (after the system state), or None when AI is not used."""
if self._mode == OFF:
self.status = ST_OFF
return None
if self._model is None:
self.status = ST_LOADING
return None
if self.now() < self._paused_until:
self.status = ST_SLOW
return None
state = self.system_state()
if state == PAUSED:
self.status = ST_BUSY
return None
self.status = ST_ACTIVE
return SAVER if state == REDUCED else self._mode
def choose(self, converter, syllables, fixed, context):
"""The reranked conversion [((start, end), text)], or None for the plain result."""
mode = self.effective_mode()
if mode is None or not syllables:
return None
key = (mode, context, tuple(s.reading for s in syllables), tuple(sorted(fixed.items())))
if key in self._cache:
return self._cache[key]
paths = converter.kbest(syllables, K[mode], fixed)
if len(paths) <= 1:
return paths[0][1] if paths else None
start = self.now()
lm = self._model.log_probs(["".join(t for _, t in segs) for _, segs in paths], context)
best = max(range(len(paths)), key=lambda i: paths[i][0] * math.log(10) + self.lam * lm[i])
if self.now() - start > BUDGET[mode]:
# Too slow: use this result (it is computed) but don't cache it, and pause AI
# after a few overruns in a row.
self._overruns += 1
if self._overruns >= PAUSE_AFTER_OVERRUNS:
self._paused_until = self.now() + SLOW_PAUSE
self._overruns = 0
self.status = ST_SLOW
return paths[best][1]
self._overruns = 0
if len(self._cache) >= CACHE_LIMIT:
self._cache.clear()
self._cache[key] = paths[best][1]
return paths[best][1]