Implantar o modelo de análise de dados no aplicativo Windows com APIs do Windows ML

Na parte anterior deste tutorial, você aprendeu a criar e exportar um modelo no formato ONNX. Agora, mostraremos como inserir seu modelo exportado em um aplicativo do Windows e executá-lo localmente em um dispositivo chamando APIs do Windows ML.

Quando terminarmos, você terá um aplicativo de análise de dados em funcionamento.

Sobre o aplicativo de exemplo

Nesta etapa do tutorial, você criará um aplicativo que pode analisar dados tabulares do Irises. O aplicativo permitirá que você adicione o arquivo do Excel com as informações de entrada necessárias ou insira manualmente os parâmetros de entrada – o comprimento e a largura do sepal e da pétala de Iris em cm. Esses recursos serão processados por um modelo ONNX de rede neural armazenado localmente criado e treinado na parte anterior. Com base na saída do modelo, o aplicativo exibirá o tipo iris correto.

Aqui, nós vamos guiá-lo por esse processo.

Observação

Se você optar por usar o exemplo de código predefinido, poderá clonar o arquivo de solução. Clone o repositório, navegue até este exemplo e abra o arquivo Iris Data Analysis.csproj com o Visual Studio. Vá diretamente para a parte Iniciar o aplicativo desta página para vê-lo em uso.

Abaixo, guiaremos como criar seu aplicativo e adicionar o código do Windows ML.

Criar um aplicativo da Área de Trabalho do Windows ML (C#)

Para criar um aplicativo windows ML em funcionamento, você precisará fazer o seguinte:

• Carregue um modelo de machine learning.
• Associe as entradas e saídas do modelo.
• Avalie o modelo e exiba resultados significativos.

Você também precisará criar uma interface do usuário básica para fornecer uma melhor experiência do usuário.

Abrir um novo projeto no Visual Studio

1. Vamos começar. Abra o Visual Studio e escolha Create a new project.

2. Na barra de pesquisa, escolha C# como seu idioma, Windows como sua plataforma de destino e Dektop como o tipo de projeto. Selecione NUnit Test Project (.NET Core) como o tipo de projeto e selecione next para abrir uma janela de configuração para o projeto.

3. Na janela de configuração, faça o seguinte:

• Nomeie o projeto. Aqui, chamamos de Análise de Dados Iris.
• Escolha o local do projeto.
• Se você está usando o VS2019, verifique se Create directory for solution está marcado.
• Se você estiver usando o VS2017, verifique se Place solution and project in the same directory está desmarcado.

Pressione create para criar o projeto. A janela de versão de destino mínima pode aparecer. Verifique se sua versão mínima está definida como Windows 10, versão 1809 (10.0; build 17763) ou superior.

4. Depois que o projeto for criado, navegue até a pasta do projeto, abra a pasta [….\DataClassifier\Assets] e copie o Network.onnx arquivo para esse local.

Explorar a solução de projeto

Vamos explorar sua solução de projeto.

O Visual Studio criou automaticamente vários arquivos cs-code dentro do Gerenciador de Soluções. MainPage.xaml contém o código XAML para sua GUI e MainPage.xaml.cs contém o código do aplicativo. Se você já criou um aplicativo UWP antes, esses arquivos devem ser muito familiares para você.

Embora tenhamos adicionado nosso Network.onnx arquivo à pasta de ativos, precisamos adicioná-lo corretamente a este projeto.

1. Clique com o botão direito do mouse na pasta Ativos no Gerenciador de Soluções e selecione Add > Existing Item.
2. Navegue até a pasta Ativos dentro Iris Data Analysis [….\Iris Data Analysis \Assets], localize o Network.onnx model que você copiou anteriormente e selecione Add.
3. Para garantir que o modelo seja criado ao compilar seu aplicativo, clique com o botão direito no arquivo Network.onnx e selecione Properties. Defina o Build Action para Content.

Você também precisará criar um novo arquivo de classe cs-code para acomodar algum código de aprendizado de máquina extra, que inclui classes e métodos que chamarão APIs do Windows ML.

4. Clique com o botão direito do mouse no nome da solução no Visual Studio e escolha add e new item. Na janela aberta, selecione Class e dê-lhe um nome - aqui, usamos IrisModel.cs. Um novo arquivo de classe aparecerá no projeto.

.

Criar código do Machine Learning

Nesta etapa, criaremos todas as classes e métodos que chamarão as APIs do Windows Machine Learning. Isso permitirá que você carregue, associe e avalie um modelo de machine learning onnx em seu projeto.

1. Clique duas vezes no IrisModel.cs arquivo.

2. Substitua as instruções using pelo indicado a seguir para ter acesso a todas as APIs necessárias.

using System;
using System.Linq;
using System.Threading.Tasks;
using Windows.AI.MachineLearning;
using Windows.Storage;

Inicializar classes de machine learning

Precisaremos adicionar várias classes a IrisModel.cs para ajudá-lo a interagir com as APIs do Windows Machine Learning.

Para obter acesso ao modelo de machine learning treinado, usaremos a LearningModel classe. Essa classe faz parte do Windows.AI.MachineLearning namespace e representa um modelo de machine learning treinado. Uma vez instanciado, o LearningModel é o objeto inicial usado para interagir com as APIs do Windows ML.

Para avaliar o modelo de aprendizado, você precisará criar uma sessão de avaliação. Para fazer isso, use a LearningModelSession classe. Essa classe é usada para avaliar modelos de machine learning e associa o modelo a um dispositivo que, em seguida, executa e avalia o modelo. Ao criar uma sessão com essa API, você também pode selecionar um dispositivo para executar seu modelo (o padrão é sua CPU).

Além disso, você precisará especificar os rótulos da saída de seus modelos de machine learning. Você pode conectar esses rótulos à saída prevista do modelo mais tarde.

Observação

Para saber mais sobre LearningModel e LearningModelSession classes, examine a documentação da classe LearningModel e a documentação da classe LearningModelSession.

3. Copie o código a seguir para o IrisModel.cs arquivo.

class IrisModel
    {
        private LearningModel _learning_model;
        private LearningModelSession _session;
        private String[] _labels = { "Iris-setosa", "Iris-versicolor", "Iris-virginica"};

Carregar o modelo

Em seguida, você precisará carregar o modelo de machine learning e criar uma sessão, o que você fará com as classes que acabou de definir. Para carregar o modelo, você usará vários métodos estáticos da LearningModel classe. Em nosso caso, usaremos LoadFromStorageFileAsync, que permite carregar um modelo ONNX de forma ISorageFile assíncrona.

Observação

Para saber mais sobre maneiras adicionais de carregar o modelo, examine a documentação Carregar um Modelo.

1. Copie o código a seguir para o IrisModel.cs arquivo.

public async Task Initialize()
{
    // Load and create the model and session
    var modelFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri($"ms-appx:///Assets//Network.onnx"));
    _learning_model = await LearningModel.LoadFromStorageFileAsync(modelFile);
    _session = new LearningModelSession(_learning_model);
}

Definir o tensor de entrada do modelo

Agora, definiremos a entrada correta com base em seus requisitos de modelo. O modelo de rede criado na parte anterior tem quatro valores de entrada. Cada valor de entrada representa os tamanhos possíveis de quatro características de íris: comprimento do sepal em cm, largura do sepal em cm, comprimento da pétala em cm e largura da pétala em cm. Com base nessa entrada, o modelo retornará o tipo de íris que melhor se ajusta a esses parâmetros. Você precisará limitar o tamanho dos valores de entrada aos valores lógicos válidos – para este tutorial, usaremos o seguinte:

• comprimento da sépala - 1cm a 100cm
• largura do sepal – 1cm a 8cm
• comprimento da pétala – 0,5cm a 10cm
• Largura da pétala – 0,1cm a 5cm

1. Copie o código a seguir para o IrisModel.cs arquivo.

private float _sepal_length = 1.0f;
public float Sepal_Length
{
    get
    {
        return _sepal_length;
    }
    set
    {
        // validate range [1,10]
        if (value >= 1 && value <= 10)
        {
            _sepal_length = value;
        }
    }
}

private float _sepal_width = 1.0f;
public float Sepal_Width
{
    get
    {
        return _sepal_width;
    }
    set
    {
        // validate range [1, 8]
        if (value >= 1 && value <= 8)
        {
            _sepal_width = value;
        }
    }
}

private float _petal_length = 0.5f;
public float Petal_Length
{
    get
    {
        return _petal_length;
    }
    set
    {
        // validate range [0.5, 10]
        if (value >= 0.5 && value <= 10)
        {
            _petal_length = value;
        }
    }
}

private float _petal_width = 0.1f;
public float Petal_Width
{
    get
    {
        return _petal_width;
    }
    set
    {
        // validate range [0.1, 5]
        if (value >= 0.1 && value <= 5)
        {
            _petal_width = value;
        }
    }
}

As APIs do Windows ML aceitam valores de entrada das quatro classes descritivas compatíveis com modelos ONNX: tensores, sequências, mapas e imagens. Nesse caso, o modelo requer um objeto tensor flutuante de 32 bits em uma forma de float32[batch_size,4]. Como o tamanho do lote é 1, a forma do tensor de entrada é [1x4].

Para criar uma entrada tensor, você usará a classe TensorFloat .

A TensorFloat classe faz parte do Windows.AI.MachineLearning namespace e é usada para definir um objeto tensor flutuante de 32 bits – um tensor de valores de ponto flutuante de 32 bits. Essa classe contém vários métodos úteis para criar um tensor. No seu caso, você usará o método CreateFromArray para criar uma entrada tensor no tamanho exato exigido pelo modelo. Adicionaremos essa chamada dentro do método de avaliação.

Associar e avaliar o modelo

Agora que você definiu o tensor de entrada do modelo e instanciou o modelo treinado e a sessão, é hora de criar um método para associar e avaliar o modelo de machine learning treinado.

Esse método é a parte chave de um aplicativo de machine learning. Ele inclui a tensorização dos valores de entrada e a associação da entrada do modelo. Você usará esse modelo posteriormente no código do aplicativo para avaliar seu modelo.

Para associar entrada e saída, use a LearningModelBinding classe. Um modelo de machine learning tem recursos de entrada e saída, que transmitem informações para dentro e para fora do modelo. Lembre-se de que os recursos necessários devem ser compatíveis com as APIs do Windows ML. A LearningModelBinding classe é aplicada em um LearningModelSession para associar valores a recursos de entrada e saída nomeados.

A LearningModelBinding classe tem vários métodos predefinidos que você pode usar para associar valores a esses recursos nomeados. Aqui, você usará o Bind método para associar valores ao seu modelo.

Para avaliar seu modelo e receber resultados dele, você chama os métodos de avaliação predefinidos relevantes de LearningModelSession – no seu caso, o método Evaluate. Esse método fornecerá a funcionalidade necessária, avaliando o modelo de machine learning usando os valores de recurso fornecidos pela LearningModelBinding classe.

Observação

Para saber mais sobre outros métodos de avaliação para executar o modelo, verifique quais métodos podem ser implementados no LearningModelSession examinando a documentação da Classe LearningModelSession.

Extrair e exibir os resultados

O modelo retorna os valores previstos no formato de tensor como uma saída de tensor flutuante. Agora você precisará extrair a saída do modelo e exibir os resultados certos. Para fazer isso, você converterá o formato tensor em um vetor executando a GetAsVectorView() função na saída predefinida.

O modelo retorna três valores de probabilidade, cada um representando um tipo de íris específico. Você precisará retornar o rótulo com a maior probabilidade.

1. Copie o código a seguir para o IrisModel.cs arquivo.

internal String Evaluate()
{
    // input tensor shape is [1x4]
    long[] shape = new long[2];
    shape[0] = 1;
    shape[1] = 4;

    // set up the input tensor
    float[] input_data = new float[4];
    input_data[0] = _sepal_length;
    input_data[1] = _sepal_width;
    input_data[2] = _petal_length;
    input_data[3] = _petal_width;
    TensorFloat tensor_float = TensorFloat.CreateFromArray(shape, input_data);

    // bind the tensor to "input"
    var binding = new LearningModelBinding(_session);
    binding.Bind("input", tensor_float);

    // evaluate
    var results = _session.Evaluate(binding, "");

    // get the results
    TensorFloat prediction = (TensorFloat)results.Outputs.First().Value;
    var prediction_data = prediction.GetAsVectorView();

    // find the highest predicted value
    int max_index = 0;
    float max_value = 0;
    for (int i = 0; i < prediction_data.Count; i++)
    {
        var val = prediction_data.ElementAt(i);
        if (val > max_value)
        {
            max_value = val;
            max_index = i;
        }
    }

    // return the label corresponding to the highest predicted value
    return _labels.ElementAt(max_index);
}

Agora você concluiu a parte de aprendizado de máquina do seu código. Agora, você pode integrar facilmente seu modelo ao aplicativo Windows. Na última parte deste tutorial, fornecemos uma GUI básica do Windows e um código de controle para testar o modelo, usando os métodos que você já criou.

Criar a GUI do aplicativo

1. Para criar um código de aplicativo gui para seu aplicativo, clique duas vezes no MainPage.xaml arquivo de código e abra um modelo predefinido para sua GUI.

2. Copie e cole o código abaixo para MainPage.xaml, na “Background="{ThemeResource ApplicationPageBackgroundThemeBrush}" " Height="939"> linha.

    <Grid Margin="30,30,30,30">
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <TextBlock x:Name="title" HorizontalAlignment="Left" Text="Data Analysis App - Windows ML" TextWrapping="Wrap" VerticalAlignment="Top" FontSize="32" TextDecorations="Underline" FontWeight="Bold"/>
        <TextBlock x:Name="subtitle" HorizontalAlignment="Left" Text="Provide the input :" TextWrapping="Wrap" VerticalAlignment="Top" FontSize="20" Grid.Row="1" FontWeight="Bold"/>
        <Grid Grid.Row="2">
            <Grid.RowDefinitions>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
                <RowDefinition Height="Auto"/>
            </Grid.RowDefinitions>
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto"/>
                <ColumnDefinition Width="Auto"/>
            </Grid.ColumnDefinitions>
            <TextBlock x:Name="sepal_length" Text="sepal length in mm [range of 10 - 100]:" VerticalAlignment="Center"/>
            <TextBlock x:Name="sepal_width" Text="sepal width in mm [range of 10 - 80]:" VerticalAlignment="Center" Grid.Row="1"/>
            <TextBlock x:Name="petal_length" Text="petal length in mm [range of 5 - 100]:" VerticalAlignment="Center" Grid.Row="2"/>
            <TextBlock x:Name="petal_width" Text="sepal width in mm [range of 1 - 50]:" VerticalAlignment="Center" Grid.Row="3"/>

            <Slider x:Name="sepal_length_input" Minimum="10" Maximum="100" Orientation="Horizontal" Grid.Column="1" Width="200" ValueChanged="sepal_length_input_ValueChanged"/>
            <Slider x:Name="sepal_width_input" Minimum="10" Maximum="80" Orientation="Horizontal" Grid.Row="1" Grid.Column="1" Width="200" ValueChanged="sepal_width_input_ValueChanged"/>
            <Slider x:Name="petal_length_input" Minimum="5" Maximum="100" Orientation="Horizontal" Grid.Row="2" Grid.Column="1" Width="200" ValueChanged="petal_length_input_ValueChanged"/>
            <Slider x:Name="petal_width_input" Minimum="1" Maximum="50" Orientation="Horizontal" Grid.Row="3" Grid.Column="1" Width="200" ValueChanged="petal_width_input_ValueChanged"/>
        </Grid>
        <TextBlock x:Name="output" Text="Output:" FontSize="20" FontWeight="Bold" Grid.Row="3"/>
        <Grid Grid.Row="4">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto"/>
                <ColumnDefinition Width="Auto"/>
            </Grid.ColumnDefinitions>
            <TextBlock x:Name="output_subtitle" Text="Based on the information provided, the Iris type is:"/>
            <TextBlock x:Name="model_output" Text="Model output" FontStyle="Italic"  Grid.Column="1" Margin="10,0,0,0"/>
        </Grid>
    </Grid>

Criar o controle de aplicativo

O código de controle do aplicativo inclui MainPage.xaml.cso método principal para executar o aplicativo e várias etapas para executar seu modelo e executar a saída:

1. Você criará uma instância de um novo objeto da IrisModel classe que você havia criado anteriormente neste tutorial.
2. Você chamará o método Evaluate() criado na parte anterior no modelo. Esse método será aplicado quatro vezes, uma em cada um dos parâmetros de entrada: comprimento do sepal, largura do sepal, comprimento da pétala e largura da pétala.

O aplicativo exibirá o resultado com base no algoritmo de previsão de aprendizado de máquina.

1. Para criar um código de controle de aplicativo, clique duas vezes no MainPage.xaml.cs arquivo de código e adicione o código a seguir.

using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
// The Blank Page item template is documented at https://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409

namespace Iris_Data_Analysis
{
    /// <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 IrisModel _iris_model;

        public MainPage()
        {
            this.InitializeComponent();
            _iris_model = new IrisModel();
#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
            _iris_model.Initialize();
#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
        }

        private void sepal_length_input_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (_iris_model != null)
            {
                _iris_model.Sepal_Length = (float)sepal_length_input.Value / 10.0f;
                model_output.Text = _iris_model.Evaluate();
            }
        }

        private void sepal_width_input_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (_iris_model != null)
            {
                _iris_model.Sepal_Width = (float)sepal_width_input.Value / 10.0f;
                model_output.Text = _iris_model.Evaluate();
            }
        }

        private void petal_length_input_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (_iris_model != null)
            {
                _iris_model.Petal_Length = (float)petal_length_input.Value / 10.0f;
                model_output.Text = _iris_model.Evaluate();
            }
        }

        private void petal_width_input_ValueChanged(object sender, RangeBaseValueChangedEventArgs e)
        {
            if (_iris_model != null)
            {
                _iris_model.Petal_Width = (float)petal_width_input.Value / 10.0f;
                model_output.Text = _iris_model.Evaluate();
            }
        }
    }
}

Iniciar o aplicativo

Agora você está pronto para iniciar seu aplicativo e ver os resultados.

Habilite o modo de desenvolvedor e teste seu aplicativo no Visual Studio. Verifique se os menus suspensos na barra de ferramentas superior estão definidos como Debug. Altere a Plataforma de Solução para x64 para executar o projeto no computador local se seu dispositivo for de 64 bits ou x86 se for de 32 bits.

A GUI do aplicativo inclui quatro controles deslizantes para alterar a entrada dos parâmetros necessários. Qualquer alteração na entrada gerará uma nova saída com base no algoritmo de previsão. A saída é exibida abaixo dos deslizadores de entrada.

Você pode ver que, dada a entrada de comprimento da sépala = 40 mm, largura da sépala = 50, comprimento da pétala = 75 e largura da pétala = 15, o aplicativo gerou uma entrada do tipo Iris-versicolor!

Resumo

Você acabou de criar seu primeiro aplicativo do Windows Machine Learning, desde a criação de modelos até a execução bem-sucedida.

Recursos adicionais

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

• Ferramentas do Windows ML: conheça mais ferramentas como o Painel do Windows ML, o WinMLRunner e o gerador de código do Windows ML mlgen.
• Modelo ONNX: saiba mais sobre o formato ONNX.
• Desempenho e memória do Windows ML: saiba mais sobre como gerenciar o desempenho do aplicativo com o Windows ML.
• Referência da API do Windows Machine Learning: saiba mais sobre três áreas de APIs do Windows ML.