简介
质量优化分类
graph TD
A[质量优化方法] --> B[参数调优]
A --> C[提示词优化]
A --> D[模型选择]
A --> E[后处理技术]
A --> F[质量控制]
B --> B1[采样参数]
B --> B2[CFG优化]
B --> B3[去噪强度]
C --> C1[提示词工程]
C --> C2[权重调整]
C --> C3[负面提示词]
D --> D1[模型对比]
D --> D2[模型微调]
D --> D3[模型融合]
E --> E1[图像增强]
E --> E2[色彩校正]
E --> E3[细节增强]
F --> F1[质量评估]
F --> F2[迭代优化]
F --> F3[A/B测试]
style A fill:#e1f5ff
style B fill:#e1ffe1
style C fill:#e1ffe1
style D fill:#e1ffe1
style E fill:#e1ffe1
style F fill:#e1ffe1
参数调优
1. 采样参数
graph TD
A[采样步数] --> B[低步数 10-20]
A --> C[中步数 20-40]
A --> D[高步数 40-60]
A --> E[超高步数 60+]
B --> B1[速度快]
B --> B2[质量一般]
C --> C1[速度适中]
C --> C2[质量良好]
D --> D1[速度慢]
D --> D2[质量优秀]
E --> E1[速度很慢]
E --> E2[质量最高]
style A fill:#e1f5ff
style B fill:#fff4e1
style C fill:#e1ffe1
style D fill:#e1ffe1
style E fill:#ffe1e1
{
"sampling_steps": {
"fast_preview": {
"steps": 15,
"use_case": "快速预览",
"quality": "⭐⭐⭐"
},
"standard": {
"steps": 30,
"use_case": "标准生成",
"quality": "⭐⭐⭐⭐"
},
"high_quality": {
"steps": 50,
"use_case": "高质量生成",
"quality": "⭐⭐⭐⭐⭐"
},
"ultra_quality": {
"steps": 80,
"use_case": "超高质量",
"quality": "⭐⭐⭐⭐⭐"
}
}
}
| 采样器 | 速度 | 质量 | 适用场景 |
|---|---|---|---|
| euler_a | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | 快速生成 |
| dpmpp_2m | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | 平衡选择 |
| dpmpp_sde | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | 高质量 |
| ddpm | ⭐⭐ | ⭐⭐⭐⭐ | 特定效果 |
2. CFG优化
graph TD
A[CFG值] --> B[低CFG 1.0-4.0]
A --> C[中CFG 4.0-8.0]
A --> D[高CFG 8.0-15.0]
A --> E[超高CFG 15.0+]
B --> B1[创意性强]
B --> B2[约束弱]
C --> C1[平衡创意和约束]
C --> C2[推荐范围]
D --> D1[约束强]
D --> D2[创意弱]
E --> E1[过度约束]
E --> E2[可能失真]
style A fill:#e1f5ff
style B fill:#fff4e1
style C fill:#e1ffe1
style D fill:#fff4e1
style E fill:#ffe1e1
def optimize_cfg(base_prompt, cfg_range=(4.0, 12.0), step=0.5):
"""优化CFG值"""
best_cfg = 7.0
best_score = 0
for cfg in np.arange(cfg_range[0], cfg_range[1], step):
# 生成图像
image = generate_with_cfg(base_prompt, cfg)
# 评估质量
score = evaluate_quality(image)
# 记录最佳
if score > best_score:
best_score = score
best_cfg = cfg
return best_cfg
3. 去噪强度
{
"denoise_strength": {
"low": {
"range": [0.3, 0.5],
"use_case": "轻微修改",
"description": "保持原图大部分特征"
},
"medium": {
"range": [0.5, 0.7],
"use_case": "中等修改",
"description": "平衡原图和生成内容"
},
"high": {
"range": [0.7, 0.9],
"use_case": "大幅修改",
"description": "主要使用生成内容"
},
"full": {
"range": [0.9, 1.0],
"use_case": "完全生成",
"description": "忽略原图"
}
}
}
graph TD
A[选择去噪强度] --> B{任务类型?}
B -->|图像修复| C[0.3-0.5]
B -->|风格转换| D[0.5-0.7]
B -->|图生图| E[0.7-0.9]
B -->|文生图| F[1.0]
C --> C1[保持原图结构]
D --> D2[平衡原图和风格]
E --> E3[主要参考原图]
F --> F4[完全生成]
style A fill:#e1f5ff
style C fill:#e1ffe1
style D fill:#e1ffe1
style E fill:#e1ffe1
style F fill:#e1ffe1
提示词优化
4. 提示词工程
graph TD
A[提示词结构] --> B[质量层]
A --> C[风格层]
A --> D[内容层]
A --> E[技术层]
B --> B1[masterpiece]
B --> B2[best quality]
B --> B3[highly detailed]
C --> C1[艺术风格]
C --> C2[摄影风格]
C --> C3[绘画风格]
D --> D1[主体描述]
D --> D2[动作描述]
D --> D3[环境描述]
E --> E1[8k resolution]
E --> E2[professional photography]
E --> E3[cinematic lighting]
style A fill:#e1f5ff
style B fill:#e1ffe1
style C fill:#e1ffe1
style D fill:#e1ffe1
style E fill:#e1ffe1
class PromptTemplates:
def __init__(self):
self.templates = {
'portrait': self._portrait_template,
'landscape': self._landscape_template,
'artistic': self._artistic_template
}
def get_template(self, template_type, **kwargs):
"""获取提示词模板"""
template_func = self.templates.get(template_type)
if template_func:
return template_func(**kwargs)
return ""
def _portrait_template(self, subject, style="realistic", **kwargs):
"""人像提示词模板"""
quality = "masterpiece, best quality, highly detailed"
style_desc = f"{style} portrait photography"
subject_desc = f"beautiful {subject}, expressive eyes, elegant pose"
technical = "8k resolution, professional photography, cinematic lighting"
return f"{quality}, {style_desc}, {subject_desc}, {technical}"
def _landscape_template(self, scene, time="golden hour", **kwargs):
"""风景提示词模板"""
quality = "masterpiece, best quality, ultra detailed"
style_desc = "landscape photography, dramatic atmosphere"
subject_desc = f"{scene}, {time}, misty valley, majestic mountains"
technical = "8k, wide angle, natural lighting"
return f"{quality}, {style_desc}, {subject_desc}, {technical}"
5. 权重调整
基础权重: (keyword:1.0)
增强权重: (keyword:1.2)
强增强权重: (keyword:1.5)
降低权重: (keyword:0.8)
负向权重: (keyword:-0.5)
def optimize_prompt_weights(base_prompt, keywords, weight_range=(0.5, 2.0)):
"""优化提示词权重"""
best_weights = {}
best_score = 0
for keyword in keywords:
best_weight = 1.0
for weight in np.arange(weight_range[0], weight_range[1], 0.1):
# 应用权重
weighted_prompt = base_prompt.replace(keyword, f"({keyword}:{weight})")
# 生成图像
image = generate_image(weighted_prompt)
# 评估质量
score = evaluate_quality(image)
# 记录最佳权重
if score > best_score:
best_score = score
best_weight = weight
best_weights[keyword] = best_weight
return best_weights
6. 负面提示词
{
"negative_prompts": {
"general": "low quality, worst quality, blurry, distorted, ugly, bad anatomy",
"portrait": "bad eyes, bad hands, bad face, deformed, disfigured, extra limbs",
"landscape": "oversaturated, undersaturated, bad composition, bad lighting",
"artistic": "photorealistic, 3d render, low resolution, jpeg artifacts"
}
}
def optimize_negative_prompt(base_prompt, negative_candidates):
"""优化负面提示词"""
best_negative = ""
best_score = 0
for negative in negative_candidates:
# 生成图像
image = generate_image(base_prompt, negative=negative)
# 评估质量
score = evaluate_quality(image)
# 记录最佳
if score > best_score:
best_score = score
best_negative = negative
return best_negative
模型选择
7. 模型对比
| 模型 | 风格 | 质量 | 速度 | 适用场景 |
|---|---|---|---|---|
| SD1.5 | 多样 | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | 通用 |
| SDXL | 写实 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | 高质量 |
| SD-Turbo | 快速 | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ | 快速预览 |
| Realistic Vision | 写实 | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ | 人像 |
| DreamShaper | 艺术 | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | 创意 |
graph TD
A[选择模型] --> B{需求类型?}
B -->|高质量| C[SDXL]
B -->|快速预览| D[SD-Turbo]
B -->|人像| E[Realistic Vision]
B -->|艺术创作| F[DreamShaper]
B -->|通用| G[SD1.5]
C --> C1[1024x1024]
D --> D2[512x512]
E --> E3[512x512]
F --> F4[512x512]
G --> G5[512x512]
style A fill:#e1f5ff
style C fill:#e1ffe1
style D fill:#e1ffe1
style E fill:#e1ffe1
style F fill:#e1ffe1
style G fill:#e1ffe1
8. 模型微调
class LoRAFineTuner:
def __init__(self, base_model):
self.base_model = base_model
self.lora_weights = {}
def apply_lora(self, lora_name, strength=1.0):
"""应用LoRA权重"""
if lora_name in self.lora_weights:
# 应用LoRA
self.base_model.apply_lora(
self.lora_weights[lora_name],
strength=strength
)
def combine_loras(self, lora_configs):
"""组合多个LoRA"""
for config in lora_configs:
self.apply_lora(
config['name'],
config['strength']
)
{
"lora_configs": {
"portrait_enhancement": {
"lora_name": "portrait_detail_lora.safetensors",
"strength": 0.8,
"use_case": "增强人像细节"
},
"style_transfer": {
"lora_name": "anime_style_lora.safetensors",
"strength": 0.6,
"use_case": "动漫风格转换"
}
}
}
9. 模型融合
graph TD
A[模型融合] --> B[权重融合]
A --> C[特征融合]
A --> D[层级融合]
B --> B1[线性组合]
B --> B2[非线性组合]
C --> C1[特征层融合]
C --> C2[注意力融合]
D --> D1[浅层融合]
D --> D2[深层融合]
style A fill:#e1f5ff
style B fill:#e1ffe1
style C fill:#e1ffe1
style D fill:#e1ffe1
def merge_models(model1, model2, alpha=0.5):
"""融合两个模型"""
merged_model = {}
for key in model1.keys():
if key in model2:
# 线性融合
merged_model[key] = (
alpha * model1[key] +
(1 - alpha) * model2[key]
)
else:
# 只在一个模型中存在的参数
merged_model[key] = model1[key]
return merged_model
后处理技术
10. 图像增强
from PIL import Image, ImageEnhance, ImageFilter
class ImageEnhancer:
def __init__(self):
self.enhancers = {
'brightness': self._enhance_brightness,
'contrast': self._enhance_contrast,
'sharpness': self._enhance_sharpness,
'color': self._enhance_color
}
def enhance(self, image, enhancements):
"""应用增强"""
for enhancement_type, value in enhancements.items():
enhancer = self.enhancers.get(enhancement_type)
if enhancer:
image = enhancer(image, value)
return image
def _enhance_brightness(self, image, factor):
"""增强亮度"""
enhancer = ImageEnhance.Brightness(image)
return enhancer.enhance(factor)
def _enhance_contrast(self, image, factor):
"""增强对比度"""
enhancer = ImageEnhance.Contrast(image)
return enhancer.enhance(factor)
def _enhance_sharpness(self, image, factor):
"""增强锐度"""
enhancer = ImageEnhance.Sharpness(image)
return enhancer.enhance(factor)
def _enhance_color(self, image, factor):
"""增强色彩"""
enhancer = ImageEnhance.Color(image)
return enhancer.enhance(factor)
{
"enhancement_configs": {
"portrait": {
"brightness": 1.05,
"contrast": 1.1,
"sharpness": 1.15,
"color": 1.05
},
"landscape": {
"brightness": 1.0,
"contrast": 1.2,
"sharpness": 1.1,
"color": 1.1
}
}
}
11. 色彩校正
import cv2
import numpy as np
class ColorCorrector:
def __init__(self):
self.corrections = {
'white_balance': self._white_balance,
'gamma_correction': self._gamma_correction,
'histogram_equalization': self._histogram_equalization
}
def correct(self, image, corrections):
"""应用色彩校正"""
for correction_type, params in corrections.items():
corrector = self.corrections.get(correction_type)
if corrector:
image = corrector(image, **params)
return image
def _white_balance(self, image, method='grayworld'):
"""白平衡校正"""
if method == 'grayworld':
result = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
avg_a = np.mean(result[:, :, 1])
avg_b = np.mean(result[:, :, 2])
result[:, :, 1] = result[:, :, 1] - ((avg_a - 128) * (result[:, :, 0] / 255.0) * 1.1)
result[:, :, 2] = result[:, :, 2] - ((avg_b - 128) * (result[:, :, 0] / 255.0) * 1.1)
return cv2.cvtColor(result, cv2.COLOR_LAB2BGR)
return image
def _gamma_correction(self, image, gamma=1.0):
"""伽马校正"""
inv_gamma = 1.0 / gamma
table = np.array([((i / 255.0) ** inv_gamma) * 255 for i in range(256)]).astype("uint8")
return cv2.LUT(image, table)
12. 细节增强
class DetailEnhancer:
def __init__(self):
self.methods = {
'unsharp_mask': self._unsharp_mask,
'high_pass_filter': self._high_pass_filter,
'wavelet_enhance': self._wavelet_enhance
}
def enhance_details(self, image, method='unsharp_mask', **kwargs):
"""增强细节"""
enhancer = self.methods.get(method)
if enhancer:
return enhancer(image, **kwargs)
return image
def _unsharp_mask(self, image, amount=1.5, radius=1.0, threshold=0):
"""USM锐化"""
blurred = cv2.GaussianBlur(image, (0, 0), radius)
sharpened = cv2.addWeighted(image, 1 + amount, blurred, -amount, 0)
return sharpened
def _high_pass_filter(self, image, sigma=1.0):
"""高通滤波"""
blurred = cv2.GaussianBlur(image, (0, 0), sigma)
high_pass = cv2.subtract(image, blurred)
return cv2.add(image, high_pass)
质量控制
13. 质量评估
class QualityEvaluator:
def __init__(self):
self.metrics = {
'sharpness': self._evaluate_sharpness,
'contrast': self._evaluate_contrast,
'noise': self._evaluate_noise,
'color_balance': self._evaluate_color_balance
}
def evaluate(self, image):
"""评估图像质量"""
scores = {}
for metric_name, metric_func in self.metrics.items():
scores[metric_name] = metric_func(image)
# 计算综合分数
total_score = self._calculate_total_score(scores)
scores['total'] = total_score
return scores
def _evaluate_sharpness(self, image):
"""评估清晰度"""
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
laplacian = cv2.Laplacian(gray, cv2.CV_64F)
return np.var(laplacian)
def _evaluate_contrast(self, image):
"""评估对比度"""
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
return gray.std()
def _evaluate_noise(self, image):
"""评估噪声"""
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
return np.var(gray - cv2.GaussianBlur(gray, (5, 5), 0))
def _calculate_total_score(self, scores):
"""计算综合分数"""
weights = {
'sharpness': 0.3,
'contrast': 0.3,
'noise': 0.2,
'color_balance': 0.2
}
total = 0
for metric, weight in weights.items():
normalized = self._normalize_score(scores[metric], metric)
total += normalized * weight
return total
def _normalize_score(self, score, metric):
"""标准化分数"""
# 根据指标类型进行标准化
if metric == 'noise':
return 1.0 / (1.0 + score)
else:
return min(score / 100.0, 1.0)
14. 迭代优化
graph TD
A[初始生成] --> B[质量评估]
B --> C{达到目标?}
C -->|否| D[调整参数]
D --> E[重新生成]
E --> B
C -->|是| F[输出结果]
style A fill:#e1f5ff
style B fill:#e1ffe1
style C fill:#fff4e1
style D fill:#e1ffe1
style F fill:#e1ffe1
class IterativeOptimizer:
def __init__(self, max_iterations=10, target_score=0.85):
self.max_iterations = max_iterations
self.target_score = target_score
self.evaluator = QualityEvaluator()
def optimize(self, base_prompt, initial_params):
"""迭代优化"""
best_image = None
best_score = 0
best_params = initial_params.copy()
for iteration in range(self.max_iterations):
# 生成图像
image = generate_image(base_prompt, **best_params)
# 评估质量
scores = self.evaluator.evaluate(image)
current_score = scores['total']
# 记录最佳
if current_score > best_score:
best_score = current_score
best_image = image
# 检查是否达到目标
if current_score >= self.target_score:
break
# 调整参数
best_params = self._adjust_parameters(best_params, scores)
return best_image, best_params
def _adjust_parameters(self, params, scores):
"""根据评估结果调整参数"""
# 根据各项指标调整参数
if scores['sharpness'] < 0.7:
params['cfg'] = min(params['cfg'] + 0.5, 12.0)
if scores['contrast'] < 0.7:
params['steps'] = min(params['steps'] + 5, 50)
return params
15. A/B测试
class ABTester:
def __init__(self):
self.test_results = []
def run_test(self, prompt, config_a, config_b, num_runs=5):
"""运行A/B测试"""
results_a = []
results_b = []
for _ in range(num_runs):
# 测试配置A
image_a = generate_image(prompt, **config_a)
score_a = evaluate_quality(image_a)
results_a.append(score_a)
# 测试配置B
image_b = generate_image(prompt, **config_b)
score_b = evaluate_quality(image_b)
results_b.append(score_b)
# 统计结果
avg_a = np.mean(results_a)
avg_b = np.mean(results_b)
return {
'config_a': {
'average': avg_a,
'std': np.std(results_a),
'results': results_a
},
'config_b': {
'average': avg_b,
'std': np.std(results_b),
'results': results_b
},
'winner': 'A' if avg_a > avg_b else 'B'
}
最佳实践
质量优化清单
## 参数调优
- [ ] 优化采样步数
- [ ] 调整CFG值
- [ ] 选择合适的去噪强度
## 提示词优化
- [ ] 构建完整提示词结构
- [ ] 调整关键词权重
- [ ] 优化负面提示词
## 模型选择
- [ ] 选择合适的模型
- [ ] 应用LoRA微调
- [ ] 尝试模型融合
## 后处理
- [ ] 应用图像增强
- [ ] 进行色彩校正
- [ ] 增强细节
## 质量控制
- [ ] 评估图像质量
- [ ] 迭代优化参数
- [ ] 进行A/B测试
总结
质量优化是ComfyUI使用的核心技能。关键要点：
- 参数调优: 精确调整采样参数
- 提示词优化: 构建高质量的提示词
- 模型选择: 选择合适的模型和微调
- 后处理: 应用适当的后期处理
- 质量控制: 建立质量评估和优化流程
通过系统性的质量优化，可以生成高质量的图像。