脚本如何实现文件内容模糊粗糙支持向量回归

wen 实用脚本 2026-07-03 24

本文目录导读：

完整实现代码
核心功能说明
使用建议

我来为您详细介绍如何用Python实现文件内容的模糊粗糙支持向量回归（Fuzzy Rough Support Vector Regression）。

完整实现代码

import numpy as np
import pandas as pd
from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, r2_score
import warnings
warnings.filterwarnings('ignore')
class FuzzyRoughSVR:
    """
    模糊粗糙支持向量回归
    """
    def __init__(self, C=1.0, epsilon=0.1, kernel='rbf', gamma='scale'):
        self.C = C
        self.epsilon = epsilon
        self.kernel = kernel
        self.gamma = gamma
        self.model = None
        self.scaler_X = StandardScaler()
        self.scaler_y = StandardScaler()
    def compute_fuzzy_membership(self, X):
        """
        计算模糊隶属度
        基于样本的密度和距离
        """
        n_samples = X.shape[0]
        membership = np.ones(n_samples)
        # 计算每个样本到中心的距离
        center = np.mean(X, axis=0)
        distances = np.linalg.norm(X - center, axis=1)
        # 基于距离计算隶属度
        max_dist = np.max(distances)
        if max_dist > 0:
            membership = 1 / (1 + distances / max_dist)
        return membership
    def compute_rough_approximation(self, X, y, k_neighbors=5):
        """
        计算粗糙集近似
        返回上近似和下近似的索引
        """
        from sklearn.neighbors import NearestNeighbors
        n_samples = X.shape[0]
        lower_approx = []
        upper_approx = []
        # 使用KNN找到每个样本的邻居
        nn = NearestNeighbors(n_neighbors=min(k_neighbors, n_samples))
        nn.fit(X)
        for i in range(n_samples):
            # 找到样本的k个最近邻
            distances, indices = nn.kneighbors(X[i].reshape(1, -1))
            neighbor_indices = indices[0]
            # 检查邻居的标签一致性
            neighbor_labels = y[neighbor_indices]
            label_range = np.max(neighbor_labels) - np.min(neighbor_labels)
            # 如果邻居标签变化小，属于下近似
            if label_range < 0.5 * np.std(y):
                lower_approx.append(i)
            else:
                upper_approx.append(i)
        return lower_approx, upper_approx
    def fit(self, X, y):
        """
        训练模糊粗糙SVR模型
        """
        # 数据标准化
        X_scaled = self.scaler_X.fit_transform(X)
        y_scaled = self.scaler_y.fit_transform(y.reshape(-1, 1)).ravel()
        # 计算模糊隶属度
        fuzzy_membership = self.compute_fuzzy_membership(X_scaled)
        # 计算粗糙集近似
        lower_idx, upper_idx = self.compute_rough_approximation(X_scaled, y_scaled)
        # 调整权重：下近似样本权重更高，上近似样本权重较低
        sample_weights = fuzzy_membership.copy()
        sample_weights[lower_idx] *= 1.5  # 下近似权重增加
        sample_weights[upper_idx] *= 0.8  # 上近似权重降低
        # 训练加权SVR
        self.model = SVR(
            C=self_C * np.mean(sample_weights),
            epsilon=self.epsilon,
            kernel=self.kernel,
            gamma=self.gamma
        )
        self.model.fit(X_scaled, y_scaled, sample_weight=sample_weights)
        return self
    def predict(self, X):
        """
        预测
        """
        X_scaled = self.scaler_X.transform(X)
        y_scaled = self.model.predict(X_scaled)
        return self.scaler_y.inverse_transform(y_scaled.reshape(-1, 1)).ravel()
def read_file_content(file_path):
    """
    读取文件内容并转换为特征矩阵
    支持CSV、TXT等格式
    """
    if file_path.endswith('.csv'):
        df = pd.read_csv(file_path)
        # 假设最后一列是目标变量
        X = df.iloc[:, :-1].values
        y = df.iloc[:, -1].values
    elif file_path.endswith('.txt'):
        with open(file_path, 'r') as f:
            lines = f.readlines()
        data = []
        for line in lines:
            if line.strip():
                values = list(map(float, line.strip().split()))
                data.append(values)
        data = np.array(data)
        X = data[:, :-1]
        y = data[:, -1]
    else:
        raise ValueError("不支持的文件格式，请使用CSV或TXT文件")
    return X, y
def train_and_evaluate_model(X, y, test_size=0.2):
    """
    训练和评估模型
    """
    # 划分训练集和测试集
    X_train, X_test, y_train, y_test = train_test_split(
        X, y, test_size=test_size, random_state=42
    )
    # 创建和训练模型
    model = FuzzyRoughSVR(C=1.0, epsilon=0.1, kernel='rbf')
    model.fit(X_train, y_train)
    # 预测
    y_pred = model.predict(X_test)
    # 评估
    mse = mean_squared_error(y_test, y_pred)
    rmse = np.sqrt(mse)
    r2 = r2_score(y_test, y_pred)
    print("模型评估结果:")
    print(f"均方误差 (MSE): {mse:.4f}")
    print(f"均方根误差 (RMSE): {rmse:.4f}")
    print(f"R² 分数: {r2:.4f}")
    return model, y_pred
# 使用示例
if __name__ == "__main__":
    # 生成示例数据
    np.random.seed(42)
    n_samples = 200
    # 创建一个非线性关系的数据
    X = np.random.randn(n_samples, 3)
    y = 2 * X[:, 0] + 3 * np.sin(X[:, 1]) + 0.5 * X[:, 2]**2 + np.random.randn(n_samples) * 0.1
    print("数据形状:", X.shape, y.shape)
    # 训练模型
    model, y_pred = train_and_evaluate_model(X, y)
    # 如果有实际文件，可以使用以下代码
    # X, y = read_file_content('your_file.csv')
    # model, y_pred = train_and_evaluate_model(X, y)
    print("\n部分预测结果:")
    for i in range(min(10, len(y_pred))):
        print(f"实际值: {y[i]:.4f}, 预测值: {y_pred[i]:.4f}")

核心功能说明

模糊隶属度计算

def compute_fuzzy_membership(self, X):
    # 基于样本到中心的距离计算隶属度
    # 距离中心越近，隶属度越高

粗糙集近似

def compute_rough_approximation(self, X, y, k_neighbors=5):
    # 下近似：邻居标签变化小的样本
    # 上近似：邻居标签变化大的样本

加权训练

# 下近似样本权重更高（1.5倍）
# 上近似样本权重降低（0.8倍）

使用建议

参数调整：
- C: 正则化参数，控制误差容忍度
- epsilon: 不敏感区间宽度
- kernel: 核函数类型（'rbf', 'linear', 'poly'）
数据预处理：
- 确保数据没有缺失值
- 考虑标准化特征
文件格式：
- CSV文件：最后一列作为目标变量
- TXT文件：每行一个样本，空格分隔特征

这个实现结合了模糊逻辑处理不确定性、粗糙集处理不精确性,以及SVR的回归能力。