File size: 4,054 Bytes
29baa44
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""
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

    @property
    def available(self):
        self._load()
        return self._session is not None

    @property
    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()
        }