[FEATURE] add GKT (#22)

* add GKT

* Update AUTHORS.md

* Delete mgkt

* add GKT docs

Author: fannazya

AUTHORS.md

@@ -6,4 +6,6 @@
 
 [Xiaonan Zeng](https://github.com/sone47)
 
+[Fangzhou Yao](https://github.com/fannazya)
+
 The starred is the corresponding author

EduKTM/GKT/GKT.py

@@ -0,0 +1,91 @@
+# coding: utf-8
+# 2022/2/25 @ fannazya
+
+import logging
+import numpy as np
+import torch
+from tqdm import tqdm
+from EduKTM import KTM
+from .GKTNet import GKTNet
+from EduKTM.utils import SLMLoss, tensor2list, pick
+from sklearn.metrics import roc_auc_score, accuracy_score
+
+
+class GKT(KTM):
+    def __init__(self, ku_num, graph, hidden_num, net_params: dict = None, loss_params=None):
+        super(GKT, self).__init__()
+        self.gkt_model = GKTNet(
+            ku_num,
+            graph,
+            hidden_num,
+            **(net_params if net_params is not None else {})
+        )
+        # self.gkt_model = GKTNet(ku_num, graph, hidden_num)
+        self.loss_params = loss_params if loss_params is not None else {}
+
+    def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.001) -> ...:
+        loss_function = SLMLoss(**self.loss_params)
+        trainer = torch.optim.Adam(self.gkt_model.parameters(), lr)
+
+        for e in range(epoch):
+            losses = []
+            for (question, data, data_mask, label, pick_index, label_mask) in tqdm(train_data, "Epoch %s" % e):
+                # convert to device
+                question: torch.Tensor = question.to(device)
+                data: torch.Tensor = data.to(device)
+                data_mask: torch.Tensor = data_mask.to(device)
+                label: torch.Tensor = label.to(device)
+                pick_index: torch.Tensor = pick_index.to(device)
+                label_mask: torch.Tensor = label_mask.to(device)
+
+                # real training
+                predicted_response, _ = self.gkt_model(question, data, data_mask)
+
+                loss = loss_function(predicted_response, pick_index, label, label_mask)
+
+                # back propagation
+                trainer.zero_grad()
+                loss.backward()
+                trainer.step()
+
+                losses.append(loss.mean().item())
+            print("[Epoch %d] SLMoss: %.6f" % (e, float(np.mean(losses))))
+
+            if test_data is not None:
+                auc, accuracy = self.eval(test_data)
+                print("[Epoch %d] auc: %.6f, accuracy: %.6f" % (e, auc, accuracy))
+
+    def eval(self, test_data, device="cpu") -> tuple:
+        self.gkt_model.eval()
+        y_true = []
+        y_pred = []
+
+        for (question, data, data_mask, label, pick_index, label_mask) in tqdm(test_data, "evaluating"):
+            # convert to device
+            question: torch.Tensor = question.to(device)
+            data: torch.Tensor = data.to(device)
+            data_mask: torch.Tensor = data_mask.to(device)
+            label: torch.Tensor = label.to(device)
+            pick_index: torch.Tensor = pick_index.to(device)
+            label_mask: torch.Tensor = label_mask.to(device)
+
+            # real evaluating
+            output, _ = self.gkt_model(question, data, data_mask)
+            output = output[:, :-1]
+            output = pick(output, pick_index.to(output.device))
+            pred = tensor2list(output)
+            label = tensor2list(label)
+            for i, length in enumerate(label_mask.numpy().tolist()):
+                length = int(length)
+                y_true.extend(label[i][:length])
+                y_pred.extend(pred[i][:length])
+        self.gkt_model.train()
+        return roc_auc_score(y_true, y_pred), accuracy_score(y_true, np.array(y_pred) >= 0.5)
+
+    def save(self, filepath) -> ...:
+        torch.save(self.gkt_model.state_dict(), filepath)
+        logging.info("save parameters to %s" % filepath)
+
+    def load(self, filepath):
+        self.gkt_model.load_state_dict(torch.load(filepath))
+        logging.info("load parameters from %s" % filepath)

EduKTM/GKT/GKTNet.py

@@ -0,0 +1,162 @@
+# coding: utf-8
+# 2022/3/1 @ fannazya
+__all__ = ["GKTNet"]
+
+import json
+import networkx as nx
+import torch
+from torch import nn
+import torch.nn.functional as F
+from EduKTM.utils import GRUCell, begin_states, get_states, expand_tensor, \
+    format_sequence, mask_sequence_variable_length
+
+
+class GKTNet(nn.Module):
+    def __init__(self, ku_num, graph, hidden_num=None, latent_dim=None, dropout=0.0):
+        super(GKTNet, self).__init__()
+        self.ku_num = int(ku_num)
+        self.hidden_num = self.ku_num if hidden_num is None else int(hidden_num)
+        self.latent_dim = self.ku_num if latent_dim is None else int(latent_dim)
+        self.neighbor_dim = self.hidden_num + self.latent_dim
+        self.graph = nx.DiGraph()
+        self.graph.add_nodes_from(list(range(ku_num)))
+        try:
+            with open(graph) as f:
+                self.graph.add_weighted_edges_from(json.load(f))
+        except ValueError:
+            with open(graph) as f:
+                self.graph.add_weighted_edges_from([e + [1.0] for e in json.load(f)])
+
+        self.rnn = GRUCell(self.hidden_num)
+        self.response_embedding = nn.Embedding(2 * self.ku_num, self.latent_dim)
+        self.concept_embedding = nn.Embedding(self.ku_num, self.latent_dim)
+        self.f_self = nn.Linear(self.neighbor_dim, self.hidden_num)
+        self.n_out = nn.Linear(2 * self.neighbor_dim, self.hidden_num)
+        self.n_in = nn.Linear(2 * self.neighbor_dim, self.hidden_num)
+        self.dropout = nn.Dropout(dropout)
+        self.out = nn.Linear(self.hidden_num, 1)
+
+    def in_weight(self, x, ordinal=True, with_weight=True):
+        if isinstance(x, torch.Tensor):
+            x = x.numpy().tolist()
+        if isinstance(x, list):
+            return [self.in_weight(_x) for _x in x]
+        elif isinstance(x, (int, float)):
+            if not ordinal:
+                return list(self.graph.predecessors(int(x)))
+            else:
+                _ret = [0] * self.ku_num
+                for i in self.graph.predecessors(int(x)):
+                    if with_weight:
+                        _ret[i] = self.graph[i][x]['weight']
+                    else:
+                        _ret[i] = 1
+                return _ret
+        else:
+            raise TypeError("cannot handle %s" % type(x))
+
+    def out_weight(self, x, ordinal=True, with_weight=True):
+        if isinstance(x, torch.Tensor):
+            x = x.numpy().tolist()
+        if isinstance(x, list):
+            return [self.out_weight(_x) for _x in x]
+        elif isinstance(x, (int, float)):
+            if not ordinal:
+                return list(self.graph.successors(int(x)))
+            else:
+                _ret = [0] * self.ku_num
+                for i in self.graph.successors(int(x)):
+                    if with_weight:
+                        _ret[i] = self.graph[x][i]['weight']
+                    else:
+                        _ret[i] = 1
+                return _ret
+        else:
+            raise TypeError("cannot handle %s" % type(x))
+
+    def neighbors(self, x, ordinal=True, with_weight=False):
+        if isinstance(x, torch.Tensor):
+            x = x.numpy().tolist()
+        if isinstance(x, list):
+            return [self.neighbors(_x) for _x in x]
+        elif isinstance(x, (int, float)):
+            if not ordinal:
+                return list(self.graph.neighbors(int(x)))
+            else:
+                _ret = [0] * self.ku_num
+                for i in self.graph.neighbors(int(x)):
+                    if with_weight:
+                        _ret[i] = self.graph[i][x]['weight']
+                    else:
+                        _ret[i] = 1
+                return _ret
+        else:
+            raise TypeError("cannot handle %s" % type(x))
+
+    def forward(self, questions, answers, valid_length=None, compressed_out=True, layout="NTC"):
+        length = questions.shape[1]
+        inputs, axis, batch_size = format_sequence(length, questions, layout, False)
+        answers, _, _ = format_sequence(length, answers, layout, False)
+
+        states = begin_states([(batch_size, self.ku_num, self.hidden_num)])[0]
+        outputs = []
+        all_states = []
+        for i in range(length):
+            # neighbors - aggregate
+            inputs_i = inputs[i].reshape([batch_size, ])
+            answer_i = answers[i].reshape([batch_size, ])
+
+            _neighbors = self.neighbors(inputs_i)
+            neighbors_mask = expand_tensor(torch.Tensor(_neighbors), -1, self.hidden_num)
+            _neighbors_mask = expand_tensor(torch.Tensor(_neighbors), -1, self.hidden_num + self.latent_dim)
+
+            # get concept embedding
+            concept_embeddings = self.concept_embedding.weight.data
+            concept_embeddings = expand_tensor(concept_embeddings, 0, batch_size)
+
+            agg_states = torch.cat((concept_embeddings, states), dim=-1)
+
+            # aggregate
+            _neighbors_states = _neighbors_mask * agg_states
+
+            # self - aggregate
+            _concept_embedding = get_states(inputs_i, states)
+            _self_hidden_states = torch.cat((_concept_embedding, self.response_embedding(answer_i)), dim=-1)
+
+            _self_mask = F.one_hot(inputs_i, self.ku_num)  # p
+            _self_mask = expand_tensor(_self_mask, -1, self.hidden_num)
+
+            self_hidden_states = expand_tensor(_self_hidden_states, 1, self.ku_num)
+
+            # aggregate
+            _hidden_states = torch.cat((_neighbors_states, self_hidden_states), dim=-1)
+
+            _in_state = self.n_in(_hidden_states)
+            _out_state = self.n_out(_hidden_states)
+            in_weight = expand_tensor(torch.Tensor(self.in_weight(inputs_i)), -1, self.hidden_num)
+            out_weight = expand_tensor(torch.Tensor(self.out_weight(inputs_i)), -1, self.hidden_num)
+
+            next_neighbors_states = in_weight * _in_state + out_weight * _out_state
+
+            # self - update
+            next_self_states = self.f_self(_self_hidden_states)
+            next_self_states = expand_tensor(next_self_states, 1, self.ku_num)
+            next_self_states = _self_mask * next_self_states
+
+            next_states = neighbors_mask * next_neighbors_states + next_self_states
+
+            next_states, _ = self.rnn(next_states, [states])
+            next_states = (_self_mask + neighbors_mask) * next_states + (1 - _self_mask - neighbors_mask) * states
+
+            states = self.dropout(next_states)
+            output = torch.sigmoid(self.out(states).squeeze(axis=-1))  # p
+            outputs.append(output)
+            if valid_length is not None and not compressed_out:
+                all_states.append([states])
+
+        if valid_length is not None:
+            if compressed_out:
+                states = None
+            outputs = mask_sequence_variable_length(torch, outputs, length, valid_length, axis, merge=True)
+
+        return outputs, states

EduKTM/GKT/__init__.py

@@ -0,0 +1,6 @@
+# coding: utf-8
+# 2022/2/25 @ fannazya
+
+
+from .GKT import GKT
+from .etl import etl

EduKTM/GKT/etl.py

@@ -0,0 +1,77 @@
+# coding: utf-8
+# 2022/2/25 @ fannazya
+
+
+import torch
+import json
+from tqdm import tqdm
+from EduKTM.utils.torch import PadSequence, FixedBucketSampler
+
+
+def extract(data_src, max_step=200):  # pragma: no cover
+    responses = []
+    step = max_step
+    with open(data_src) as f:
+        for line in tqdm(f, "reading data from %s" % data_src):
+            data = json.loads(line)
+            if step is not None:
+                for i in range(0, len(data), step):
+                    if len(data[i: i + step]) < 2:
+                        continue
+                    responses.append(data[i: i + step])
+            else:
+                responses.append(data)
+
+    return responses
+
+
+def transform(raw_data, batch_size, num_buckets=100):
+    # 定义数据转换接口
+    # raw_data --> batch_data
+
+    responses = raw_data
+
+    batch_idxes = FixedBucketSampler([len(rs) for rs in responses], batch_size, num_buckets=num_buckets)
+    batch = []
+
+    def index(r):
+        correct = 0 if r[1] <= 0 else 1
+        return r[0] * 2 + correct
+
+    for batch_idx in tqdm(batch_idxes, "batchify"):
+        batch_qs = []
+        batch_rs = []
+        batch_pick_index = []
+        batch_labels = []
+        for idx in batch_idx:
+            batch_qs.append([r[0] for r in responses[idx]])
+            batch_rs.append([index(r) for r in responses[idx]])
+            if len(responses[idx]) <= 1:  # pragma: no cover
+                pick_index, labels = [], []
+            else:
+                pick_index, labels = zip(*[(r[0], 0 if r[1] <= 0 else 1) for r in responses[idx][1:]])
+            batch_pick_index.append(list(pick_index))
+            batch_labels.append(list(labels))
+
+        max_len = max([len(rs) for rs in batch_rs])
+        padder = PadSequence(max_len, pad_val=0)
+        batch_qs = [padder(qs) for qs in batch_qs]
+        batch_rs, data_mask = zip(*[(padder(rs), len(rs)) for rs in batch_rs])
+
+        max_len = max([len(rs) for rs in batch_labels])
+        padder = PadSequence(max_len, pad_val=0)
+        batch_labels, label_mask = zip(*[(padder(labels), len(labels)) for labels in batch_labels])
+        batch_pick_index = [padder(pick_index) for pick_index in batch_pick_index]
+        # Load
+        batch.append(
+            [torch.tensor(batch_qs), torch.tensor(batch_rs), torch.tensor(data_mask), torch.tensor(batch_labels),
+             torch.tensor(batch_pick_index),
+             torch.tensor(label_mask)])
+
+    return batch
+
+
+def etl(data_src, cfg=None, batch_size=None, **kwargs):  # pragma: no cover
+    batch_size = batch_size if batch_size is not None else cfg.batch_size
+    raw_data = extract(data_src)
+    return transform(raw_data, batch_size, **kwargs)

EduKTM/__init__.py

@@ -8,3 +8,4 @@
 from .DKTPlus import DKTPlus
 from .AKT import AKT
 from .LPKT import LPKT
+from .GKT import GKT

EduKTM/utils/torch/__init__.py

@@ -3,3 +3,4 @@
 
 from .extlib import *
 from .functional import *
+from .rnn import *