규정 준수

AI 공정성은 법적 및 규제 요구 사항에 의해 점점 더 규제되고 있습니다. 이 장에서는 弘益人間 원칙과 일치하는 AI 시스템에 대한 규제 환경, 준수 요구 사항, 문서화 관행을 다룹니다.

글로벌 규제 환경

다른 관할권은 AI 공정성 규제에 대해 다른 접근 방식을 취합니다. 준수하는 AI 시스템을 배포하려면 이러한 규정을 이해하는 것이 중요합니다.

유럽연합 AI법

위험 기반 분류

EU AI법은 AI 시스템을 위험 수준에 따라 분류합니다:

위험 수준	예시	요구 사항
수용 불가 위험	사회적 점수 매기기, 실시간 생체 감시	금지됨
고위험	채용, 신용 점수, 법 집행	엄격한 준수 요구 사항
제한적 위험	챗봇, 딥페이크	투명성 의무
최소 위험	스팸 필터, 비디오 게임	특정 요구 사항 없음

고위험 시스템 요구 사항

고위험 AI 시스템은 엄격한 요구 사항을 충족해야 합니다:

# EU AI법 준수 체크리스트
class EUAIActCompliance:
    """
    EU AI법 요구 사항 준수 추적
    """
    def __init__(self, system_name, risk_level):
        self.system_name = system_name
        self.risk_level = risk_level
        self.compliance_checklist = self._initialize_checklist()

    def _initialize_checklist(self):
        """
        위험 수준에 따라 준수 요구 사항 초기화
        """
        if self.risk_level == "high":
            return {
                'risk_management': {
                    'required': True,
                    'completed': False,
                    'description': '위험 관리 시스템 수립'
                },
                'data_governance': {
                    'required': True,
                    'completed': False,
                    'description': '데이터 거버넌스 관행 구현'
                },
                'technical_documentation': {
                    'required': True,
                    'completed': False,
                    'description': '포괄적인 기술 문서 유지'
                },
                'record_keeping': {
                    'required': True,
                    'completed': False,
                    'description': '이벤트 자동 로깅'
                },
                'transparency': {
                    'required': True,
                    'completed': False,
                    'description': '사용자에게 명확한 정보 제공'
                },
                'human_oversight': {
                    'required': True,
                    'completed': False,
                    'description': '의미 있는 인간 감독 보장'
                },
                'accuracy_robustness': {
                    'required': True,
                    'completed': False,
                    'description': '적절한 정확도와 견고성 입증'
                },
                'cybersecurity': {
                    'required': True,
                    'completed': False,
                    'description': '사이버 보안 조치 구현'
                },
                'conformity_assessment': {
                    'required': True,
                    'completed': False,
                    'description': '적합성 평가 수행'
                }
            }
        else:
            return {}

    def mark_completed(self, requirement):
        """
        요구 사항을 완료로 표시
        """
        if requirement in self.compliance_checklist:
            self.compliance_checklist[requirement]['completed'] = True
            print(f"✓ '{requirement}'를 완료로 표시함")

    def generate_compliance_report(self):
        """
        준수 상태 보고서 생성
        """
        print("\nEU AI법 준수 보고서")
        print("=" * 70)
        print(f"시스템: {self.system_name}")
        print(f"위험 수준: {self.risk_level}")

        if not self.compliance_checklist:
            print("\n이 위험 수준에 대한 특정 요구 사항 없음")
            return

        total = len(self.compliance_checklist)
        completed = sum(1 for r in self.compliance_checklist.values() if r['completed'])

        print(f"\n준수 상태: {completed}/{total} 요구 사항 충족")
        print("-" * 70)

        for req_name, req_data in self.compliance_checklist.items():
            status = "✓" if req_data['completed'] else "✗"
            print(f"{status} {req_name}: {req_data['description']}")

        if completed == total:
            print("\n✓ 완전 준수")
        else:
            print(f"\n⚠ {total - completed}개 요구 사항 미완료")

        print("\n弘益人間 - 준수는 모든 사용자를 위한 공정성을 보장합니다")
        print("=" * 70)

        return completed / total if total > 0 else 1.0

# 사용
# compliance = EUAIActCompliance("채용 AI", "high")
# compliance.generate_compliance_report()

GDPR 및 데이터 보호

설명에 대한 권리

GDPR 제22조는 자동화된 결정에 대한 설명을 받을 권리를 개인에게 부여합니다.

# GDPR 준수 설명 시스템
class GDPRExplanationSystem:
    """
    AI 결정에 대한 GDPR 준수 설명 생성
    """
    def __init__(self, model, feature_names):
        self.model = model
        self.feature_names = feature_names

    def generate_explanation(self, instance, prediction):
        """
        결정에 대한 사람이 읽을 수 있는 설명 생성
        """
        explanation = {
            'decision': '승인됨' if prediction == 1 else '거부됨',
            'confidence': self.model.predict_proba([instance])[0][prediction],
            'factors': self._get_influential_factors(instance),
            'alternative_outcome': self._alternative_outcome_guidance(instance),
            'appeal_process': '사람의 검토를 요청하려면 support@company.com으로 문의하세요'
        }

        return explanation

    def _get_influential_factors(self, instance):
        """
        결정에 가장 영향을 미친 요인 식별
        """
        # 간소화됨 - 실제로는 SHAP 또는 LIME을 사용
        feature_importance = self.model.feature_importances_
        instance_values = instance

        factors = []
        for i, (fname, fvalue, importance) in enumerate(
            zip(self.feature_names, instance_values, feature_importance)
        ):
            if importance > 0.1:  # 중요한 요인
                factors.append({
                    'factor': fname,
                    'value': fvalue,
                    'importance': importance,
                    'impact': '긍정적' if fvalue > 0 else '부정적'
                })

        return sorted(factors, key=lambda x: x['importance'], reverse=True)[:5]

    def _alternative_outcome_guidance(self, instance):
        """
        대안적 결과를 달성하는 방법에 대한 안내 제공
        """
        # 다른 결과를 위해 무엇이 변경되어야 하는지 식별
        guidance = []

        # 간소화됨 - 실제 구현은 반사실적 설명을 사용
        guidance.append("신용 점수를 50점 향상시키면 결과가 변경될 수 있습니다")
        guidance.append("부채 대 소득 비율을 30% 이하로 줄이면 도움이 될 수 있습니다")

        return guidance

    def format_user_friendly_explanation(self, explanation):
        """
        최종 사용자를 위해 설명 형식화
        """
        output = f"\n결정 설명\n"
        output += "=" * 70 + "\n"
        output += f"결정: {explanation['decision']}\n"
        output += f"신뢰도: {explanation['confidence']:.0%}\n\n"

        output += "이 결정의 주요 요인:\n"
        output += "-" * 70 + "\n"
        for i, factor in enumerate(explanation['factors'], 1):
            output += f"{i}. {factor['factor']}: {factor['value']} "
            output += f"({factor['impact']} 영향)\n"

        output += "\n다른 결과를 달성하려면:\n"
        output += "-" * 70 + "\n"
        for guidance in explanation['alternative_outcome']:
            output += f"• {guidance}\n"

        output += f"\n항소 절차:\n{explanation['appeal_process']}\n"
        output += "\n" + "=" * 70

        return output

# 사용
# explainer = GDPRExplanationSystem(model, feature_names)
# explanation = explainer.generate_explanation(instance, prediction)
# print(explainer.format_user_friendly_explanation(explanation))

미국 규정

평등 신용 기회법(ECOA)

ECOA는 보호되는 특성에 기반한 신용 결정의 차별을 금지합니다.

# ECOA 준수 검사기
class ECOACompliance:
    """
    ECOA 요구 사항 준수 확인
    """
    def __init__(self):
        self.protected_attributes = [
            'race', 'color', 'religion', 'national_origin',
            'sex', 'marital_status', 'age'
        ]

    def check_adverse_action_notice(self, decision, reasons):
        """
        불리한 조치 통지 요구 사항 확인
        """
        if decision == 'rejected':
            required_elements = {
                'specific_reasons': len(reasons) > 0,
                'max_four_reasons': len(reasons) <= 4,
                'applicant_rights': True,  # 권리에 대해 알려야 함
                'contact_info': True  # 질문을 위한 연락처 제공해야 함
            }

            compliance = all(required_elements.values())

            if not compliance:
                print("⚠️ 불리한 조치 통지 불완전")
                for element, satisfied in required_elements.items():
                    if not satisfied:
                        print(f"  누락: {element}")

            return compliance

        return True  # 승인에는 불리한 조치 통지 필요 없음

    def verify_prohibited_factors(self, model_features):
        """
        보호 속성이 사용되지 않았는지 확인 (예외 있음)
        """
        prohibited_found = []

        for attr in self.protected_attributes:
            if attr in model_features:
                # 연령은 특정 목적으로 허용됨
                if attr == 'age' and self._age_allowed():
                    continue

                prohibited_found.append(attr)

        if prohibited_found:
            print("⚠️ 경고: 잠재적으로 금지된 요인 발견:")
            for factor in prohibited_found:
                print(f"  • {factor}")
            print("\n법적으로 사용하거나 제거하는지 확인하세요")

        return len(prohibited_found) == 0

    def _age_allowed(self):
        """
        연령 사용이 허용되는지 확인 (예: 노인 우대)
        """
        # 간소화됨 - 실제 구현은 특정 맥락을 확인
        return False

# 사용
# ecoa = ECOACompliance()
# ecoa.check_adverse_action_notice('rejected', ['insufficient income', 'high debt ratio'])

공정 주택법

주택 관련 결정의 차별을 금지합니다.

EEOC 지침 (고용)

평등 고용 기회 위원회는 공정한 고용 관행에 대한 지침을 제공합니다.

# EEOC 준수 - 불리한 영향 분석
class EEOCCompliance:
    """
    EEOC 지침에 따른 불리한 영향 분석 수행
    """
    def four_fifths_rule(self, selection_rates):
        """
        80% (5분의 4) 규칙 적용
        """
        print("\nEEOC 5분의 4 규칙 분석")
        print("=" * 70)

        groups = list(selection_rates.keys())
        rates = list(selection_rates.values())

        # 최고 선택률 찾기
        max_rate = max(rates)
        max_group = groups[rates.index(max_rate)]

        print(f"최고 선택률: {max_group} ({max_rate:.1%})")
        print(f"\n5분의 4 임계값: {max_rate * 0.8:.1%}")
        print("-" * 70)

        violations = []
        for group, rate in selection_rates.items():
            ratio = rate / max_rate
            compliant = ratio >= 0.8

            status = "✓ 통과" if compliant else "✗ 실패"
            print(f"{group:<20} {rate:.1%}  {ratio:.2f}  {status}")

            if not compliant:
                violations.append({
                    'group': group,
                    'rate': rate,
                    'ratio': ratio
                })

        if violations:
            print(f"\n⚠️ 불리한 영향 탐지됨")
            print("EEOC는 이것을 차별의 증거로 간주할 수 있습니다")
            print("\n권장 사항:")
            print("1. 편향에 대한 선택 기준 검토")
            print("2. 대안적 선택 방법 고려")
            print("3. 기준 유지 시 비즈니스 필요성 문서화")
            print("4. 불리한 영향을 줄이기 위한 조치 구현")

        else:
            print(f"\n✓ 불리한 영향 탐지되지 않음")
            print("시스템이 5분의 4 규칙을 충족합니다")

        print("\n弘益人間 - 모든 이를 위한 공정한 고용")
        print("=" * 70)

        return len(violations) == 0

# 사용
# eeoc = EEOCCompliance()
# selection_rates = {'male': 0.45, 'female': 0.32}
# eeoc.four_fifths_rule(selection_rates)

문서화 요구 사항

모델 카드

모델 특성 및 성능에 대한 표준화된 문서.

# 모델 카드 생성기
class ModelCard:
    """
    문서화를 위한 포괄적인 모델 카드 생성
    """
    def __init__(self, model_name, version):
        self.model_name = model_name
        self.version = version
        self.sections = {}

    def add_model_details(self, details):
        """
        기본 모델 정보 추가
        """
        self.sections['model_details'] = details

    def add_intended_use(self, use_case, users, out_of_scope):
        """
        의도된 사용 및 한계 문서화
        """
        self.sections['intended_use'] = {
            'primary_use': use_case,
            'intended_users': users,
            'out_of_scope_uses': out_of_scope
        }

    def add_training_data(self, description, size, demographics):
        """
        학습 데이터 특성 문서화
        """
        self.sections['training_data'] = {
            'description': description,
            'size': size,
            'demographics': demographics
        }

    def add_performance_metrics(self, overall, by_group):
        """
        그룹 전체의 성능 문서화
        """
        self.sections['performance'] = {
            'overall': overall,
            'by_group': by_group
        }

    def add_fairness_assessment(self, metrics, mitigation):
        """
        공정성 평가 및 완화 문서화
        """
        self.sections['fairness'] = {
            'metrics': metrics,
            'mitigation_strategies': mitigation
        }

    def add_ethical_considerations(self, considerations):
        """
        윤리적 고려 사항 및 위험 문서화
        """
        self.sections['ethical_considerations'] = considerations

    def generate_card(self):
        """
        완전한 모델 카드 생성
        """
        card = f"""
모델 카드: {self.model_name} v{self.version}
{'=' * 70}

모델 세부 정보
{'-' * 70}
{self._format_section(self.sections.get('model_details', {}))}

의도된 사용
{'-' * 70}
{self._format_section(self.sections.get('intended_use', {}))}

학습 데이터
{'-' * 70}
{self._format_section(self.sections.get('training_data', {}))}

성능 지표
{'-' * 70}
{self._format_section(self.sections.get('performance', {}))}

공정성 평가
{'-' * 70}
{self._format_section(self.sections.get('fairness', {}))}

윤리적 고려 사항
{'-' * 70}
{self._format_section(self.sections.get('ethical_considerations', {}))}

{'=' * 70}
弘益人間 - 모든 인류를 위한 투명한 AI
생성: {datetime.now().strftime('%Y-%m-%d')}
        """

        return card

    def _format_section(self, section_data):
        """
        표시를 위한 섹션 데이터 형식화
        """
        if isinstance(section_data, dict):
            return '\n'.join(f"{k}: {v}" for k, v in section_data.items())
        elif isinstance(section_data, list):
            return '\n'.join(f"• {item}" for item in section_data)
        else:
            return str(section_data)

# 사용
# card = ModelCard("신용 점수 모델", "2.1")
# card.add_model_details({'type': 'Random Forest', 'features': 25})
# card.add_fairness_assessment(
#     metrics={'demographic_parity': 0.92},
#     mitigation=['reweighting', 'threshold optimization']
# )
# print(card.generate_card())

감사 추적 및 기록 보관

# 포괄적인 감사 추적 시스템
class AuditTrail:
    """
    준수를 위한 포괄적인 감사 추적 유지
    """
    def __init__(self, system_name):
        self.system_name = system_name
        self.records = []

    def log_decision(self, decision_id, inputs, outputs, timestamp=None):
        """
        모든 세부 정보와 함께 개별 결정 로그
        """
        if timestamp is None:
            timestamp = datetime.now()

        record = {
            'decision_id': decision_id,
            'timestamp': timestamp,
            'inputs': inputs,
            'outputs': outputs,
            'system_version': self.get_system_version()
        }

        self.records.append(record)

    def log_model_update(self, old_version, new_version, changes):
        """
        모델 업데이트 및 변경 로그
        """
        record = {
            'type': 'model_update',
            'timestamp': datetime.now(),
            'old_version': old_version,
            'new_version': new_version,
            'changes': changes
        }

        self.records.append(record)

    def log_fairness_audit(self, audit_results):
        """
        공정성 감사 결과 로그
        """
        record = {
            'type': 'fairness_audit',
            'timestamp': datetime.now(),
            'results': audit_results
        }

        self.records.append(record)

    def get_system_version(self):
        """
        현재 시스템 버전 가져오기
        """
        return "v2.1.0"  # 동적으로 검색됨

    def export_audit_trail(self, output_file):
        """
        규제 검토를 위한 감사 추적 내보내기
        """
        import json

        with open(output_file, 'w') as f:
            json.dump({
                'system_name': self.system_name,
                'export_date': datetime.now().isoformat(),
                'total_records': len(self.records),
                'records': self.records
            }, f, indent=2, default=str)

        print(f"감사 추적이 {output_file}로 내보내기됨")
        print(f"전체 기록: {len(self.records)}")

# 사용
# audit_trail = AuditTrail("채용 AI 시스템")
# audit_trail.log_decision("D123456", inputs, outputs)
# audit_trail.export_audit_trail("audit_trail_2025.json")