ssci-subagent-skills 1.0.0

package/skills/validity-reliability/scripts/validity_reliability_toolkit.py

@@ -0,0 +1,480 @@
+"""
+Validity and Reliability Analysis Toolkit
+信度效度分析工具包
+"""
+
+import numpy as np
+import pandas as pd
+import scipy.stats as stats
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.decomposition import FactorAnalysis
+from sklearn.preprocessing import StandardScaler
+from factor_analyzer import FactorAnalyzer
+from factor_analyzer.factor_analyzer import calculate_bartlett_sphericity, calculate_kmo
+import pingouin as pg
+from scipy.stats import pearsonr
+import warnings
+warnings.filterwarnings('ignore')
+
+class ValidityReliabilityAnalyzer:
+    """信度效度分析器"""
+    
+    def __init__(self):
+        self.data = None
+        self.results = {}
+    
+    def load_data(self, data_path=None, data_frame=None):
+        """加载数据"""
+        if data_path:
+            self.data = pd.read_csv(data_path)
+        elif data_frame is not None:
+            self.data = data_frame.copy()
+        else:
+            raise ValueError("请提供数据路径或DataFrame")
+        
+        print(f"数据加载成功: {self.data.shape[0]} 行, {self.data.shape[1]} 列")
+        return self.data.head()
+    
+    def reliability_analysis(self, items, alpha=0.05):
+        """信度分析"""
+        # 移除缺失值
+        data_clean = self.data[items].dropna()
+        
+        # Cronbach's Alpha
+        cronbach_alpha = self._calculate_cronbach_alpha(data_clean)
+        
+        # 分半信度
+        split_half = self._calculate_split_half_reliability(data_clean)
+        
+        # 项目统计
+        item_stats = self._calculate_item_statistics(data_clean)
+        
+        # 删除项后的Alpha
+        alpha_if_deleted = self._calculate_alpha_if_deleted(data_clean)
+        
+        # McDonald's Omega
+        omega = self._calculate_omega(data_clean)
+        
+        result = {
+            'cronbach_alpha': cronbach_alpha,
+            'omega': omega,
+            'split_half_reliability': split_half,
+            'item_statistics': item_stats,
+            'alpha_if_deleted': alpha_if_deleted,
+            'interpretation': self._interpret_reliability(cronbach_alpha)
+        }
+        
+        return result
+    
+    def _calculate_cronbach_alpha(self, data):
+        """计算Cronbach's Alpha"""
+        from pingouin import cronbach_alpha
+        alpha, _ = cronbach_alpha(data)
+        return alpha
+    
+    def _calculate_omega(self, data):
+        """计算McDonald's Omega"""
+        # 使用因子分析计算Omega
+        fa = FactorAnalyzer(n_factors=1, rotation=None)
+        fa.fit(data)
+        
+        loadings = fa.loadings_.flatten()
+        loadings_sq = loadings ** 2
+        error_variances = 1 - loadings_sq
+        
+        omega = np.sum(loadings_sq) / (np.sum(loadings_sq) + np.sum(error_variances))
+        return omega
+    
+    def _calculate_split_half_reliability(self, data):
+        """计算分半信度"""
+        n_items = data.shape[1]
+        half = n_items // 2
+        
+        first_half = data.iloc[:, :half]
+        second_half = data.iloc[:, half:]
+        
+        # 计算两半的总分
+        first_half_score = first_half.sum(axis=1)
+        second_half_score = second_half.sum(axis=1)
+        
+        # 计算相关系数
+        correlation, _ = stats.pearsonr(first_half_score, second_half_score)
+        
+        # Spearman-Brown校正
+        spearman_brown = (2 * correlation) / (1 + correlation)
+        
+        return spearman_brown
+    
+    def _calculate_item_statistics(self, data):
+        """计算项目统计"""
+        item_stats = {}
+        
+        for item in data.columns:
+            item_data = data[item]
+            
+            stats_dict = {
+                'mean': item_data.mean(),
+                'std': item_data.std(),
+                'item_total_correlation': self._item_total_correlation(data, item),
+                'skewness': stats.skew(item_data),
+                'kurtosis': stats.kurtosis(item_data),
+                'difficulty': item_data.mean() / item_data.max() if item_data.max() > 0 else 0
+            }
+            
+            item_stats[item] = stats_dict
+        
+        return pd.DataFrame(item_stats).T
+    
+    def _item_total_correlation(self, data, item):
+        """计算项目-总分相关"""
+        total_scores = data.drop(columns=[item]).sum(axis=1)
+        correlation, _ = stats.pearsonr(data[item], total_scores)
+        return correlation
+    
+    def _calculate_alpha_if_deleted(self, data):
+        """计算删除某项后的Alpha"""
+        alpha_if_deleted = {}
+        
+        for item in data.columns:
+            data_without_item = data.drop(columns=[item])
+            alpha = self._calculate_cronbach_alpha(data_without_item)
+            alpha_if_deleted[item] = alpha
+        
+        return alpha_if_deleted
+    
+    def _interpret_reliability(self, alpha):
+        """解释信度系数"""
+        if alpha < 0.6:
+            return "不可接受"
+        elif alpha < 0.7:
+            return "可接受但需改进"
+        elif alpha < 0.8:
+            return "可接受"
+        elif alpha < 0.9:
+            return "良好"
+        else:
+            return "优秀"
+    
+    def construct_validity_analysis(self, items, n_factors=None, rotation='varimax'):
+        """构念效度分析"""
+        # 数据准备
+        data_subset = self.data[items].dropna()
+        
+        # 标准化数据
+        scaler = StandardScaler()
+        data_scaled = scaler.fit_transform(data_subset)
+        
+        # KMO和Bartlett检验
+        kmo_result = self._kmo_test(data_scaled)
+        bartlett_result = self._bartlett_test(data_scaled)
+        
+        # 确定因子数量
+        if n_factors is None:
+            n_factors = self._determine_factors(data_scaled)
+        
+        # 执行因子分析
+        fa = FactorAnalysis(n_components=n_factors, rotation=rotation, random_state=42)
+        fa.fit(data_scaled)
+        
+        # 因子载荷矩阵
+        loadings = pd.DataFrame(
+            fa.components_.T,
+            index=items,
+            columns=[f'Factor_{i+1}' for i in range(n_factors)]
+        )
+        
+        # 因子得分
+        factor_scores = fa.transform(data_scaled)
+        
+        # 收敛效度和区分效度
+        validity_metrics = self._calculate_validity_metrics(data_scaled, loadings)
+        
+        result = {
+            'kmo_test': kmo_result,
+            'bartlett_test': bartlett_result,
+            'n_factors': n_factors,
+            'rotation': rotation,
+            'loadings': loadings,
+            'factor_scores': factor_scores,
+            'explained_variance': fa.explained_variance_,
+            'explained_variance_ratio': fa.explained_variance_ratio_,
+            'communalities': self._calculate_communalities(loadings),
+            'validity_metrics': validity_metrics
+        }
+        
+        return result
+    
+    def _kmo_test(self, data):
+        """KMO检验"""
+        from factor_analyzer import calculate_kmo
+        kmo_all, kmo_model = calculate_kmo(data)
+        
+        return {
+            'kmo_overall': kmo_model,
+            'kmo_individual': kmo_all,
+            'interpretation': self._interpret_kmo(kmo_model)
+        }
+    
+    def _bartlett_test(self, data):
+        """Bartlett球形检验"""
+        from factor_analyzer import calculate_bartlett_sphericity
+        chi_square, p_value = calculate_bartlett_sphericity(data)
+        
+        return {
+            'chi_square': chi_square,
+            'p_value': p_value,
+            'significant': p_value < 0.05
+        }
+    
+    def _interpret_kmo(self, kmo_value):
+        """解释KMO值"""
+        if kmo_value < 0.5:
+            return "不适合进行因子分析"
+        elif kmo_value < 0.6:
+            return "不太适合"
+        elif kmo_value < 0.7:
+            return "中等程度适合"
+        elif kmo_value < 0.8:
+            return "适合"
+        elif kmo_value < 0.9:
+            return "很适合"
+        else:
+            return "非常适合"
+    
+    def _determine_factors(self, data):
+        """确定因子数量"""
+        # 特征值大于1准则
+        from factor_analyzer import FactorAnalyzer
+        fa = FactorAnalyzer(rotation=None)
+        fa.fit(data)
+        ev, _ = fa.get_eigenvalues()
+        n_factors_eigen = sum(ev > 1)
+        
+        # 碎石图
+        plt.figure(figsize=(8, 6))
+        plt.plot(range(1, len(ev) + 1), ev, 'bo-')
+        plt.axhline(y=1, color='r', linestyle='--')
+        plt.xlabel('因子数量')
+        plt.ylabel('特征值')
+        plt.title('碎石图')
+        plt.grid(True)
+        plt.savefig('scree_plot.png', dpi=300, bbox_inches='tight')
+        plt.show()
+        
+        return max(1, n_factors_eigen)
+    
+    def _calculate_communalities(self, loadings):
+        """计算共同度"""
+        communalities = (loadings ** 2).sum(axis=1)
+        return communalities.to_dict()
+    
+    def _calculate_validity_metrics(self, data, loadings):
+        """计算效度指标"""
+        # 收敛效度 (AVE)
+        n_factors = loadings.shape[1]
+        ave_values = {}
+        
+        for i in range(n_factors):
+            factor_items = loadings.iloc[:, i]
+            factor_loadings_sq = factor_items ** 2
+            ave = np.sum(factor_loadings_sq) / len(factor_loadings_sq)
+            ave_values[f'Factor_{i+1}'] = ave
+        
+        # 区分效度 (Fornell-Larcker准则)
+        factor_correlations = np.corrcoef(data.T)
+        
+        return {
+            'convergent_validity': ave_values,
+            'discriminant_validity': factor_correlations,
+            'composite_reliability': self._calculate_composite_reliability(loadings)
+        }
+    
+    def _calculate_composite_reliability(self, loadings):
+        """计算组合信度"""
+        n_factors = loadings.shape[1]
+        cr_values = {}
+        
+        for i in range(n_factors):
+            factor_loadings = loadings.iloc[:, i]
+            loadings_sq = factor_loadings ** 2
+            sum_loadings_sq = np.sum(loadings_sq)
+            sum_error_variances = np.sum(1 - loadings_sq)
+            
+            cr = sum_loadings_sq / (sum_loadings_sq + sum_error_variances)
+            cr_values[f'Factor_{i+1}'] = cr
+        
+        return cr_values
+    
+    def content_validity_analysis(self, expert_ratings):
+        """内容效度分析"""
+        """
+        expert_ratings: DataFrame，行为专家，列为项目
+        """
+        # 计算内容效度比 (CVR)
+        n_experts = len(expert_ratings)
+        essential_ratings = (expert_ratings == 3).sum()  # 假设3分表示"必要"
+        cvr = (essential_ratings - n_experts/2) / (n_experts/2)
+        
+        # 计算内容效度指数 (CVI)
+        cvi_i = (expert_ratings >= 3).sum() / n_experts  # 项目水平CVI
+        cvi_s = cvr.mean()  # 量表水平CVI
+        
+        result = {
+            'content_validity_ratio': cvr,
+            'cvi_item': cvi_i,
+            'cvi_scale': cvi_s,
+            'interpretation': self._interpret_cvi(cvi_s)
+        }
+        
+        return result
+    
+    def _interpret_cvi(self, cvi_value):
+        """解释CVI值"""
+        if cvi_value >= 0.99:
+            return "优秀的内容效度"
+        elif cvi_value >= 0.80:
+            return "良好的内容效度"
+        elif cvi_value >= 0.70:
+            return "可接受的内容效度"
+        else:
+            return "需要改进的内容效度"
+    
+    def criterion_validity_analysis(self, scale_scores, criterion_measures):
+        """效标效度分析"""
+        """
+        scale_scores: 量表总分
+        criterion_measures: 效标测量
+        """
+        correlations = {}
+        
+        for criterion in criterion_measures.columns:
+            corr, p_value = stats.pearsonr(scale_scores, criterion_measures[criterion])
+            correlations[criterion] = {
+                'correlation': corr,
+                'p_value': p_value,
+                'significant': p_value < 0.05,
+                'interpretation': self._interpret_correlation(corr)
+            }
+        
+        return correlations
+    
+    def _interpret_correlation(self, r):
+        """解释相关系数"""
+        abs_r = abs(r)
+        if abs_r < 0.1:
+            return "极弱相关"
+        elif abs_r < 0.3:
+            return "弱相关"
+        elif abs_r < 0.5:
+            return "中等相关"
+        elif abs_r < 0.7:
+            return "强相关"
+        else:
+            return "极强相关"
+    
+    def generate_report(self, output_file='validity_reliability_report.md'):
+        """生成分析报告"""
+        report = ["# 信度效度分析报告\n"]
+        
+        for test_name, test_result in self.results.items():
+            if isinstance(test_result, dict):
+                report.append(f"## {test_name.replace('_', ' ').title()}")
+                
+                for key, value in test_result.items():
+                    if isinstance(value, dict):
+                        report.append(f"### {key}")
+                        for sub_key, sub_value in value.items():
+                            report.append(f"- {sub_key}: {sub_value}")
+                    else:
+                        report.append(f"- {key}: {value}")
+                
+                report.append("")
+        
+        # 保存报告
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write('\n'.join(report))
+        
+        print(f"信度效度分析报告已保存到 {output_file}")
+
+# 使用示例
+def main():
+    """主函数示例"""
+    # 创建模拟量表数据
+    np.random.seed(42)
+    n = 300
+    
+    # 6个项目的量表
+    scale_data = pd.DataFrame({
+        'item1': np.random.normal(4, 1, n),
+        'item2': np.random.normal(4.2, 1.1, n),
+        'item3': np.random.normal(3.8, 0.9, n),
+        'item4': np.random.normal(4.1, 1.2, n),
+        'item5': np.random.normal(3.9, 1.0, n),
+        'item6': np.random.normal(4.3, 1.1, n)
+    })
+    
+    # 确保数据在合理范围内（1-5分李克特量表）
+    for col in scale_data.columns:
+        scale_data[col] = np.clip(scale_data[col], 1, 5)
+    
+    # 创建分析器实例
+    analyzer = ValidityReliabilityAnalyzer()
+    analyzer.load_data(data_frame=scale_data)
+    
+    # 1. 信度分析
+    print("=== 信度分析 ===")
+    reliability_results = analyzer.reliability_analysis(scale_data.columns.tolist())
+    print(f"Cronbach's Alpha: {reliability_results['cronbach_alpha']:.3f}")
+    print(f"McDonald's Omega: {reliability_results['omega']:.3f}")
+    print(f"分半信度: {reliability_results['split_half_reliability']:.3f}")
+    print(f"信度评价: {reliability_results['interpretation']}")
+    
+    # 2. 构念效度分析
+    print("\n=== 构念效度分析 ===")
+    validity_results = analyzer.construct_validity_analysis(scale_data.columns.tolist())
+    print(f"KMO值: {validity_results['kmo_test']['kmo_overall']:.3f}")
+    print(f"KMO评价: {validity_results['kmo_test']['interpretation']}")
+    print(f"因子数量: {validity_results['n_factors']}")
+    
+    # 3. 专家评分（模拟）
+    print("\n=== 内容效度分析 ===")
+    expert_ratings = pd.DataFrame({
+        'item1': np.random.choice([1, 2, 3], size=5, p=[0.1, 0.2, 0.7]),
+        'item2': np.random.choice([1, 2, 3], size=5, p=[0.1, 0.3, 0.6]),
+        'item3': np.random.choice([1, 2, 3], size=5, p=[0.2, 0.2, 0.6]),
+        'item4': np.random.choice([1, 2, 3], size=5, p=[0.1, 0.2, 0.7]),
+        'item5': np.random.choice([1, 2, 3], size=5, p=[0.1, 0.3, 0.6]),
+        'item6': np.random.choice([1, 2, 3], size=5, p=[0.1, 0.2, 0.7])
+    })
+    
+    content_validity = analyzer.content_validity_analysis(expert_ratings)
+    print(f"内容效度指数 (CVI): {content_validity['cvi_scale']:.3f}")
+    print(f"内容效度评价: {content_validity['interpretation']}")
+    
+    # 4. 效标效度（模拟）
+    print("\n=== 效标效度分析 ===")
+    scale_scores = scale_data.sum(axis=1)
+    criterion_measures = pd.DataFrame({
+        'job_performance': np.random.normal(3.5, 0.8, n),
+        'job_satisfaction': np.random.normal(3.8, 0.7, n),
+        'turnover_intention': np.random.normal(2.5, 0.9, n)
+    })
+    
+    criterion_validity = analyzer.criterion_validity_analysis(scale_scores, criterion_measures)
+    for criterion, results in criterion_validity.items():
+        print(f"{criterion}: r = {results['correlation']:.3f}, p = {results['p_value']:.3f} ({results['interpretation']})")
+    
+    # 生成完整报告
+    analyzer.results = {
+        'reliability_analysis': reliability_results,
+        'construct_validity': validity_results,
+        'content_validity': content_validity,
+        'criterion_validity': criterion_validity
+    }
+    analyzer.generate_report()
+    
+    print("\n信度效度分析完成！报告已保存。")
+
+if __name__ == "__main__":
+    main()

package/skills/verify_compliance.ps1

@@ -0,0 +1,40 @@
+# PowerShell script to verify all skill files compliance with agentskills.io standard
+
+$dirs = Get-ChildItem 'D:\stigmergy-CLI-Multi-Agents\sscisubagent-skills\skills' -Directory
+$compliant = 0
+$nonCompliant = 0
+$totalCount = 0
+
+foreach ($dir in $dirs) {
+    $skillFile = Join-Path $dir.FullName 'SKILL.md'
+    if (Test-Path $skillFile) {
+        $totalCount++
+        $lines = Get-Content $skillFile
+        
+        # Check if first line is ---
+        if ($lines.Count -ge 1 -and $lines[0] -eq '---') {
+            # Check if second line contains name field
+            if ($lines.Count -ge 2) {
+                $secondLine = $lines[1].Trim()
+                if ($secondLine -match '^name:\s*(.+)$') {
+                    Write-Host "$($dir.Name): COMPLIANT" -ForegroundColor Green
+                    $compliant++
+                } else {
+                    Write-Host "$($dir.Name): MISSING name field in second line" -ForegroundColor Red
+                    $nonCompliant++
+                }
+            } else {
+                Write-Host "$($dir.Name): TOO FEW LINES" -ForegroundColor Red
+                $nonCompliant++
+            }
+        } else {
+            Write-Host "$($dir.Name): MISSING YAML frontmatter separator" -ForegroundColor Red
+            $nonCompliant++
+        }
+    }
+}
+
+Write-Host ""
+Write-Host "Total skills checked: $totalCount" -ForegroundColor Yellow
+Write-Host "Compliant skills: $compliant" -ForegroundColor Yellow
+Write-Host "Non-compliant skills: $nonCompliant" -ForegroundColor Yellow

package/skills/visualization-expert/INFO.md

@@ -0,0 +1,77 @@
+# 可视化专家技能 - AI优化参考文档
+
+## 技能核心信息
+- **技能ID**: visualization-expert
+- **版本**: 2.0.0
+- **分类**: 数据可视化
+- **类型**: 可视化生成与设计类技能
+
+## 技能概述（简明扼要）
+可视化专家技能基于数据可视化理论和最佳实践，为企业分析结果创建直观、有效的可视化图表和仪表板。该技能运用信息设计原则和视觉分析技术，将复杂数据转化为易于理解的视觉表现形式。
+
+## 核心功能（要点式）
+1. 图表生成 - 创建柱状图、折线图、饼图等基础图表
+2. 仪表板设计 - 构建综合性数据仪表板
+3. 网络图可视化 - 展示关系和连接数据
+4. 热力图生成 - 表现数据密度和强度
+5. 散点图分析 - 展示变量间关系
+6. 无障碍访问 - 确保可视化内容可访问性
+7. 主题定制 - 支持多种视觉主题风格
+8. 格式输出 - 支持多种输出格式
+
+## 输入输出规范
+### 输入参数
+- `data`: 待可视化的数据对象（必需）
+- `visualizationType`: 可视化类型（必需）
+- `config`: 可视化配置选项（可选）
+- `targetAudience`: 目标受众（可选）
+
+### 输出结果
+- `visualization`: 可视化对象
+- `recommendations`: 可视化改进建议
+- `accessibilityReport`: 无障碍访问报告
+- `validationScore`: 验证分数
+
+## 执行流程（步骤化）
+1. **数据解析** - 解析输入数据结构和类型
+2. **图表选择** - 根据数据特征选择合适的可视化类型
+3. **设计生成** - 应用设计原则生成可视化图表
+4. **无障碍处理** - 添加无障碍访问支持
+5. **质量验证** - 验证可视化质量和可读性
+6. **结果输出** - 生成指定格式的可视化结果
+
+## 关键算法与方法
+- **图表类型选择算法** - 基于数据特征的可视化类型推荐
+- **视觉编码算法** - 颜色、形状、大小的最优映射
+- **布局优化算法** - 图表元素的空间布局优化
+- **无障碍算法** - 确保可视化内容对所有用户可访问
+
+## 应用场景
+- 业务分析报告可视化
+- 管理仪表板创建
+- 数据探索和发现
+- 演示文稿图表制作
+- 决策支持系统界面
+
+## 常见使用模式
+- 快速图表生成：基于默认设置快速生成图表
+- 定制化设计：根据特定需求定制视觉风格
+- 仪表板构建：创建综合性数据仪表板
+- 批量可视化：批量处理多个数据集
+
+## 关键配置选项
+- `visualizationType`: 可视化类型（柱状图/折线图/饼图等）
+- `theme`: 主题风格（明亮/暗色/企业/简约）
+- `format`: 输出格式（SVG/PNG/HTML/JSON）
+- `targetAudience`: 目标受众（高管/经理/分析师/客户）
+
+## 评估标准
+- **验证分数**: 80分以上为合格可视化
+- **可读性要求**: 图表清晰易懂，无歧义
+- **无障碍标准**: 符合WCAG可访问性指南
+
+## 与其他技能的交互
+- 从其他分析技能获取数据输入
+- 为报告生成技能提供可视化内容
+- 与数据处理技能配合进行数据准备
+- 可调用信息验证技能确保数据质量

package/skills/visualization-expert/README.md

@@ -0,0 +1,78 @@
+# 可视化专家技能文档
+
+## 概述
+可视化专家技能是商业模型系统分析智能体的重要组成部分，专门负责将复杂的商业数据和分析结果转换为直观、易于理解的图表和仪表板。该技能基于数据可视化理论和最佳实践，遵循信息设计原则，确保可视化结果既美观又有效传达信息。
+
+## 功能特性
+1. **多种图表类型**：支持柱状图、折线图、饼图、散点图等多种图表
+2. **仪表板创建**：创建综合性的数据仪表板
+3. **智能推荐**：根据数据特征推荐最适合的可视化类型
+4. **主题定制**：支持多种主题和样式定制
+5. **无障碍设计**：确保可视化内容对所有用户可访问
+6. **交互功能**：提供交互式可视化功能
+7. **响应式设计**：适配不同设备和屏幕尺寸
+8. **数据故事化**：将数据转化为有逻辑的故事
+
+## 输入参数
+- `data`：待可视化的数据对象（必需）
+- `visualizationType`：可视化类型（必需）
+  - `bar-chart`：柱状图
+  - `line-chart`：折线图
+  - `pie-chart`：饼图
+  - `scatter-plot`：散点图
+  - `dashboard`：仪表板
+  - `heatmap`：热力图
+  - `network-graph`：网络图
+  - `custom-visualization`：自定义可视化
+- `config`：可视化配置选项
+  - `title`：图表标题
+  - `theme`：主题风格
+  - `size`：图表尺寸
+  - `format`：输出格式
+- `targetAudience`：目标受众类型
+
+## 输出结果
+返回包含以下字段的可视化结果对象：
+- `visualization`：可视化对象
+  - `type`：可视化类型
+  - `content`：可视化内容
+  - `metadata`：元数据信息
+- `recommendations`：可视化改进建议
+- `accessibilityReport`：无障碍访问报告
+- `validationScore`：验证分数
+- `metadata`：元数据信息
+
+## 实现架构
+该技能采用模块化设计，包含以下核心模块：
+1. **VisualizationDataProcessor**：数据处理
+2. **ChartRecommendationModule**：图表推荐
+3. **VisualizationGenerator**：可视化生成
+4. **AccessibilityModule**：无障碍访问
+5. **VisualizationReportingModule**：报告生成
+
+## 设计原则
+1. **渐进式信息披露**：根据用户需求逐步展开详细信息
+2. **数据驱动设计**：根据数据特征选择最佳可视化方式
+3. **用户体验优先**：确保可视化易于理解和使用
+4. **无障碍访问**：遵循无障碍设计标准
+5. **美观与功能并重**：在保证功能的同时注重美观
+
+## 使用示例
+```javascript
+const skill = new VisualizationExpertSkill();
+const inputs = {
+  data: {
+    labels: ["产品A", "产品B", "产品C"],
+    values: [100, 150, 200]
+  },
+  visualizationType: "bar-chart",
+  config: {
+    title: "产品销售情况",
+    theme: "corporate",
+    size: { width: 800, height: 600 }
+  },
+  targetAudience: "managers"
+};
+
+const result = await skill.execute(inputs);
+```