脚本如何实现文件内容模糊粗糙集

wen 实用脚本 2026-07-06 181

本文目录导读：

脚本如何实现文件内容模糊粗糙集

模糊粗糙集基本概念
Python实现示例
运行说明

的模糊粗糙集处理。

模糊粗糙集基本概念

模糊粗糙集结合了模糊集和粗糙集理论,处理不确定性和模糊性信息。

Python实现示例

1 基础模糊粗糙集类

import numpy as np
import pandas as pd
from typing import List, Dict, Tuple
class FuzzyRoughSet:
    def __init__(self, decision_factor: float = 0.5):
        """
        初始化模糊粗糙集
        :param decision_factor: 决策阈值
        """
        self.decision_factor = decision_factor
        self.fuzzy_equivalence = None
    def compute_similarity(self, x: np.array, y: np.array) -> float:
        """计算两个对象的模糊相似度"""
        if np.array_equal(x, y):
            return 1.0
        # 使用高斯核函数计算相似度
        diff = np.abs(x - y)
        similarity = np.exp(-np.sum(diff ** 2) / (2 * 0.5 ** 2))
        return similarity
    def fuzzy_upper_approximation(self, data: np.array, concept: np.array) -> np.array:
        """计算模糊上近似"""
        n_samples = len(data)
        upper_approx = np.zeros(n_samples)
        for i in range(n_samples):
            max_membership = 0
            for j in range(n_samples):
                if concept[j] > 0:  # 属于概念的对象
                    similarity = self.compute_similarity(data[i], data[j])
                    membership = min(similarity, concept[j])
                    max_membership = max(max_membership, membership)
            upper_approx[i] = max_membership
        return upper_approx
    def fuzzy_lower_approximation(self, data: np.array, concept: np.array) -> np.array:
        """计算模糊下近似"""
        n_samples = len(data)
        lower_approx = np.ones(n_samples)
        for i in range(n_samples):
            min_membership = 1
            for j in range(n_samples):
                if concept[j] > 0:  # 属于概念的对象
                    similarity = self.compute_similarity(data[i], data[j])
                    if similarity > 0:
                        membership = max(1 - similarity, concept[j])
                        min_membership = min(min_membership, membership)
            lower_approx[i] = min_membership
        return lower_approx

2 文件内容处理类

import re
from collections import Counter
from sklearn.feature_extraction.text import TfidfVectorizer
class FileContentFuzzyRough:
    def __init__(self):
        self.frs = FuzzyRoughSet()
        self.vectorizer = TfidfVectorizer(max_features=100, stop_words='english')
    def read_file(self, filepath: str) -> str:
        """读取文件内容"""
        try:
            with open(filepath, 'r', encoding='utf-8') as file:
                content = file.read()
            return content
        except Exception as e:
            print(f"读取文件 {filepath} 时出错: {e}")
            return ""
    def preprocess_text(self, text: str) -> str:
        """预处理文本"""
        # 转换为小写
        text = text.lower()
        # 移除非字母字符
        text = re.sub(r'[^a-zA-Z\s]', '', text)
        # 去除多余空格
        text = ' '.join(text.split())
        return text
    def extract_keywords(self, text: str, top_k: int = 10) -> List[str]:
        """提取关键词"""
        words = text.split()
        word_freq = Counter(words)
        # 返回最常出现的top_k个词
        return [word for word, _ in word_freq.most_common(top_k)]
    def create_feature_vector(self, files_content: List[str]) -> np.array:
        """创建特征向量矩阵"""
        # 预处理所有文件内容
        processed_content = [self.preprocess_text(content) for content in files_content]
        # 使用TF-IDF转换为特征向量
        feature_matrix = self.vectorizer.fit_transform(processed_content)
        return feature_matrix.toarray()
    def fuzzy_rough_clustering(self, files: List[str], categories: Dict[str, float] = None) -> Dict:
        """
        模糊粗糙聚类
        :param files: 文件路径列表
        :param categories: 文件类别隶属度字典
        :return: 聚类结果
        """
        # 读取所有文件内容
        file_contents = [self.read_file(file) for file in files]
        # 创建特征矩阵
        feature_matrix = self.create_feature_vector(file_contents)
        if categories is None:
            # 如果没有预定义类别，使用K均值初始化
            categories = self._initialize_categories(feature_matrix)
        # 计算模糊上下近似
        results = {}
        for category, membership in categories.items():
            if isinstance(membership, (int, float)):
                membership = np.array([membership] * len(files))
            upper = self.frs.fuzzy_upper_approximation(feature_matrix, membership)
            lower = self.frs.fuzzy_lower_approximation(feature_matrix, membership)
            results[category] = {
                'upper': upper,
                'lower': lower,
                'boundary': upper - lower
            }
        return results
    def _initialize_categories(self, feature_matrix: np.array) -> Dict[str, np.array]:
        """初始化类别隶属度"""
        n_samples = len(feature_matrix)
        # 简单K均值初始化
        from sklearn.cluster import KMeans
        kmeans = KMeans(n_clusters=3, random_state=42)
        labels = kmeans.fit_predict(feature_matrix)
        categories = {}
        unique_labels = np.unique(labels)
        for label in unique_labels:
            category_name = f"Category_{label}"
            membership = (labels == label).astype(float)
            categories[category_name] = membership
        return categories

3 高级模糊粗糙集处理

class AdvancedFuzzyRoughSet:
    def __init__(self, fuzzy_relation: str = 'gaussian'):
        self.fuzzy_relation = fuzzy_relation
    def fuzzy_granulation(self, data: np.array, granularity: float = 0.8) -> List[np.array]:
        """
        模糊粒化
        :param data: 输入数据
        :param granularity: 粒度参数
        :return: 粒化后的模糊集
        """
        n_samples = len(data)
        granules = []
        for i in range(n_samples):
            granule = np.zeros(n_samples)
            for j in range(n_samples):
                if i != j:
                    similarity = self._compute_similarity(data[i], data[j])
                    granule[j] = 1 if similarity >= granularity else 0
                else:
                    granule[j] = 1  # 自反性
            granules.append(granule)
        return granules
    def _compute_similarity(self, x: np.array, y: np.array) -> float:
        """计算模糊相似度"""
        if self.fuzzy_relation == 'gaussian':
            diff = np.linalg.norm(x - y)
            return np.exp(-diff ** 2)
        elif self.fuzzy_relation == 'triangular':
            diff = np.abs(x - y).mean()
            return max(0, 1 - diff)
        else:
            return 1 / (1 + np.linalg.norm(x - y))
    def fuzzy_similarity_matrix(self, data: np.array) -> np.array:
        """计算模糊相似矩阵"""
        n_samples = len(data)
        similarity_matrix = np.zeros((n_samples, n_samples))
        for i in range(n_samples):
            for j in range(n_samples):
                similarity_matrix[i][j] = self._compute_similarity(data[i], data[j])
        return similarity_matrix
    def attribute_reduction(self, data: np.array, labels: np.array) -> List[int]:
        """
        属性约简
        :param data: 属性数据
        :param labels: 标签数据
        :return: 重要属性索引
        """
        n_features = data.shape[1]
        feature_importance = []
        for feature_idx in range(n_features):
            # 计算该特征的重要性
            feature_data = data[:, feature_idx].reshape(-1, 1)
            importance = self._feature_importance(feature_data, labels)
            feature_importance.append((feature_idx, importance))
        # 按重要性排序
        feature_importance.sort(key=lambda x: x[1], reverse=True)
        # 返回重要属性索引
        threshold = 0.5  # 重要性阈值
        important_features = [idx for idx, imp in feature_importance if imp > threshold]
        return important_features
    def _feature_importance(self, feature_data: np.array, labels: np.array) -> float:
        """计算特征重要性"""
        # 简单方法：使用信息增益
        from sklearn.feature_selection import mutual_info_classif
        if len(np.unique(labels)) > 1:  # 确保有多个类别
            mi = mutual_info_classif(feature_data, labels.ravel())[0]
            return mi
        return 0.0

4 使用示例

def main():
    # 示例文件列表
    files = [
        "document1.txt",
        "document2.txt",
        "document3.txt"
    ]
    # 创建示例文件
    sample_contents = {
        "document1.txt": "This is a sample document about machine learning and artificial intelligence.",
        "document2.txt": "Deep learning is a subset of machine learning with neural networks.",
        "document3.txt": "Natural language processing involves text analysis and understanding."
    }
    for filename, content in sample_contents.items():
        with open(filename, 'w') as f:
            f.write(content)
    # 1. 基础模糊粗糙集处理
    print("=== 基础模糊粗糙集处理 ===")
    fcr = FileContentFuzzyRough()
    # 读取文件内容
    for file in files:
        content = fcr.read_file(file)
        processed = fcr.preprocess_text(content)
        keywords = fcr.extract_keywords(processed)
        print(f"文件 {file} 的关键词: {keywords}")
    # 2. 模糊粗糙聚类
    print("\n=== 模糊粗糙聚类 ===")
    results = fcr.fuzzy_rough_clustering(files)
    for category, result in results.items():
        print(f"\n{category}:")
        print(f"  上近似: {result['upper']}")
        print(f"  下近似: {result['lower']}")
        print(f"  边界域: {result['boundary']}")
    # 3. 高级模糊粗糙集处理
    print("\n=== 高级模糊粗糙集处理 ===")
    afrs = AdvancedFuzzyRoughSet()
    # 创建示例数据
    data = np.array([
        [1, 0, 1],
        [0, 1, 0],
        [1, 1, 1],
        [0, 0, 0]
    ])
    labels = np.array([1, 0, 1, 0])
    # 属性约简
    important_features = afrs.attribute_reduction(data, labels)
    print(f"重要属性索引: {important_features}")
    # 模糊相似矩阵
    similarity = afrs.fuzzy_similarity_matrix(data)
    print(f"模糊相似矩阵:\n{similarity}")
if __name__ == "__main__":
    main()