本文目录导读：
的模糊粗糙贝叶斯优化脚本，这个脚本结合了模糊逻辑、粗糙集理论和贝叶斯优化的特点。
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""模糊粗糙贝叶斯优化
结合模糊逻辑、粗糙集和贝叶斯优化的文件优化工具
"""
import numpy as np
from scipy import stats
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import Matern, WhiteKernel, RBF
from sklearn.preprocessing import StandardScaler
import re
import os
import warnings
warnings.filterwarnings('ignore')
class FuzzyRoughBayesianOptimizer:
"""
模糊粗糙贝叶斯优化器
用于优化文件内容参数
"""
def __init__(self, file_path, target_metric='size'):
self.file_path = file_path
self.target_metric = target_metric
self.content = self._load_file()
self.optimization_history = []
# 模糊隶属度函数参数
self.fuzzy_params = {
'low': (0, 0.3),
'medium': (0.2, 0.8),
'high': (0.7, 1.0)
}
# 粗糙集近似参数
self.rough_params = {
'lower_approx': 0.3,
'upper_approx': 0.7,
'boundary_region': 0.4
}
# 初始化高斯过程
kernel = 1.0 * Matern(length_scale=1.0, nu=2.5) + WhiteKernel(noise_level=0.1)
self.gp = GaussianProcessRegressor(
kernel=kernel,
n_restarts_optimizer=10,
random_state=42
)
self.scaler = StandardScaler()
self.is_fitted = False
def _load_file(self):
"""加载文件内容"""
try:
with open(self.file_path, 'r', encoding='utf-8') as f:
return f.read()
except UnicodeDecodeError:
with open(self.file_path, 'rb') as f:
return f.read().decode('latin-1')
except FileNotFoundError:
raise FileNotFoundError(f"文件 {self.file_path} 未找到")
def _extract_features(self, content):
"""提取文件特征向量"""
features = {}
# 文本统计特征
features['char_count'] = len(content)
features['word_count'] = len(content.split())
features['line_count'] = content.count('\n') + 1
# 语言特征
if isinstance(content, str):
features['avg_word_len'] = np.mean([len(w) for w in content.split()]) if content.split() else 0
features['unique_ratio'] = len(set(content.split())) / max(len(content.split()), 1)
# 标点符号比例
punct_count = len(re.findall(r'[.,!?;:\'\"()\[\]{}]', content))
features['punct_ratio'] = punct_count / max(len(content), 1)
# 大写字母比例
upper_count = sum(1 for c in content if c.isupper())
features['upper_ratio'] = upper_count / max(len(content), 1)
return np.array(list(features.values()))
def _fuzzy_membership(self, value, membership_type='medium'):
"""计算模糊隶属度"""
if membership_type == 'low':
a, b = self.fuzzy_params['low']
if value <= a:
return 1.0
elif value <= b:
return (b - value) / (b - a)
else:
return 0.0
elif membership_type == 'medium':
a, b = self.fuzzy_params['medium']
if value <= a:
return 0.0
elif value <= (a + b) / 2:
return (value - a) / ((b - a) / 2)
elif value <= b:
return (b - value) / ((b - a) / 2)
else:
return 0.0
elif membership_type == 'high':
a, b = self.fuzzy_params['high']
if value <= a:
return 0.0
elif value <= b:
return (value - a) / (b - a)
else:
return 1.0
def _rough_set_approximation(self, features, threshold=0.5):
"""计算粗糙集近似"""
# 下近似：完全属于某类
lower_approx = np.minimum(np.maximum(features - self.rough_params['lower_approx'], 0), 1)
lower_approx = np.mean(lower_approx > threshold)
# 上近似：可能属于某类
upper_approx = np.minimum(np.maximum(features + self.rough_params['upper_approx'], 0), 1)
upper_approx = np.mean(upper_approx > threshold)
# 边界区域
boundary = upper_approx - lower_approx
return lower_approx, upper_approx, boundary
def _objective_function(self, params):
"""目标函数：评估参数配置的质量"""
# 解析参数
scale_factor, noise_level, complexity = params
features = self._extract_features(self.content)
# 计算模糊评分
fuzzy_scores = []
for f in features:
low_score = self._fuzzy_membership(f, 'low')
med_score = self._fuzzy_membership(f, 'medium')
high_score = self._fuzzy_membership(f, 'high')
fuzzy_scores.append(max(low_score, med_score, high_score))
fuzzy_score = np.mean(fuzzy_scores) * scale_factor
# 计算粗糙集近似
rough_features = features / np.max(features) if np.max(features) > 0 else features
lower, upper, boundary = self._rough_set_approximation(rough_features)
# 组合评分（带噪声和复杂度惩罚）
score = (fuzzy_score * 0.4 +
(lower + upper) * 0.3 +
(1 - boundary) * 0.3)
# 添加噪声和复杂度惩罚
noise_penalty = noise_level * np.random.randn() * 0.1
complexity_penalty = complexity * 0.05
final_score = score * (1 - noise_penalty) - complexity_penalty
# 记录优化历史
self.optimization_history.append({
'params': params,
'score': final_score,
'fuzzy_score': fuzzy_score,
'rough_approx': (lower, upper, boundary)
})
return final_score
def optimize(self, n_iterations=20, n_initial=5):
"""
执行模糊粗糙贝叶斯优化
参数:
- n_iterations: 总迭代次数
- n_initial: 初始随机采样次数
"""
# 定义参数空间
param_ranges = {
'scale_factor': (0.5, 2.0),
'noise_level': (0.0, 0.5),
'complexity': (0.0, 1.0)
}
# 初始随机采样
X_samples = []
y_samples = []
print(f"开始模糊粗糙贝叶斯优化...")
print(f"文件: {self.file_path}")
print(f"初始特征: {self._extract_features(self.content)}")
print("-" * 50)
for i in range(n_initial):
params = np.array([np.random.uniform(low, high)
for low, high in param_ranges.values()])
score = self._objective_function(params)
X_samples.append(params)
y_samples.append(score)
print(f"初始采样 {i+1}/{n_initial}: 参数={params.round(3)}, 分数={score:.4f}")
X_samples = np.array(X_samples)
y_samples = np.array(y_samples)
# 标准化
X_scaled = self.scaler.fit_transform(X_samples)
# 拟合高斯过程
self.gp.fit(X_scaled, y_samples)
self.is_fitted = True
# 贝叶斯优化循环
for i in range(n_iterations - n_initial):
# 采集函数（期望改进）
def acquisition(x):
x = x.reshape(1, -1)
mean, std = self.gp.predict(x, return_std=True)
best_y = np.max(self.optimization_history, key=lambda x: x['score'])['score']
if std > 0:
z = (mean - best_y) / std
ei = (mean - best_y) * stats.norm.cdf(z) + std * stats.norm.pdf(z)
else:
ei = 0
return ei
# 寻找最优采样点
best_ei = -np.inf
best_params = None
for _ in range(100): # 随机搜索
candidate = np.array([np.random.uniform(low, high)
for low, high in param_ranges.values()])
candidate_scaled = self.scaler.transform(candidate.reshape(1, -1))
ei = acquisition(candidate_scaled)
if ei > best_ei:
best_ei = ei
best_params = candidate
# 评估最优参数
score = self._objective_function(best_params)
# 更新高斯过程
X_samples = np.vstack([X_samples, best_params])
y_samples = np.append(y_samples, score)
X_scaled = self.scaler.fit_transform(X_samples)
self.gp.fit(X_scaled, y_samples)
print(f"迭代 {i+1}/{n_iterations - n_initial}: "
f"参数={best_params.round(3)}, 分数={score:.4f}, EI={best_ei:.4f}")
# 找到最优解
best_idx = np.argmax(y_samples)
best_params = X_samples[best_idx]
best_score = y_samples[best_idx]
print("-" * 50)
print(f"优化完成!")
print(f"最优参数: scale_factor={best_params[0]:.3f}, "
f"noise_level={best_params[1]:.3f}, "
f"complexity={best_params[2]:.3f}")
print(f"最优分数: {best_score:.4f}")
return {
'best_params': best_params,
'best_score': best_score,
'optimization_history': self.optimization_history,
'convergence': np.max(y_samples[-min(10, len(y_samples)):]) - best_score
}
def generate_optimized_content(self, params=None):
"""生成优化后的文件内容"""
if params is None:
if len(self.optimization_history) > 0:
best = max(self.optimization_history, key=lambda x: x['score'])
params = best['params']
else:
params = np.array([1.0, 0.1, 0.3])
scale_factor, noise_level, complexity = params
# 根据优化参数修改内容
lines = self.content.split('\n')
optimized_lines = []
for line in lines:
if line.strip():
# 根据复杂度决定是否修改
if np.random.random() < complexity:
# 应用模糊规则修改
if np.random.random() < scale_factor * 0.5:
# 添加冗余（模糊扩展）
line = line + ' ' + line[-min(len(line), 10):]
elif np.random.random() < 0.3:
# 压缩内容
words = line.split()
if len(words) > 5:
keep_ratio = 1 - noise_level
keep_count = max(2, int(len(words) * keep_ratio))
line = ' '.join(words[:keep_count])
optimized_lines.append(line)
return '\n'.join(optimized_lines)
def save_optimized_content(self, output_path=None, params=None):
"""保存优化后的内容"""
if output_path is None:
base, ext = os.path.splitext(self.file_path)
output_path = f"{base}_optimized{ext}"
optimized_content = self.generate_optimized_content(params)
with open(output_path, 'w', encoding='utf-8') as f:
f.write(optimized_content)
print(f"优化后的内容已保存到: {output_path}")
return output_path
def main():
"""主函数示例"""
import sys
if len(sys.argv) < 2:
print("用法: python script.py <file_path> [iterations]")
print("示例: python script.py myfile.txt 30")
return
file_path = sys.argv[1]
n_iterations = int(sys.argv[2]) if len(sys.argv) > 2 else 20
try:
# 创建优化器
optimizer = FuzzyRoughBayesianOptimizer(file_path)
# 执行优化
result = optimizer.optimize(n_iterations=n_iterations)
# 保存优化后的文件
optimizer.save_optimized_content()
# 显示优化摘要
print("\n优化摘要:")
print(f"优化迭代次数: {len(result['optimization_history'])}")
print(f"收敛指标: {result['convergence']:.6f}")
print(f"最终参数配置: {result['best_params'].round(3)}")
except Exception as e:
print(f"错误: {e}")
sys.exit(1)
if __name__ == "__main__":
main()
安装依赖
pip install numpy scipy scikit-learn
使用示例
# 基本用法
optimizer = FuzzyRoughBayesianOptimizer('your_file.txt')
result = optimizer.optimize(n_iterations=30)
# 生成优化内容
optimized_file = optimizer.save_optimized_content('optimized_output.txt')
# 查看优化历史
for entry in result['optimization_history'][-5:]:
print(f"Score: {entry['score']:.4f}, Params: {entry['params']}")
脚本功能特点
-
模糊逻辑处理：
- 使用三角隶属度函数评估参数质量
- 支持低、中、高三种模糊级别
-
粗糙集近似：
- 计算下近似和上近似
- 识别边界区域
-
贝叶斯优化：
- 使用高斯过程回归建模
- 期望改进（EI）采集函数
- 自适应参数选择
-
文件优化能力：
- 文本特征提取结构调整
- 参数自适应优化
-
可视化支持（可选）：
可以添加matplotlib绘制优化曲线
高级用法
# 自定义参数
optimizer = FuzzyRoughBayesianOptimizer('input.txt')
# 调整模糊参数
optimizer.fuzzy_params['medium'] = (0.3, 0.7)
# 调整粗糙集参数
optimizer.rough_params['lower_approx'] = 0.4
# 执行深入优化
result = optimizer.optimize(n_iterations=50, n_initial=10)
# 生成多个候选优化版本
for i in range(3):
output_path = f"optimized_v{i+1}.txt"
optimizer.save_optimized_content(output_path)
这个脚本提供了一个完整的模糊粗糙贝叶斯优化框架,可以根据实际需求调整参数和扩展功能。
