Merge pull request #33 from ViviHong200709/main

[BUGFIX] Limit the range of parameters in IRT and MIRT

Author: tswsxk

EduCDM/DINA/GD/DINA.py

@@ -85,6 +85,7 @@ def __init__(self, user_num, item_num, hidden_dim, ste=False):
             self.dina_net = DINANet(user_num, item_num, hidden_dim)
 
     def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.001) -> ...:
+        self.dina_net = self.dina_net.to(device)
         loss_function = nn.BCELoss()
 
         trainer = torch.optim.Adam(self.dina_net.parameters(), lr)
@@ -109,10 +110,11 @@ def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.00
             print("[Epoch %d] LogisticLoss: %.6f" % (e, float(np.mean(losses))))
 
             if test_data is not None:
-                auc, accuracy = self.eval(test_data)
+                auc, accuracy = self.eval(test_data, device=device)
                 print("[Epoch %d] auc: %.6f, accuracy: %.6f" % (e, auc, accuracy))
 
     def eval(self, test_data, device="cpu") -> tuple:
+        self.dina_net = self.dina_net.to(device)
         self.dina_net.eval()
         y_pred = []
         y_true = []

EduCDM/IRR/DINA.py

@@ -17,6 +17,7 @@ def __init__(self, user_num, item_num, knowledge_num, ste=False, zeta=0.5):
         self.zeta = zeta
 
     def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.001) -> ...:
+        self.dina_net = self.dina_net.to(device)
         point_loss_function = nn.BCELoss()
         pair_loss_function = PairSCELoss()
         loss_function = HarmonicLoss(self.zeta)
@@ -32,6 +33,7 @@ def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.00
                 user_id: torch.Tensor = user_id.to(device)
                 item_id: torch.Tensor = item_id.to(device)
                 knowledge: torch.Tensor = knowledge.to(device)
+                n_samples: torch.Tensor = n_samples.to(device)
                 predicted_pos_score: torch.Tensor = self.dina_net(user_id, item_id, knowledge)
                 score: torch.Tensor = score.to(device)
                 neg_score = 1 - score
@@ -40,6 +42,7 @@ def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.00
                 predicted_neg_scores = []
                 if neg_users:
                     for neg_user in neg_users:
+                        neg_user: torch.Tensor = neg_user.to(device)
                         predicted_neg_score = self.dina_net(neg_user, item_id, knowledge)
                         predicted_neg_scores.append(predicted_neg_score)
 
@@ -75,10 +78,11 @@ def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.00
             )
 
             if test_data is not None:
-                eval_data = self.eval(test_data)
+                eval_data = self.eval(test_data, device=device)
                 print("[Epoch %d]\n%s" % (e, eval_data))
 
     def eval(self, test_data, device="cpu"):
+        self.dina_net = self.dina_net.to(device)
         self.dina_net.eval()
         y_pred = []
         y_true = []
@@ -87,6 +91,7 @@ def eval(self, test_data, device="cpu"):
             user_id, item_id, knowledge, response = batch_data
             user_id: torch.Tensor = user_id.to(device)
             item_id: torch.Tensor = item_id.to(device)
+            knowledge: torch.Tensor = knowledge.to(device)
             pred: torch.Tensor = self.dina_net(user_id, item_id, knowledge)
             y_pred.extend(pred.tolist())
             y_true.extend(response.tolist())

EduCDM/IRR/IRT.py

@@ -14,12 +14,13 @@
 
 
 class IRT(PointIRT):
-    def __init__(self, user_num, item_num, knowledge_num, value_range=10, zeta=0.5):
-        super(IRT, self).__init__(user_num, item_num, value_range=value_range)
+    def __init__(self, user_num, item_num, knowledge_num, zeta=0.5):
+        super(IRT, self).__init__(user_num, item_num)
         self.knowledge_num = knowledge_num
         self.zeta = zeta
 
     def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.001) -> ...:
+        self.irt_net = self.irt_net.to(device)
         point_loss_function = nn.BCELoss()
         pair_loss_function = PairSCELoss()
         loss_function = HarmonicLoss(self.zeta)
@@ -34,6 +35,7 @@ def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.00
                 user_id, item_id, _, score, n_samples, *neg_users = batch_data
                 user_id: torch.Tensor = user_id.to(device)
                 item_id: torch.Tensor = item_id.to(device)
+                n_samples: torch.Tensor = n_samples.to(device)
                 predicted_pos_score: torch.Tensor = self.irt_net(user_id, item_id)
                 score: torch.Tensor = score.to(device)
                 neg_score = 1 - score
@@ -42,6 +44,7 @@ def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.00
                 predicted_neg_scores = []
                 if neg_users:
                     for neg_user in neg_users:
+                        neg_user: torch.Tensor = neg_user.to(device)
                         predicted_neg_score = self.irt_net(neg_user, item_id)
                         predicted_neg_scores.append(predicted_neg_score)
 
@@ -77,10 +80,11 @@ def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.00
             )
 
             if test_data is not None:
-                eval_data = self.eval(test_data)
+                eval_data = self.eval(test_data, device=device)
                 print("[Epoch %d]\n%s" % (e, eval_data))
 
     def eval(self, test_data, device="cpu"):
+        self.irt_net = self.irt_net.to(device)
         self.irt_net.eval()
         y_pred = []
         y_true = []

EduCDM/IRR/MIRT.py

@@ -22,6 +22,7 @@ def __init__(self, user_num, item_num, knowledge_num, latent_dim=None, zeta=0.5)
         self.zeta = zeta
 
     def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.001) -> ...:
+        self.irt_net = self.irt_net.to(device)
         point_loss_function = nn.BCELoss()
         pair_loss_function = PairSCELoss()
         loss_function = HarmonicLoss(self.zeta)
@@ -36,6 +37,7 @@ def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.00
                 user_id, item_id, _, score, n_samples, *neg_users = batch_data
                 user_id: torch.Tensor = user_id.to(device)
                 item_id: torch.Tensor = item_id.to(device)
+                n_samples: torch.Tensor = n_samples.to(device)
                 predicted_pos_score: torch.Tensor = self.irt_net(user_id, item_id)
                 score: torch.Tensor = score.to(device)
                 neg_score = 1 - score
@@ -44,6 +46,7 @@ def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.00
                 predicted_neg_scores = []
                 if neg_users:
                     for neg_user in neg_users:
+                        neg_user: torch.Tensor = neg_user.to(device)
                         predicted_neg_score = self.irt_net(neg_user, item_id)
                         predicted_neg_scores.append(predicted_neg_score)
 
@@ -79,10 +82,11 @@ def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.00
             )
 
             if test_data is not None:
-                eval_data = self.eval(test_data)
+                eval_data = self.eval(test_data, device=device)
                 print("[Epoch %d]\n%s" % (e, eval_data))
 
     def eval(self, test_data, device="cpu"):
+        self.irt_net = self.irt_net.to(device)
         self.irt_net.eval()
         y_pred = []
         y_true = []

EduCDM/IRR/NCDM.py

@@ -17,6 +17,7 @@ def __init__(self, user_num, item_num, knowledge_num, zeta=0.5):
         self.zeta = zeta
 
     def train(self, train_data, test_data=None, epoch=10, device="cpu", lr=0.002, silence=False) -> ...:
+        self.ncdm_net = self.ncdm_net.to(device)
         point_loss_function = nn.BCELoss()
         pair_loss_function = PairSCELoss()
         loss_function = HarmonicLoss(self.zeta)
@@ -32,6 +33,7 @@ def train(self, train_data, test_data=None, epoch=10, device="cpu", lr=0.002, si
                 user_id: torch.Tensor = user_id.to(device)
                 item_id: torch.Tensor = item_id.to(device)
                 knowledge: torch.Tensor = knowledge.to(device)
+                n_samples: torch.Tensor = n_samples.to(device)
                 predicted_pos_score: torch.Tensor = self.ncdm_net(user_id, item_id, knowledge)
                 score: torch.Tensor = score.to(device)
                 neg_score = 1 - score
@@ -40,6 +42,7 @@ def train(self, train_data, test_data=None, epoch=10, device="cpu", lr=0.002, si
                 predicted_neg_scores = []
                 if neg_users:
                     for neg_user in neg_users:
+                        neg_user: torch.Tensor = neg_user.to(device)
                         predicted_neg_score = self.ncdm_net(neg_user, item_id, knowledge)
                         predicted_neg_scores.append(predicted_neg_score)
 
@@ -75,10 +78,11 @@ def train(self, train_data, test_data=None, epoch=10, device="cpu", lr=0.002, si
             )
 
             if test_data is not None:
-                eval_data = self.eval(test_data)
+                eval_data = self.eval(test_data, device=device)
                 print("[Epoch %d]\n%s" % (e, eval_data))
 
     def eval(self, test_data, device="cpu"):
+        self.ncdm_net = self.ncdm_net.to(device)
         self.ncdm_net.eval()
         y_pred = []
         y_true = []
@@ -87,6 +91,7 @@ def eval(self, test_data, device="cpu"):
             user_id, item_id, knowledge, response = batch_data
             user_id: torch.Tensor = user_id.to(device)
             item_id: torch.Tensor = item_id.to(device)
+            knowledge: torch.Tensor = knowledge.to(device)
             pred: torch.Tensor = self.ncdm_net(user_id, item_id, knowledge)
             y_pred.extend(pred.tolist())
             y_true.extend(response.tolist())

EduCDM/IRT/GD/IRT.py

@@ -6,13 +6,14 @@
 import torch
 from EduCDM import CDM
 from torch import nn
+import torch.nn.functional as F
 from tqdm import tqdm
 from ..irt import irt3pl
 from sklearn.metrics import roc_auc_score, accuracy_score
 
 
 class IRTNet(nn.Module):
-    def __init__(self, user_num, item_num, value_range, irf_kwargs=None):
+    def __init__(self, user_num, item_num, value_range, a_range, irf_kwargs=None):
         super(IRTNet, self).__init__()
         self.user_num = user_num
         self.item_num = item_num
@@ -22,16 +23,23 @@ def __init__(self, user_num, item_num, value_range, irf_kwargs=None):
         self.b = nn.Embedding(self.item_num, 1)
         self.c = nn.Embedding(self.item_num, 1)
         self.value_range = value_range
+        self.a_range = a_range
 
     def forward(self, user, item):
         theta = torch.squeeze(self.theta(user), dim=-1)
-        theta = self.value_range * (torch.sigmoid(theta) - 0.5)
         a = torch.squeeze(self.a(item), dim=-1)
-        a = torch.sigmoid(a)
         b = torch.squeeze(self.b(item), dim=-1)
-        b = self.value_range * (torch.sigmoid(b) - 0.5)
         c = torch.squeeze(self.c(item), dim=-1)
         c = torch.sigmoid(c)
+        if self.value_range is not None:
+            theta = self.value_range * (torch.sigmoid(theta) - 0.5)
+            b = self.value_range * (torch.sigmoid(b) - 0.5)
+        if self.a_range is not None:
+            a = self.a_range * torch.sigmoid(a)
+        else:
+            a = F.softplus(a)
+        if torch.max(theta != theta) or torch.max(a != a) or torch.max(b != b):  # pragma: no cover
+            raise ValueError('ValueError:theta,a,b may contains nan!  The value_range or a_range is too large.')
         return self.irf(theta, a, b, c, **self.irf_kwargs)
 
     @classmethod
@@ -40,11 +48,12 @@ def irf(cls, theta, a, b, c, **kwargs):
 
 
 class IRT(CDM):
-    def __init__(self, user_num, item_num, value_range=10):
+    def __init__(self, user_num, item_num, value_range=None, a_range=None):
         super(IRT, self).__init__()
-        self.irt_net = IRTNet(user_num, item_num, value_range)
+        self.irt_net = IRTNet(user_num, item_num, value_range, a_range)
 
     def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.001) -> ...:
+        self.irt_net = self.irt_net.to(device)
         loss_function = nn.BCELoss()
 
         trainer = torch.optim.Adam(self.irt_net.parameters(), lr)
@@ -68,10 +77,11 @@ def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.00
             print("[Epoch %d] LogisticLoss: %.6f" % (e, float(np.mean(losses))))
 
             if test_data is not None:
-                auc, accuracy = self.eval(test_data)
+                auc, accuracy = self.eval(test_data, device=device)
                 print("[Epoch %d] auc: %.6f, accuracy: %.6f" % (e, auc, accuracy))
 
     def eval(self, test_data, device="cpu") -> tuple:
+        self.irt_net = self.irt_net.to(device)
         self.irt_net.eval()
         y_pred = []
         y_true = []

EduCDM/MCD/MCD.py

@@ -36,6 +36,7 @@ def __init__(self, user_num, item_num, latent_dim):
         self.mf_net = MFNet(user_num, item_num, latent_dim)
 
     def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.001) -> ...:
+        self.mf_net = self.mf_net.to(device)
         loss_function = nn.BCELoss()
 
         trainer = torch.optim.Adam(self.mf_net.parameters(), lr)
@@ -63,6 +64,7 @@ def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.00
                 print("[Epoch %d] auc: %.6f, accuracy: %.6f" % (e, auc, accuracy))
 
     def eval(self, test_data, device="cpu") -> tuple:
+        self.mf_net = self.mf_net.to(device)
         self.mf_net.eval()
         y_pred = []
         y_true = []

EduCDM/MIRT/MIRT.py

@@ -7,6 +7,7 @@
 import torch
 from EduCDM import CDM
 from torch import nn
+import torch.nn.functional as F
 from tqdm import tqdm
 from sklearn.metrics import roc_auc_score, accuracy_score
 
@@ -41,19 +42,26 @@ def irt2pl(theta, a, b, *, F=np):
 
 
 class MIRTNet(nn.Module):
-    def __init__(self, user_num, item_num, latent_dim, irf_kwargs=None):
+    def __init__(self, user_num, item_num, latent_dim, a_range, irf_kwargs=None):
         super(MIRTNet, self).__init__()
         self.user_num = user_num
         self.item_num = item_num
         self.irf_kwargs = irf_kwargs if irf_kwargs is not None else {}
         self.theta = nn.Embedding(self.user_num, latent_dim)
         self.a = nn.Embedding(self.item_num, latent_dim)
         self.b = nn.Embedding(self.item_num, 1)
+        self.a_range = a_range
 
     def forward(self, user, item):
         theta = torch.squeeze(self.theta(user), dim=-1)
         a = torch.squeeze(self.a(item), dim=-1)
+        if self.a_range is not None:
+            a = self.a_range * torch.sigmoid(a)
+        else:
+            a = F.softplus(a)
         b = torch.squeeze(self.b(item), dim=-1)
+        if torch.max(theta != theta) or torch.max(a != a) or torch.max(b != b):  # pragma: no cover
+            raise ValueError('ValueError:theta,a,b may contains nan!  The a_range is too large.')
         return self.irf(theta, a, b, **self.irf_kwargs)
 
     @classmethod
@@ -62,11 +70,12 @@ def irf(cls, theta, a, b, **kwargs):
 
 
 class MIRT(CDM):
-    def __init__(self, user_num, item_num, latent_dim):
+    def __init__(self, user_num, item_num, latent_dim, a_range=None):
         super(MIRT, self).__init__()
-        self.irt_net = MIRTNet(user_num, item_num, latent_dim)
+        self.irt_net = MIRTNet(user_num, item_num, latent_dim, a_range)
 
     def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.001) -> ...:
+        self.irt_net = self.irt_net.to(device)
         loss_function = nn.BCELoss()
 
         trainer = torch.optim.Adam(self.irt_net.parameters(), lr)
@@ -90,10 +99,11 @@ def train(self, train_data, test_data=None, *, epoch: int, device="cpu", lr=0.00
             print("[Epoch %d] LogisticLoss: %.6f" % (e, float(np.mean(losses))))
 
             if test_data is not None:
-                auc, accuracy = self.eval(test_data)
+                auc, accuracy = self.eval(test_data, device=device)
                 print("[Epoch %d] auc: %.6f, accuracy: %.6f" % (e, auc, accuracy))
 
     def eval(self, test_data, device="cpu") -> tuple:
+        self.irt_net = self.irt_net.to(device)
         self.irt_net.eval()
         y_pred = []
         y_true = []

tests/irt/gd/test_gdirt.py

@@ -2,6 +2,7 @@
 # 2021/4/23 @ tongshiwei
 
 from EduCDM import GDIRT
+import pytest
 
 
 def test_train(data, conf, tmp_path):
@@ -11,3 +12,15 @@ def test_train(data, conf, tmp_path):
     filepath = tmp_path / "mcd.params"
     cdm.save(filepath)
     cdm.load(filepath)
+
+
+def test_exception(data, conf, tmp_path):
+    try:
+        user_num, item_num = conf
+        cdm = GDIRT(user_num, item_num, value_range=10, a_range=100)
+        cdm.train(data, test_data=data, epoch=2)
+        filepath = tmp_path / "mcd.params"
+        cdm.save(filepath)
+        cdm.load(filepath)
+    except ValueError:
+        print(ValueError)

tests/mirt/test_mirt.py

@@ -2,6 +2,7 @@
 # 2021/4/23 @ tongshiwei
 
 from EduCDM import MIRT
+import pytest
 
 
 def test_train(data, conf, tmp_path):
@@ -11,3 +12,15 @@ def test_train(data, conf, tmp_path):
     filepath = tmp_path / "mcd.params"
     cdm.save(filepath)
     cdm.load(filepath)
+
+
+def test_exception(data, conf, tmp_path):
+    try:
+        user_num, item_num = conf
+        cdm = MIRT(user_num, item_num, 10, a_range=100)
+        cdm.train(data, test_data=data, epoch=2)
+        filepath = tmp_path / "mcd.params"
+        cdm.save(filepath)
+        cdm.load(filepath)
+    except ValueError:
+        print(ValueError)