AI 版权与知识产权：法律、技术与伦理

# 训练数据版权合规检查工具

from dataclasses import dataclass
from typing import List, Optional
from enum import Enum

class LicenseType(Enum):
    PUBLIC_DOMAIN = "public_domain"       # 公共领域
    CREATIVE_COMMON = "creative_common"    # 知识共享
    PROPRIETARY = "proprietary"            # 专有版权
    UNKNOWN = "unknown"                    # 未知

@dataclass
class DataItem:
    source_url: str
    license: LicenseType
    copyright_holder: Optional[str]
    has_permission: bool
    commercial_use_allowed: bool

class DatasetComplianceChecker:
    """训练数据集版权合规检查器"""

    def __init__(self, items: List[DataItem]):
        self.items = items

    def audit(self) -> dict:
        """全面审计数据集的版权合规性"""
        total = len(self.items)
        by_license = {}
        for item in self.items:
            key = item.license.value
            by_license[key] = by_license.get(key, 0) + 1

        risky = [
            item for item in self.items
            if item.license in (LicenseType.PROPRIETARY, LicenseType.UNKNOWN)
            and not item.has_permission
        ]

        return {
            "total_items": total,
            "by_license": by_license,
            "risky_items": len(risky),
            "risk_rate": len(risky) / total if total > 0 else 0,
            "recommendation": (
                "数据集版权风险较高，建议清理" if len(risky) / total > 0.1
                else "数据集版权风险可控"
            )
        }

# 使用示例
dataset = DatasetComplianceChecker(sample_items)
audit = dataset.audit()
print(f"风险项: {audit['risky_items']}/{audit['total_items']}")
print(f"风险率: {audit['risk_rate']:.1%}")
print(f"建议: {audit['recommendation']}")

# 计算数据集的版权风险评分

def calculate_copyright_risk_score(
    public_domain_ratio: float,
    licensed_ratio: float,
    unknown_ratio: float,
    commercial_use_ratio: float,
    has_opt_out_mechanism: bool,
    data_source_transparency: bool
) -> dict:
    """
    计算数据集版权风险评分 (0-100, 越低越安全)

    评分维度:
    - 公共领域数据比例 (权重 20%)
    - 有明确许可的数据比例 (权重 25%)
    - 允许商业使用的比例 (权重 20%)
    - 有无 opt-out 机制 (权重 15%)
    - 数据来源透明度 (权重 20%)
    """
    weights = {
        "public_domain": 0.20,
        "licensed": 0.25,
        "commercial_use": 0.20,
        "opt_out": 0.15,
        "transparency": 0.20
    }

    scores = {
        "public_domain": public_domain_ratio * 100,
        "licensed": licensed_ratio * 100,
        "commercial_use": commercial_use_ratio * 100,
        "opt_out": 100 if has_opt_out_mechanism else 0,
        "transparency": 100 if data_source_transparency else 0
    }

    # 加权总分 (100 表示完全合规)
    compliance_score = sum(
        weights[k] * scores[k] for k in weights
    )

    # 风险评分 (0 表示无风险, 100 表示高风险)
    risk_score = 100 - compliance_score

    risk_level = (
        "低" if risk_score < 20
        else "中低" if risk_score < 40
        else "中" if risk_score < 60
        else "中高" if risk_score < 80
        else "高"
    )

    return {
        "risk_score": round(risk_score, 1),
        "risk_level": risk_level,
        "breakdown": {k: round(scores[k], 1) for k in scores}
    }

# 示例评估
result = calculate_copyright_risk_score(
    public_domain_ratio=0.3,
    licensed_ratio=0.4,
    unknown_ratio=0.3,
    commercial_use_ratio=0.6,
    has_opt_out_mechanism=True,
    data_source_transparency=True
)
print(f"风险评分: {result['risk_score']} ({result['risk_level']})")

# AI 生成内容的人类贡献度评估框架

from dataclasses import dataclass
from typing import List

@dataclass
class HumanContributionFactor:
    """人类贡献度评估因子"""
    name: str
    weight: float       # 权重 (0-1)
    score: float        # 评分 (0-100)
    description: str

def assess_human_contribution(
    prompt_complexity: float,      # 提示词复杂程度 (0-100)
    iteration_count: int,           # 迭代次数
    manual_editing: float,          # 后期编辑程度 (0-100)
    creative_direction: float,      # 创意指导程度 (0-100)
    selection_curation: float,      # 筛选策展程度 (0-100)
) -> dict:
    """
    评估人类在 AI 生成内容中的贡献度

    参考标准:
    - 纯 AI 生成 (< 20): 不太可能获得版权
    - 中等人类贡献 (20-50): 灰色地带
    - 高人类贡献 (> 50): 更可能获得版权
    """
    factors = [
        HumanContributionFactor("提示词复杂度", 0.15, prompt_complexity,
                               "提示词的详细程度和创意性"),
        HumanContributionFactor("迭代次数", 0.10, min(iteration_count * 10, 100),
                               "生成-修改-再生的迭代过程"),
        HumanContributionFactor("后期编辑", 0.30, manual_editing,
                               "生成后的人工修改和完善"),
        HumanContributionFactor("创意指导", 0.25, creative_direction,
                               "整体的创意方向和设计决策"),
        HumanContributionFactor("筛选策展", 0.20, selection_curation,
                               "从多个结果中选择和组合"),
    ]

    weighted_score = sum(f.weight * f.score for f in factors)
    human_contribution = weighted_score

    level = (
        "纯AI生成" if human_contribution < 20
        else "低人类贡献" if human_contribution < 35
        else "中等人类贡献" if human_contribution < 50
        else "高人类贡献" if human_contribution < 70
        else "人类主导创作"
    )

    copyright_likelihood = (
        "极低" if human_contribution < 20
        else "较低" if human_contribution < 35
        else "不确定" if human_contribution < 50
        else "较可能" if human_contribution < 70
        else "很可能"
    )

    return {
        "human_contribution_score": round(human_contribution, 1),
        "contribution_level": level,
        "copyright_likelihood": copyright_likelihood,
        "factors": [
            {"name": f.name, "weight": f.weight, "score": round(f.score, 1)}
            for f in factors
        ]
    }

result = assess_human_contribution(
    prompt_complexity=80,
    iteration_count=15,
    manual_editing=60,
    creative_direction=70,
    selection_curation=80
)
print(f"人类贡献度: {result['human_contribution_score']}%")
print(f"版权可能性: {result['copyright_likelihood']}")

# AI 生成内容的版权标记系统

from datetime import datetime
from dataclasses import dataclass, field
import hashlib
import json

@dataclass
class AIContentAttribution:
    """AI 生成内容的归属标记"""
    content_hash: str
    ai_model: str
    ai_version: str
    prompt: str
    human_edits: list = field(default_factory=list)
    creation_date: str = field(default_factory=lambda: datetime.now().isoformat())
    jurisdiction: str = "unknown"  # 适用的司法管辖区

    def generate_manifest(self) -> str:
        """生成 C2PA 风格的归属清单"""
        manifest = {
            "@context": "https://schema.org/",
            "@type": "CreativeWork",
            "creator": [
                {"@type": "Person", "name": "人类创作者"},
                {"@type": "SoftwareApplication",
                 "name": self.ai_model,
                 "softwareVersion": self.ai_version}
            ],
            "dateCreated": self.creation_date,
            "creativeWorkStatus": f"AI-assisted: {len(self.human_edits)} manual edits",
            "contentHash": self.content_hash
        }
        return json.dumps(manifest, indent=2, ensure_ascii=False)

    @classmethod
    def from_content(cls, content: str, ai_model: str, prompt: str):
        content_hash = hashlib.sha256(content.encode()).hexdigest()
        return cls(
            content_hash=content_hash,
            ai_model=ai_model,
            ai_version="unknown",
            prompt=prompt
        )

# 使用示例
artwork = "..."  # 生成的内容
attribution = AIContentAttribution.from_content(
    content=artwork,
    ai_model="Stable Diffusion 3",
    prompt="a sunset over mountains in oil painting style"
)
attribution.human_edits = ["color correction", "composition adjustment"]
print(attribution.generate_manifest())

# 合理使用四要素分析框架

from dataclasses import dataclass
from typing import Tuple

@dataclass
class FairUseFactor:
    name: str
    description: str
    score: float  # -1.0 (强反对) 到 +1.0 (强支持)
    weight: float

def analyze_fair_use(
    purpose_and_character: float,  # 转换性程度 (-1 到 +1)
    nature_of_work: float,         # 作品性质 (-1 到 +1)
    amount_used: float,            # 使用数量和实质性 (-1 到 +1)
    market_effect: float           # 对市场的影响 (-1 到 +1)
) -> dict:
    """
    分析 AI 训练是否构成合理使用

    评分规则:
    +1.0: 强烈支持合理使用
    0.0: 中性
    -1.0: 强烈反对合理使用
    """
    factors = [
        FairUseFactor(
            "使用的目的和性质",
            "是否转换性使用，是否商业用途",
            purpose_and_character,
            0.35  # 最重要的因素
        ),
        FairUseFactor(
            "作品的性质",
            "事实性作品 vs 创意性作品",
            nature_of_work,
            0.15
        ),
        FairUseFactor(
            "使用的数量和实质性",
            "使用了多少，是否使用了核心部分",
            amount_used,
            0.25
        ),
        FairUseFactor(
            "对原作品市场的影响",
            "是否替代了原作品",
            market_effect,
            0.25
        ),
    ]

    # 加权总分
    total_score = sum(f.score * f.weight for f in factors)

    # 判断
    if total_score > 0.5:
        verdict = "很可能构成合理使用"
    elif total_score > 0.2:
        verdict = "倾向于合理使用"
    elif total_score > -0.2:
        verdict = "不确定，需个案分析"
    elif total_score > -0.5:
        verdict = "倾向于不构成合理使用"
    else:
        verdict = "很可能不构成合理使用"

    return {
        "total_score": round(total_score, 3),
        "verdict": verdict,
        "factors": [
            {"name": f.name, "score": round(f.score, 2), "weight": f.weight}
            for f in factors
        ]
    }

# 场景: AI 使用受版权保护的新闻文章训练语言模型
result = analyze_fair_use(
    purpose_and_character=0.6,   # 有一定转换性，但有商业目的
    nature_of_work=-0.3,          # 新闻文章有部分创意性
    amount_used=-0.5,             # 使用了大量文章
    market_effect=0.2             # 影响不确定
)
print(f"合理使用的可能性: {result['verdict']}")
print(f"综合评分: {result['total_score']}")

# 各国 TDM（文本和数据挖掘）法律对比

class TDMRegimeAnalyzer:
    """分析各国文本和数据挖掘法律环境"""

    REGIMES = {
        "US": {
            "name": "美国",
            "framework": "合理使用 (Fair Use)",
            "opt_out": False,
            "commercial_allowed": "法院判定中",
            "risk_level": "中",
            "notes": "法院个案判定，尚未有统一标准"
        },
        "EU": {
            "name": "欧盟",
            "framework": "版权指令第3/4条",
            "opt_out": True,
            "commercial_allowed": "可(除非opt-out)",
            "risk_level": "中低",
            "notes": "版权持有者可 opt-out"
        },
        "JP": {
            "name": "日本",
            "framework": "版权法第30-4条",
            "opt_out": False,
            "commercial_allowed": "是",
            "risk_level": "低",
            "notes": "最开放，只要不侵犯道德权利"
        },
        "UK": {
            "name": "英国",
            "framework": "CDPA 第29A条",
            "opt_out": False,
            "commercial_allowed": "有限",
            "risk_level": "中",
            "notes": "非商业研究允许，商业用途待定"
        },
        "CN": {
            "name": "中国",
            "framework": "生成式 AI 管理办法",
            "opt_out": False,
            "commercial_allowed": "有条件",
            "risk_level": "中",
            "notes": "要求数据来源合法"
        }
    }

    def compare(self, countries: list[str]) -> str:
        """对比指定国家的法律环境"""
        lines = ["TDM 法律环境对比:", ""]
        for country_code in countries:
            regime = self.REGIMES.get(country_code, {})
            lines.append(f"--- {regime.get('name', country_code)} ---")
            for key in ['framework', 'opt_out', 'commercial_allowed',
                        'risk_level', 'notes']:
                lines.append(f"  {key}: {regime.get(key, 'N/A')}")
            lines.append("")
        return "\n".join(lines)

analyzer = TDMRegimeAnalyzer()
print(analyzer.compare(["US", "EU", "JP", "CN"]))

# AI 生成内容的商标相似度检查

import numpy as np
from typing import List, Tuple

class TrademarkSimilarityChecker:
    """
    检查 AI 生成的标志/名称是否与已有商标过于相似
    使用多维度相似度评估
    """

    def __init__(self, trademark_db: List[dict]):
        """
        trademark_db: [{"name": str, "class": int, "image_hash": str, ...}]
        """
        self.db = trademark_db

    def check_text_similarity(
        self,
        candidate: str,
        threshold: float = 0.8
    ) -> List[Tuple[str, float]]:
        """
        检查文本相似度
        返回: [(商标名称, 相似度), ...]
        """
        results = []
        for tm in self.db:
            sim = self._levenshtein_similarity(
                candidate.lower(), tm["name"].lower()
            )
            if sim >= threshold:
                results.append((tm["name"], sim))
        return sorted(results, key=lambda x: x[1], reverse=True)

    @staticmethod
    def _levenshtein_similarity(s1: str, s2: str) -> float:
        """计算两个字符串的编辑距离相似度"""
        if len(s1) == 0 and len(s2) == 0:
            return 1.0
        max_len = max(len(s1), len(s2))
        distance = TrademarkSimilarityChecker._edit_distance(s1, s2)
        return 1.0 - distance / max_len

    @staticmethod
    def _edit_distance(s1: str, s2: str) -> int:
        """计算编辑距离"""
        m, n = len(s1), len(s2)
        dp = [[0] * (n + 1) for _ in range(m + 1)]
        for i in range(m + 1):
            dp[i][0] = i
        for j in range(n + 1):
            dp[0][j] = j
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                cost = 0 if s1[i-1] == s2[j-1] else 1
                dp[i][j] = min(
                    dp[i-1][j] + 1,
                    dp[i][j-1] + 1,
                    dp[i-1][j-1] + cost
                )
        return dp[m][n]

# 使用示例
checker = TrademarkSimilarityChecker(trademark_database)
similar = checker.check_text_similarity("ChatGPT-5")
for name, score in similar:
    print(f"  与 '{name}' 相似度: {score:.2%}")

# AI 辅助发明的专利资格评估

from dataclasses import dataclass
from typing import List

@dataclass
class PatentClaim:
    description: str
    human_contribution: float  # 0-1, 人类贡献比例
    ai_contribution: float     # 0-1, AI 贡献比例
    novelty_score: float       # 0-100, 新颖性评分
    inventive_step: float      # 0-100, 创造性评分

def assess_patent_eligibility(claims: List[PatentClaim]) -> dict:
    """
    评估 AI 辅助发明的专利资格

    关键原则:
    1. 发明人必须是人类
    2. 人类必须有实质性贡献
    3. 满足新颖性和创造性要求
    """
    total_human = sum(c.human_contribution for c in claims)
    avg_human = total_human / len(claims) if claims else 0

    avg_novelty = sum(c.novelty_score for c in claims) / len(claims)
    avg_inventive = sum(c.inventive_step for c in claims) / len(claims)

    # 人类贡献门槛
    human_threshold_met = avg_human >= 0.3
    novelty_threshold_met = avg_novelty >= 70
    inventive_threshold_met = avg_inventive >= 60

    overall_eligible = (
        human_threshold_met
        and novelty_threshold_met
        and inventive_threshold_met
    )

    return {
        "eligible": overall_eligible,
        "human_contribution_avg": round(avg_human, 2),
        "human_threshold_met": human_threshold_met,
        "novelty_avg": round(avg_novelty, 1),
        "novelty_met": novelty_threshold_met,
        "inventive_avg": round(avg_inventive, 1),
        "inventive_met": inventive_threshold_met,
        "recommendation": (
            "满足专利资格，可以提交申请" if overall_eligible
            else "需要增加人类贡献或提高创新性"
        )
    }

# 示例评估
claims = [
    PatentClaim("使用 AI 优化的药物分子设计", 0.6, 0.4, 85, 75),
    PatentClaim("AI 辅助的电路布局优化", 0.4, 0.6, 70, 65),
    PatentClaim("AI 生成的数据处理算法", 0.2, 0.8, 60, 50),
]
result = assess_patent_eligibility(claims)
print(f"专利资格: {'✅ 通过' if result['eligible'] else '❌ 不通过'}")
print(f"建议: {result['recommendation']}")

# AI 数据治理框架核心组件

from dataclasses import dataclass, field
from typing import List, Optional, Dict
from datetime import datetime
from enum import Enum

class DataCategory(Enum):
    TEXT = "text"
    IMAGE = "image"
    AUDIO = "audio"
    CODE = "code"
    MULTIMODAL = "multimodal"

class RiskLevel(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    CRITICAL = "critical"

@dataclass
class DataSource:
    """数据源注册信息"""
    name: str
    url: str
    category: DataCategory
    license_type: str
    copyright_status: str
    opt_out_available: bool
    collection_date: str
    volume_records: int
    risk_level: RiskLevel
    notes: str = ""

@dataclass
class DataGovernanceRegistry:
    """数据治理注册中心"""
    data_sources: List[DataSource] = field(default_factory=list)
    last_audit_date: Optional[str] = None
    compliance_officer: str = ""

    def register_source(self, source: DataSource):
        """注册新的数据源"""
        self.data_sources.append(source)

    def audit(self) -> dict:
        """执行数据治理审计"""
        total = len(self.data_sources)
        by_risk = {level.value: 0 for level in RiskLevel}
        by_category = {cat.value: 0 for cat in DataCategory}
        opt_out_count = 0

        for source in self.data_sources:
            by_risk[source.risk_level.value] += 1
            by_category[source.category.value] += 1
            if source.opt_out_available:
                opt_out_count += 1

        critical_sources = [
            s for s in self.data_sources
            if s.risk_level == RiskLevel.CRITICAL
        ]

        return {
            "total_sources": total,
            "by_risk_level": by_risk,
            "by_category": by_category,
            "opt_out_available": opt_out_count,
            "critical_items": len(critical_sources),
            "critical_sources": [s.name for s in critical_sources],
            "last_audit": self.last_audit_date
        }

# 使用示例
registry = DataGovernanceRegistry(compliance_officer="法务团队")
registry.register_source(DataSource(
    name="Common Crawl",
    url="https://commoncrawl.org",
    category=DataCategory.TEXT,
    license_type="Various",
    copyright_status="Mixed",
    opt_out_available=True,
    collection_date="2026-01-15",
    volume_records=10_000_000,
    risk_level=RiskLevel.MEDIUM
))
audit = registry.audit()
print(f"数据源总数: {audit['total_sources']}")
print(f"高风险: {audit['by_risk_level']['high']}")

# 模型卡片自动生成器

def generate_model_card(
    model_name: str,
    model_type: str,
    training_data_summary: dict,
    performance_metrics: dict,
    limitations: List[str],
    ethical_considerations: List[str],
    intended_use: str,
    out_of_scope: List[str],
) -> str:
    """
    生成标准化的模型卡片
    参考: https://huggingface.co/docs/hub/model-cards
    """
    card = f"""# {model_name}

## 模型详情
- 类型: {model_type}
- 生成日期: {datetime.now().strftime("%Y-%m-%d")}

## 训练数据
- 数据来源: {training_data_summary.get('sources', '未披露')}
- 数据规模: {training_data_summary.get('volume', '未披露')}
- 数据处理: {training_data_summary.get('preprocessing', '未披露')}
- 版权合规: {training_data_summary.get('copyright', '未评估')}

## 性能指标
"""
    for metric, value in performance_metrics.items():
        card += f"- {metric}: {value}\n"

    card += f"""
## 预期用途
{intended_use}

## 超出范围的使用
"""
    for item in out_of_scope:
        card += f"- {item}\n"

    card += f"""
## 局限性
"""
    for item in limitations:
        card += f"- {item}\n"

    card += f"""
## 伦理考量
"""
    for item in ethical_considerations:
        card += f"- {item}\n"

    return card

# 使用示例
card = generate_model_card(
    model_name="AI-Master-LLM-v2",
    model_type="Decoder-only Transformer (7B)",
    training_data_summary={
        "sources": "Common Crawl, Wikipedia, 开源书籍",
        "volume": "2.5T tokens",
        "preprocessing": "去重、过滤、质量评分",
        "copyright": "已进行版权审计，风险率 < 5%"
    },
    performance_metrics={
        "MMLU": "68.5%",
        "HumanEval": "52.3%",
        "BLEU (WMT14 EN-DE)": "28.1"
    },
    limitations=[
        "知识截止于 2025 年 12 月",
        "可能在数学推理上存在幻觉",
        "对低资源语言支持有限"
    ],
    ethical_considerations=[
        "训练数据可能包含社会偏见",
        "可能生成有害内容，已添加安全过滤",
        "不应替代专业法律或医疗建议"
    ],
    intended_use="研究、教育、辅助创作",
    out_of_scope=[
        "自动化决策系统",
        "高风险领域（医疗诊断、法律判决）",
        "生成虚假信息"
    ]
)
print(card)