更新 function.py

function.py

@@ -1,6 +1,9 @@
 # function.py
 import numpy as np
-import pandas as pd
+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
 
 
 """
@@ -30,94 +33,139 @@ name = "邓龙树"
 
 
 # 这里写自己的代码实现
-def train_svm(X, y, learning_rate=0.01, iterations=1000):
-    """
-    支持向量机训练函数。
-
-    Args:
-    - X (numpy array): 特征数据。
-    - y (numpy array): 标签数据。
-
-    Returns:
-    - numpy array: 训练得到的权重。
-    """
-    num_samples, num_features = X.shape
-    weights = np.zeros(num_features)
-    # 迭代更新权重
-    for _ in range(iterations):
-        for i in range(num_samples):
-            if y[i] * (np.dot(X[i], weights)) < 1:
-                weights += learning_rate * (y[i] * X[i])
-    return weights
-
-
-def predict_svm(inX, weights):
-    """
-    支持向量机预测函数。
-
-    Args:
-    - inX (numpy array): 输入待分类的样本。
-    - weights (numpy array): 训练得到的权重。
-
-    Returns:
-    - int: 预测的分类标签。
-    """
-    result = np.dot(inX, weights)
-    # 根据结果判断类别（更合理的三分类策略调整）
-    if result >= 0.5:
-        return 1
-    elif result < -0.5:
-        return 3
-    return 2
-
-
 def load_data(filepath):
     """
     从文件中加载数据，若不自行正确实现，则无法通过评测，**不记录成绩**。
 
     Args:
-    - directory (str): 数据文件路径。
+    - filepath (str): 数据文件路径。
 
     Returns:
     - np.array: 特征数据。
     - np.array: 标签数据。
     """
-    # 使用pandas读取数据文件，假设数据是用空格等分隔的简单文本格式，可根据实际调整
+    data = []
-    df = pd.read_csv(filepath, sep=' ', header=None, na_values='?')  # 将 '?' 视为缺失值
+    labels = []
-    # 填充缺失值，这里简单用0填充，也可以根据特征的分布等采用更合理的填充方式，比如均值填充等
+    with open(filepath, 'r') as file:
-    df.fillna(0, inplace=True)
+        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
+            label_mapping = {1: 0, 2: 1, 3: 2}
+            if label in label_mapping:
+                label = label_mapping[label]
+            else:
+                print(f"无效标签，跳过此样本：{label}")
+                continue  # 跳过无效标签
+            data.append(features)
+            labels.append(label)
+    return np.array(data), np.array(labels)
 
-    # 先检查标签列是否存在除1、2、3之外的其他值，整体进行判断
-    unique_labels = df.iloc[:, -1].unique()
-    if not all(label in [1, 2, 3] for label in unique_labels):
-        raise ValueError("数据标签列存在不符合1、2、3三分类要求的值，请检查数据文件")
 
-    # 获取特征数据和标签数据
+def train_svm(X, y, C):
-    data = df.iloc[:, :-1].values
+    """
-    labels = df.iloc[:, -1].values.astype(int)
+    训练支持向量机模型。
 
-    # 选择特征23（从1开始由左向右数）作为目标变量
+    Args:
-    data = data[:, 22].reshape(-1, 1)
+    - X (numpy array): 特征数据。
-    return data, labels
+    - y (numpy array): 标签数据。
+    - C (float): SVM的正则化参数C。
+
+    Returns:
+    - SVC: 训练好的SVM模型。
+    """
+    model = SVC(kernel='rbf', C=C, gamma='scale', random_state=42)
+    model.fit(X, y)
+    return model
+
+
+def cross_validation(X_full_train, y_full_train, C_values):
+    """
+    进行交叉验证，选出最佳模型。
+
+    Args:
+    - X_full_train (numpy array): 完整训练集的特征数据。
+    - y_full_train (numpy array): 完整训练集的标签数据。
+    - C_values (list): 要尝试的SVM正则化参数C的取值列表。
+
+    Returns:
+    - SVC: 在交叉验证中表现最佳的模型。
+    """
+    best_accuracy = 0
+    best_model = None
+    kf = KFold(n_splits=5, shuffle=True, random_state=42)
+    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 = train_svm(X_train_fold, y_train_fold, C)
+            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
+    return best_model
+
+
+def evaluate_model(model, X_final_test, y_final_test):
+    """
+    使用模型在最终测试集上进行评估并输出相关结果。
+
+    Args:
+    - model (SVC): 训练好的模型。
+    - X_final_test (numpy array): 最终测试集的特征数据。
+    - y_final_test (numpy array): 最终测试集的标签数据。
+    """
+    y_pred = 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}%")
+
+
+def predict_single_sample(model, test_sample, actual_result):
+    """
+    使用模型对单个样本进行预测并输出预测结果和实际结果对比。
+
+    Args:
+    - model (SVC): 训练好的模型。
+    - test_sample (numpy array): 单个测试样本的特征数据。
+    - actual_result (int): 单个测试样本的实际标签。
+    """
+    y_pred_single = model.predict(test_sample.reshape(1, -1))[0]
+    print(f"\n单个样本预测结果: {y_pred_single}, 实际结果: {actual_result}")
 
 
 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("./horse-colic.test")
-    X_test, y_test = load_data("./data/horse-colic.test")
 
-    # 训练支持向量机模型
+    # 划分数据集（这里划分出一部分作为最终测试集，剩下的用于交叉验证训练）
-    weights = train_svm(X_train, y_train, learning_rate=0.01, iterations=1000)
+    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)
 
-    # 统计正确分类的样本个数
+    # 数据标准化
-    correct_count = 0
+    scaler = StandardScaler()
-    for i in range(len(X_test)):
+    X_full_train = scaler.fit_transform(X_full_train)
-        y_pred = predict_svm(X_test[i], weights)
+    X_final_test = scaler.transform(X_final_test)
-        if y_pred == y_test[i]:
-            correct_count += 1
 
-    # 计算准确率（得分）
+    # 定义要尝试的C值列表
-    score = correct_count / len(X_test) * 100
+    C_values = [0.1, 1, 10]
 
-    print(f"预测准确率: {score}%")
+    # 进行交叉验证选出最佳模型
+    best_model = cross_validation(X_full_train, y_full_train, C_values)
+
+    # 使用在交叉验证中选出的最佳模型在最终测试集上进行评估
+    evaluate_model(best_model, X_final_test, y_final_test)
+
+    # 测试单个数据
+    test_sample = X_final_test[11]  # 选择第12个样本（从0开始计数）
+    predict_single_sample(best_model, test_sample, y_final_test[11])