## Усовершенствованный исходный код для системы верификации ИИ «Mira» Ниже — структурированный код с пояснениями, реализующий ключевые принципы работы Mira: **шардинг**, **бинаризацию**, **ансамблевую верификацию** и **блокчейн‑интеграцию**. ### 1. Основные компоненты системы ```python from typing import List, Dict, Any import hashlib import json from dataclasses import dataclass from enum import Enum # Перечисление типов утверждений class ClaimType(Enum): FACTUAL = "factual" REASONING = "reasoning" CONCLUSION = "conclusion" # Структура данных для шарда (фрагмента) @dataclass class Shard: shard_id: str claims: List[Dict[str, Any]] metadata: Dict[str, Any] # Структура верифицированного результата @dataclass class VerificationResult: claim_id: str is_valid: bool confidence: float validator_ids: List[str] timestamp: float ``` ### 2. Модуль шардинга (разбиение контента) ```python class ShardingModule: def __init__(self, max_claims_per_shard: int = 5): self.max_claims_per_shard = max_claims_per_shard def split_into_shards(self, claims: List[Dict[str, Any]]) -> List[Shard]: shards = [] for i in range(0, len(claims), self.max_claims_per_shard): shard_claims = claims[i:i + self.max_claims_per_shard] shard_id = self._generate_shard_id(shard_claims) shard = Shard( shard_id=shard_id, claims=shard_claims, metadata={"created_at": time.time()} ) shards.append(shard) return shards def _generate_shard_indic(self, claims: List[Dict[str, Any]]) -> str: # Хэш-идентификатор шарда на основе содержимого content = json.dumps([c["text"] for c in claims], sort_keys=True) return hashlib.sha256(content.encode()).hexdigest()[:16] ``` ### 3. Модуль бинаризации (преобразование в вопросы с выбором) ```python class BinarizationModule: def convert_to_binary_questions(self, claims: List[Dict[str, Any]]) -> List[Dict[str, Any]]: questions = [] for claim in claims: question = { "claim_id": claim["id"], "question": f"Верно ли утверждение: '{claim['text']}'?", "options": ["Да", "Нет"], "correct_answer": "Да" if claim["is_true"] else "Нет", "type": claim["type"].value } questions.append(question) return questions ``` ### 4. Модуль ансамблевой верификации ```python class EnsembleVerifier: def __init__(self, validators: List[Any]): self.validators = validators # Список моделей ИИ/валидаторов def verify_shard(self, shard: Shard) -> List[VerificationResult]: results = [] for claim in shard.claims: # Сбор ответов от всех валидаторов validator_responses = [] for validator in self.validators: response = validator.predict(claim["text"]) validator_responses.append({ "validator_id": validator.id, "is_valid": response["is_valid"], "confidence": response["confidence"] }) # Консенсус (большинство голосов) valid_count = sum(1 for r in validator_responses if r["is_valid"]) is_valid = valid_count >= len(validator_responses) / 2 confidence = sum(r["confidence"] for r in validator_responses) / len(validator_responses) result = VerificationResult( claim_id=claim["id"], is_valid=is_valid, confidence=confidence, validator_ids=[r["validator_id"] for r in validator_responses], timestamp=time.time() ) results.append(result) return results ``` ### 5. Модуль блокчейн‑интеграции ```python class BlockchainIntegrator: def __init__(self, web3_provider: str): self.web3 = Web3(Web3.HTTPProvider(web3_provider)) def store_verification_result(self, result: VerificationResult) -> str: # Сериализация результата data = { "claim_id": result.claim_id, "is_valid": result.is_valid, "confidence": result.confidence, "validators": result.validator_ids, "timestamp": result.timestamp } data_json = json.dumps(data, sort_keys=True) # Отправка в блокчейн (пример через смарт‑контракт) tx = self._send_to_contract(data_json) return tx.hex() def _send_to_contract(self, data: str) -> bytes: # Псевдокод взаимодействия со смарт‑контрактом contract = self.web3.eth.contract(address=CONTRACT_ADDRESS, abi=CONTRACT_ABI) tx = contract.functions.storeResult(data).buildTransaction({ 'chainId': 1, 'gas': 2000000, 'maxFeePerGas': Web3.toWei('2', 'gwei'), 'nonce': self.web3.eth.getTransactionCount(MY_ADDRESS), }) signed_tx = self.web3.eth.account.sign_transaction(tx, PRIVATE_KEY) tx_hash = self.web3.eth.sendRawTransaction(signed_tx.rawTransaction) return tx_hash ``` ### 6. Основной класс системы Mira ```python import time class MiraSystem: def __init__(self, validators: List[Any], web3_provider: str): self.sharding = ShardingModule(max_claims_per_shard=5) self.binarization = BinarizationModule() self.ensemble = EnsembleVerifier(validators) self.blockchain = BlockchainIntegrator(web3_provider) def process_ai_output(self, ai_output: List[Dict[str, Any]]) -> Dict[str, Any]: # Шаг 1: Шардинг shards = self.sharding.split_into_shards(ai_output) # Шаг 2: Бинаризация (для каждого шарда) all_questions = [] for shard in shards: questions = self.binarization.convert_to_binary_questions(shard.claims) all_questions.extend(questions) # Шаг 3: Ансамблевая верификация all_results = [] for shard in shards: results = self.ensemble.verify_shard(shard) all_results.extend(results) # Шаг 4: Запись в блокчейн tx_hashes = [] for result in all_results: tx_hash = self.blockchain.store_verification_result(result) tx_hashes.append(tx_hash) return { "shards": [s.shard_id for s in shards], "verification_results": all_results, "blockchain_txs": tx_hashes, "timestamp": time.time() } ``` ### 7. Пример использования ```python # Инициализация валидаторов (моделей ИИ) validators = [ AIValidator(id="gpt-4", model="gpt-4"), AIValidator(id="claude-3", model="claude-3"), AIValidator(id="command-r", model="command-r") ] # Создание системы Mira mira = MiraSystem( validators=validators, web3_provider="https://mainnet.infura.io/v3/YOUR_INFURA_KEY" ) # Пример входных данных (результат работы ИИ) ai_output = [ { "id": "claim-1", "text": "Фотосинтез происходит в растения