Compartilhar via

Usar modelos criptografados com o Windows ML

Há vários métodos estáticos que podemos aplicar na classe LearningModel para carregar modelos de machine learning, como carregar o modelo de um arquivo em seu aplicativo, de um arquivo em disco ou carregar um modelo de um fluxo.

O carregamento a partir de um método de fluxo permite um controle melhor sobre o modelo. Nesse caso, você pode optar por ter o modelo criptografado em disco e descriptografá-lo somente na memória antes de chamar um dos métodos LoadFromStream.

Neste tutorial, você aprenderá a integrar um modelo de machine learning criptografado ao aplicativo Windows ML (C#).

As APIs do Windows ML não fornecem serviço de criptografia de machine learning e não serão responsabilizadas por nenhum dano ou perda de qualquer tipo.

Obter o modelo ONNX

Neste tutorial, você usará o modelo SqueezeNet no formato ONNX para executar a criptografia, a descriptografia e a carga do fluxo.

Baixe ou clone o aplicativo de exemplo de Detecção de Objetos SqueezeNet do GitHub para obter o modelo SqueezeNet.onnx.

Especificar as declarações e variáveis necessárias

  1. Copie o seguinte usando declarações de instruções para obter acesso a todas as APIs de que você precisará:
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;

Você definirá duas variáveis especiais para uma chave e um vetor de inicialização.

A chave é uma variável da classe CryptographicKey, que representa um par de chaves simétrico (ou assimétrico). Você precisará de um objeto dessa classe, pois usará o AsymmetricKeyAlgorithmProvider método para criar ou importar chaves.

O vetor de inicialização é uma variável da classe IBuffer, que representa uma matriz referenciada de bytes usados por interfaces de leitura e gravação de fluxo de bytes.

Ambas as variáveis de classe CryptographicKey e IBuffer são usadas para criptografar e descriptografar o fluxo.

  1. Adicione as seguintes declarações de variável e a MainPage classe após as instruções de uso dentro do namespace de criptografia:
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();
        }
    }
}

Criptografar o modelo

As APIs do Windows fornecem um conjunto avançado de funcionalidades e recursos, que podem aprimorar a funcionalidade do conjunto de APIs do Windows ML. Aqui, você usará um serviço de criptografia e descriptografia fornecido no conjunto de API do Windows para produzir um fluxo na memória e usará APIs do Windows ML para carregar o modelo desse fluxo.

Você pode usar qualquer serviço de criptografia para criptografar seu modelo de machine learning, de acordo com sua conveniência. Neste tutorial, usaremos o método de criptografia – SymmetricAlgorithmNames - .AesCbcPkcs7.

A classe SymmetricAlgorithmNames ajuda você a recuperar algoritmos de chave simétrica para aplicar criptografia de chave simétrica em seu modelo. Esse tipo de criptografia requer que a mesma chave usada para criptografia também seja usada para descriptografia.

Usando a SymmetricKeyAlgorithmProvider classe, você pode selecionar um algoritmo e criar sua chave. Neste tutorial, usaremos o .AesCbcPkcs7. algoritmo.

O AES_CBC_PKCS7 algoritmo representa um algoritmo AES (Encryption Standard) avançado, juntamente com um modo de operação de encadeamento de blocos de criptografia e preenchimento PKCS#7.

  1. O código a seguir mostra como gerar a chave e criptografar o modelo.
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;
}

[OBSERVAÇÃO!] Interessado em saber mais sobre chaves criptográficas? Examine a documentação de chaves criptográficas.

Descriptografar o Modelo e carregar do fluxo de dados

Antes de carregar o modelo, você precisa descriptografá-lo usando o método CryptographicEngine.Decrypt. CryptographicEngine.Decrypt é um método para descriptografar o conteúdo que foi criptografado anteriormente usando um algoritmo simétrico ou assimétrico. Ao chamar o método, você precisará fornecer a chave gerada anteriormente.

Para acessar o modelo descriptografado, você usará a InMemoryRandomAccessStream classe, que fornece acesso aleatório de dados em fluxos de entrada e saída armazenados na memória em vez de em disco.

Como última etapa, você criará uma sessão para carregar o modelo do fluxo usando o LearningModel.LoadFromStreamAsync método. Você pode chamar esse método como uma tarefa síncrona ou assíncrona.

O código a seguir mostra como descriptografar o modelo usando a chave gerada, gravá-lo em um fluxo e, em seguida, carregar o modelo do fluxo.

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);
}

Executar o modelo

Copie o método Executar a seguir para chamar os métodos definidos anteriormente.

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);
}

Resumo

É isso! Você carregou com êxito o modelo em seu aplicativo do Windows ML.

Depois de carregar o modelo, você pode continuar a criar uma sessão, associar entradas e saídas de modelo e avaliar o modelo para concluir seu aplicativo do Windows ML.

Recursos adicionais

Para saber mais sobre os tópicos mencionados neste tutorial, visite os seguintes recursos:

  • Last updated on