更新 function.py

function.py

@@ -30,95 +30,128 @@ name = "章程鸿"
 # 这里写自己的代码实现
 import numpy as np
 from sklearn.svm import SVC
+from sklearn.model_selection import train_test_split, KFold
+from sklearn.metrics import classification_report, accuracy_score
 from sklearn.preprocessing import StandardScaler
 
+# 数据加载函数
 def load_data(filepath):
     """
-    从文件中加载数据，并进行必要的预处理，处理缺失值。
+    从文件中加载数据，若不自行正确实现，则无法通过评测，**不记录成绩**。
 
     Args:
-    - filepath (str): 数据文件路径。
+    - directory (str): 数据文件路径。
 
     Returns:
-    - X (numpy array): 特征数据。
+    - np.array: 特征数据。
-    - y (numpy array): 标签数据。
+    - np.array: 标签数据。
     """
-    # 加载数据，假设分隔符是空格或者制表符
+    data = []
-    data = np.genfromtxt(filepath, delimiter=' ', dtype=str)
+    labels = []
+    with open(filepath, 'r') as file:
+        for line in file:
+            fields = line.strip().split()
+            # 处理缺失值，用0填充
+            fields = [0 if f == '?' else float(f) for f in fields]
+            # 标签是倒数第6列
+            label = int(fields[-6])
+            # 特征为其他列（不包含倒数第6列标签）
+            features = np.array(fields[: -6] + fields[-5:], dtype=float)
+            # 标签映射：将 1->0, 2->1, 3->2
+            if label == 1:
+                label = 0
+            elif label == 2:
+                label = 1
+            elif label == 3:
+                label = 2
+            else:
+                print(f"无效标签，跳过此样本：{label}")
+                continue  # 跳过无效标签
+            # 添加数据和标签
+            data.append(features)
+            labels.append(label)
+    # 转换为numpy数组
+    data = np.array(data)
+    labels = np.array(labels)
+    return data, labels
 
-    # 处理缺失值，将 '?' 替换为 np.nan
-    data[data == '?'] = np.nan
 
-    # 将非数值字段转为浮动类型
+def train_svm(X, y, other_params=None):
-    data = data.astype(np.float64)
-
-    # 选择特征和标签
-    X = data[:, :-1]  # 特征数据（假设最后一列是目标变量）
-    y = data[:, -1]   # 最后一列作为目标变量
-    
-    # 不合并死亡与安乐死，直接使用原始标签
-    # 1 = lived, 2 = died, 3 = euthanized
-    
-    # 将缺失值填充为 0（或其他合适的值）
-    X = np.nan_to_num(X, nan=0)
-    
-    return X, y
-
-def train_svm(X, y):
     """
-    使用 SVM 核方法进行训练。
+    支持向量机训练函数。
 
     Args:
     - X (numpy array): 特征数据。
     - y (numpy array): 标签数据。
+    - other_params (str): 其它参数，可选设置。若需设置其它参数，必须设置其默认值，否则将无法通过自动评测，成绩为零。
 
     Returns:
-    - model (SVC): 训练得到的 SVM 模型。
+    - SVC: 训练好的SVM模型。
-    - scaler (StandardScaler): 用于后续预测的数据标准化器。
     """
-    # 数据标准化
+    model = SVC(kernel='rbf', C=1.0, gamma='scale', random_state=42)
-    scaler = StandardScaler()
+    model.fit(X, y)
-    X_scaled = scaler.fit_transform(X)
+    return model
 
-    # 使用RBF核的SVM模型
-    model = SVC(kernel='rbf', decision_function_shape='ovo')  # 采用RBF核，多类分类使用'ovo'
-    model.fit(X_scaled, y)
 
-    return model, scaler
+def predict_svm(inX, model):
-
-def predict_svm(model, scaler, X):
     """
-    使用训练好的SVM模型进行预测。
+    支持向量机预测函数。
 
     Args:
-    - model (SVC): 训练好的SVM模型。
+    - inX (numpy array): 输入待分类的样本。
-    - scaler (StandardScaler): 标准化器，用于测试数据的标准化。
+    - model (SVC): 训练得到的支持向量机模型。
-    - X (numpy array): 输入特征数据。
 
     Returns:
-    - int: 预测标签。
+    - int: 预测的分类标签。
     """
-    X_scaled = scaler.transform([X])  # 将输入特征进行标准化
+    return model.predict(inX.reshape(1, -1))[0]
-    return model.predict(X_scaled)[0]
+
 
 if __name__ == "__main__":
     # 加载数据
-    X_train, y_train = load_data("./data/horse-colic.data")
+    X_train, y_train = load_data("./horse-colic.data")
-    X_test, y_test = load_data("./data/horse-colic.test")
+    X_test, y_test = load_data("./horse-colic.test")
 
-    # 训练SVM
+    # 划分数据集（这里划分出一部分作为最终测试集，剩下的用于交叉验证训练）
-    model, scaler = train_svm(X_train, y_train)
+    X_full_train, X_final_test, y_full_train, y_final_test = train_test_split(X_train, y_train, test_size=0.2, random_state=42, stratify=y_train)
 
-    # 测试单个数据点
+    # 数据标准化
-    y_pred = predict_svm(model, scaler, X_test[11])
+    scaler = StandardScaler()
-    print(f"预测结果: {y_pred}, 实际结果: {y_test[11]}")
+    X_full_train = scaler.fit_transform(X_full_train)
+    X_final_test = scaler.transform(X_final_test)
 
-    # 测试整个测试集并评估准确率
+    # 定义要尝试的C值列表
-    correct = 0
+    C_values = [0.1, 1, 10]
-    for i in range(len(X_test)):
+    best_accuracy = 0
-        y_pred = predict_svm(model, scaler, X_test[i])
+    best_model = None
-        if y_pred == y_test[i]:
+    kf = KFold(n_splits=5, shuffle=True, random_state=42)
-            correct += 1
+    for C in C_values:
+        avg_accuracy = 0
+        for train_index, val_index in kf.split(X_full_train):
+            X_train_fold, X_val_fold = X_full_train[train_index], X_full_train[val_index]
+            y_train_fold, y_val_fold = y_full_train[train_index], y_full_train[val_index]
+            model = SVC(kernel='rbf', C=C, gamma='scale', random_state=42)
+            model.fit(X_train_fold, y_train_fold)
+            y_pred_fold = model.predict(X_val_fold)
+            accuracy_fold = accuracy_score(y_val_fold, y_pred_fold)
+            avg_accuracy += accuracy_fold
+        avg_accuracy /= 5
+        if avg_accuracy > best_accuracy:
+            best_accuracy = avg_accuracy
+            best_model = model
 
-    accuracy = correct / len(X_test) * 100
+    # 使用在交叉验证中选出的最佳模型在最终测试集上进行评估
-    print(f"测试集准确率: {accuracy}%")
+    y_pred = best_model.predict(X_final_test)
+
+    # 输出评估结果
+    print("\n分类报告:")
+    print(classification_report(y_final_test, y_pred, target_names=["存活", "安乐死", "死亡"]))
+
+    # 输出准确率
+    accuracy = accuracy_score(y_final_test, y_pred)
+    print(f"测试集准确率: {accuracy * 100:.2f}%")
+
+    # 测试单个数据
+    test_sample = X_final_test[11]  # 选择第12个样本（从0开始计数）
+    y_pred_single = predict_svm(test_sample, best_model)
+    print(f"\n单个样本预测结果: {y_pred_single}, 实际结果: {y_final_test[11]}")