--- title: "LLM治理工具：管理AI系统" description: "使用工具管理LLM的开发、部署和运维，确保AI系统合规可控" tags: ["AI治理", "LLM管理", "合规", "工具", "治理框架"] category: "llm" icon: "🏛️"

LLM治理工具：管理AI系统

治理概述

LLM治理是确保AI系统负责任地开发和使用的框架，包括模型管理、合规检查和风险控制。

治理框架

1. 模型注册表

from dataclasses import dataclass, field
from typing import Dict, List, Optional
from datetime import datetime
import json

@dataclass
class ModelMetadata:
    """模型元数据"""
    model_id: str
    name: str
    version: str
    description: str
    owner: str
    created_at: datetime
    updated_at: datetime
    status: str  # "registered", "approved", "deprecated"
    tags: List[str] = field(default_factory=list)
    permissions: Dict[str, List[str]] = field(default_factory=dict)
    audit_log: List[Dict] = field(default_factory=list)

class ModelRegistry:
    """模型注册表"""
    
    def __init__(self, storage_path: str = "model_registry"):
        self.storage_path = storage_path
        self.models = {}
    
    def register_model(self, metadata: ModelMetadata):
        """注册模型"""
        self.models[metadata.model_id] = metadata
        self._log_action(metadata.model_id, "registered", metadata.owner)
        self._save()
    
    def approve_model(self, model_id: str, approver: str):
        """审批模型"""
        if model_id in self.models:
            self.models[model_id].status = "approved"
            self.models[model_id].updated_at = datetime.now()
            self._log_action(model_id, "approved", approver)
            self._save()
    
    def deprecate_model(self, model_id: str, reason: str, deprecator: str):
        """弃用模型"""
        if model_id in self.models:
            self.models[model_id].status = "deprecated"
            self.models[model_id].updated_at = datetime.now()
            self._log_action(model_id, "deprecated", deprecator, {"reason": reason})
            self._save()
    
    def get_model(self, model_id: str) -> Optional[ModelMetadata]:
        """获取模型"""
        return self.models.get(model_id)
    
    def list_models(self, status: str = None, owner: str = None) -> List[ModelMetadata]:
        """列出模型"""
        models = list(self.models.values())
        
        if status:
            models = [m for m in models if m.status == status]
        if owner:
            models = [m for m in models if m.owner == owner]
        
        return models
    
    def _log_action(self, model_id: str, action: str, actor: str, details: Dict = None):
        """记录操作日志"""
        log_entry = {
            "action": action,
            "actor": actor,
            "timestamp": datetime.now().isoformat(),
            "details": details or {}
        }
        self.models[model_id].audit_log.append(log_entry)
    
    def _save(self):
        """保存注册表"""
        # 简化实现
        pass

2. 合规检查器

class ComplianceChecker:
    """合规检查器"""
    
    def __init__(self):
        self.rules = []
    
    def add_rule(self, name: str, check_func, severity: str = "high"):
        """添加合规规则"""
        self.rules.append({
            "name": name,
            "check_func": check_func,
            "severity": severity
        })
    
    def check_model(self, model_metadata: ModelMetadata) -> Dict:
        """检查模型合规性"""
        violations = []
        
        for rule in self.rules:
            try:
                is_compliant = rule["check_func"](model_metadata)
                if not is_compliant:
                    violations.append({
                        "rule": rule["name"],
                        "severity": rule["severity"],
                        "message": f"违反规则: {rule['name']}"
                    })
            except Exception as e:
                violations.append({
                    "rule": rule["name"],
                    "severity": "high",
                    "message": f"检查失败: {str(e)}"
                })
        
        return {
            "model_id": model_metadata.model_id,
            "is_compliant": len(violations) == 0,
            "violations": violations,
            "checked_at": datetime.now().isoformat()
        }
    
    def register_default_rules(self):
        """注册默认规则"""
        
        def check_owner(metadata):
            return metadata.owner and len(metadata.owner) > 0
        
        def check_description(metadata):
            return metadata.description and len(metadata.description) > 10
        
        def check_status(metadata):
            return metadata.status in ["registered", "approved"]
        
        self.add_rule("has_owner", check_owner, "critical")
        self.add_rule("has_description", check_description, "high")
        self.add_rule("valid_status", check_status, "medium")

3. 访问控制

class AccessController:
    """访问控制器"""
    
    def __init__(self):
        self.roles = {}
        self.permissions = {}
    
    def define_role(self, role: str, permissions: List[str]):
        """定义角色"""
        self.roles[role] = permissions
    
    def grant_permission(self, user: str, permission: str):
        """授予权限"""
        if user not in self.permissions:
            self.permissions[user] = []
        self.permissions[user].append(permission)
    
    def check_permission(self, user: str, permission: str) -> bool:
        """检查权限"""
        user_permissions = self.permissions.get(user, [])
        return permission in user_permissions
    
    def check_model_access(self, user: str, model_id: str, action: str) -> bool:
        """检查模型访问权限"""
        permission = f"model:{action}"
        return self.check_permission(user, permission)

监控和审计

class AuditLogger:
    """审计日志"""
    
    def __init__(self, log_path: str = "audit_logs"):
        self.log_path = log_path
        self.logs = []
    
    def log_event(self, event_type: str, actor: str, resource: str, details: Dict = None):
        """记录事件"""
        log_entry = {
            "timestamp": datetime.now().isoformat(),
            "event_type": event_type,
            "actor": actor,
            "resource": resource,
            "details": details or {}
        }
        self.logs.append(log_entry)
        self._save_log(log_entry)
    
    def query_logs(self, event_type: str = None, actor: str = None, 
                  start_time: str = None, end_time: str = None) -> List[Dict]:
        """查询日志"""
        filtered = self.logs
        
        if event_type:
            filtered = [l for l in filtered if l["event_type"] == event_type]
        if actor:
            filtered = [l for l in filtered if l["actor"] == actor]
        
        return filtered
    
    def _save_log(self, log_entry: Dict):
        """保存日志"""
        # 简化实现
        pass

class MonitoringDashboard:
    """监控仪表板"""
    
    def __init__(self):
        self.metrics = {}
    
    def record_metric(self, metric_name: str, value: float, tags: Dict = None):
        """记录指标"""
        if metric_name not in self.metrics:
            self.metrics[metric_name] = []
        
        self.metrics[metric_name].append({
            "value": value,
            "timestamp": datetime.now().isoformat(),
            "tags": tags or {}
        })
    
    def get_metric_summary(self, metric_name: str) -> Dict:
        """获取指标摘要"""
        if metric_name not in self.metrics:
            return {}
        
        values = [m["value"] for m in self.metrics[metric_name]]
        
        return {
            "metric": metric_name,
            "count": len(values),
            "mean": sum(values) / len(values),
            "min": min(values),
            "max": max(values)
        }

最佳实践

1. 建立治理流程：制定明确的模型管理和审批流程
2. 自动化检查：将合规检查集成到CI/CD流程
3. 持续监控：监控模型使用情况和性能指标
4. 定期审计：定期审查模型使用和访问日志

总结

LLM治理工具是确保AI系统负责任地开发和使用的重要保障。通过建立完善的治理框架，可以有效管理模型生命周期和风险。