Garantir l’intégrité des données grâce au hachage cryptographique et à la blockchain Ethereum

flux de travail scientifiques, les équipes ont souvent besoin d’accéder à un ensemble de données partagé qui reste parfaitement synchronisé et ne peut pas être modifiépar exemple, dans des environnements d’apprentissage automatique distribués où plusieurs équipes s’appuient exactement sur le même ensemble de fonctionnalités.

Dans cet article, je vais parcourir un méthode simple et gratuite pour hacher cryptographiquement un ensemble de données de n’importe quelle taille et stocker son hachage de manière immuable sur la blockchain Ethereumcréant un enregistrement permanent et vérifiable de l’intégrité de l’ensemble de données.

Cette méthode peut également être simplement étendue aux poids de modèle, aux transformations spécifiques qui doivent être appliquées de manière cohérente, au code source ou à d’autres données qui doivent être immuables et vérifiables.

🤔Pourquoi l’intégrité est importante

Si vous êtes au moins quelque peu familier avec la science des données en tant que pratique, vous êtes déjà conscient de l’importance de l’intégrité des données. Même de petits changements ou erreurs dans les données d’entrée peuvent faire échouer un projet.

Les modèles modernes d’apprentissage automatique sont extrêmement sensibles à leurs données d’entraînement. Des étapes de normalisation manquantes, un fichier CSV modifié, des lignes mélangées, des fonctionnalités corrompues ou des incohérences entre les ensembles de données d’entraînement et de validation peuvent produire des résultats radicalement différents.

Les manquements à l’intégrité sont difficiles à détecter et font souvent dérailler.

Les modèles peuvent toujours sembler fonctionner normalement ou s’entraîner, mais les mesures peuvent se dégrader lentement, la dérive s’accumule ou les expériences deviennent impossibles à reproduire. L’intégrité est doublement importante lorsque l’équipe est répartie, éventuellement dans différentes organisations, et doit travailler sur différentes versions du même problème.

🔐Utiliser un hachage cryptographique comme « source de vérité »

Un hachage cryptographique nous offre un mécanisme simple et très utile pour vérifier l’intégrité des données.

Une brève introduction aux hachages cryptographiques

Une fonction de hachage prend n’importe quelle quantité de données d’entrée (octets) et produit de manière déterministe une sortie de longueur fixe appelée hachage ou résumé. Les hachages cryptographiques sont fondamentaux en informatique, comme vous le savez probablement déjà.

La clé est le déterminisme :

Mêmes données entrantes → même hachage sortant

Même un seul octet modifié dans les données d’entrée produit un hachage complètement différent.

En raison de cette propriété, les hachages agissent comme des empreintes digitales uniques pour les données et sont extrêmement utiles pour vérifier l’intégrité. Il existe de nombreux types de fonctions de hachage, et certaines sont plus utiles pour cette tâche, comme je vais le décrire.

Comment cela s’applique-t-il aux ensembles de données ?

En raison du déterminisme de la fonction de hachage, une fois appliquée à un ensemble de données, nous pouvons tester rapidement et de manière fiable si l’ensemble de données est identique à ce que nous attendons.

C’est exceptionnellement précieux avec de grands ensembles de données utilisés par plusieurs équipes, plusieurs entreprises, passer d’une version à l’autre. Équipe 1 du Groupe de Recherche Alpha crée les fonctionnalités 1 à 10, Équipe 2 du groupe de recherche Zeta crée les fonctionnalités 10 à 100, le système X consomme la version Y, etc.

Nous n’avons plus besoin de remettre en question les données, calculez simplement la fonction de hachage sur l’ensemble de données et comparez-la au hachage calculé à un point de référence. Si ça correspond, OK. Sinon, quelque chose a changé.

Le hachage est extrêmement efficace. L’exécution d’une fonction de hachage sur un ensemble de données de 10 Mo ou 10 To nous donne rapidement une petite chaîne de taille fixe qui peut être partagée, stockée ou publiée.

🧐 Pourquoi utiliser Ethereum comme magasin immuable ?

C’est la véritable partie utile de cet article.

Ethereum, encore une fois, comme vous le savez déjà, est une blockchain. Cela nous donne :

1. Immutabilité: une transaction ne peut jamais être modifiée
2. Disponibilité distribuée: toujours accessible sans autorité centrale
3. Permanent: une fois écrit, il est accessible en permanence

Mais Ethereum est destiné aux transactions ? N’avons-nous pas besoin d’écrire un contrat intelligent compliqué dans ce but spécialisé ?

Vous pourriez en effet. Mais nous n’en avons pas besoin.

Le plus intelligent consiste à utiliser ce système rarement utilisé input data champ dans un Ethereum transactionparfois appelés « données d’appel ».

Mais les transactions Ethereum coûtent de l’argent réel (essence, frais, etc.)?

C’est également vrai. Sur Ethereum, du « gaz » vous est facturé pour chaque octet des données d’entrée. Sur le réseau principal, avec un prix de 2 000 $ par ETH, cela pourrait nous coûter entre 0,04 et 0,10 $ par hachage. Cela n’inclut pas le gaz requis pour qu’un transfert réel soit inclus par un validateur de bloc, qui peut être important en fonction de la charge actuelle du réseau.

Rendons cela plus intelligent. 🦊

En déchargeant tout sur le « testnet », dont dispose généralement chaque blockchain, nous pouvons rendre cela entièrement gratuit.

Sépolie (le testnet ETH) est rarement utilisé, sauf si vous êtes un développeur de contrats intelligents. Sepolia ETH est gratuit et accessible au public depuis les robinets.

Cela signifie nous pouvons créer gratuitement une quantité infinie de transactions, sur le testnet accessible au public (appelé Sepolia pour Ethereum) !

Tant que nos données d’entrée sont de taille raisonnable, Sepolia fournit un moyen d’utiliser la blockchain pour un stockage de données infiniavec essentiellement les mêmes propriétés que le réseau principal*

* Les blockchains Sepolia ne sont pas permanentes, mais sont pour la plupart fiables pendant plusieurs années. Si vous avez besoin d’une permanence absolue, vous devrez la payer en utilisant le réseau principal.

N’oubliez pas que nous ne stockons pas les données réelles en chaîne. Juste l’empreinte digitale.

⚙️Le processus

Tout d’abord, nous devons trouver un moyen de créer des transactions fiables sur Ethereum.

Même si cela semble complexe, cela est en réalité extrêmement simple. Nous n’avons besoin d’aucun logiciel ou technologie de portefeuille supplémentaire. Un portefeuille n’est rien de plus qu’une clé, associée à un secret utilisé pour le signer.

Pour créer une transaction Ethereum, nous créons un objet python avec les clés et le format requis, l’encodons avec notre clé et le diffusons sur le réseau. Un validateur récupère ensuite notre transaction dans le « mempool » et l’inclut dans un bloc.

Tant que nous incluons tous les champs obligatoires et que tout est vérifié, il fait désormais partie intégrante de la blockchain en environ 12 secondes.

Étape 1 : Créez la clé et le secret avec web3.py avec quelques lignes de code

from eth_account import Account 

account = Account.create() 

print("Address:", account.address) 
print("Private Key:", account.key.hex())

Étape 2 : Obtenez de l’ETH sur Sepolia. Branchez votre adresse ici et attendez 12 secondes. Merci Google !

Étape 3 : hacher l’ensemble de données

Comme je l’ai mentionné, certains hachages sont meilleurs pour ce processus. Nous pourrions utiliser un hachage SHA256, mais Blake2b est en réalité meilleur en termes de débit. En réalité, n’importe quelle fonction de hachage fonctionnera.

import hashlib
from pathlib import Path

def hash_dataset(dataset, algorithm="blake2b", chunk_size=1024 * 1024):
    h = hashlib.new(algorithm)

    def update(obj):
        if isinstance(obj, (str, Path)) and Path(obj).exists():
            with open(obj, "rb") as f:
                while chunk := f.read(chunk_size):
                    h.update(chunk)
        elif isinstance(obj, bytes):
            h.update(obj)
        elif isinstance(obj, str):
            h.update(obj.encode("utf-8"))
        elif isinstance(obj, dict):
            for k in sorted(obj.keys()):
                update(k)
                update(obj[k])
        
        elif isinstance(obj, (list, tuple)):
            for item in obj:
                update(item)
                
        elif isinstance(obj, set):
            try:
                for item in sorted(obj):
                    update(item)
            except TypeError:
                for item in sorted(obj, key=str):
                    update(item)
                    
        elif hasattr(obj, "__iter__"):
            for item in obj:
                update(item)
        else:
            h.update(repr(obj).encode("utf-8"))

    update(dataset)
    return h.hexdigest()


digest = hash_dataset("hugedataset.parquet", algorithm="blake2b")

Étape 4 : Écrivez, signez et publiez une transaction avec le hachage de notre ensemble de données.

En utilisant le web3.py bibliothèque, nous pouvons structurer notre transaction comme un dict python, puis la publier sur le réseau.

Nous avons besoin d’un fournisseur pour diffuser notre transaction (nous n’avons pas de nœud). Ici, nous utilisons Infuramais il y en a d’autres, comme Alchimie

Notez simplement que nous ajoutons un bit zéro « 0x » au hachage calculé sur notre ensemble de données. Nous devons le supprimer lorsque nous validons notre hachage.

from web3 import Web3 
w3 = Web3(Web3.HTTPProvider("https://sepolia.infura.io/v3/YOUR_KEY")) 
dataset_hash = "0x" + digest
 
account = w3.eth.account.from_key("YOUR_PRIVATE_KEY") 

tx = { 
	"to": account.address, # self-send (no contract required) 
	"value": 0, # no ETH transfer 
	"gas": 50_000, 
	"maxFeePerGas": w3.to_wei("20", "gwei"), 
	"maxPriorityFeePerGas": w3.to_wei("2", "gwei"),
	"nonce": w3.eth.get_transaction_count(account.address), 
	"chainId": 11155111, # Sepolia testnet 
	"data": dataset_hash 
}

Signez-le et envoyez-le. Ici, on attend que la transaction soit finalisée.

signed_tx = account.sign_transaction(tx)

tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
print("Broadcast tx hash:", tx_hash.hex())

# Wait for mining / inclusion in a block
tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)

print("Transaction mined in block:", tx_receipt["blockNumber"])
print("Status:", tx_receipt["status"])

Assurez-vous de conserver l’identifiant de la transaction.

Étape 5 : Créer un enregistrement de métadonnées à stocker avec notre ensemble de données

Ici, nous créons une simple métadonnée, qui peut être stockée dans une base de données (DynamoDB, MongoDB) ou directement à côté de notre objet de données (S3, Google Cloud Storage).

Les métadonnées pourraient ressembler à ceci :

{
  "dataset_id": "feature_set_v42",
  "dataset_uri": "s3://ml-bucket/features/v42.parquet",
  "dataset_hash": "0x9f3c...ab21",
  "tx_hash": "0x7c1a...e91d",
  "timestamp_unix": 1730000000,
  "hash_algorithm": "blake2b",
  "creator": "0xabc123...",
  "notes": "normalized features"
}

Étape 6 : À chaque lecture de l’ensemble de données, validez que le hachage correspond au hachage d’origine stocké à côté de nos données

La dernière étape du processus combine trois actions :

1. Récupérer la transaction Ethereum
2. Extraire le hachage de l’ensemble de données des données d’appel
3. Comparez-le à un hachage recalculé localement

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://sepolia.infura.io/v3/YOUR_KEY"))

def verify_dataset(dataset_path, tx_hash):
    tx = w3.eth.get_transaction(tx_hash)

    raw_input = tx["input"]
    onchain_hash = raw_input.hex() if hasattr(raw_input, 'hex') else str(raw_input).lower()

    computed_hash = "0x" + hash_dataset(dataset_path).lower()

    if computed_hash != onchain_hash:
        raise ValueError(f"Integrity FAILED: Local {computed_hash} != On-chain {onchain_hash}")
    
    print("Integrity check PASSED. Dataset matches the blockchain record.")
    return True

C’est ça!

Une remarque importantecela n’empêche personne de réécrire notre objet métadonnées. Cependant, il existe de nombreuses façons d’empêcher la modification d’un petit élément de métadonnées en interne, comme les bases de données d’audit ou Verrouillage d’objet S3.

Conclusion

En fin de compte, l’utilisation d’un hachage cryptographique pour vérifier l’intégrité des ensembles de données constitue une approche légère à un problème grave.

Certaines extensions naturelles incluent l’utilisation de cette méthode pour vérifier les poids du modèle, ou même le hachage de morceaux de code source pour garantir la pertinence du prétraitement.

Que vous collaboriez entre des équipes distribuées et open source, que vous construisiez des recherches reproductibles ou que vous créiez simplement une piste d’audit pour la conformité, la blockchain est un notaire agréable et impartial pour vos données. Vous n’avez pas besoin de faire confiance à l’infrastructure ; il vous suffit de faire confiance aux mathématiques.