本文目录导读：
的模糊粗糙集处理。
模糊粗糙集基本概念
模糊粗糙集结合了模糊集和粗糙集理论,处理不确定性和模糊性信息。
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()
运行说明
-
安装依赖：
pip install numpy pandas scikit-learn
-
运行脚本：
python fuzzy_rough_set.py
-
输出结果将显示：
- 文件的关键词提取结果
- 模糊粗糙聚类的上下近似值
- 重要属性索引
这个实现提供了模糊粗糙集的基本框架,可以处理文件内容的模糊分类和特征约简任务。
