AI与电影剧本分析：机器学习剧本评估的链上验证

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

contract ScriptAnalysis {
    struct AnalysisRequest {
        address submitter;
        bytes32 scriptHash;
        string title;
        string genre;
        uint256 scriptLength;
        uint256 timestamp;
        AnalysisStatus status;
        address analyzer;
        bytes32 resultHash;
        uint256 fee;
    }

    struct AnalysisResult {
        bytes32 requestId;
        uint256 overallScore;
        uint256 plotScore;
        uint256 characterScore;
        uint256 dialogueScore;
        uint256 structureScore;
        uint256 marketPotential;
        string[] strengths;
        string[] weaknesses;
        string recommendations;
        bytes32 reportHash;
    }

    enum AnalysisStatus { PENDING, IN_PROGRESS, COMPLETED, REJECTED }

    mapping(bytes32 => AnalysisRequest) public requests;
    mapping(bytes32 => AnalysisResult) public results;
    mapping(address => bytes32[]) public userRequests;
    mapping(address => bool) public approvedAnalyzers;

    uint256 public baseFee = 0.1 ether;
    address public admin;

    event RequestSubmitted(bytes32 indexed requestId, address indexed submitter, string title);
    event AnalysisStarted(bytes32 indexed requestId, address indexed analyzer);
    event AnalysisCompleted(bytes32 indexed requestId, bytes32 resultHash);
    event AnalyzerApproved(address indexed analyzer);
    event AnalyzerRemoved(address indexed analyzer);

    modifier onlyAdmin() {
        require(msg.sender == admin, "Not admin");
        _;
    }

    constructor() {
        admin = msg.sender;
    }

    function submitRequest(
        bytes32 scriptHash,
        string calldata title,
        string calldata genre,
        uint256 scriptLength
    ) external payable returns (bytes32) {
        require(msg.value >= baseFee, "Insufficient fee");
        require(scriptHash != bytes32(0), "Invalid hash");

        bytes32 requestId = keccak256(abi.encodePacked(msg.sender, scriptHash, block.timestamp));

        requests[requestId] = AnalysisRequest({
            submitter: msg.sender,
            scriptHash: scriptHash,
            title: title,
            genre: genre,
            scriptLength: scriptLength,
            timestamp: block.timestamp,
            status: AnalysisStatus.PENDING,
            analyzer: address(0),
            resultHash: bytes32(0),
            fee: msg.value
        });

        userRequests[msg.sender].push(requestId);
        emit RequestSubmitted(requestId, msg.sender, title);
        return requestId;
    }

    function approveAnalyzer(address analyzer) external onlyAdmin {
        approvedAnalyzers[analyzer] = true;
        emit AnalyzerApproved(analyzer);
    }

    function startAnalysis(bytes32 requestId) external {
        require(approvedAnalyzers[msg.sender], "Not approved analyzer");
        require(requests[requestId].status == AnalysisStatus.PENDING, "Not pending");

        requests[requestId].status = AnalysisStatus.IN_PROGRESS;
        requests[requestId].analyzer = msg.sender;

        emit AnalysisStarted(requestId, msg.sender);
    }

    function submitResult(
        bytes32 requestId,
        uint256 overallScore,
        uint256 plotScore,
        uint256 characterScore,
        uint256 dialogueScore,
        uint256 structureScore,
        uint256 marketPotential,
        string[] calldata strengths,
        string[] calldata weaknesses,
        string calldata recommendations,
        bytes32 reportHash
    ) external {
        require(requests[requestId].analyzer == msg.sender, "Not assigned analyzer");
        require(requests[requestId].status == AnalysisStatus.IN_PROGRESS, "Not in progress");

        bytes32 resultHash = keccak256(
            abi.encodePacked(requestId, overallScore, plotScore, characterScore, 
                           dialogueScore, structureScore, marketPotential, reportHash)
        );

        results[requestId] = AnalysisResult({
            requestId: requestId,
            overallScore: overallScore,
            plotScore: plotScore,
            characterScore: characterScore,
            dialogueScore: dialogueScore,
            structureScore: structureScore,
            marketPotential: marketPotential,
            strengths: strengths,
            weaknesses: weaknesses,
            recommendations: recommendations,
            reportHash: reportHash
        });

        requests[requestId].status = AnalysisStatus.COMPLETED;
        requests[requestId].resultHash = resultHash;

        // Pay analyzer
        uint256 fee = requests[requestId].fee;
        payable(msg.sender).transfer(fee * 90 / 100); // 90% to analyzer, 10% platform

        emit AnalysisCompleted(requestId, resultHash);
    }

    function getResult(bytes32 requestId) external view returns (AnalysisResult memory) {
        require(requests[requestId].status == AnalysisStatus.COMPLETED, "Not completed");
        require(
            requests[requestId].submitter == msg.sender || 
            requests[requestId].analyzer == msg.sender ||
            msg.sender == admin,
            "Not authorized"
        );
        return results[requestId];
    }

    function verifyResult(bytes32 requestId, bytes32 claimedResultHash) 
        external view returns (bool) {
        return requests[requestId].resultHash == claimedResultHash;
    }

    function getUserRequests(address user) external view returns (bytes32[] memory) {
        return userRequests[user];
    }
}

import numpy as np
import pandas as pd
from transformers import AutoTokenizer, AutoModelForSequenceClassification
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
from typing import Dict, List, Tuple
import torch
import json
import re
from collections import Counter
import warnings
warnings.filterwarnings('ignore')

class ScriptAnalyzer:
    def __init__(self):
        self.tokenizer = None
        self.model = None
        self.genre_keywords = {
            'action': ['explosion', 'chase', 'fight', 'gun', 'battle', 'attack'],
            'drama': ['love', 'loss', 'family', 'relationship', 'emotion', 'conflict'],
            'comedy': ['funny', 'joke', 'laugh', 'humor', 'witty', 'hilarious'],
            'horror': ['dark', 'fear', 'death', 'monster', 'scream', 'blood'],
            'sci-fi': ['future', 'space', 'technology', 'alien', 'robot', 'dimension']
        }

    def load_model(self, model_name: str = "bert-base-uncased"):
        """Load pre-trained NLP model"""
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSequenceClassification.from_pretrained(
            model_name, 
            num_labels=10
        )
        self.model.eval()

    def analyze_structure(self, script_text: str) -> Dict:
        """Analyze screenplay structure (three-act structure)"""
        # Detect act breaks
        act_breaks = {
            'act_1': script_text.find('ACT ONE') if 'ACT ONE' in script_text.upper() else 0,
            'act_2': script_text.find('ACT TWO') if 'ACT TWO' in script_text.upper() else 0,
            'act_3': script_text.find('ACT THREE') if 'ACT THREE' in script_text.upper() else 0
        }

        # Calculate act proportions
        total_length = len(script_text)
        if act_breaks['act_2'] > 0 and act_breaks['act_3'] > 0:
            act1_ratio = act_breaks['act_2'] / total_length
            act2_ratio = (act_breaks['act_3'] - act_breaks['act_2']) / total_length
            act3_ratio = (total_length - act_breaks['act_3']) / total_length
        else:
            act1_ratio = act2_ratio = act3_ratio = 1/3

        # Score structure
        ideal_ratios = [0.25, 0.50, 0.25]
        actual_ratios = [act1_ratio, act2_ratio, act3_ratio]
        structure_score = 100 - sum(abs(ideal - actual) * 100 for ideal, actual in zip(ideal_ratios, actual_ratios))

        return {
            'act_breakdown': {
                'act_1': act1_ratio,
                'act_2': act2_ratio,
                'act_3': act3_ratio
            },
            'structure_score': max(0, structure_score),
            'has_clear_acts': act_breaks['act_2'] > 0 and act_breaks['act_3'] > 0
        }

    def analyze_dialogue(self, script_text: str) -> Dict:
        """Analyze dialogue quality and distribution"""
        # Extract dialogue lines (text between character names)
        dialogue_pattern = re.findall(r'([A-Z\s]+)\n((?:[^A-Z\n][^\n]*\n?)*)', script_text)
        
        if not dialogue_pattern:
            return {'error': 'No dialogue found'}

        # Analyze dialogue characteristics
        characters = {}
        total_lines = 0
        total_words = 0
        
        for char_name, dialogue in dialogue_pattern:
            char_name = char_name.strip()
            words = dialogue.split()
            if char_name not in characters:
                characters[char_name] = {'lines': 0, 'words': 0}
            characters[char_name]['lines'] += 1
            characters[char_name]['words'] += len(words)
            total_lines += 1
            total_words += len(words)

        # Calculate dialogue diversity
        character_count = len(characters)
        avg_words_per_line = total_words / total_lines if total_lines > 0 else 0
        
        # Check for balanced dialogue
        if characters:
            main_char_ratio = max(c['words'] for c in characters.values()) / total_words if total_words > 0 else 0
        else:
            main_char_ratio = 1

        dialogue_score = 100
        if main_char_ratio > 0.5:
            dialogue_score -= 20  # Too much monologue
        if character_count < 3:
            dialogue_score -= 15  # Too few characters
        if avg_words_per_line > 30:
            dialogue_score -= 10  # Too wordy
        if avg_words_per_line < 5:
            dialogue_score -= 10  # Too terse

        return {
            'character_count': character_count,
            'total_dialogue_lines': total_lines,
            'avg_words_per_line': avg_words_per_line,
            'main_character_ratio': main_char_ratio,
            'dialogue_diversity': 1 - main_char_ratio,
            'dialogue_score': max(0, dialogue_score)
        }

    def analyze_plot_complexity(self, script_text: str) -> Dict:
        """Analyze plot complexity and subplot structure"""
        # Count plot-related keywords
        plot_keywords = ['meanwhile', 'later', 'earlier', 'flashback', 'subplot',
                        'reveal', 'twist', 'climax', 'resolution', 'conflict']
        
        keyword_counts = {}
        for keyword in plot_keywords:
            keyword_counts[keyword] = len(re.findall(r'\b' + keyword + r'\b', script_text.lower()))

        # Count scene changes
        scene_changes = len(re.findall(r'(?:INT\.|EXT\.|INT/EXT\.)', script_text))

        # Calculate complexity metrics
        total_keywords = sum(keyword_counts.values())
        plot_complexity = min(100, total_keywords * 5 + scene_changes)

        # Detect subplots
        subplot_indicators = ['subplot', 'secondary', 'b-story', 'side story']
        subplot_count = sum(1 for indicator in subplot_indicators 
                          if indicator in script_text.lower())

        return {
            'keyword_density': total_keywords / max(1, len(script_text.split())) * 1000,
            'scene_changes': scene_changes,
            'plot_complexity': plot_complexity,
            'subplot_count': subplot_count,
            'has_flashbacks': keyword_counts.get('flashback', 0) > 0,
            'has_plot_twist': keyword_counts.get('twist', 0) > 0
        }

    def analyze_market_potential(self, script_text: str, genre: str) -> Dict:
        """Analyze market potential based on genre trends"""
        # Check genre alignment
        genre_word_count = 0
        total_words = len(script_text.split())
        
        if genre.lower() in self.genre_keywords:
            for keyword in self.genre_keywords[genre.lower()]:
                genre_word_count += len(re.findall(r'\b' + keyword + r'\b', script_text.lower()))

        genre_alignment = (genre_word_count / max(1, total_words)) * 1000

        # Check for marketable elements
        marketable_elements = ['sequel', 'franchise', 'series', 'based on', 
                              'true story', 'adaptation', 'blockbuster', 'oscar']
        marketable_count = sum(1 for element in marketable_elements 
                             if element in script_text.lower())

        market_potential = min(100, genre_alignment * 10 + marketable_count * 5)

        return {
            'genre_alignment': genre_alignment * 10,
            'marketable_elements': marketable_count,
            'market_potential': market_potential,
            'recommended_genre': self._detect_genre(script_text)
        }

    def _detect_genre(self, script_text: str) -> str:
        """Detect the most likely genre"""
        scores = {}
        for genre, keywords in self.genre_keywords.items():
            score = sum(1 for keyword in keywords 
                      if keyword in script_text.lower()[:1000])
            scores[genre] = score
        
        if not scores or max(scores.values()) == 0:
            return 'unknown'
        return max(scores, key=scores.get)

    def comprehensive_analysis(self, script_text: str, genre: str = "drama") -> Dict:
        """Perform comprehensive script analysis"""
        structure = self.analyze_structure(script_text)
        dialogue = self.analyze_dialogue(script_text)
        plot = self.analyze_plot_complexity(script_text)
        market = self.analyze_market_potential(script_text, genre)

        # Calculate overall score
        scores = [
            structure.get('structure_score', 0) * 0.25,
            dialogue.get('dialogue_score', 0) * 0.25,
            plot.get('plot_complexity', 0) * 0.25,
            market.get('market_potential', 0) * 0.25
        ]
        overall_score = sum(scores)

        return {
            'overall_score': overall_score,
            'structure_analysis': structure,
            'dialogue_analysis': dialogue,
            'plot_analysis': plot,
            'market_analysis': market,
            'recommendations': self._generate_recommendations(structure, dialogue, plot, market)
        }

    def _generate_recommendations(self, structure, dialogue, plot, market) -> List[str]:
        """Generate improvement recommendations"""
        recommendations = []
        
        if structure.get('structure_score', 100) < 60:
            recommendations.append("Consider restructuring the screenplay to follow the classic three-act structure more closely")
        
        if dialogue.get('dialogue_score', 100) < 60:
            if dialogue.get('main_character_ratio', 0) > 0.5:
                recommendations.append("Reduce the main character's dialogue dominance and give more lines to supporting characters")
            recommendations.append("Consider varying dialogue length and rhythm for better pacing")
        
        if not plot.get('has_plot_twist', True):
            recommendations.append("Consider adding a plot twist or revelation to increase engagement")
        
        if market.get('market_potential', 0) < 50:
            recommendations.append("Consider adding more genre-specific elements to increase market appeal")
        
        return recommendations if recommendations else ["The script shows strong potential in all areas"]


# Demo
analyzer = ScriptAnalyzer()

sample_script = """
ACT ONE

INT. WRITER'S STUDIO - DAY

A cluttered room filled with books and screenplays. JOHN (30s) sits at his desk, staring at a blank page.

JOHN
(to himself)
Three years. Three years of writing and rewriting. And still nothing.

The phone rings. John hesitates, then answers.

JOHN
Hello?

PRODUCER (V.O.)
John, it's Michael. We read your script. We want to make it.

John's eyes widen. He can't believe what he's hearing.

ACT TWO

EXT. HOLLYWOOD - DAY

John walks through the bustling streets of Hollywood. He's made it. But something feels wrong.

The producer's office is cold and corporate. The script has been rewritten by five different writers.

JOHN
This isn't my script anymore.

PRODUCER
It's a better script now. Trust the process.

ACT THREE

INT. PREMIERE - NIGHT

The film premieres. John watches his story unfold on screen. It's beautiful, but it's not his.

The audience applauds. John smiles, but his eyes are sad.

JOHN
(whispering)
Maybe the next one will be different.
"""

result = analyzer.comprehensive_analysis(sample_script, "drama")
print(json.dumps(result, indent=2))

const express = require('express');
const { ethers } = require('ethers');
const crypto = require('crypto');
const cors = require('cors');

const app = express();
app.use(cors());
app.use(express.json({ limit: '50mb' }));

const ANALYSIS_ABI = [
    "function submitRequest(bytes32 scriptHash, string title, string genre, uint256 scriptLength) external payable returns (bytes32)",
    "function startAnalysis(bytes32 requestId) external",
    "function submitResult(bytes32 requestId, uint256 overallScore, uint256 plotScore, uint256 characterScore, uint256 dialogueScore, uint256 structureScore, uint256 marketPotential, string[] strengths, string[] weaknesses, string recommendations, bytes32 reportHash) external",
    "function getResult(bytes32 requestId) external view returns (tuple)",
    "event RequestSubmitted(bytes32 indexed requestId, address indexed submitter, string title)",
    "event AnalysisCompleted(bytes32 indexed requestId, bytes32 resultHash)"
];

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

    async submitScript(privateKey, title, genre, scriptContent) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        const contract = this.contract.connect(wallet);

        const scriptHash = ethers.utils.solidityKeccak256(
            ['string'],
            [scriptContent]
        );
        const scriptLength = scriptContent.length;

        const tx = await contract.submitRequest(
            scriptHash,
            title,
            genre,
            scriptLength,
            { value: ethers.utils.parseEther('0.1') }
        );
        const receipt = await tx.wait();
        return receipt;
    }

    async analyzeScript(scriptContent) {
        // In production, this would call the ML model
        const analysis = {
            overallScore: Math.floor(Math.random() * 40) + 60,
            plotScore: Math.floor(Math.random() * 40) + 60,
            characterScore: Math.floor(Math.random() * 40) + 60,
            dialogueScore: Math.floor(Math.random() * 40) + 60,
            structureScore: Math.floor(Math.random() * 40) + 60,
            marketPotential: Math.floor(Math.random() * 40) + 60,
            strengths: [
                "Strong character development",
                "Engaging dialogue",
                "Well-paced narrative"
            ],
            weaknesses: [
                "Predictable plot twist",
                "Underdeveloped secondary characters"
            ],
            recommendations: "Consider adding more complexity to the subplot structure"
        };

        return analysis;
    }

    async submitAnalysis(privateKey, requestId, analysis) {
        const wallet = new ethers.Wallet(privateKey, this.provider);
        const contract = this.contract.connect(wallet);

        const reportHash = ethers.utils.solidityKeccak256(
            ['string'],
            [JSON.stringify(analysis)]
        );

        const tx = await contract.submitResult(
            requestId,
            analysis.overallScore,
            analysis.plotScore,
            analysis.characterScore,
            analysis.dialogueScore,
            analysis.structureScore,
            analysis.marketPotential,
            analysis.strengths,
            analysis.weaknesses,
            analysis.recommendations,
            reportHash
        );
        const receipt = await tx.wait();
        return receipt;
    }
}

app.post('/api/script/submit', async (req, res) => {
    const { privateKey, title, genre, scriptContent } = req.body;
    const platform = new ScriptAnalysisPlatform(
        process.env.RPC_URL,
        process.env.ANALYSIS_ADDRESS
    );
    const receipt = await platform.submitScript(privateKey, title, genre, scriptContent);
    res.json(receipt);
});

app.post('/api/script/analyze', async (req, res) => {
    const { scriptContent } = req.body;
    const platform = new ScriptAnalysisPlatform(
        process.env.RPC_URL,
        process.env.ANALYSIS_ADDRESS
    );
    const analysis = await platform.analyzeScript(scriptContent);
    res.json(analysis);
});

app.post('/api/script/submit-analysis', async (req, res) => {
    const { privateKey, requestId, analysis } = req.body;
    const platform = new ScriptAnalysisPlatform(
        process.env.RPC_URL,
        process.env.ANALYSIS_ADDRESS
    );
    const receipt = await platform.submitAnalysis(privateKey, requestId, analysis);
    res.json(receipt);
});

app.get('/api/script/result/:requestId', async (req, res) => {
    const platform = new ScriptAnalysisPlatform(
        process.env.RPC_URL,
        process.env.ANALYSIS_ADDRESS
    );
    const result = await platform.contract.getResult(req.params.requestId);
    res.json({
        overallScore: result.overallScore.toNumber(),
        plotScore: result.plotScore.toNumber(),
        characterScore: result.characterScore.toNumber(),
        dialogueScore: result.dialogueScore.toNumber(),
        structureScore: result.structureScore.toNumber(),
        marketPotential: result.marketPotential.toNumber(),
        strengths: result.strengths,
        weaknesses: result.weaknesses,
        recommendations: result.recommendations
    });
});

app.listen(3007, () => {
    console.log('Script Analysis API running on port 3007');
});