ZKML 零知識機器學習以太坊實戰應用完整指南：技術架構、協議實現與部署實例

概述

零知識證明（Zero-Knowledge Proof）與機器學習（Machine Learning）的結合，催生了 ZKML（Zero-Knowledge Machine Learning）這一前沿技術領域。ZKML 允許在不暴露模型權重或輸入數據的情況下驗證 AI 模型的輸出，為區塊鏈上的隱私保護、AI 驗證和去中心化 AI 應用開闢了全新的可能性。

截至 2026 年第一季度，ZKML 技術已從理論走向實際部署。越來越多的以太坊應用開始整合 ZKML 功能，包括去中心化預言機、隱私保護的信用評估、AI 生成內容驗證、模型智慧財產權保護等場景。本指南從工程師視角出發，深入分析 ZKML 的技術原理、主流協議實現、智慧合約整合方法，並提供可直接部署的程式碼範例，幫助開發者快速掌握這項前沿技術。

本指南的目標讀者包括：以太坊開發者希望了解 ZKML 整合方法、DeFi 協議開發者需要實現隱私保護的 AI 功能、區塊鏈研究者感興趣於 ZKML 前沿應用、以及 Web3 創業者尋找創新應用場景。我們假設讀者具備基本的密碼學知識和以太坊智慧合約開發經驗。

第一章：ZKML 技術基礎

1.1 零知識證明複習

在深入 ZKML 之前，讓我們先回顧零知識證明的基本概念。零知識證明是一種密碼學協議，允許證明者向驗證者證明某個陳述是正確的，同時不透露任何額外信息。

零知識證明的核心特性：

• 完整性（Completeness）：如果陳述為真，誠實的證明者能夠說服驗證者
• 穩健性（Soundness）：如果陳述為假，欺騙的證明者無法說服驗證者
• 零知識性（Zero-Knowledge）：驗證者除了陳述的真假之外，無法獲得任何其他信息

zk-SNARK 與 zk-STARK 比較：

1.2 為什麼需要 ZKML

傳統的區塊鏈應用中，AI 和 ML 模型面臨幾個關鍵挑戰：

隱私問題：許多 AI 應用需要保護敏感數據，如醫療記錄、財務信息或個人偏好。將這些數據直接上鏈會暴露隱私，而 ZKML 允許在保護隱私的前提下進行 AI 推理驗證。

計算效率問題：在區塊鏈上執行複雜的 ML 模型成本極高。ZKML 允許在鏈下執行計算密集的 ML 推理，然後生成簡潔的證明在鏈上驗證，大幅降低成本。

信任問題：用戶如何相信 AI 模型的輸出是正確的？ZKML 提供了可驗證的 AI 推理機制，確保模型按照預期執行。

知識產權保護：模型所有者可能不願意公開模型權重，但又需要證明模型執行了特定推理。ZKML 允許驗證推理結果而不暴露模型權重。

1.3 ZKML 的工作原理

ZKML 的核心思想是：將 ML 模型的前向傳播過程編譯為零知識電路，然後生成證明來驗證推理的正確性。

ZKML 工作流程：

1. 模型準備
   ┌─────────────┐
   │  ML 模型    │ → 轉換為計算圖
   └─────────────┘

2. 電路編譯
   ┌─────────────┐
   │  計算圖     │ → 編譯為 ZK 電路
   └─────────────┘

3. 輸入準備
   ┌─────────────┐
   │ 輸入數據    │ → 量化為定點數
   └─────────────┘

4. 證明生成
   ┌─────────────┐
   │ ZK 電路 + 輸入 │ → 生成 ZK 證明
   └─────────────┘

5. 鏈上驗證
   ┌─────────────┐
   │ 智慧合約  │ → 驗證 ZK 證明
   └─────────────┘

第二章：ZKML 主流協議與工具

2.1 Giza Protocol

Giza 是專注於將 ML 模型編譯為可驗證 ZK 電路的領先協議。Giza 的目標是成為「ZKML 的編譯器」，簡化開發者將現有 ML 模型轉換為 ZK 電路的過程。

Giza 核心特性：

• 多框架支持：支援 PyTorch、TensorFlow 等主流 ML 框架
• 自動量化：自動將浮點數模型量化為定點數
• 優化編譯：自動優化電路結構，減少證明大小和驗證時間
• SDK 提供：提供易於使用的 Python SDK

Giza 架構：

輸入模型 (PyTorch/TensorFlow)
        ↓
    ONNX 轉換
        ↓
   圖優化 Pass
        ↓
  量化處理
        ↓
  ZK 電路生成 (Cairo)
        ↓
  證明生成 (STARK)
        ↓
  鏈上驗證

2.2 EZKL

EZKL 是一個開源的 ZKML 工具套件，專注於將大型語言模型（LLM）和神經網路轉換為可驗證的零知識電路。

EZKL 特色功能：

• 大型模型支持：支援數十億參數的 Transformer 模型
• 混合精度：支持動態精度調整
• 高效證明：優化的證明生成算法
• 社區驅動：活躍的開源社區

2.3 Modulus Labs

Modulus Labs 是 ZKML 領域的先驅協議，專注於為 AI 模型提供可驗證的推理服務。他們開發了專用的 ZK 硬體加速器，大幅提升證明生成速度。

Modulus 產品：

• ZK 推理服務：為 AI 模型提供可驗證的推理 API
• ZK 硬體加速：專用 ASIC 加速器
• 應用框架：提供構建 ZKML 應用的框架

2.4 RiscZero

RiscZero 是一個通用的零知識證明平台，其bonsai 電路可以用於執行任意 Rust 程序，這使其非常適合 ZKML 應用。

RiscZero ZKML 流程：

// RiscZero ZKML 示例
use risc0_zkvm::serde::to_vec;
use risc0_zkvm::prove;

fn main() {
    // 1. 準備 ML 模型和輸入
    let model = load_model("model.onnx");
    let input = prepare_input(data);
    
    // 2. 執行推理（在 ZKVM 中）
    let output = model.forward(input);
    
    // 3. 生成 receipt（包含證明）
    let receipt = prove::<_, M>(COMPUTE_ELF, to_vec!(&output).unwrap());
    
    // 4. 在鏈上驗證 receipt
    // ...
}

2.5 工具比較選擇

下表比較了主流 ZKML 工具：

選擇建議：

• 小型模型：選擇 Giza
• LLM/大型模型：選擇 EZKL 或 RiscZero
• 生產部署：選擇 Modulus
• 自定義需求：選擇 RiscZero

第三章：ZKML 智慧合約整合

3.1 合約設計架構

將 ZKML 整合到以太坊智慧合約中需要考慮以下組件：

┌─────────────────────────────────────────────────────┐
│                    DApp 前端                         │
└─────────────────────┬───────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────┐
│                  應用合約                           │
│  - 用戶接口                                         │
│  - 業務邏輯                                        │
│  - 獎勵分發                                        │
└─────────────────────┬───────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────┐
│                 驗證合約                            │
│  - 接收 ZK 證明                                    │
│  - 驗證證明有效性                                  │
│  - 記錄驗證結果                                    │
└─────────────────────┬───────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────┐
│              外部證明服務器                         │
│  - 接收推理請求                                    │
│  - 執行 ML 推理                                    │
│  - 生成 ZK 證明                                    │
└─────────────────────────────────────────────────────┘

3.2 驗證合約實現

以下是一個支持多種 ZK 證明系統的驗證合約：

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

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";

/**
 * @title ZKMLVerifier
 * @dev 零知識機器學習驗證合約
 */
contract ZKMLVerifier is Ownable, Pausable {
    
    // 驗證事件
    event ProofVerified(
        bytes32 indexed requestId,
        address indexed prover,
        bool success,
        uint256 timestamp
    );
    
    event ProverRegistered(address indexed prover, string metadata);
    event ProverUpdated(address indexed prover, bool enabled);
    
    // 請求結構
    struct VerificationRequest {
        bytes32 modelHash;      // 模型哈希
        bytes32 inputHash;     // 輸入數據哈希
        bytes32 outputHash;    // 輸出結果哈希
        address prover;         // 證明者地址
        uint256 timestamp;     // 請求時間
        bool verified;          // 是否已驗證
    }
    
    // 證明者結構
    struct Prover {
        bool isRegistered;
        bool isEnabled;
        string metadata;       // 證明者元數據
        uint256 verificationCount;
        uint256 successCount;
    }
    
    // 存儲映射
    mapping(bytes32 => VerificationRequest) public requests;
    mapping(address => Prover) public provers;
    address[] public proverList;
    
    // 模型註冊
    mapping(bytes32 => bool) public registeredModels;
    
    // 合約狀態
    uint256 public verificationFee = 0.01 ether;
    uint256 public totalVerifications;
    
    // 修飾符
    modifier onlyRegisteredProver() {
        require(
            provers[msg.sender].isRegistered && provers[msg.sender].isEnabled,
            "Caller is not a registered prover"
        );
        _;
    }
    
    /**
     * @dev 註冊新的證明者
     */
    function registerProver(string memory _metadata) external {
        require(!provers[msg.sender].isRegistered, "Already registered");
        
        provers[msg.sender] = Prover({
            isRegistered: true,
            isEnabled: true,
            metadata: _metadata,
            verificationCount: 0,
            successCount: 0
        });
        
        proverList.push(msg.sender);
        emit ProverRegistered(msg.sender, _metadata);
    }
    
    /**
     * @dev 更新證明者狀態
     */
    function updateProverStatus(address _prover, bool _enabled) 
        external 
        onlyOwner 
    {
        require(provers[_prover].isRegistered, "Prover not registered");
        provers[_prover].isEnabled = _enabled;
        emit ProverUpdated(_prover, _enabled);
    }
    
    /**
     * @dev 註冊模型
     */
    function registerModel(bytes32 _modelHash) external onlyOwner {
        registeredModels[_modelHash] = true;
    }
    
    /**
     * @dev 提交 ZK 證明進行驗證（STARK 證明）
     */
    function submitProofSTARK(
        bytes32 _requestId,
        bytes32 _modelHash,
        bytes32 _inputHash,
        bytes32 _outputHash,
        bytes calldata _proof,
        uint256[] calldata _publicInputs
    ) 
        external 
        payable 
        whenNotPaused 
        onlyRegisteredProver 
    {
        require(msg.value >= verificationFee, "Insufficient fee");
        require(registeredModels[_modelHash], "Model not registered");
        
        // 存儲驗證請求
        requests[_requestId] = VerificationRequest({
            modelHash: _modelHash,
            inputHash: _inputHash,
            outputHash: _outputHash,
            prover: msg.sender,
            timestamp: block.timestamp,
            verified: false
        });
        
        // 在實際應用中，這裡會調用 STARK 驗證庫
        // 為示例，我們模擬驗證過程
        bool success = _verifySTARKProof(
            _modelHash,
            _inputHash,
            _outputHash,
            _proof,
            _publicInputs
        );
        
        // 更新請求狀態
        requests[_requestId].verified = success;
        
        // 更新統計
        provers[msg.sender].verificationCount++;
        if (success) {
            provers[msg.sender].successCount++;
            // 退還費用並獎勵
            payable(msg.sender).transfer(msg.value);
        }
        
        totalVerifications++;
        
        emit ProofVerified(_requestId, msg.sender, success, block.timestamp);
    }
    
    /**
     * @dev 提交 ZK 證明進行驗證（SNARK 證明）
     */
    function submitProofSNARK(
        bytes32 _requestId,
        bytes32 _modelHash,
        bytes32 _inputHash,
        bytes32 _outputHash,
        bytes calldata _proof,
        uint256[2] calldata _vk
    ) 
        external 
        payable 
        whenNotPaused 
        onlyRegisteredProver 
    {
        require(msg.value >= verificationFee, "Insufficient fee");
        require(registeredModels[_modelHash], "Model not registered");
        
        requests[_requestId] = VerificationRequest({
            modelHash: _modelHash,
            inputHash: _inputHash,
            outputHash: _outputHash,
            prover: msg.sender,
            timestamp: block.timestamp,
            verified: false
        });
        
        bool success = _verifySNARKProof(
            _modelHash,
            _inputHash,
            _outputHash,
            _proof,
            _vk
        );
        
        requests[_requestId].verified = success;
        provers[msg.sender].verificationCount++;
        if (success) {
            provers[msg.sender].successCount++;
            payable(msg.sender).transfer(msg.value);
        }
        
        totalVerifications++;
        
        emit ProofVerified(_requestId, msg.sender, success, block.timestamp);
    }
    
    /**
     * @dev STARK 證明驗證（簡化版）
     * @notice 實際部署需要集成具體的 STARK 驗證庫
     */
    function _verifySTARKProof(
        bytes32 _modelHash,
        bytes32 _inputHash,
        bytes32 _outputHash,
        bytes calldata _proof,
        uint256[] calldata _publicInputs
    ) internal pure returns (bool) {
        // 這是一個簡化的示例
        // 實際實現需要：
        // 1. 解析 STARK 證明
        // 2. 驗證 Merkle 樹根
        // 3. 驗證約束條件
        // 4. 驗證 public inputs
        
        // 為示例，假設所有證明都有效
        // 實際生產環境中，應集成：
        // - Stone/STarknet 驗證器
        // - Winterfell 驗證器
        // 或使用鏈上驗證庫
        
        return true;
    }
    
    /**
     * @dev SNARK 證明驗證（簡化版）
     */
    function _verifySNARKProof(
        bytes32 _modelHash,
        bytes32 _inputHash,
        bytes32 _outputHash,
        bytes calldata _proof,
        uint256[2] calldata _vk
    ) internal pure returns (bool) {
        // 這是一個簡化的示例
        // 實際實現需要：
        // 1. 解析 Groth16/PLONK 證明
        // 2. 執行配對驗證
        // 3. 驗證 public inputs
        
        return true;
    }
    
    /**
     * @dev 查詢驗證請求狀態
     */
    function getRequestStatus(bytes32 _requestId) 
        external 
        view 
        returns (
            bool verified,
            address prover,
            uint256 timestamp
        ) 
    {
        VerificationRequest storage req = requests[_requestId];
        return (req.verified, req.prover, req.timestamp);
    }
    
    /**
     * @dev 查詢證明者統計
     */
    function getProverStats(address _prover) 
        external 
        view 
        returns (
            bool isRegistered,
            bool isEnabled,
            uint256 verificationCount,
            uint256 successCount,
            uint256 successRate
        ) 
    {
        Prover storage p = provers[_prover];
        uint256 rate = p.verificationCount > 0 
            ? (p.successCount * 100) / p.verificationCount 
            : 0;
            
        return (
            p.isRegistered,
            p.isEnabled,
            p.verificationCount,
            p.successCount,
            rate
        );
    }
    
    /**
     * @dev 設置驗證費用
     */
    function setVerificationFee(uint256 _fee) external onlyOwner {
        verificationFee = _fee;
    }
    
    /**
     * @dev 緊急暫停
     */
    function pause() external onlyOwner {
        _pause();
    }
    
    function unpause() external onlyOwner {
        _unpause();
    }
}

3.3 應用合約示例：信用評估

以下是一個使用 ZKML 實現的隱私保護信用評估合約：

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

import "@openzeppelin/contracts/access/Ownable.sol";
import "./ZKMLVerifier.sol";

/**
 * @title ZKMLCreditScore
 * @dev 使用 ZKML 的隱私保護信用評估合約
 */
contract ZKMLCreditScore is Ownable {
    
    ZKMLVerifier public verifier;
    
    // 信用評估結果結構
    struct CreditScore {
        uint256 score;          // 信用分數 (0-1000)
        uint256 tier;           // 等級 (1-5)
        bytes32 proofHash;      // 證明哈希
        uint256 timestamp;
    }
    
    // 用戶信用記錄
    mapping(address => CreditScore[]) public creditHistory;
    mapping(address => uint256) public latestScoreIndex;
    
    // 模型信息
    bytes32 public creditModelHash;
    uint256 public constant CREDIT_THRESHOLD = 650; // 最低信用門檻
    
    // 事件
    event CreditScoreComputed(
        address indexed user,
        uint256 score,
        uint256 tier,
        bytes32 proofHash
    );
    
    event LoanApproved(
        address indexed borrower,
        uint256 amount,
        uint256 interestRate
    );
    
    event LoanRejected(
        address indexed borrower,
        string reason
    );
    
    /**
     * @dev 構造函數
     */
    constructor(address _verifier, bytes32 _modelHash) {
        require(_verifier != address(0), "Invalid verifier");
        verifier = ZKMLVerifier(_verifier);
        creditModelHash = _modelHash;
    }
    
    /**
     * @dev 提交信用評估證明
     */
    function submitCreditProof(
        bytes32 _requestId,
        bytes32 _inputHash,     // 用戶數據的哈希
        bytes32 _outputHash,    // 信用分數的哈希
        bytes calldata _proof,
        uint256[] calldata _publicInputs
    ) external {
        // 調用驗證合約
        verifier.submitProofSTARK(
            _requestId,
            creditModelHash,
            _inputHash,
            _outputHash,
            _proof,
            _publicInputs
        );
        
        // 解析輸出（實際應從證明中解析）
        // 這裡簡化處理
        uint256 score = _publicInputs[0];
        uint256 tier = _calculateTier(score);
        
        // 記錄信用歷史
        creditHistory[msg.sender].push(CreditScore({
            score: score,
            tier: tier,
            proofHash: keccak256(_proof),
            timestamp: block.timestamp
        }));
        
        latestScoreIndex[msg.sender] = creditHistory[msg.sender].length - 1;
        
        emit CreditScoreComputed(msg.sender, score, tier, keccak256(_proof));
    }
    
    /**
     * @dev 申請贷款（基於信用評估）
     */
    function applyForLoan(uint256 _amount, uint256 _duration) 
        external 
        returns (bool approved, uint256 interestRate) 
    {
        // 獲取最新信用評分
        uint256 index = latestScoreIndex[msg.sender];
        require(
            creditHistory[msg.sender].length > 0,
            "No credit score available"
        );
        
        CreditScore memory score = creditHistory[msg.sender][index];
        
        // 檢查信用分數是否低於門檻
        if (score.score < CREDIT_THRESHOLD) {
            emit LoanRejected(msg.sender, "Credit score below threshold");
            return (false, 0);
        }
        
        // 根據信用等級確定利率
        interestRate = _calculateInterestRate(score.tier, _duration);
        
        // 批準贷款
        emit LoanApproved(msg.sender, _amount, interestRate);
        
        return (true, interestRate);
    }
    
    /**
     * @dev 計算信用等級
     */
    function _calculateTier(uint256 _score) internal pure returns (uint256) {
        if (_score >= 850) return 5;      // 優秀
        if (_score >= 750) return 4;      // 良好
        if (_score >= 700) return 3;      // 中等
        if (_score >= 650) return 2;      // 一般
        return 1;                         // 較差
    }
    
    /**
     * @dev 計算利率
     */
    function _calculateInterestRate(uint256 _tier, uint256 _duration) 
        internal 
        pure 
        returns (uint256) 
    {
        // 基準利率 + 期限調整 + 信用等級調整
        uint256 baseRate = 500; // 5%
        uint256 durationBonus = _duration * 10; // 期限越長利率越高
        uint256 tierDiscount = (5 - _tier) * 50; // 信用越好折扣越大
        
        return baseRate + durationBonus - tierDiscount;
    }
    
    /**
     * @dev 獲取用戶信用歷史
     */
    function getCreditHistory(address _user) 
        external 
        view 
        returns (CreditScore[] memory) 
    {
        return creditHistory[_user];
    }
    
    /**
     * @dev 獲取最新信用評分
     */
    function getLatestCreditScore(address _user) 
        external 
        view 
        returns (uint256 score, uint256 tier) 
    {
        uint256 index = latestScoreIndex[_user];
        if (creditHistory[_user].length == 0) {
            return (0, 0);
        }
        
        CreditScore memory cs = creditHistory[_user][index];
        return (cs.score, cs.tier);
    }
}

第四章：ZKML 實際應用場景

4.1 去中心化預言機

ZKML 可以增強預言機的數據可靠性和隱私保護：

// zkml-oracle/server/src/index.js
const express = require('express');
const { ethers } = require('hardhat');
const { prove } = require('./zkml/prover');

const app = express();
app.use(express.json());

// 預言機合約接口
const ORACLE_ABI = [
    "function submitPrice(bytes32 requestId, uint256 price, bytes proof) external",
    "event PriceUpdated(bytes32 indexed requestId, uint256 price)"
];

class ZKMLOracle {
    constructor(contractAddress, prover) {
        this.contractAddress = contractAddress;
        this.prover = prover;
        this.cache = new Map();
    }
    
    // 執行 ML 模型推理
    async runModel(modelId, inputData) {
        const model = await this.loadModel(modelId);
        
        // 量化輸入數據
        const quantizedInput = this.quantize(inputData);
        
        // 執行推理
        const output = await model.predict(quantizedInput);
        
        return output;
    }
    
    // 生成 ZK 證明
    async generateProof(modelId, inputData, output) {
        const inputHash = ethers.keccak256(
            ethers.AbiCoder.defaultAbiCoder().encode(
                ['bytes'],
                [JSON.stringify(inputData)]
            )
        );
        
        const outputHash = ethers.keccak256(
            ethers.AbiCoder.defaultAbiCoder().encode(
                ['uint256'],
                [output]
            )
        );
        
        const proof = await this.prover.prove(
            modelId,
            inputHash,
            outputHash
        );
        
        return { inputHash, outputHash, proof };
    }
    
    // 提交價格到鏈上
    async submitPrice(requestId, price, proof) {
        const [signer] = await ethers.getSigners();
        const oracle = new ethers.Contract(
            this.contractAddress,
            ORACLE_ABI,
            signer
        );
        
        const tx = await oracle.submitPrice(requestId, price, proof);
        await tx.wait();
        
        return tx;
    }
}

// API 端點
app.post('/api/price', async (req, res) => {
    try {
        const { modelId, inputData, requestId } = req.body;
        
        // 1. 執行 ML 模型
        const output = await oracle.runModel(modelId, inputData);
        
        // 2. 生成 ZK 證明
        const { inputHash, outputHash, proof } = await oracle.generateProof(
            modelId,
            inputData,
            output
        );
        
        // 3. 提交到鏈上
        await oracle.submitPrice(requestId, output, proof);
        
        res.json({
            success: true,
            price: output,
            proofHash: ethers.keccak256(proof)
        });
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

// 價格預測模型示例
const pricePredictionModel = {
    async predict(input) {
        // 簡化的價格預測模型
        // 實際應用中，這裡會加載真實的 ML 模型
        const features = this.extractFeatures(input);
        
        // 簡單的線性回歸 + 移動平均
        const weights = [0.3, 0.4, 0.3];
        const prediction = features.reduce((sum, f, i) => 
            sum + f * weights[i], 0
        );
        
        return Math.round(prediction);
    },
    
    extractFeatures(input) {
        return [
            input.priceMA7,   // 7日移動平均
            input.priceMA30,  // 30日移動平均
            input.volume      // 交易量
        ];
    }
};

// 初始化預言機
const oracle = new ZKMLOracle(
    process.env.ORACLE_CONTRACT,
    prover
);

// 註冊模型
oracle.registerModel('price-prediction-v1', pricePredictionModel);

app.listen(3000, () => {
    console.log('ZKML Oracle server running on port 3000');
});

4.2 AI 生成內容驗證

ZKML 可以用於驗證內容是否由 AI 生成的同時保護模型隱私：

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

/**
 * @title AIGCVerifier
 * @dev AI 生成內容驗證合約
 */
contract AIGCVerifier {
    
    struct AIGCRecord {
        bytes32 contentHash;     // 內容哈希
        bytes32 modelHash;        // 模型哈希
        bool isVerified;         // 是否已驗證
        uint256 timestamp;
        address verifier;
    }
    
    mapping(bytes32 => AIGCRecord) public records;
    mapping(address => bool) public authorizedVerifiers;
    
    event AIGCVerified(
        bytes32 indexed contentHash,
        bool isAIGenerated,
        bytes32 modelHash
    );
    
    modifier onlyVerifier() {
        require(authorizedVerifiers[msg.sender], "Not authorized");
        _;
    }
    
    constructor() {
        authorizedVerifiers[msg.sender] = true;
    }
    
    /**
     * @dev 驗證 AI 生成內容
     */
    function verifyAIGC(
        bytes32 _contentHash,
        bytes32 _modelHash,
        bytes calldata _proof,
        uint256[] calldata _publicInputs
    ) external onlyVerifier returns (bool isAIGenerated) {
        // _publicInputs[0] 包含驗證結果
        // 1 = AI 生成，0 = 人類創作
        isAIGenerated = _publicInputs[0] == 1;
        
        // 記錄驗證結果
        records[_contentHash] = AIGCRecord({
            contentHash: _contentHash,
            modelHash: _modelHash,
            isVerified: true,
            timestamp: block.timestamp,
            verifier: msg.sender
        });
        
        emit AIGCVerified(_contentHash, isAIGenerated, _modelHash);
        
        return isAIGenerated;
    }
    
    /**
     * @dev 查詢內容驗證狀態
     */
    function getVerificationStatus(bytes32 _contentHash) 
        external 
        view 
        returns (bool isVerified, uint256 timestamp) 
    {
        AIGCRecord memory record = records[_contentHash];
        return (record.isVerified, record.timestamp);
    }
    
    /**
     * @dev 授權新的驗證者
     */
    function authorizeVerifier(address _verifier) external {
        authorizedVerifiers[_verifier] = true;
    }
}

4.3 遊戲中的 AI 對手驗證

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

/**
 * @title ZKMLGameAI
 * @dev 遊戲 AI 對手驗證合約
 */
contract ZKMLGameAI {
    
    // 遊戲狀態
    struct GameState {
        bytes32 aiModelHash;
        uint256 difficulty;
        uint256 moveCount;
        bytes32 lastMoveHash;
        bool completed;
    }
    
    // 遊戲記錄
    mapping(bytes32 => GameState) public games;
    mapping(address => bytes32[]) public playerGames;
    
    // AI 移動記錄
    struct AIMove {
        bytes32 gameId;
        uint256 moveIndex;
        bytes32 moveDataHash;
        bytes32 proofHash;
        uint256 timestamp;
    }
    
    mapping(bytes32 => AIMove[]) public gameMoves;
    
    event GameStarted(
        bytes32 indexed gameId,
        address indexed player,
        bytes32 modelHash,
        uint256 difficulty
    );
    
    event AIMoveMade(
        bytes32 indexed gameId,
        uint256 moveIndex,
        bytes32 moveHash
    );
    
    event GameCompleted(
        bytes32 indexed gameId,
        address winner,  // address(0) = AI
        uint256 score
    );
    
    /**
     * @dev 開始新遊戲
     */
    function startGame(
        bytes32 _gameId,
        bytes32 _aiModelHash,
        uint256 _difficulty
    ) external {
        require(games[_gameId].moveCount == 0, "Game already exists");
        
        games[_gameId] = GameState({
            aiModelHash: _aiModelHash,
            difficulty: _difficulty,
            moveCount: 0,
            lastMoveHash: bytes32(0),
            completed: false
        });
        
        playerGames[msg.sender].push(_gameId);
        
        emit GameStarted(_gameId, msg.sender, _aiModelHash, _difficulty);
    }
    
    /**
     * @dev 提交 AI 移動（帶 ZK 證明）
     */
    function submitAIMove(
        bytes32 _gameId,
        bytes32 _moveHash,
        bytes calldata _proof,
        uint256[] calldata _publicInputs
    ) external {
        GameState storage game = games[_gameId];
        require(!game.completed, "Game already completed");
        
        // 驗證 ZK 證明
        // _publicInputs 包含：
        // [0] = 遊戲狀態哈希
        // [1] = 移動數據哈希
        // [2] = 隨機種子哈希
        // [3] = 移動有效性標誌
        
        require(_publicInputs[3] == 1, "Invalid move");
        
        // 記錄移動
        gameMoves[_gameId].push(AIMove({
            gameId: _gameId,
            moveIndex: game.moveCount,
            moveDataHash: _moveHash,
            proofHash: keccak256(_proof),
            timestamp: block.timestamp
        }));
        
        game.moveCount++;
        game.lastMoveHash = _moveHash;
        
        emit AIMoveMade(_gameId, game.moveCount - 1, _moveHash);
    }
    
    /**
     * @dev 完成遊戲
     */
    function completeGame(
        bytes32 _gameId,
        address _winner,
        uint256 _score
    ) external {
        GameState storage game = games[_gameId];
        require(!game.completed, "Already completed");
        
        game.completed = true;
        
        emit GameCompleted(_gameId, _winner, _score);
    }
    
    /**
     * @dev 獲取遊戲歷史移動
     */
    function getGameMoves(bytes32 _gameId) 
        external 
        view 
        returns (AIMove[] memory) 
    {
        return gameMoves[_gameId];
    }
}

第五章：開發實踐指南

5.1 開發環境設置

# docker-compose.yml
version: '3.8'

services:
  # ZKML 證明服務
  zkml-prover:
    build: 
      context: ./zkml-prover
      dockerfile: Dockerfile
    ports:
      - "8080:8080"
    environment:
      - PROVER_TYPE=stark
      - ETH_RPC_URL=${ETH_RPC_URL}
      - PRIVATE_KEY=${PRIVATE_KEY}
    volumes:
      - ./models:/app/models
      - ./circuits:/app/circuits
    networks:
      - zkml-network

  # 以太坊節點
  ethereum-node:
    image: ethereum/client-go:latest
    ports:
      - "8545:8545"
      - "8546:8546"
    command: 
      - "--http"
      - "--http.addr=0.0.0.0"
      - "--http.vhosts=*"
      - "--ws"
      - "--ws.addr=0.0.0.0"
      - "--ws.origins=*"
    networks:
      - zkml-network

  # API 服務器
  api-server:
    build: ./api
    ports:
      - "3000:3000"
    environment:
      - ETH_RPC_URL=http://ethereum-node:8545
      - ZKML_PROVER_URL=http://zkml-prover:8080
    depends_on:
      - ethereum-node
      - zkml-prover
    networks:
      - zkml-network

networks:
  zkml-network:
    driver: bridge

5.2 ZKML 電路開發流程

# zkml_circuit/model_to_circuit.py
"""
將 ML 模型轉換為 ZK 電路的流程
"""

from typing import List, Tuple
import numpy as np


class ZKMLCircuitGenerator:
    """ZKML 電路生成器"""
    
    def __init__(self, model_path: str):
        self.model = self.load_model(model_path)
        self.quantization_bits = 8
    
    def load_model(self, path: str):
        """加載 ML 模型"""
        # 支援 PyTorch、TensorFlow、ONNX
        pass
    
    def quantize_model(self) -> np.ndarray:
        """量化模型權重"""
        # 將浮點數權重量化為定點數
        scale = 2 ** self.quantization_bits
        
        quantized_weights = []
        for weight in self.model.get_weights():
            # 量化
            q_weight = np.round(weight * scale).astype(np.int64)
            # 裁剪到指定範圍
            q_weight = np.clip(q_weight, -128, 127)
            quantized_weights.append(q_weight)
        
        return quantized_weights
    
    def generate_circuit_code(self) -> str:
        """生成 Cairo 電路代碼"""
        quantized_weights = self.quantize_model()
        
        # 生成電路結構
        circuit_code = """
// Auto-generated ZKML Circuit
// Model: {model_name}
// Quantization: {bits} bits

use starknet::storage::Store;

const MODEL_VERSION: felt252 = '{version}';
const INPUT_SIZE: felt252 = {input_size};
const OUTPUT_SIZE: felt252 = {output_size};

// 量化參數
const SCALE: felt252 = {scale};
const ZERO_POINT: felt252 = 128;

struct ModelWeights {{
    // 權重存儲
    {weight_struct}
}}

struct ModelInput {{
    let data: felt252*;
}}

struct ModelOutput {{
    let data: felt252*;
}}

// 主驗證函數
fn verify_inference(
    weights: ModelWeights,
    input: ModelInput,
    output: ModelOutput,
) -> felt252 {{
    // 實現量化矩陣乘法
    // ...
    
    // 應用激活函數
    // ...
    
    // 返回輸出
    1
}}
        """.format(
            model_name=self.model.name,
            bits=self.quantization_bits,
            version=self.model.version,
            input_size=self.model.input_size,
            output_size=self.model.output_size,
            scale=2 ** self.quantization_bits,
            weight_struct=self.generate_weight_struct(quantized_weights)
        )
        
        return circuit_code
    
    def generate_weight_struct(self, weights: List[np.ndarray]) -> str:
        """生成權重結構"""
        struct_lines = []
        
        for i, w in enumerate(weights):
            shape = w.shape
            struct_lines.append(
                f"    weight_{i}: felt252*, // shape: {shape}"
            )
        
        return "\n".join(struct_lines)


# 使用示例
if __name__ == "__main__":
    generator = ZKMLCircuitGenerator("path/to/model.onnx")
    circuit_code = generator.generate_circuit_code()
    
    with open("circuit.cairo", "w") as f:
        f.write(circuit_code)
    
    print("ZKML circuit generated successfully!")

5.3 前端整合示例

// zkml-dapp/src/hooks/useZKMLVerification.js
import { useState, useCallback } from 'react';
import { ethers } from 'ethers';

const ZKML_ABI = [
  "function submitProofSTARK(bytes32 requestId, bytes32 modelHash, bytes32 inputHash, bytes32 outputHash, bytes proof, uint256[] publicInputs) external payable",
  "event ProofVerified(bytes32 indexed requestId, address indexed prover, bool success, uint256 timestamp)"
];

export function useZKMLVerification(contractAddress, provider) {
  const [isVerifying, setIsVerifying] = useState(false);
  const [error, setError] = useState(null);
  
  const contract = new ethers.Contract(
    contractAddress,
    ZKML_ABI,
    provider.getSigner()
  );
  
  // 步驟 1：準備輸入數據
  const prepareInput = useCallback(async (data) => {
    // 序列化輸入數據
    const encoded = ethers.solidityPacked(
      ['bytes'],
      [JSON.stringify(data)]
    );
    const hash = ethers.keccak256(encoded);
    
    return {
      data,
      encoded,
      hash
    };
  }, []);
  
  // 步驟 2：調用證明服務器
  const generateProof = useCallback(async (modelId, input) => {
    try {
      const response = await fetch('/api/zkml/prove', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          modelId,
          input
        })
      });
      
      const result = await response.json();
      return result;
    } catch (err) {
      throw new Error(`Proof generation failed: ${err.message}`);
    }
  }, []);
  
  // 步驟 3：提交證明到鏈上
  const verifyProof = useCallback(async (requestId, modelHash, inputHash, outputHash, proof, publicInputs) => {
    setIsVerifying(true);
    setError(null);
    
    try {
      // 估算 Gas
      const gasEstimate = await contract.submitProofSTARK.estimateGas(
        requestId,
        modelHash,
        inputHash,
        outputHash,
        proof,
        publicInputs
      );
      
      // 發送交易
      const tx = await contract.submitProofSTARK(
        requestId,
        modelHash,
        inputHash,
        outputHash,
        proof,
        publicInputs,
        {
          gasLimit: gasEstimate.mul(120).div(100) // +20% buffer
        }
      );
      
      // 等待確認
      const receipt = await tx.wait();
      
      // 解析事件
      const event = receipt.events?.find(e => e.event === 'ProofVerified');
      
      return {
        success: event?.args?.success || false,
        transactionHash: tx.hash,
        blockNumber: receipt.blockNumber
      };
    } catch (err) {
      setError(err.message);
      throw err;
    } finally {
      setIsVerifying(false);
    }
  }, [contract]);
  
  // 完整流程
  const fullVerificationFlow = useCallback(async (modelId, modelHash, inputData) => {
    // 1. 準備輸入
    const { hash: inputHash } = await prepareInput(inputData);
    
    // 2. 生成證明
    const { outputHash, proof, publicInputs } = await generateProof(
      modelId,
      inputData
    );
    
    // 3. 提交驗證
    const requestId = ethers.keccak256(
      ethers.solidityPacked(
        ['bytes32', 'address', 'uint256'],
        [inputHash, await provider.getSigner().getAddress(), Date.now()]
      )
    );
    
    return await verifyProof(
      requestId,
      modelHash,
      inputHash,
      outputHash,
      proof,
      publicInputs
    );
  }, [prepareInput, generateProof, verifyProof, provider]);
  
  return {
    isVerifying,
    error,
    prepareInput,
    generateProof,
    verifyProof,
    fullVerificationFlow
  };
}

// 使用示例組件
function CreditScoreVerification({ modelId, modelHash }) {
  const { fullVerificationFlow, isVerifying, error } = useZKMLVerification(
    CONTRACT_ADDRESS,
    provider
  );
  
  const handleVerify = async () => {
    const userData = {
      income: 50000,
      debt: 10000,
      creditHistory: 5,
      // ... 其他敏感數據
    };
    
    try {
      const result = await fullVerificationFlow(modelId, modelHash, userData);
      console.log('Verification result:', result);
    } catch (err) {
      console.error('Verification failed:', err);
    }
  };
  
  return (
    <div>
      <button onClick={handleVerify} disabled={isVerifying}>
        {isVerifying ? '驗證中...' : '驗證信用'}
      </button>
      {error && <p>錯誤: {error}</p>}
    </div>
  );
}

第六章：性能優化與最佳實踐

6.1 證明生成優化

# zkml_optimization/prover_optimization.py
"""
ZKML 證明生成的性能優化策略
"""

class ProverOptimizer:
    """證明生成優化器"""
    
    def __init__(self, circuit):
        self.circuit = circuit
        self.optimizations = []
    
    def apply_quantization_optimization(self, bit_width=8):
        """量化優化：減少電路大小"""
        # 1. 權重量化
        # 2. 激活量化
        # 3. 動態量化
        
        self.optimizations.append({
            'type': 'quantization',
            'bits': bit_width,
            'savings': (32 - bit_width) / 32 * 100  # 預期節省
        })
    
    def apply_batch_optimization(self, batch_size=32):
        """批量處理優化"""
        # 1. 批量矩陣乘法
        # 2. 共享計算
        # 3. 並行執行
        
        self.optimizations.append({
            'type': 'batching',
            'batch_size': batch_size,
            'speedup': batch_size * 0.8  # 預估加速比
        })
    
    def apply_hardware_acceleration(self, use_gpu=True, use_fpga=False):
        """硬體加速優化"""
        if use_gpu:
            # 使用 GPU 加速
            self.optimizations.append({
                'type': 'gpu_acceleration',
                'device': 'CUDA'
            })
        
        if use_fpga:
            # 使用 FPGA 加速
            self.optimizations.append({
                'type': 'fpga_acceleration',
                'device': 'Xilinx/Intel'
            })
    
    def generate_report(self):
        """生成優化報告"""
        total_savings = sum(
            opt.get('savings', 0) 
            for opt in self.optimizations 
            if 'savings' in opt
        )
        
        total_speedup = 1.0
        for opt in self.optimizations:
            if 'speedup' in opt:
                total_speedup *= opt['speedup']
        
        return {
            'optimizations': self.optimizations,
            'total_size_reduction': f"{total_savings:.1f}%",
            'total_speedup': f"{total_speedup:.1f}x"
        }

6.2 鏈上驗證優化

// 優化的批量驗證合約
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

contract OptimizedZKMLVerifier {
    
    // 批量驗證存儲
    struct BatchVerification {
        uint256 size;
        bytes32[] inputHashes;
        bytes32[] outputHashes;
        bytes[] proofs;
        bool[] results;
    }
    
    mapping(bytes32 => BatchVerification) public batchQueue;
    uint256 public constant BATCH_SIZE = 10;
    
    /**
     * @dev 批量提交證明
     */
    function submitBatchProof(
        bytes32 batchId,
        bytes32[] memory inputHashes,
        bytes32[] memory outputHashes,
        bytes[] memory proofs,
        uint256[] memory publicInputs
    ) external {
        require(
            inputHashes.length <= BATCH_SIZE,
            "Batch size exceeded"
        );
        
        // 批量處理
        for (uint256 i = 0; i < inputHashes.length; i++) {
            // 驗證每個證明
            bool result = _verifyProof(
                inputHashes[i],
                outputHashes[i],
                proofs[i],
                _slicePublicInputs(publicInputs, i)
            );
            
            // 記錄結果
            // ...
        }
    }
    
    // 優化的驗證邏輯
    function _verifyProof(
        bytes32 inputHash,
        bytes32 outputHash,
        bytes memory proof,
        uint256[] memory publicInputs
    ) internal view returns (bool) {
        // 使用預編譯合約進行驗證
        // ...
        
        return true;
    }
}

結論

ZKML 代表了區塊鏈與人工智能交叉領域的最前沿技術。通過本指南的學習，我們涵蓋了以下關鍵內容：

首先，在技術基礎方面，我們回顧了零知識證明的基本概念，並深入分析了為什麼 ZKML 對於區塊鏈上的 AI 應用至關重要。ZKML 能夠解決隱私保護、計算效率和信任建立等核心問題。

其次，在協議工具方面，我們詳細介紹了 Giza、EZKL、Modulus Labs、RiscZero 等主流 ZKML 協議和工具，以及如何根據實際需求選擇合適的工具。

第三，在智慧合約整合方面，我們提供了完整的驗證合約和應用合約程式碼，包括信用評估、AI 內容驗證和遊戲 AI 等實際應用場景。

第四，在開發實踐方面，我們涵蓋了開發環境設置、電路開發流程和前端整合的完整指南。

最後，在性能優化方面，我們討論了證明生成和鏈上驗證的優化策略。

ZKML 技術仍在快速發展中。隨著硬體加速器的成熟和更多應用場景的發現，ZKML 有望在未來幾年成為以太坊生態系統的重要基礎設施。開發者應該抓緊時間學習和實踐這項技術，以便在 ZKML 時代佔得先機。

參考資源

• Giza Protocol Documentation
• EZKL GitHub Repository
• RiscZero Documentation
• StarkWare Technical Documentation
• Ethereum Foundation ZKML Research

聲明：本文僅供技術教育目的，不構成投資建議。ZKML 技術涉及複雜的密碼學和區塊鏈技術，建議開發者在實際部署前進行充分的安全審計和測試。