fix bug:cannot run on cuda device

Author: ViviHong200709

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

@@ -53,6 +53,7 @@ def __init__(self, user_num, item_num, value_range=None, a_range=None):
         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)
@@ -76,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,8 @@ 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 +65,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

@@ -75,6 +75,7 @@ def __init__(self, user_num, item_num, latent_dim, a_range=None):
         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)
@@ -98,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 = []