Partager via

Utiliser des modèles chiffrés avec Windows ML

Il existe plusieurs méthodes statiques que nous pouvons appliquer à la classe LearningModel pour charger des modèles Machine Learning tels que charger le modèle à partir d’un fichier dans votre application, à partir d’un fichier sur disque ou charger un modèle à partir d’un flux.

Le chargement à partir d’une méthode de flux permet un meilleur contrôle sur le modèle. Dans ce cas, vous pouvez choisir d’avoir le modèle chiffré sur le disque et de le déchiffrer uniquement en mémoire avant d’appeler l’une des méthodes LoadFromStream.

Dans ce tutoriel, vous allez apprendre à intégrer un modèle Machine Learning chiffré à l’application Windows ML (C#).

Les API Windows ML ne fournissent pas de service de chiffrement Machine Learning et ne sont pas tenues responsables des dommages ou de la perte d’un type quelconque.

Obtenir un modèle ONNX

Dans ce tutoriel, vous allez utiliser le modèle SqueezeNet au format ONNX pour effectuer le chiffrement, le déchiffrement et le chargement à partir du flux.

Téléchargez ou clonez l’exemple d’application De détection d’objets SqueezeNet à partir de GitHub pour obtenir le modèle SqueezeNet.onnx.

Spécifier les déclarations et variables requises

  1. Copiez les déclarations d’instructions ci-dessous pour obtenir l’accès à toutes les API dont vous aurez besoin :
using System;
using System.Threading.Tasks;
using Windows.AI.MachineLearning;
using Windows.Security.Cryptography;
using Windows.Security.Cryptography.Core;
using Windows.Storage;
using Windows.Storage.Streams;
using Windows.UI.Xaml.Controls;

Vous allez définir deux variables spéciales pour une clé et un vecteur d’initialisation.

La clé est une variable de la classe CryptographicKey, qui représente une paire de clés symétrique (ou asymétrique). Vous aurez besoin d’un objet de cette classe, car vous utiliserez la AsymmetricKeyAlgorithmProvider méthode pour créer ou importer des clés.

Le vecteur d’initialisation est une variable de la classe IBuffer, qui représente un tableau référencé d’octets utilisé par les interfaces de lecture et d’écriture de flux d’octets.

Les variables de classe CryptographicKey et IBuffer sont utilisées pour chiffrer et déchiffrer le flux.

  1. Ajoutez les déclarations de variables suivantes et la classe MainPage après les instructions using à l’intérieur de l’espace de noms de chiffrement.
namespace crypto
{
    /// <summary>
    /// An empty page that can be used on its own or navigated to within a Frame.
    /// </summary>
    public sealed partial class MainPage : Page
    {
        private CryptographicKey _key;
        private IBuffer _initialization_vector;
        public MainPage()
        {
            this.InitializeComponent();

            Run();
        }
    }
}

Chiffrer le modèle

Les API Windows fournissent un ensemble complet de fonctionnalités et de fonctionnalités, qui peuvent améliorer les fonctionnalités de l’ensemble d’API Windows ML. Ici, vous allez utiliser un service de chiffrement et de déchiffrement fourni dans l’ensemble d’API Windows pour produire un flux en mémoire et utiliser les API Windows ML pour charger le modèle à partir de ce flux.

Vous pouvez utiliser n’importe quel service de chiffrement pour chiffrer votre modèle Machine Learning, selon vos besoins. Dans ce tutoriel, nous allons utiliser la méthode de chiffrement : SymmetricAlgorithmNames - .AesCbcPkcs7.

La classe SymmetricAlgorithmNames vous aide à récupérer des algorithmes de clé symétrique pour appliquer le chiffrement de clé symétrique sur votre modèle. Ce type de chiffrement nécessite que la même clé utilisée pour le chiffrement soit également utilisée pour le déchiffrement.

À l’aide de la SymmetricKeyAlgorithmProvider classe, vous pouvez sélectionner un algorithme et créer votre clé. Dans ce tutoriel, nous allons utiliser l’algorithme .AesCbcPkcs7. .

L’algorithme AES_CBC_PKCS7 représente un algorithme AES (Encryption Standard) avancé, associé à un mode de chaînage de blocs de chiffrement et de remplissage PKCS#7.

  1. Le code ci-dessous montre comment générer la clé et chiffrer le modèle.
async Task<IBuffer> EncryptAsync(StorageFile model_file)
{
	// get a buffer for the model file
	var file_buffer = await Windows.Storage.FileIO.ReadBufferAsync(model_file);

	// set up the encryption algorithm
	var algorithm = SymmetricKeyAlgorithmProvider.OpenAlgorithm(SymmetricAlgorithmNames.AesCbcPkcs7);
	uint key_length = 32;
	var key_buffer = CryptographicBuffer.GenerateRandom(key_length);
	_key = algorithm.CreateSymmetricKey(key_buffer);
	_initialization_vector = CryptographicBuffer.GenerateRandom(algorithm.BlockLength);

	// perform the encryption
	var encrypted_buffer = CryptographicEngine.Encrypt(_key, file_buffer, _initialization_vector);

	return encrypted_buffer;
}

[REMARQUE :] Vous souhaitez en savoir plus sur les clés de chiffrement ? Consultez la documentation sur les clés de chiffrement.

Déchiffrer le modèle et charger à partir du flux

Avant de charger le modèle, vous devez le déchiffrer à l’aide de la méthode CryptographicEngine.Decrypt. CryptographicEngine.Decrypt est une méthode pour déchiffrer le contenu précédemment chiffré à l’aide d’un algorithme symétrique ou asymétrique. Lorsque vous appelez la méthode, vous devez fournir la clé générée précédemment.

Pour accéder au modèle déchiffré, vous allez utiliser la InMemoryRandomAccessStream classe, qui fournit un accès aléatoire des données dans les flux d’entrée et de sortie stockés en mémoire au lieu du disque.

À la dernière étape, vous allez créer une session pour charger le modèle à partir du flux à l’aide de la LearningModel.LoadFromStreamAsync méthode. Vous pouvez appeler cette méthode en tant que tâche synchrone ou asynchrone.

Le code ci-dessous montre comment déchiffrer le modèle à l’aide de la clé générée, l’écrire dans un flux, puis charger le modèle à partir du flux.

async Task DecryptAndRunAsync(IBuffer encryptyed_buffer)
{
	// decrypt the buffer
	var decrypted_buffer = CryptographicEngine.Decrypt(_key, encryptyed_buffer, _initialization_vector);

	// write it to a stream
	var decrypted_stream = new InMemoryRandomAccessStream();
	await decrypted_stream.WriteAsync(decrypted_buffer);

	// load the model from the stream
	var model = await LearningModel.LoadFromStreamAsync(RandomAccessStreamReference.CreateFromStream(decrypted_stream));

	// create a session
	var session = new LearningModelSession(model);
}

Exécuter le modèle

Copiez la méthode Run suivante pour appeler les méthodes définies précédemment.

async Task Run()
{

	// get the model file
	var model_file = await StorageFile.GetFileFromApplicationUriAsync(new Uri($"ms-appx:///Assets/SqueezeNet.onnx"));

	// encrypt the model file.
	var encryptyed_buffer = await EncryptAsync(model_file);

	// decrypt the model file and load it
	await DecryptAndRunAsync(encryptyed_buffer);
}

Résumé

Et voilà ! Vous avez correctement chargé le modèle sur votre application Windows ML.

Une fois que vous avez chargé le modèle, vous pouvez continuer à créer une session, lier des entrées et des sorties de modèle et évaluer le modèle pour terminer votre application Windows ML.

Ressources additionnelles

Pour en savoir plus sur les rubriques mentionnées dans ce tutoriel, consultez les ressources suivantes :

  • Last updated on