AI与电影音乐：机器学习作曲的版权归属

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

contract AIMusicRegistry {
    struct Composition {
        bytes32 compositionHash;
        address composer;
        string prompt;
        string modelVersion;
        uint256 timestamp;
        bool registered;
        Royalty[] royalties;
    }

    struct Royalty {
        address recipient;
        uint256 percentage;
        bool active;
    }

    mapping(bytes32 => Composition) public compositions;
    mapping(address => bytes32[]) public composerWorks;

    event CompositionRegistered(bytes32 hash, address composer, string prompt);
    event RoyaltyDistributed(bytes32 hash, uint256 amount);

    function registerComposition(bytes32 hash, string calldata prompt, 
                                  string calldata modelVersion) external {
        compositions[hash] = Composition({
            compositionHash: hash,
            composer: msg.sender,
            prompt: prompt,
            modelVersion: modelVersion,
            timestamp: block.timestamp,
            registered: true,
            royalties: new Royalty[](0)
        });
        composerWorks[msg.sender].push(hash);
        emit CompositionRegistered(hash, msg.sender, prompt);
    }

    function setRoyalty(bytes32 hash, address recipient, uint256 percentage) external {
        Composition storage c = compositions[hash];
        require(c.composer == msg.sender, "Not composer");
        c.royalties.push(Royalty(recipient, percentage, true));
    }
}

import numpy as np
from typing import Dict, List
import json

class MusicAnalyzer:
    def analyze_composition(self, audio_features: Dict) -> Dict:
        tempo = audio_features.get('tempo', 120)
        key = audio_features.get('key', 'C')
        mood = audio_features.get('mood', 'neutral')
        return {
            'tempo': tempo,
            'key': key,
            'mood': mood,
            'complexity': len(audio_features.get('instruments', [])),
            'ai_generated': audio_features.get('ai_generated', False)
        }

    def detect_ai_music(self, features: Dict) -> float:
        ai_indicators = [
            features.get('repetition_rate', 0) > 0.8,
            features.get('harmonic_diversity', 1) < 0.3,
            features.get('dynamic_range', 1) < 0.2
        ]
        return sum(ai_indicators) / len(ai_indicators)


analyzer = MusicAnalyzer()
sample = {'tempo': 120, 'key': 'C', 'mood': 'happy', 'instruments': ['piano'], 'ai_generated': True}
result = analyzer.analyze_composition(sample)
print(json.dumps(result, indent=2))

const express = require('express');
const { ethers } = require('ethers');
const app = express();
app.use(express.json());

const MUSIC_ABI = [
    "function registerComposition(bytes32 hash, string prompt, string modelVersion) external",
    "function setRoyalty(bytes32 hash, address recipient, uint256 percentage) external",
    "event CompositionRegistered(bytes32 hash, address composer, string prompt)"
];

class AIMusicCopyright {
    constructor(providerUrl, registryAddress) {
        this.provider = new ethers.providers.JsonRpcProvider(providerUrl);
        this.registry = new ethers.Contract(registryAddress, MUSIC_ABI, this.provider);
    }

    async register(privateKey, hash, prompt, modelVersion) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        const registry = this.registry.connect(wallet);
        const tx = await registry.registerComposition(hash, prompt, modelVersion);
        return await tx.wait();
    }
}

app.post('/api/music/register', async (req, res) => {
    const { privateKey, hash, prompt, modelVersion } = req.body;
    const music = new AIMusicCopyright(process.env.RPC_URL, process.env.MUSIC_ADDRESS);
    const receipt = await music.register(privateKey, hash, prompt, modelVersion);
    res.json(receipt);
});

app.listen(3015, () => {
    console.log('AI Music Copyright API running on port 3015');
});