ZKML 與以太坊代理自動化實作完整指南：從理論到去中心化推理服務

執行摘要

人工智慧與區塊鏈技術的融合正在催生一個全新的技術範式。零知識機器學習（ZKML）將零知識證明的隱私保護能力與機器學習的智能決策相結合，為以太坊生態系統帶來了革命性的應用場景。本文深入探討 ZKML 在以太坊上的技術實作，涵蓋模型推理驗證、代理自動化交易、去中心化推理服務等多個維度。我們將提供完整的智慧合約程式碼範例、客戶端整合教學、以及生產環境部署的最佳實踐。透過本文，開發者將能夠構建基於 ZKML 的智能以太坊應用，實現真正的去中心化人工智能。

第一章：ZKML 技術基礎

1.1 什麼是 ZKML？

ZKML（Zero-Knowledge Machine Learning）是指使用零知識證明技術來驗證機器學習模型推理結果的密碼學方法。在傳統的機器學習應用中，模型推理通常在中心化伺服器上進行，用戶無法驗證推理過程是否正確或模型是否被篡改。ZKML 透過生成零知識證明，讓任何人都可以在不透露輸入數據和模型權重的情況下，驗證推理結果的正確性。

核心價值

ZKML 為區塊鏈帶來了以下關鍵能力：

1. 隱私保護推理：用戶可以獲得 AI 模型的推理結果，而無需透露輸入數據
2. 模型智慧財產權保護：模型所有者可以在不公開模型權重的情況下提供推理服務
3. 驗證去中心化：推理可以在任何地方進行，結果可以透過零知識證明在鏈上驗證
4. 抗審查：即使原始推理服務被關閉，任何人都可以驗證歷史推理結果

1.2 ZKML 工作原理

ZKML 的工作流程可以分為以下幾個階段：

┌─────────────────────────────────────────────────────────────────┐
│                       ZKML 工作流程                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  訓練階段：                                                    │
│  ┌─────────────┐                                               │
│  │   訓練數據  │ → 機器學習模型 → 模型權重                      │
│  └─────────────┘                                               │
│                                                                 │
│  電路編譯階段：                                                 │
│  ┌─────────────┐                                               │
│  │   模型權重   │ → 編譯器 → ZK 電路                           │
│  └─────────────┘                                               │
│                                                                 │
│  推理階段：                                                     │
│  ┌─────────────┐                                               │
│  │   輸入數據   │ → 模型推理 → 輸出 + ZK 證明                  │
│  └─────────────┘                                               │
│                                                                 │
│  驗證階段：                                                     │
│  ┌─────────────────────────────────────────┐                   │
│  │   驗證ZK證明 → 輸出是否正確（不透露輸入） │                  │
│  └─────────────────────────────────────────┘                   │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

1.3 ZKML 技術堆疊

目前主流的 ZKML 技術堆疊包括：

第二章：ZKML 合約開發實作

2.1 模型準備與電路編譯

在開始 ZKML 合約開發之前，需要先準備機器學習模型並編譯為 ZK 電路。以下是一個完整的流程：

步驟一：訓練簡單分類模型

# 訓練一個簡單的分類模型
import torch
import torch.nn as nn

class SimpleClassifier(nn.Module):
    def __init__(self, input_dim=4, hidden_dim=8, output_dim=2):
        super().__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.fc2 = nn.Linear(hidden_dim, output_dim)
        self.relu = nn.ReLU()
        
    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 創建模型實例
model = SimpleClassifier()

# 訓練過程（省略）
# ...

# 導出為 ONNX 格式
dummy_input = torch.randn(1, 4)
torch.onnx.export(
    model,
    dummy_input,
    "classifier.onnx",
    input_names=['input'],
    output_names=['output'],
    dynamic_axes={'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}}
)

步驟二：使用 ezkl 編譯為 ZK 電路

# 使用 ezkl 將 ONNX 模型編譯為 ZK 電路
import ezkl
import os

# 設置路徑
model_path = "classifier.onnx"
compiled_model_path = "model.compiled"
zk_circuit_path = "zk_circuit.json"

# 1. 校準模型（確定量化參數）
settings = {
    "input_shapes": [{"name": "input", "shape": [1, 4]}],
    "output_shapes": [{"name": "output", "shape": [1, 2]}],
    "scale_report": {"activations": 8, "parameters": 8},
}

ezkl.gen_settings(model_path, settings)
ezkl.calibrate_settings(model_path, settings)

# 2. 編譯模型
ezkl.compile_model(model_path, compiled_model_path)

# 3. 獲取電路結構
circuit = ezkl.load_circuit(compiled_model_path)

print("電路信息：")
print(f"  - 輸入數量: {circuit.num_inputs}")
print(f"  - 約束數量: {circuit.num_constraints}")
print(f"  - 見證數量: {circuit.num_witnesses}")

2.2 智慧合約驗證

以下是 ZKML 驗證的完整智慧合約實現：

// ZKML 驗證合約
contract ZKMLVerifier {
    // 驗證器接口
    IVerifier public verifier;
    
    // 模型元數據
    struct Model {
        string name;
        bytes32 modelHash;  // 模型權重的哈希
        uint256 version;
        bool active;
    }
    
    mapping(bytes32 => Model) public models;
    
    // 推理記錄
    struct Inference {
        bytes32 inferenceId;
        bytes32 modelId;
        bytes32 inputHash;
        bytes32 outputHash;
        address prover;
        uint256 timestamp;
        bool verified;
    }
    
    mapping(bytes32 => Inference) public inferences;
    
    // 事件
    event ModelRegistered(
        bytes32 indexed modelId,
        string name,
        bytes32 modelHash
    );
    event InferenceVerified(
        bytes32 indexed inferenceId,
        bytes32 indexed modelId,
        bool success
    );
    
    constructor(address _verifier) {
        verifier = IVerifier(_verifier);
    }
    
    // 註冊模型
    function registerModel(
        bytes32 _modelId,
        string calldata _name,
        bytes32 _modelHash
    ) external {
        require(models[_modelId].version == 0, "Model exists");
        
        models[_modelId] = Model({
            name: _name,
            modelHash: _modelHash,
            version: 1,
            active: true
        });
        
        emit ModelRegistered(_modelId, _name, _modelHash);
    }
    
    // 驗證推理結果
    function verifyInference(
        bytes32 _inferenceId,
        bytes32 _modelId,
        bytes32 _inputHash,
        bytes32 _outputHash,
        bytes calldata _proof
    ) external returns (bool) {
        Model storage model = models[_modelId];
        require(model.active, "Model not active");
        
        // 準備驗證輸入
        uint256[8] memory inputs = [
            uint256(_modelId),
            uint256(_inputHash),
            uint256(_outputHash),
            uint256(uint160(msg.sender)),
            uint256(block.timestamp),
            0, 0, 0  // 預留
        ];
        
        // 調用驗證器
        bool valid = verifier.verifyProof(_proof, inputs);
        
        // 記錄推理結果
        inferences[_inferenceId] = Inference({
            inferenceId: _inferenceId,
            modelId: _modelId,
            inputHash: _inputHash,
            outputHash: _outputHash,
            prover: msg.sender,
            timestamp: block.timestamp,
            verified: valid
        });
        
        emit InferenceVerified(_inferenceId, _modelId, valid);
        
        return valid;
    }
    
    // 批量驗證
    function batchVerify(
        bytes32[] calldata _inferenceIds,
        bytes32[] calldata _modelIds,
        bytes32[] calldata _inputHashes,
        bytes32[] calldata _outputHashes,
        bytes[] calldata _proofs
    ) external returns (bool[] memory) {
        require(
            _inferenceIds.length == _modelIds.length &&
            _modelIds.length == _inputHashes.length &&
            _inputHashes.length == _outputHashes.length &&
            _outputHashes.length == _proofs.length,
            "Length mismatch"
        );
        
        bool[] memory results = new bool[](_inferenceIds.length);
        
        for (uint256 i = 0; i < _inferenceIds.length; i++) {
            results[i] = verifyInference(
                _inferenceIds[i],
                _modelIds[i],
                _inputHashes[i],
                _outputHashes[i],
                _proofs[i]
            );
        }
        
        return results;
    }
}

// 驗證器接口
interface IVerifier {
    function verifyProof(
        bytes calldata proof,
        uint256[] memory inputs
    ) external view returns (bool);
}

2.3 客戶端推理與證明生成

# ZKML 推理客戶端
import ezkl
import json
from eth_abi import encode
from web3 import Web3

class ZKMLClient:
    """ZKML 推理客戶端"""
    
    def __init__(self, private_key: str, rpc_url: str, contract_address: str):
        self.account = Account.from_key(private_key)
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self.contract_address = contract_address
        
        # 合約 ABI
        self.abi = [...]  # ZKMLVerifier ABI
        
    def load_model(self, compiled_model_path: str):
        """加載編譯後的模型"""
        self.model = ezkl.load_circuit(compiled_model_path)
        
    def run_inference(self, input_data: list) -> dict:
        """運行推理"""
        
        # 準備輸入數據
        input_data = [float(x) for x in input_data]
        
        # 運行推理
        output = ezkl.forward(self.model, [input_data])
        
        return {
            'output': output['output'].tolist(),
            'proof': output.get('proof')
        }
    
    def generate_proof(self, input_data: list, model_id: bytes32) -> dict:
        """生成零知識證明"""
        
        # 1. 運行推理
        inference_result = self.run_inference(input_data)
        
        # 2. 計算輸入和輸出的哈希
        input_hash = Web3.solidity_keccak(
            ['uint256[]'],
            [input_data]
        )
        
        output_data = inference_result['output']
        output_hash = Web3.solidity_keccak(
            ['uint256[]'],
            [output_data]
        )
        
        # 3. 生成證明
        witness = ezkl.generate_witness(
            self.model,
            [input_data]
        )
        
        proof = ezkl.prove(
            witness,
            self.model,
            "test_crs"
        )
        
        return {
            'input_hash': input_hash,
            'output_hash': output_hash,
            'proof': proof,
            'output': output_data
        }
    
    def submit_inference(
        self,
        model_id: bytes32,
        input_data: list
    ) -> dict:
        """提交推理結果到區塊鏈"""
        
        # 1. 生成證明
        proof_data = self.generate_proof(input_data, model_id)
        
        # 2. 生成推理 ID
        inference_id = Web3.solidity_keccak(
            ['address', 'uint256', 'bytes32'],
            [self.account.address, block.timestamp, model_id]
        )
        
        # 3. 構建交易
        contract = self.w3.eth.contract(
            address=self.contract_address,
            abi=self.abi
        )
        
        tx = contract.functions.verifyInference(
            inference_id,
            model_id,
            proof_data['input_hash'],
            proof_data['output_hash'],
            proof_data['proof']
        ).build_transaction({
            'from': self.account.address,
            'nonce': self.w3.eth.get_transaction_count(self.account.address),
        })
        
        # 4. 簽名並發送
        signed_tx = self.account.sign_transaction(tx)
        tx_hash = self.w3.eth.send_raw_transaction(signed_tx.raw_transaction)
        
        receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
        
        return {
            'inference_id': inference_id,
            'tx_hash': tx_hash,
            'output': proof_data['output'],
            'verified': receipt['status'] == 1
        }

第三章：AI 代理自動化交易實作

3.1 代理架構設計

AI 代理自動化交易系統的架構如下：

┌─────────────────────────────────────────────────────────────────┐
│                    AI 代理交易系統架構                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  [市場數據] ─┐                                                  │
│              ↓                                                  │
│  [數據預處理] ──→ [ML 模型推理] ──→ [交易決策]                │
│              ↑                                    ↓             │
│  [錢包狀態] ─┘                                    [交易執行]     │
│                                                        ↓         │
│                                            [以太坊區塊鏈]        │
│                                                                 │
│  [ZKML 驗證層] ◄─────────────────────────────────────┐        │
│         ↓                                               │        │
│  [智慧合約] ──────────────────────────────────────────┘        │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

3.2 交易代理智慧合約

以下是支持 AI 代理的交易合約實現：

// AI 代理交易合約
contractAITradingAgent {
    // 代理配置
    struct AgentConfig {
        address owner;
        address strategyContract;
        uint256 maxTradeSize;
        uint256 maxSlippage;
        bool active;
        bytes32 modelId;  // ZKML 模型 ID
    }
    
    mapping(address => AgentConfig) public agentConfigs;
    
    // 交易記錄
    struct Trade {
        bytes32 tradeId;
        address agent;
        address tokenIn;
        address tokenOut;
        uint256 amountIn;
        uint256 minAmountOut;
        uint256 executedAmountOut;
        TradeStatus status;
        uint256 timestamp;
    }
    
    enum TradeStatus { 
        Pending, 
        Executed, 
        Failed, 
        Cancelled 
    }
    
    mapping(bytes32 => Trade) public trades;
    
    // 事件
    event TradeRequested(
        bytes32 indexed tradeId,
        address indexed agent,
        address tokenIn,
        address tokenOut,
        uint256 amountIn
    );
    event TradeExecuted(
        bytes32 indexed tradeId,
        uint256 amountOut
    );
    event TradeFailed(
        bytes32 indexed tradeId,
        string reason
    );
    
    // 註冊代理
    function registerAgent(
        address _strategyContract,
        uint256 _maxTradeSize,
        uint256 _maxSlippage,
        bytes32 _modelId
    ) external {
        agentConfigs[msg.sender] = AgentConfig({
            owner: msg.sender,
            strategyContract: _strategyContract,
            maxTradeSize: _maxTradeSize,
            maxSlippage: _maxSlippage,
            active: true,
            modelId: _modelId
        });
    }
    
    // 請求交易
    function requestTrade(
        address _tokenIn,
        address _tokenOut,
        uint256 _amountIn,
        uint256 _minAmountOut,
        bytes32 _modelId,
        bytes calldata _zkProof
    ) external returns (bytes32) {
        AgentConfig storage config = agentConfigs[msg.sender];
        require(config.active, "Agent not active");
        require(_amountIn <= config.maxTradeSize, "Exceeds max trade size");
        
        // 驗證 ZKML 模型（可選）
        if (config.modelId != bytes32(0)) {
            require(
                _verifyModelInference(_modelId, msg.sender, _zkProof),
                "Model verification failed"
            );
        }
        
        // 計算交易 ID
        bytes32 tradeId = keccak256(abi.encodePacked(
            msg.sender,
            _tokenIn,
            _tokenOut,
            _amountIn,
            block.timestamp
        ));
        
        trades[tradeId] = Trade({
            tradeId: tradeId,
            agent: msg.sender,
            tokenIn: _tokenIn,
            tokenOut: _tokenOut,
            amountIn: _amountIn,
            minAmountOut: _minAmountOut,
            executedAmountOut: 0,
            status: TradeStatus.Pending,
            timestamp: block.timestamp
        });
        
        // 從代理帳戶轉入代幣
        IERC20(_tokenIn).transferFrom(msg.sender, address(this), _amountIn);
        
        emit TradeRequested(tradeId, msg.sender, _tokenIn, _tokenOut, _amountIn);
        
        return tradeId;
    }
    
    // 執行交易
    function executeTrade(bytes32 _tradeId) external {
        Trade storage trade = trades[_tradeId];
        
        require(trade.status == TradeStatus.Pending, "Invalid status");
        
        // 獲取代幣交換路徑
        address[] memory path = new address[](2);
        path[0] = trade.tokenIn;
        path[1] = trade.tokenOut;
        
        // 計算預期輸出
        uint256[] memory amounts = UniswapV2Router02(
            routerAddress()
        ).getAmountsOut(trade.amountIn, path);
        
        uint256 expectedOut = amounts[amounts.length - 1];
        
        // 檢查滑點
        AgentConfig storage config = agentConfigs[trade.agent];
        uint256 minAcceptable = trade.amountIn * (10000 - config.maxSlippage) / 10000;
        
        require(expectedOut >= minAcceptable, "Slippage too high");
        
        // 執行交換
        IERC20(trade.tokenIn).approve(routerAddress(), trade.amountIn);
        
        uint256[] memory swapAmounts = UniswapV2Router02(
            routerAddress()
        ).swapExactTokensForTokens(
            trade.amountIn,
            trade.minAmountOut,
            path,
            address(this),
            block.timestamp + 300  // 5 分鐘過期
        );
        
        trade.executedAmountOut = swapAmounts[swapAmounts.length - 1];
        trade.status = TradeStatus.Executed;
        
        // 將輸出代幣轉回代理
        IERC20(trade.tokenOut).transfer(trade.agent, trade.executedAmountOut);
        
        emit TradeExecuted(tradeId, trade.executedAmountOut);
    }
    
    function _verifyModelInference(
        bytes32 _modelId,
        address _agent,
        bytes calldata _proof
    ) internal pure returns (bool) {
        // 實際實現需要調用 ZKML 驗證合約
        return true;
    }
    
    function routerAddress() internal pure returns (address) {
        // Uniswap V2 Router 地址
        return 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
    }
}

3.3 Python 交易代理客戶端

# AI 交易代理客戶端
class AITradingAgent:
    """AI 交易代理"""
    
    def __init__(
        self,
        private_key: str,
        rpc_url: str,
        agent_config: dict
    ):
        self.account = Account.from_key(private_key)
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self.config = agent_config
        
        # ZKML 客戶端
        self.zkml_client = ZKMLClient(
            private_key,
            rpc_url,
            config.get('zkml_contract')
        )
        
    async def start_trading_loop(self):
        """開始交易循環"""
        
        while True:
            try:
                # 1. 獲取市場數據
                market_data = await self.fetch_market_data()
                
                # 2. 準備模型輸入
                model_input = self.prepare_model_input(market_data)
                
                # 3. 運行 ZKML 推理
                inference_result = await self.run_zkml_inference(model_input)
                
                # 4. 根據推理結果生成交易
                if inference_result['action'] != 'hold':
                    trade_params = self.generate_trade_params(
                        inference_result,
                        market_data
                    )
                    
                    # 5. 執行交易
                    await self.execute_trade(trade_params)
                
            except Exception as e:
                print(f"交易循環錯誤: {e}")
                
            await asyncio.sleep(self.config['check_interval'])
    
    async def fetch_market_data(self) -> dict:
        """獲取市場數據"""
        
        # 獲取 ETH 價格
        eth_price = await self.get_token_price(ETH_ADDRESS)
        
        # 獲取相關 DeFi 數據
        gas_price = self.w3.eth.gas_price
        
        return {
            'eth_price': eth_price,
            'gas_price': gas_price,
            'timestamp': block.timestamp
        }
    
    def prepare_model_input(self, market_data: dict) -> list:
        """準備模型輸入"""
        
        # 簡單的特征工程
        features = [
            market_data['eth_price'],
            market_data['gas_price'],
            self.get_portfolio_value(),
            self.get_eth_balance()
        ]
        
        # 歸一化
        return [f / 1e18 for f in features]
    
    async def run_zkml_inference(self, input_data: list) -> dict:
        """運行 ZKML 推理"""
        
        # 生成證明
        proof_data = self.zkml_client.generate_proof(
            input_data,
            self.config['model_id']
        )
        
        # 解析輸出
        output = proof_data['output']
        
        # 根據輸出決定動作
        action_idx = output.index(max(output))
        
        actions = ['hold', 'buy', 'sell']
        
        return {
            'action': actions[action_idx],
            'confidence': max(output),
            'proof': proof_data['proof'],
            'input_hash': proof_data['input_hash']
        }
    
    async def execute_trade(self, trade_params: dict):
        """執行交易"""
        
        # 構建交易
        tx = self.trading_contract.functions.requestTrade(
            trade_params['token_in'],
            trade_params['token_out'],
            trade_params['amount'],
            trade_params['min_out'],
            self.config['model_id'],
            trade_params['proof']
        ).build_transaction({
            'from': self.account.address,
            'nonce': self.w3.eth.get_transaction_count(self.account.address),
            'gas': 500000
        })
        
        # 簽名並發送
        signed = self.account.sign_transaction(tx)
        tx_hash = self.w3.eth.send_raw_transaction(signed.raw_transaction)
        
        return await self.w3.eth.wait_for_transaction_receipt(tx_hash)

第四章：去中心化推理服務

4.1 架構設計

去中心化推理服務允許用戶請求 AI 模型推理，而推理過程由分散的節點網路執行。這種架構確保了服務的抗審查性和可用性。

┌─────────────────────────────────────────────────────────────────┐
│                 去中心化推理服務架構                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  [用戶] ──┐                                                     │
│           │ 請求                                               │
│  ┌───────▼────────┐                                            │
│  │  請求合約      │ ◄────── [爭議解決合約]                     │
│  └───────┬────────┘                                            │
│          │                                                      │
│  ┌───────▼──────────────────────────────────┐                 │
│  │           節點網路                        │                 │
│  │  ┌────────┐  ┌────────┐  ┌────────┐      │                 │
│  │  │ 節點 1 │  │ 節點 2 │  │ 節點 3 │ ... │                 │
│  │  │推理+證明│  │推理+證明│  │推理+證明│     │                 │
│  │  └────────┘  └────────┘  └────────┘      │                 │
│  └───────┬──────────────────────────────────┘                 │
│          │ 提交證明                                             │
│  ┌───────▼────────┐                                            │
│  │  驗證+獎勵分發 │                                            │
│  └────────────────┘                                            │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

4.2 去中心化推理合約

// 去中心化推理服務合約
contract DecentralizedInference {
    // 節點信息
    struct Node {
        address nodeAddress;
        string modelId;  // 支持的模型 ID
        uint256 stakeAmount;
        uint256 reputation;
        bool active;
        uint256 lastUpdate;
    }
    
    mapping(address => Node) public nodes;
    address[] public nodeList;
    
    // 推理請求
    struct InferenceRequest {
        bytes32 requestId;
        address requester;
        string modelId;
        bytes inputDataHash;
        uint256 reward;
        RequestStatus status;
        uint256 createdAt;
        uint256 resolvedAt;
    }
    
    enum RequestStatus {
        Pending,
        Responding,
        Confirmed,
        Disputed,
        Cancelled
    }
    
    mapping(bytes32 => InferenceRequest) public requests;
    
    // 節點響應
    struct NodeResponse {
        bytes32 requestId;
        address node;
        bytes outputData;
        bytes proof;
        uint256 timestamp;
        bool verified;
    }
    
    mapping(bytes32 => NodeResponse[]) public responses;
    
    // 事件
    event NodeRegistered(address indexed node, string modelId);
    event InferenceRequested(
        bytes32 indexed requestId,
        address indexed requester,
        string modelId,
        uint256 reward
    );
    event InferenceResponded(
        bytes32 indexed requestId,
        address indexed node,
        bytes outputHash
    );
    event InferenceConfirmed(
        bytes32 indexed requestId,
        address indexed node,
        uint256 reward
    );
    
    // 註冊為推理節點
    function registerNode(string calldata _modelId) external payable {
        require(nodes[msg.sender].stakeAmount == 0, "Already registered");
        require(msg.value >= MIN_STAKE, "Insufficient stake");
        
        nodes[msg.sender] = Node({
            nodeAddress: msg.sender,
            modelId: _modelId,
            stakeAmount: msg.value,
            reputation: 1000,  // 初始聲譽
            active: true,
            lastUpdate: block.timestamp
        });
        
        nodeList.push(msg.sender);
        
        emit NodeRegistered(msg.sender, _modelId);
    }
    
    // 請求推理
    function requestInference(
        string calldata _modelId,
        bytes calldata _inputDataHash,
        uint256 _reward
    ) external payable returns (bytes32) {
        require(msg.value >= _reward, "Insufficient reward");
        
        bytes32 requestId = keccak256(abi.encodePacked(
            msg.sender,
            _modelId,
            _inputDataHash,
            block.timestamp
        ));
        
        requests[requestId] = InferenceRequest({
            requestId: requestId,
            requester: msg.sender,
            modelId: _modelId,
            inputDataHash: _inputDataHash,
            reward: _reward,
            status: RequestStatus.Pending,
            createdAt: block.timestamp,
            resolvedAt: 0
        });
        
        emit InferenceRequested(requestId, msg.sender, _modelId, _reward);
        
        return requestId;
    }
    
    // 節點響應推理請求
    function respondToRequest(
        bytes32 _requestId,
        bytes calldata _outputData,
        bytes calldata _proof
    ) external {
        InferenceRequest storage request = requests[_requestId];
        
        require(request.status == RequestStatus.Pending, "Invalid status");
        require(nodes[msg.sender].active, "Node not active");
        require(
            keccak256(abi.encodePacked(nodes[msg.sender].modelId)) == 
            keccak256(abi.encodePacked(request.modelId)),
            "Model mismatch"
        );
        
        // 記錄響應
        responses[_requestId].push(NodeResponse({
            requestId: _requestId,
            node: msg.sender,
            outputData: _outputData,
            proof: _proof,
            timestamp: block.timestamp,
            verified: false
        }));
        
        emit InferenceResponded(
            _requestId,
            msg.sender,
            keccak256(_outputData)
        );
        
        // 如果已經有多個響應，標記為可確認
        if (responses[_requestId].length >= MIN_RESPONSES) {
            request.status = RequestStatus.Responding;
        }
    }
    
    // 確認推理結果
    function confirmInference(
        bytes32 _requestId,
        uint256 _responseIndex
    ) external {
        InferenceRequest storage request = requests[_requestId];
        
        require(
            msg.sender == request.requester,
            "Only requester can confirm"
        );
        require(
            request.status == RequestStatus.Responding,
            "Invalid status"
        );
        
        NodeResponse storage response = responses[_requestId][_responseIndex];
        
        // 驗證 ZK 證明（簡化版）
        // 實際實現需要調用 ZKML 驗證器
        
        // 獎勵節點
        payable(response.node).transfer(request.reward);
        
        // 更新節點聲譽
        nodes[response.node].reputation += 100;
        
        request.status = RequestStatus.Confirmed;
        request.resolvedAt = block.timestamp;
        
        emit InferenceConfirmed(
            _requestId,
            response.node,
            request.reward
        );
    }
    
    // 爭議處理
    function raiseDispute(bytes32 _requestId) external {
        InferenceRequest storage request = requests[_requestId];
        
        require(
            msg.sender == request.requester ||
            responses[_requestId].length > 0,
            "Not authorized"
        );
        
        request.status = RequestStatus.Disputed;
        
        // 進入仲裁流程
    }
    
    // 獲取節點列表
    function getNodes() external view returns (address[] memory) {
        return nodeList;
    }
    
    // 獲取請求的所有響應
    function getResponses(
        bytes32 _requestId
    ) external view returns (NodeResponse[] memory) {
        return responses[_requestId];
    }
}

4.3 節點客戶端實現

# 推理節點客戶端
class InferenceNodeClient:
    """推理節點客戶端"""
    
    def __init__(
        self,
        private_key: str,
        rpc_url: str,
        contract_address: str,
        model_config: dict
    ):
        self.account = Account.from_key(private_key)
        self.w3 = Web3(Web3.HTTPProvider(rpc_url))
        self.contract_address = contract_address
        self.model_config = model_config
        
        # ZKML 客戶端
        self.zkml_client = ZKMLClient(
            private_key,
            rpc_url,
            model_config.get('zkml_contract')
        )
        
    async def start_listening(self):
        """開始監聽推理請求"""
        
        # 獲取合約
        contract = self.w3.eth.contract(
            address=self.contract_address,
            abi=self.inference_contract_abi
        )
        
        # 獲取當前區塊
        current_block = self.w3.eth.block_number
        
        while True:
            try:
                # 監控新請求
                events = contract.events.InferenceRequested.getLogs(
                    fromBlock=current_block + 1
                )
                
                for event in events:
                    await self.handle_inference_request(event)
                
                current_block = self.w3.eth.block_number
                
            except Exception as e:
                print(f"監聽錯誤: {e}")
                
            await asyncio.sleep(10)
    
    async def handle_inference_request(self, event: dict):
        """處理推理請求"""
        
        request_data = event['args']
        
        # 檢查是否是自己支持的模型
        if request_data['modelId'] != self.model_config['model_id']:
            return
        
        # 檢查獎勵是否足夠
        if request_data['reward'] < self.model_config['min_reward']:
            return
        
        try:
            # 1. 獲取輸入數據（從 IPFS 或其他來源）
            input_data = await self.fetch_input_data(
                request_data['inputDataHash']
            )
            
            # 2. 運行 ZKML 推理
            inference_result = await self.run_inference(input_data)
            
            # 3. 提交響應
            await self.submit_response(
                request_data['requestId'],
                inference_result
            )
            
        except Exception as e:
            print(f"處理請求失敗: {e}")
    
    async def run_inference(self, input_data: any) -> dict:
        """運行推理"""
        
        # 使用本地模型進行推理
        output = self.model.predict(input_data)
        
        # 生成 ZK 證明
        proof_data = self.zkml_client.generate_proof(
            input_data,
            self.model_config['model_id']
        )
        
        return {
            'output': output,
            'proof': proof_data['proof'],
            'output_hash': proof_data['output_hash']
        }
    
    async def submit_response(
        self,
        request_id: bytes32,
        inference_result: dict
    ):
        """提交推理響應"""
        
        contract = self.w3.eth.contract(
            address=self.contract_address,
            abi=self.inference_contract_abi
        )
        
        tx = contract.functions.respondToRequest(
            request_id,
            json.dumps(inference_result['output']).encode(),
            inference_result['proof']
        ).build_transaction({
            'from': self.account.address,
            'nonce': self.w3.eth.get_transaction_count(self.account.address),
            'gas': 300000
        })
        
        signed = self.account.sign_transaction(tx)
        tx_hash = self.w3.eth.send_raw_transaction(signed.raw_transaction)
        
        return await self.w3.eth.wait_for_transaction_receipt(tx_hash)

第五章：實際應用場景

5.1 預測市場

ZKML 可以用於創建基於 AI 預測的去中心化預測市場。

// AI 預測市場合約
contract AIPredictionMarket {
    // 預測問題
    struct Question {
        string question;
        string description;
        uint256 endTime;
        bytes32 modelId;  // ZKML 模型 ID
        uint256 totalShares;
        mapping(address => uint256) shares;
        bool resolved;
        bytes32 resultHash;
    }
    
    mapping(bytes32 => Question) public questions;
    
    // 預測結果
    struct Prediction {
        address predictor;
        bytes32 questionId;
        uint256 amount;
        bool predictedYes;
        bytes proof;
    }
    
    mapping(bytes32 => Prediction[]) public predictions;
    
    // 創建預測問題
    function createQuestion(
        bytes32 _questionId,
        string calldata _question,
        string calldata _description,
        uint256 _duration,
        bytes32 _modelId
    ) external {
        questions[_questionId] = Question({
            question: _question,
            description: _description,
            endTime: block.timestamp + _duration,
            modelId: _modelId,
            totalShares: 0,
            resolved: false,
            resultHash: bytes32(0)
        });
    }
    
    // 提交預測
    function submitPrediction(
        bytes32 _questionId,
        bool _yes,
        bytes calldata _proof
    ) external payable {
        Question storage question = questions[_questionId];
        
        require(block.timestamp < question.endTime, "Prediction closed");
        require(msg.value >= MIN_BET, "Bet too small");
        
        // 驗證 ZKML 預測證明
        require(verifyPredictionProof(_questionId, msg.sender, _proof), 
            "Invalid proof");
        
        bytes32 predictionId = keccak256(abi.encodePacked(
            _questionId,
            msg.sender,
            block.timestamp
        ));
        
        predictions[_questionId].push(Prediction({
            predictor: msg.sender,
            questionId: _questionId,
            amount: msg.value,
            predictedYes: _yes,
            proof: _proof
        }));
        
        question.totalShares += msg.value;
    }
    
    // 結算預測
    function resolveQuestion(
        bytes32 _questionId,
        bytes32 _resultHash,
        bytes calldata _resolutionProof
    ) external {
        Question storage question = questions[_questionId];
        
        require(block.timestamp >= question.endTime, "Not ended");
        require(!question.resolved, "Already resolved");
        
        // 驗證結算證明
        require(
            verifyResolutionProof(question.modelId, _resultHash, _resolutionProof),
            "Invalid resolution proof"
        );
        
        question.resolved = true;
        question.resultHash = _resultHash;
        
        // 分發獎勵
        // ...
    }
    
    function verifyPredictionProof(
        bytes32 _questionId,
        address _predictor,
        bytes calldata _proof
    ) internal pure returns (bool) {
        // 驗證預測的 ZKML 證明
        return _proof.length > 0;
    }
    
    function verifyResolutionProof(
        bytes32 _modelId,
        bytes32 _resultHash,
        bytes calldata _proof
    ) internal pure returns (bool) {
        // 驗證結算的 ZKML 證明
        return _proof.length > 0;
    }
}

5.2 信用評估

ZKML 可以用於去中心化信用評估，保護用戶隱私的同時提供可信的信用分數。

// 去中心化信用評估合約
contract DecentralizedCreditScore {
    // 信用評估模型
    struct CreditModel {
        bytes32 modelId;
        string name;
        bytes32 modelHash;
        uint256 minCreditScore;
        uint256 maxCreditScore;
        bool active;
    }
    
    mapping(bytes32 => CreditModel) public models;
    
    // 用戶信用記錄
    struct CreditRecord {
        bytes32 modelId;
        uint256 score;
        bytes32 proofHash;
        uint256 lastUpdate;
    }
    
    mapping(address => mapping(bytes32 => CreditRecord)) public creditRecords;
    
    // 註冊信用模型
    function registerModel(
        bytes32 _modelId,
        string calldata _name,
        bytes32 _modelHash,
        uint256 _minScore,
        uint256 _maxScore
    ) external {
        models[_modelId] = CreditModel({
            modelId: _modelId,
            name: _name,
            modelHash: _modelHash,
            minCreditScore: _minScore,
            maxCreditScore: _maxScore,
            active: true
        });
    }
    
    // 提交信用評估
    function submitCreditScore(
        bytes32 _modelId,
        uint256 _score,
        bytes calldata _proof
    ) external {
        CreditModel storage model = models[_modelId];
        
        require(model.active, "Model not active");
        require(
            _score >= model.minCreditScore && 
            _score <= model.maxCreditScore,
            "Invalid score"
        );
        
        // 驗證 ZKML 證明
        require(
            verifyScoreProof(msg.sender, _score, _proof),
            "Invalid proof"
        );
        
        creditRecords[msg.sender][_modelId] = CreditRecord({
            modelId: _modelId,
            score: _score,
            proofHash: keccak256(_proof),
            lastUpdate: block.timestamp
        });
    }
    
    // 查詢信用分數（可選擇性隱藏）
    function getCreditScore(
        address _user,
        bytes32 _modelId,
        bool _reveal
    ) external view returns (uint256) {
        CreditRecord storage record = creditRecords[_user][_modelId];
        
        if (_reveal) {
            return record.score;
        } else {
            // 返回哈希而非實際分數
            return uint256(keccak256(abi.encodePacked(
                record.score,
                record.proofHash
            )));
        }
    }
    
    function verifyScoreProof(
        address _user,
        uint256 _score,
        bytes calldata _proof
    ) internal pure returns (bool) {
        return _proof.length > 0;
    }
}

結論

ZKML 代表了人工智慧與區塊鏈技術融合的前沿方向。透過零知識證明，機器學習模型可以在保護隱私的前提下提供可信的推理服務，這為以太坊生態系統開闢了全新的應用場景。

從 AI 代理自動化交易到去中心化推理服務，從預測市場到信用評估，ZKML 的應用潛力正在逐步釋放。開發者應當：

1. 深入理解 ZKML 的技術原理與限制
2. 選擇合適的技術堆疊（ezkl, circom 等）
3. 關注模型大小與證明效率的平衡
4. 建立完善的風險控制機制

隨著 ZKML 技術的持續成熟，我們可以預期在以太坊上將會出現更多創新的 AI + 區塊鏈應用。

參考資源

• ezkl 官方文檔
• ZKML 社區資源
• 以太坊智慧合約最佳實踐
• 機器學習模型壓縮技術
• 零知識證明系統比較