更新 function.py

function.py

@@ -2,19 +2,16 @@ import numpy as np
 import pandas as pd
 from sklearn.preprocessing import StandardScaler
 from sklearn.model_selection import train_test_split
-from sklearn.linear_model import LogisticRegression
 
 id = "202210423130"
 name = "董秋"
 
-def train_logreg(X, y, learning_rate=0.01, iterations=1500, lambda_reg=0.01):
+def train_logreg(X, y, learning_rate=0.01, iterations=1000, lambda_reg=0.01):
     """
     逻辑回归训练函数。
-
     Args:
     - X (numpy array): 特征数据。
     - y (numpy array): 标签数据。
-
     Returns:
     - numpy array: 训练得到的权重。
     """
@@ -22,37 +19,26 @@ def train_logreg(X, y, learning_rate=0.01, iterations=1500, lambda_reg=0.01):
     weights = np.zeros(n)
 
     for i in range(iterations):
-        # 每100次迭代后随机打乱数据
-        if i % 100 == 0:
-            indices = np.arange(m)
-            np.random.shuffle(indices)
-            X = X[indices]
-            y = y[indices]
-
         z = np.dot(X, weights)
         predictions = 1 / (1 + np.exp(-z))
         gradient = np.dot(X.T, (predictions - y)) / m
         
-        # L2正则化：将正则项添加到梯度上
+        # L2正则化
         gradient += (lambda_reg / m) * weights
 
-        # 更新权重
         weights -= learning_rate * gradient
 
-        # 每100次迭代后衰减学习率
-        if i % 100 == 0 and i > 0:  # 确保不在第一次迭代后衰减学习率
-            learning_rate *= 0.99  # 每次100次迭代将学习率乘以0.99
+        # 动态调整学习率，逐渐减小
+        learning_rate *= 0.99  # 每次迭代将学习率乘以0.99
 
     return weights
 
 def predict_logreg(inX, weights):
     """
     逻辑回归预测函数。
-
     Args:
     - inX (numpy array): 输入待分类的样本。
     - weights (numpy array): 训练得到的权重。
-
     Returns:
     - int: 预测的分类标签。
     """
@@ -69,37 +55,45 @@ def load_data(filepath):
             values = line.strip().replace('?', '0').split()
             try:
                 values = [float(v) for v in values]
-                if values[22] == 2 or values[22] == 3:
-                    labels.append(0)
+                
+                # 合并特征23的取值
+                if values[22] == 2 or values[22] == 3:  # 特征23（索引22）
+                    labels.append(0)  # 死亡
                 elif values[22] == 1:
-                    labels.append(1)
+                    labels.append(1)  # 生存
                 else:
-                    continue
-                values = [0 if np.isnan(v) else v for v in values]
-                data.append(values[:2] + values[3:23])  # 根据数据结构选择特征
+                    continue  # 无效标签，丢弃
+                
+                # 用0填充缺失值
+                values = [np.nan if v == 0 else v for v in values]  # 先标记为NaN
+                data.append(values[:2] + values[3:23])  # 保留特征1, 2 和特征4-23
             except ValueError:
                 continue
 
-    return np.array(data), np.array(labels)
+    data = np.array(data)
+    labels = np.array(labels)
+
+    # 使用均值填充处理缺失值
+    df = pd.DataFrame(data)
+    df.fillna(df.mean(), inplace=True)  # 均值填充
+
+    return df.to_numpy(), labels
 
 def preprocess_data(X):
-    # 标准化
+    # 特征标准化
     scaler = StandardScaler()
-    X_scaled = scaler.fit_transform(X)
-    return X_scaled
+    return scaler.fit_transform(X)
 
 if __name__ == "__main__":
     # 加载数据集
     X, y = load_data("./data/horse-colic.data")
     X = preprocess_data(X)
+
+    # 使用 train_test_split 打乱并随机抽取数据
     X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
 
-    # 使用sklearn的LogisticRegression进行训练
-    model = LogisticRegression(penalty='l2', solver='lbfgs', max_iter=2000)
-    model.fit(X_train, y_train)
-
-    # 获取权重
-    weights = model.coef_[0]  # 只获取第一类的权重
+    # 训练逻辑回归模型
+    weights = train_logreg(X_train, y_train, learning_rate=0.1, iterations=1000, lambda_reg=0.01)
 
     # 测试单个数据
     y_pred = predict_logreg(X_test[11], weights)