고영향 AI

# 고영향 AI 컴플라이언스 체커
from typing import List, Optional
from dataclasses import dataclass
from enum import Enum

class ComplianceStatus(Enum):
    COMPLIANT = "준수"
    PARTIAL = "부분 준수"
    NON_COMPLIANT = "미준수"
    NOT_APPLICABLE = "해당 없음"

@dataclass
class ComplianceRequirement:
    requirement_id: str
    description: str
    legal_basis: str
    status: ComplianceStatus = ComplianceStatus.NON_COMPLIANT
    evidence: Optional[str] = None
    remediation: Optional[str] = None

class HighImpactAIComplianceChecker:
    """한국 AI 기본법 고영향 AI 컴플라이언스 체커"""

    def __init__(self, system_name: str):
        self.system_name = system_name
        self.requirements: List[ComplianceRequirement] = []
        self._initialize_requirements()

    def _initialize_requirements(self):
        """AI 기본법 기반 요구사항 초기화"""
        base_requirements = [
            # 투명성 요구사항
            ComplianceRequirement(
                requirement_id="TRANS-001",
                description="AI 시스템 사용 사실 고지",
                legal_basis="AI 기본법 제X조"
            ),
            ComplianceRequirement(
                requirement_id="TRANS-002",
                description="AI 의사결정 과정 설명 제공",
                legal_basis="AI 기본법 제X조"
            ),
            ComplianceRequirement(
                requirement_id="TRANS-003",
                description="학습 데이터 출처 기록 유지",
                legal_basis="AI 기본법 제X조"
            ),

            # 인간 감독 요구사항
            ComplianceRequirement(
                requirement_id="HUMAN-001",
                description="인간 최종 결정권 보장",
                legal_basis="AI 기본법 제X조"
            ),
            ComplianceRequirement(
                requirement_id="HUMAN-002",
                description="AI 결정 이의신청 절차 마련",
                legal_basis="AI 기본법 제X조"
            ),

            # 위험 관리 요구사항
            ComplianceRequirement(
                requirement_id="RISK-001",
                description="위험 평가 및 완화 계획 수립",
                legal_basis="AI 기본법 제X조"
            ),
            ComplianceRequirement(
                requirement_id="RISK-002",
                description="편향성 테스트 및 모니터링",
                legal_basis="AI 기본법 제X조"
            ),
            ComplianceRequirement(
                requirement_id="RISK-003",
                description="사고 대응 절차 마련",
                legal_basis="AI 기본법 제X조"
            ),

            # 데이터 품질 요구사항
            ComplianceRequirement(
                requirement_id="DATA-001",
                description="학습 데이터 품질 관리 체계",
                legal_basis="AI 기본법 제X조"
            ),
            ComplianceRequirement(
                requirement_id="DATA-002",
                description="개인정보 처리 적법성 확보",
                legal_basis="개인정보보호법 연계"
            ),
        ]
        self.requirements = base_requirements

    def update_status(self, req_id: str,
                       status: ComplianceStatus,
                       evidence: str = None,
                       remediation: str = None):
        """요구사항 준수 상태 업데이트"""
        for req in self.requirements:
            if req.requirement_id == req_id:
                req.status = status
                req.evidence = evidence
                req.remediation = remediation
                return

    def get_compliance_score(self) -> float:
        """컴플라이언스 점수 계산 (0-100)"""
        applicable = [r for r in self.requirements
                      if r.status != ComplianceStatus.NOT_APPLICABLE]
        if not applicable:
            return 100.0

        score_map = {
            ComplianceStatus.COMPLIANT: 1.0,
            ComplianceStatus.PARTIAL: 0.5,
            ComplianceStatus.NON_COMPLIANT: 0.0
        }

        total = sum(score_map.get(r.status, 0) for r in applicable)
        return (total / len(applicable)) * 100

    def get_gaps(self) -> List[ComplianceRequirement]:
        """미준수 항목 조회"""
        return [r for r in self.requirements
                if r.status in [ComplianceStatus.NON_COMPLIANT,
                               ComplianceStatus.PARTIAL]]

    def generate_gap_report(self) -> str:
        """갭 분석 보고서 생성"""
        gaps = self.get_gaps()
        score = self.get_compliance_score()

        report = f"""
╔══════════════════════════════════════════════════════════╗
║       고영향 AI 컴플라이언스 갭 분석 보고서              ║
╠══════════════════════════════════════════════════════════╣
║ 시스템명: {self.system_name:<40}║
║ 준수 점수: {score:.1f}% {'🟢' if score >= 80 else '🟡' if score >= 50 else '🔴':<37}║
╚══════════════════════════════════════════════════════════╝

[미준수/부분준수 항목]
"""
        for gap in gaps:
            status_emoji = "🔴" if gap.status == ComplianceStatus.NON_COMPLIANT else "🟡"
            report += f"""
{status_emoji} [{gap.requirement_id}] {gap.description}
   법적 근거: {gap.legal_basis}
   현재 상태: {gap.status.value}
"""
            if gap.remediation:
                report += f"   개선 방안: {gap.remediation}\n"

        return report

# 사용 예시
checker = HighImpactAIComplianceChecker("AI 대출 심사 시스템")

# 상태 업데이트
checker.update_status("TRANS-001", ComplianceStatus.COMPLIANT,
                      evidence="서비스 이용약관에 AI 사용 고지 포함")
checker.update_status("TRANS-002", ComplianceStatus.PARTIAL,
                      remediation="설명 가능한 AI 모듈 도입 필요")
checker.update_status("HUMAN-001", ComplianceStatus.COMPLIANT,
                      evidence="최종 승인은 심사역이 수행")

print(checker.generate_gap_report())

# 고영향 AI 위험 매트릭스 도구
from typing import List, Tuple
from dataclasses import dataclass
from enum import IntEnum

class Likelihood(IntEnum):
    RARE = 1        # 거의 발생하지 않음
    UNLIKELY = 2    # 발생 가능성 낮음
    POSSIBLE = 3    # 발생 가능
    LIKELY = 4      # 발생 가능성 높음
    CERTAIN = 5     # 거의 확실

class Severity(IntEnum):
    NEGLIGIBLE = 1  # 미미
    MINOR = 2       # 경미
    MODERATE = 3    # 보통
    MAJOR = 4       # 심각
    CATASTROPHIC = 5  # 치명적

@dataclass
class AIRisk:
    risk_id: str
    description: str
    category: str
    likelihood: Likelihood
    severity: Severity
    mitigation: str = ""

    @property
    def risk_score(self) -> int:
        return self.likelihood * self.severity

    @property
    def risk_level(self) -> str:
        score = self.risk_score
        if score >= 20:
            return "극심"
        elif score >= 15:
            return "높음"
        elif score >= 8:
            return "보통"
        elif score >= 4:
            return "낮음"
        return "미미"

class AIRiskMatrix:
    """고영향 AI 위험 매트릭스"""

    def __init__(self, system_name: str):
        self.system_name = system_name
        self.risks: List[AIRisk] = []

    def add_risk(self, risk: AIRisk):
        self.risks.append(risk)

    def get_high_priority_risks(self) -> List[AIRisk]:
        """높은 우선순위 위험 조회"""
        return sorted(
            [r for r in self.risks if r.risk_score >= 15],
            key=lambda x: x.risk_score,
            reverse=True
        )

    def render_matrix(self) -> str:
        """위험 매트릭스 시각화"""
        matrix = [
            [" " for _ in range(5)] for _ in range(5)
        ]

        # 위험을 매트릭스에 배치
        for risk in self.risks:
            x = risk.likelihood - 1
            y = 4 - (risk.severity - 1)
            current = matrix[y][x]
            if current == " ":
                matrix[y][x] = risk.risk_id
            else:
                matrix[y][x] = "*"  # 다중 위험 표시

        output = f"""
    ╔══════════════════════════════════════════════════════════╗
    ║          {self.system_name} 위험 매트릭스                ║
    ╚══════════════════════════════════════════════════════════╝

    심각도 ↑
         5 │ {matrix[0][0]:^6} │ {matrix[0][1]:^6} │ {matrix[0][2]:^6} │ {matrix[0][3]:^6} │ {matrix[0][4]:^6} │
    치명적 ├────────┼────────┼────────┼────────┼────────┤
         4 │ {matrix[1][0]:^6} │ {matrix[1][1]:^6} │ {matrix[1][2]:^6} │ {matrix[1][3]:^6} │ {matrix[1][4]:^6} │
      심각 ├────────┼────────┼────────┼────────┼────────┤
         3 │ {matrix[2][0]:^6} │ {matrix[2][1]:^6} │ {matrix[2][2]:^6} │ {matrix[2][3]:^6} │ {matrix[2][4]:^6} │
      보통 ├────────┼────────┼────────┼────────┼────────┤
         2 │ {matrix[3][0]:^6} │ {matrix[3][1]:^6} │ {matrix[3][2]:^6} │ {matrix[3][3]:^6} │ {matrix[3][4]:^6} │
      경미 ├────────┼────────┼────────┼────────┼────────┤
         1 │ {matrix[4][0]:^6} │ {matrix[4][1]:^6} │ {matrix[4][2]:^6} │ {matrix[4][3]:^6} │ {matrix[4][4]:^6} │
      미미 └────────┴────────┴────────┴────────┴────────┘
               1        2        3        4        5     → 발생 가능성
             희박     낮음     보통     높음     확실

    [범례] 🟢 미미(1-3) | 🟡 낮음(4-7) | 🟠 보통(8-14) | 🔴 높음(15-19) | ⚫ 극심(20+)
    """
        return output

    def generate_mitigation_plan(self) -> str:
        """위험 완화 계획 생성"""
        plan = """
╔══════════════════════════════════════════════════════════╗
║              위험 완화 계획 (우선순위순)                  ║
╚══════════════════════════════════════════════════════════╝
"""
        sorted_risks = sorted(self.risks, key=lambda x: x.risk_score, reverse=True)

        for i, risk in enumerate(sorted_risks, 1):
            level_emoji = {
                "극심": "⚫", "높음": "🔴", "보통": "🟠",
                "낮음": "🟡", "미미": "🟢"
            }.get(risk.risk_level, "⚪")

            plan += f"""
{i}. [{risk.risk_id}] {risk.description}
   {level_emoji} 위험 수준: {risk.risk_level} (점수: {risk.risk_score})
   📁 분류: {risk.category}
   🛡️ 완화 방안: {risk.mitigation or '수립 필요'}
"""
        return plan

# 사용 예시: AI 채용 시스템
matrix = AIRiskMatrix("AI 채용 심사 시스템")

matrix.add_risk(AIRisk(
    risk_id="R01",
    description="성별/연령 기반 차별적 판단",
    category="공정성",
    likelihood=Likelihood.LIKELY,
    severity=Severity.MAJOR,
    mitigation="편향성 감사 및 공정성 제약 조건 적용"
))

matrix.add_risk(AIRisk(
    risk_id="R02",
    description="설명 불가능한 탈락 결정",
    category="투명성",
    likelihood=Likelihood.POSSIBLE,
    severity=Severity.MODERATE,
    mitigation="SHAP/LIME 기반 설명 생성 모듈 도입"
))

matrix.add_risk(AIRisk(
    risk_id="R03",
    description="학습 데이터 개인정보 유출",
    category="프라이버시",
    likelihood=Likelihood.UNLIKELY,
    severity=Severity.CATASTROPHIC,
    mitigation="차분 프라이버시 적용 및 접근 통제"
))

print(matrix.render_matrix())
print(matrix.generate_mitigation_plan())