訓練模型是機器學習和深度學習中的核心過程，旨在通過大量數據學習模型參數，以便模型能夠對新的、未見過的數據做出準確的預測。

訓練模型通常包括以下幾個步驟：

1.數據準備：
收集和處理數據，包括清洗、標準化和歸一化。
將數據分為訓練集、驗證集和測試集。

2.定義模型：
選擇模型架構，例如決策樹、神經網絡等。
初始化模型參數（權重和偏置）。

3.選擇損失函數：
根據任務類型（如分類、回歸）選擇合適的損失函數。

4.選擇優化器：
選擇一個優化算法，如SGD、Adam等，來更新模型參數。

5.前向傳播：
在每次迭代中，將輸入數據通過模型傳遞，計算預測輸出。

6.計算損失：
使用損失函數評估預測輸出與真實標簽之間的差異。

7.反向傳播：
利用自動求導計算損失相對于模型參數的梯度。

8.參數更新：
根據計算出的梯度和優化器的策略更新模型參數。

9.迭代優化：
重復步驟5-8，直到模型在驗證集上的性能不再提升或達到預定的迭代次數。

10.評估和測試：
使用測試集評估模型的最終性能，確保模型沒有過擬合。

11.模型調優：
根據模型在測試集上的表現進行調參，如改變學習率、增加正則化等。

12.部署模型：
將訓練好的模型部署到生產環境中，用于實際的預測任務。

---

一、PyTorch 數據處理與加載

PyTorch 提供了Dataset 和 DataLoader，幫助管理數據集、批量加載和數據增強等任務。

PyTorch 數據處理與加載：
自定義 Dataset：通過繼承 torch.utils.data.Dataset 來加載自己的數據集。
DataLoader：使用DataLoader 按批次加載數據，支持多線程加載并進行數據打亂。（torch.utils.data.DataLoader）

（一）自定義 Dataset

torch.utils.data.Dataset 是一個抽象類，允許你自己的數據源中創建數據集。

使用時需要繼承該類并實現以下兩個方法：
len(self)：返回數據集中的樣本數量。
getitem(self, idx)：通過索引返回一個樣本。

import os
import numpy as np
import pandas as pd
from torch.utils.data import Dataset
from models.utils import match_seq_lenDATASET_DIR = "D:\EMDKT\datasets\ASSIST2009"class ASSIST2009(Dataset):def __init__(self, seq_len, dataset_dir=DATASET_DIR) -> None:super().__init__()self.dataset_dir = dataset_dirself.dataset_path = os.path.join(self.dataset_dir, "skill_builder_data.csv")# 調用預處理self.q_seqs, self.r_seqs, self.q_list, self.u_list, self.q2idx, \self.u2idx = self.preprocess()self.num_u = self.u_list.shape[0]  # 用戶總數self.num_q = self.q_list.shape[0]  # 題目總數if seq_len:self.q_seqs, self.r_seqs = match_seq_len(self.q_seqs, self.r_seqs, seq_len)self.len = len(self.q_seqs)def __getitem__(self, index):return self.q_seqs[index], self.r_seqs[index]def __len__(self):return self.lendef preprocess(self):# 數據加載與清洗df = pd.read_csv(self.dataset_path, encoding="ISO-8859-15").dropna(subset=["skill_name"]).drop_duplicates(subset=["order_id", "skill_name"]).sort_values(by=["order_id"])u_list = np.unique(df["user_id"].values)q_list = np.unique(df["skill_name"].values)u2idx = {u: idx for idx, u in enumerate(u_list)}q2idx = {q: idx for idx, q in enumerate(q_list)}# 生成序列數據q_seqs = []r_seqs = []for u in u_list:df_u = df[df["user_id"] == u]q_seq = np.array([q2idx[q] for q in df_u["skill_name"]])r_seq = df_u["correct"].valuesq_seqs.append(q_seq)r_seqs.append(r_seq)# 返回結果return q_seqs, r_seqs, q_list, u_list, q2idx, u2idx

（二）使用 DataLoader 加載數據

DataLoader 是 PyTorch 提供的一個重要工具，用于從 Dataset 中按批次（batch）加載數據。
DataLoader 允許批量讀取數據并進行多線程加載，從而提高訓練效率。

from torch.utils.data import DataLoader, random_split
from models.utils import collate_fn# 加載數據集
dataset = ASSIST2009(seq_len)  # seq_len 是序列長度參數# 劃分數據集
train_size = int(len(dataset) * train_ratio)  # train_ratio 是訓練集比例
test_size = len(dataset) - train_size
train_dataset, test_dataset = random_split(dataset, [train_size, test_size]
)# 創建數據加載器
train_loader = DataLoader(train_dataset,batch_size=batch_size,  # batch_size 是批處理大小shuffle=True,collate_fn=collate_fn  # 使用自定義的collate函數
)test_loader = DataLoader(test_dataset,batch_size=test_size,  # 測試集使用整個測試集作為一個批次shuffle=True,collate_fn=collate_fn  # 使用自定義的collate函數
)

注釋：
batch_size: 每次加載的樣本數量。
shuffle: 是否對數據進行洗牌，通常訓練時需要將數據打亂。

二、模型架構實現

通過繼承 nn.Module 來定義模型

class DKT(Module):def __init__(self, num_q, emb_size, hidden_size):super().__init__()self.num_q = num_qself.emb_size = emb_sizeself.hidden_size = hidden_sizeself.interaction_emb = Embedding(self.num_q * 2, self.emb_size)self.lstm_layer = LSTM(self.emb_size, self.hidden_size, batch_first=True)self.out_layer = Linear(self.hidden_size, self.num_q)self.dropout_layer = Dropout()def forward(self, q, r):'''q: [batch_size, n]r: [batch_size, n]'''x = q + self.num_q * rh, _ = self.lstm_layer(self.interaction_emb(x))y = self.out_layer(h)y = self.dropout_layer(y)y = torch.sigmoid(y)return y# 創建模型實例
model = DKT()

---

三、訓練配置

（一）初始化模型與設備

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')model = DKT(dataset.num_q, emb_size=100,hidden_size=100).to(device)

（二）定義損失函數與優化器

損失函數用于衡量預測值與真實值之間的差異。PyTorch 中提供了現成的損失函數。
將使用 SGD（隨機梯度下降） 或 Adam 優化器來最小化損失函數。

（1）損失函數

from torch.nn.functional import binary_cross_entropy
criterion = nn.binary_cross_entropy()

（2）優化器

from torch.optim import SGD, Adamif optimizer == "sgd":opt = SGD(model.parameters(), learning_rate, momentum=0.9)elif optimizer == "adam":opt = Adam(model.parameters(), learning_rate)

（三）訓練模型評估模型

在訓練過程中，將執行以下步驟：
使用輸入數據 X 進行前向傳播，得到預測值。
計算損失（預測值與實際值之間的差異）。
使用反向傳播計算梯度。
更新模型參數（權重和偏置）。

# 訓練模型
num_epochs = 1000  # 訓練 1000 輪
for epoch in range(num_epochs):model.train()  # 設置模型為訓練模式# 前向傳播predictions = model(X)  # 模型輸出預測值loss = criterion(predictions.squeeze(), Y)  # 計算損失# 反向傳播optimizer.zero_grad()  # 清空之前的梯度loss.backward()  # 計算梯度optimizer.step()  # 更新模型參數# 打印損失if (epoch + 1) % 100 == 0:print(f'Epoch [{epoch + 1}/1000], Loss: {loss.item():.4f}')

注釋：
optimizer.zero_grad()：每次反向傳播前需要清空之前的梯度。
loss.backward()：計算梯度。
optimizer.step()：更新權重和偏置。

（四）評估模型

訓練完成后，可以通過查看模型的權重和偏置來評估模型的效果

with torch.no_grad():  # 評估時不需要計算梯度predictions = model(X)

（五）訓練循環實現

import os
import numpy as np
import torch
from torch.nn.functional import one_hot, binary_cross_entropy
from sklearn import metricsdef train_dkt_model(model, train_loader, test_loader, num_epochs, optimizer, ckpt_path):"""訓練DKT模型的獨立函數參數:model: 要訓練的DKT模型實例train_loader: 訓練數據加載器test_loader: 測試數據加載器num_epochs: 訓練輪數optimizer: 優化器實例ckpt_path: 模型檢查點保存路徑"""aucs = []       # 存儲每輪測試AUCloss_means = [] # 存儲每輪平均訓練損失max_auc = 0     # 記錄最佳AUC# 開始訓練循環for epoch in range(1, num_epochs + 1):epoch_losses = []  # 存儲當前epoch的訓練損失# 訓練階段model.train()for data in train_loader:# 解包數據q, r, qshft, rshft, mask = data# 前向傳播y_pred = model(q.long(), r.long())y_pred = (y_pred * one_hot(qshft.long(), model.num_q)).sum(-1)# 應用掩碼選擇有效預測valid_pred = torch.masked_select(y_pred, mask)valid_target = torch.masked_select(rshft, mask)# 計算損失loss = binary_cross_entropy(valid_pred, valid_target)# 反向傳播optimizer.zero_grad()loss.backward()optimizer.step()# 記錄損失epoch_losses.append(loss.detach().cpu().item())# 計算本輪平均訓練損失epoch_loss_mean = np.mean(epoch_losses)loss_means.append(epoch_loss_mean)# 驗證階段model.eval()all_preds = []all_targets = []with torch.no_grad():for data in test_loader:q, r, qshft, rshft, mask = data# 預測并選擇有效結果y_pred = model(q.long(), r.long())y_pred = (y_pred * one_hot(qshft.long(), model.num_q)).sum(-1)valid_pred = torch.masked_select(y_pred, mask).cpu().numpy()valid_target = torch.masked_select(rshft, mask).cpu().numpy()all_preds.extend(valid_pred)all_targets.extend(valid_target)# 計算整體AUCauc = metrics.roc_auc_score(all_targets, all_preds)aucs.append(auc)# 打印訓練信息print(f"Epoch: {epoch}, AUC: {auc:.4f}, Loss Mean: {epoch_loss_mean:.4f}")# 保存最佳模型if auc > max_auc:torch.save(model.state_dict(), os.path.join(ckpt_path, "model.ckpt"))max_auc = aucprint(f"保存最佳模型，AUC = {auc:.4f}")return aucs, loss_means

理解 y = self(q.long(), r.long())

這行代碼是知識追蹤模型的核心，表示將輸入數據傳入模型進行前向傳播。

1. 代碼結構解析

y = self(q.long(), r.long())

self: 指當前模型實例（EM_DKT）

q.long(): 將問題ID序列轉換為長整型（整數類型）

r.long(): 將響應序列（0/1）轉換為長整型

y: 模型輸出（預測概率）

2. 數據流分析

輸入數據
變量 含義 維度 示例
q 問題ID序列 (batch_size, seq_len) [[101, 102, 0], [201, 0, 0]]
r 響應序列 (batch_size, seq_len) [[1, 0, 0], [0, 0, 0]]

3. 模型內部處理（在EM_DKT.forward()中）

步驟1: 交互編碼

x = q + self.num_q * r

目的: 創建唯一的交互ID
邏輯:
-正確響應: ID = q + num_q * 1
-錯誤響應: ID = q + num_q * 0 = q

示例:
問題101正確: 101 + 100 * 1 = 201
問題101錯誤: 101 + 100 * 0= 101

步驟2: 嵌入層

emb = self.interaction_emb(x)

輸入: 交互ID (batch_size, seq_len)
輸出: 嵌入向量 (batch_size, seq_len, emb_size)
作用: 將離散ID映射為連續向量表示

步驟3: XLSTM處理

for t in range(seq_len):x_t = emb[:, t, :]  # 當前時間步h_t, states = self.xlstm(x_t, states)y_t = self.out_layer(h_t)

XLSTM結構:
-7層MLSTM: 處理長期知識狀態
-1層ELSTM: 處理近期動態

狀態傳遞: 每個時間步更新內部狀態

輸出: 每個時間步的隱藏表示 (hidden_size)

步驟4: 輸出層

y = torch.stack(outputs, dim=1)
y = torch.sigmoid(y)

維度變化: (batch_size, seq_len, num_q)
sigmoid激活: 將輸出轉換為概率[0,1]

4. 輸出

輸出 y 的結構[batch_size，seq_len，num_q]
輸出示例 y[0, 2, 101] = 0.85
表示：批次0中，第2個時間步后，學生答對問題101的概率是85%

5. 實際應用場景

訓練時

# 預測下一個問題的正確概率
y_next = (y * one_hot(qshft)).sum(-1)

預測時

# 獲取學生當前知識狀態
current_state = self.xlstm.states# 預測下一個問題
next_q = 105
next_input = create_input(next_q)
next_pred = self(next_input, current_state)

6. 數學表示

模型本質上學習了一個函數：

$P(r_{t+1}=1|q_{1:t},r_{1:t})=f(q_{1:t},r_{1:t})$
其中：

$q_{1:t}$: 到時間t為止的問題序列

$r_{1:t}$: 到時間t為止的響應序列

$f$: 由EM_DKT模型參數化的復雜非線性函數