AI与电影剧本：机器学习编剧的版权争议

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title AI剧本版权登记合约
 * @notice 登记AI辅助生成的电影剧本版权
 */
contract AIScriptCopyright {
    struct Script {
        uint256 id;
        string title;
        address[] humanAuthors;
        string aiModel;
        string promptHistory;
        string ipfsHash;
        uint256 humanContributionPercent;
        uint256 timestamp;
        bool registered;
    }
    
    struct Revision {
        uint256 scriptId;
        uint256 version;
        address author;
        string ipfsHash;
        string changeDescription;
        uint256 timestamp;
        uint256 aiAssistedPercent;
    }
    
    mapping(uint256 => Script) public scripts;
    mapping(uint256 => Revision[]) public revisions;
    mapping(address => uint256[]) public authorScripts;
    
    uint256 public nextScriptId;
    
    event ScriptRegistered(uint256 indexed id, string title, address[] authors);
    event RevisionAdded(uint256 indexed scriptId, uint256 version, address author);
    
    function registerScript(
        string memory title,
        address[] memory humanAuthors,
        string memory aiModel,
        string memory promptHistory,
        string memory ipfsHash,
        uint256 humanContributionPercent
    ) external returns (uint256) {
        uint256 id = nextScriptId++;
        scripts[id] = Script({
            id: id,
            title: title,
            humanAuthors: humanAuthors,
            aiModel: aiModel,
            promptHistory: promptHistory,
            ipfsHash: ipfsHash,
            humanContributionPercent: humanContributionPercent,
            timestamp: block.timestamp,
            registered: true
        });
        
        for (uint256 i = 0; i < humanAuthors.length; i++) {
            authorScripts[humanAuthors[i]].push(id);
        }
        
        emit ScriptRegistered(id, title, humanAuthors);
        return id;
    }
    
    function addRevision(
        uint256 scriptId,
        string memory ipfsHash,
        string memory changeDescription,
        uint256 aiAssistedPercent
    ) external {
        Script storage script = scripts[scriptId];
        require(script.registered, "Script not found");
        
        uint256 version = revisions[scriptId].length + 1;
        revisions[scriptId].push(Revision({
            scriptId: scriptId,
            version: version,
            author: msg.sender,
            ipfsHash: ipfsHash,
            changeDescription: changeDescription,
            timestamp: block.timestamp,
            aiAssistedPercent: aiAssistedPercent
        }));
        
        emit RevisionAdded(scriptId, version, msg.sender);
    }
    
    function getAuthorScripts(address author) 
        external view returns (uint256[] memory) {
        return authorScripts[author];
    }
}

from transformers import AutoModelForCausalLM, AutoTokenizer
from typing import List, Dict
import json

class AIScriptWriter:
    """AI剧本生成器"""
    
    def __init__(self, model_name: str = "gpt2"):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForCausalLM.from_pretrained(model_name)
        
    def generate_scene(
        self, 
        premise: str,
        characters: List[str],
        tone: str = "dramatic"
    ) -> str:
        """生成单个场景"""
        prompt = f"Scene: {premise}\nCharacters: {', '.join(characters)}\nTone: {tone}\n\n"
        inputs = self.tokenizer(prompt, return_tensors="pt")
        outputs = self.model.generate(
            inputs.input_ids,
            max_length=500,
            temperature=0.8,
            do_sample=True
        )
        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
    
    def generate_script(
        self,
        logline: str,
        num_scenes: int = 10
    ) -> List[Dict]:
        """生成完整剧本"""
        scenes = []
        for i in range(num_scenes):
            scene = {
                'scene_number': i + 1,
                'content': self.generate_scene(
                    f"Scene {i+1}: {logline}",
                    ['PROTAGONIST', 'ANTAGONIST', 'SUPPORTING']
                ),
                'ai_generated': True
            }
            scenes.append(scene)
        return scenes
    
    def calculate_human_contribution(self, original: str, modified: str) -> float:
        """计算人类修改的贡献百分比"""
        if not original:
            return 1.0
        changes = sum(1 for a, b in zip(original, modified) if a != b)
        return changes / max(len(original), 1)

writer = AIScriptWriter()
script = writer.generate_script("A detective discovers AI is writing movie scripts")
print(json.dumps(script[:2], indent=2, ensure_ascii=False))

const ethers = require('ethers');

class ScriptCollaboration {
  constructor(contractAddress, providerUrl) {
    this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
    this.contract = new ethers.Contract(contractAddress, AIScriptCopyrightABI, this.provider);
  }

  async createScript(title, authors, aiModel, signer) {
    const contract = this.contract.connect(signer);
    const tx = await contract.registerScript(
      title, authors, aiModel, '', '', 100
    );
    await tx.wait();
    return tx;
  }

  async addRevision(scriptId, content, signer) {
    const ipfsHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(content));
    const contract = this.contract.connect(signer);
    const tx = await contract.addRevision(scriptId, ipfsHash, 'Revision', 0);
    await tx.wait();
    return tx;
  }
}

const collab = new ScriptCollaboration(
  '0xContractAddress',
  'https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY'
);