Download backend/ml/kt_runtime.py from sawabedarain/adaptive-elearning-backend: direct link, hf CLI and curl.
- Browser
- Download file 4.05 kB
-
https://huggingface.co/spaces/sawabedarain/adaptive-elearning-backend/resolve/main/backend/ml/kt_runtime.py
- Command line
-
hf download hf://spaces/sawabedarain/adaptive-elearning-backend/backend/ml/kt_runtime.py
-
curl -L -o kt_runtime.py https://huggingface.co/spaces/sawabedarain/adaptive-elearning-backend/resolve/main/backend/ml/kt_runtime.py
4.05 kB
| """ | |
| CPU inference for the transformer knowledge-tracing model (trained in training/train_kt.py | |
| and exported to ONNX). Given a learner's interaction history it predicts, for every topic | |
| and difficulty, the probability that the *next* answer will be correct. | |
| Uses onnxruntime only (no torch) so the deployed image stays small. If the model or | |
| onnxruntime is unavailable, `available` is False and callers fall back to BKT. | |
| """ | |
| import json | |
| import logging | |
| import os | |
| import threading | |
| import numpy as np | |
| log = logging.getLogger(__name__) | |
| # Hours since previous interaction -> bucket id (0 is reserved for BOS / unknown) | |
| GAP_EDGES_HOURS = [1, 24, 72, 168, 720] | |
| def gap_bucket(hours): | |
| if hours is None: | |
| return 0 | |
| for i, edge in enumerate(GAP_EDGES_HOURS): | |
| if hours < edge: | |
| return i + 1 | |
| return len(GAP_EDGES_HOURS) + 1 | |
| class KTRuntime: | |
| def __init__(self, artifacts_dir): | |
| self.artifacts_dir = artifacts_dir | |
| self._session = None | |
| self._meta = None | |
| self._lock = threading.Lock() | |
| self._loaded = False | |
| def _load(self): | |
| with self._lock: | |
| if self._loaded: | |
| return | |
| self._loaded = True | |
| model_path = os.path.join(self.artifacts_dir, 'kt_model.onnx') | |
| meta_path = os.path.join(self.artifacts_dir, 'kt_meta.json') | |
| if not (os.path.exists(model_path) and os.path.exists(meta_path)): | |
| log.info('KT model artifacts not found; using BKT only') | |
| return | |
| try: | |
| import onnxruntime as ort | |
| opts = ort.SessionOptions() | |
| opts.intra_op_num_threads = 1 | |
| opts.inter_op_num_threads = 1 | |
| self._session = ort.InferenceSession(model_path, opts, providers=['CPUExecutionProvider']) | |
| with open(meta_path) as f: | |
| self._meta = json.load(f) | |
| log.info('Loaded KT model (%s topics, val AUC %.3f)', len(self._meta['topics']), | |
| self._meta.get('metrics', {}).get('val_auc', float('nan'))) | |
| except Exception as exc: # pragma: no cover - defensive | |
| log.warning('Failed to load KT model: %s', exc) | |
| self._session = None | |
| def available(self): | |
| self._load() | |
| return self._session is not None | |
| def meta(self): | |
| self._load() | |
| return self._meta or {} | |
| def predict(self, history): | |
| """ | |
| history: list of dicts {slug, difficulty, correct, timestamp(datetime)} ordered by time. | |
| returns: {slug: {difficulty: p_correct}} or None if model unavailable. | |
| """ | |
| if not self.available: | |
| return None | |
| meta = self._meta | |
| topic_index = {s: i for i, s in enumerate(meta['topics'])} | |
| diff_index = {d: i for i, d in enumerate(meta['difficulties'])} | |
| max_len = meta['max_len'] - 1 # leave room for BOS | |
| events = [h for h in history if h['slug'] in topic_index][-max_len:] | |
| n_topics = len(meta['topics']) | |
| topics, diffs, resp, gaps = [n_topics], [0], [2], [0] # BOS token | |
| prev_ts = None | |
| for e in events: | |
| topics.append(topic_index[e['slug']]) | |
| diffs.append(diff_index.get(e['difficulty'], 1)) | |
| resp.append(1 if e['correct'] else 0) | |
| hours = None if prev_ts is None else (e['timestamp'] - prev_ts).total_seconds() / 3600 | |
| gaps.append(gap_bucket(hours)) | |
| prev_ts = e['timestamp'] | |
| feeds = { | |
| 'topic': np.asarray([topics], dtype=np.int64), | |
| 'difficulty': np.asarray([diffs], dtype=np.int64), | |
| 'response': np.asarray([resp], dtype=np.int64), | |
| 'gap': np.asarray([gaps], dtype=np.int64), | |
| } | |
| probs = self._session.run(['probs'], feeds)[0][0] # [n_topics, n_diff] | |
| return { | |
| slug: {d: float(probs[ti, di]) for d, di in diff_index.items()} | |
| for slug, ti in topic_index.items() | |
| } | |