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

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

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

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 excel com as informações de entrada necessárias ou insira manualmente os parâmetros de entrada - o comprimento e a largura da sépala e pétala de Iris em cm. Esses recursos serão processados por um modelo ONNX de rede neural armazenado localmente que você construiu e treinou na parte anterior. Com base na saída do modelo, o aplicativo exibirá o tipo de íris correto.

Aqui, vamos orientá-lo através desse 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 Iris Data Analysis.csproj arquivo com o Visual Studio. Pule para a parte Iniciar a Aplicação desta página para vê-lo em uso.

Abaixo, vamos orientá-lo sobre como criar seu aplicativo e adicionar o código de ML do Windows.

Criar um aplicativo de área de trabalho do Windows ML (C#)

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

Carregue um modelo de aprendizado de máquina.
Vincule 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 ao usuário.

Abrir um novo projeto no Visual Studio

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

Criar novo projeto do Visual Studio

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

Criar novo aplicativo NUnit Test Project

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

Atribua um nome ao seu projeto. Aqui, chamamos isso de Análise de Dados Iris.
Escolha a localização do seu projeto.
Se você estiver 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 seu projeto. A janela da versão de destino mínima pode aparecer. Certifique-se de que a sua versão mínima está definida para Windows 10, versão 1809 (10.0; build 17763) ou superior.

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.

Explore a solução do projeto

Vamos explorar a solução do seu projeto.

O Visual Studio criou automaticamente vários arquivos de código cs, 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.

Clique com o botão direito do mouse na pasta Ativos no Gerenciador de Soluções e selecione Add > Existing Item.
Navegue até a pasta Ativos dentro de Iris Data Analysis [….\Iris Data Analysis \Assets], encontre o Network.onnx model que você copiou anteriormente lá e selecione Add.
Para garantir que o modelo seja compilado ao compilar a sua aplicação, clique com o botão direito do rato no ficheiro Network.onnx e selecione Properties. Defina o Build Action como 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 de ML do Windows.

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 ficheiro de classe aparecerá no seu projeto.

Adicione um novo arquivo de classe ao seu projeto VS .

Criar código de Aprendizado de Máquina

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

Clique duas vezes no IrisModel.cs arquivo.
Substitua as instruções using pelo seguinte, para obter acesso a todas as APIs necessárias.

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

Inicializar aulas de aprendizado de máquina

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

Para ter acesso ao modelo de aprendizado de máquina treinado, usaremos a LearningModel classe. Essa classe faz parte do Windows.AI.MachineLearning namespace e representa um modelo de aprendizado de máquina treinado. Uma vez instanciado, o é o LearningModel objeto principal que você usa para interagir com APIs de ML do Windows.

Para avaliar o modelo de aprendizagem, terá de criar uma sessão de avaliação. Para fazer isso, você usa a LearningModelSession classe. Essa classe é usada para avaliar modelos de aprendizado de máquina e vincula 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 aprendizado de máquina. Você pode conectar essas etiquetas à saída prevista do modelo mais tarde.

Observação

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

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

Carregue o modelo

Em seguida, você precisará carregar o modelo de aprendizado de máquina e criar uma sessão, o que será feito com as classes que acabou de definir. Para carregar o modelo, você usará vários métodos estáticos da LearningModel classe - no 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, consulte a documentação de Carregamento de um modelo.

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 nos requisitos do seu 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 das íris: comprimento da sépala em cm, largura da sépala 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 encaixa nesses 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 da sépala – 1 cm a 8 cm
comprimento da pétala – 0.5cm a 10cm
largura da pétala – 0.1cm a 5cm

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 suportadas pelos modelos ONNX: tensores, sequências, mapas e imagens. Neste caso, o modelo requer um objeto float tensor de 32 bits em forma de float32[batch_size,4]. Como o tamanho do lote é 1, a forma do tensor de entrada é [1x4].

Para criar uma entrada tensora, 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. Esta classe contém vários métodos úteis para construir um tensor. No seu caso, você usará o método CreateFromArray para criar uma entrada tensor no tamanho exato que seu modelo exige. Adicionaremos essa chamada dentro do método de avaliação.

Vincular 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 vincular e avaliar o modelo de aprendizado de máquina treinado.

Esse método é a parte fundamental de um aplicativo de aprendizado de máquina. Inclui a tensorização dos valores de entrada e a ligação da entrada do modelo. Você usará esse modelo posteriormente no código do aplicativo para avaliar o modelo.

Para vincular entrada e saída, use a LearningModelBinding classe. Um modelo de aprendizado de máquina tem recursos de entrada e saída, que passam informações para dentro e para fora do modelo. Lembre-se de que os recursos necessários devem ser suportados pelas APIs de ML do Windows. A LearningModelBinding classe é aplicada em um LearningModelSession para vincular valores a recursos de entrada e saída nomeados.

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

Para avaliar o seu modelo e receber resultados dele, você chama os métodos de avaliação predefinidos de LearningModelSession - no seu caso, o método Evaluate. Esse método fornecerá a funcionalidade que você precisa, avaliando o modelo de aprendizado de máquina 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 em formato tensor, como uma saída do tensor em ponto flutuante. Agora você precisará extrair a saída do modelo e exibir os resultados corretos. Para fazer isso, você converterá o formato tensor em um vetor executando a GetAsVectorView() função na saída predicada.

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

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 facilmente integrar seu modelo com o aplicativo do 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

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.
Copie e cole o código abaixo para MainPage.xaml, abaixo da “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, MainPage.xaml.cs, inclui o método principal para executar o aplicativo e várias etapas para executar seu modelo e executar a saída:

Você instanciará um novo objeto da IrisModel classe que você criou anteriormente neste tutorial.
Irá chamar o método Evaluate() que construiu na parte anterior sobre o modelo. Este método será aplicado quatro vezes, uma em cada um dos parâmetros de entrada: comprimento da sépala, largura da sépala, 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.

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

Inicie o aplicativo

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

Habilite o modo de desenvolvedor e teste seu aplicativo do 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 em sua máquina local se o 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 irá gerar uma nova saída com base no algoritmo de previsão. A saída é exibida abaixo dos controles deslizantes de entrada.

Pode ver que, com a entrada de comprimento da sépala = 40mm, largura da sépala = 50mm, comprimento da pétala = 75mm e largura da pétala = 15mm, o aplicativo gerou uma classificação do tipo Iris-versicolor!

Classificação bem-sucedida em seu aplicativo

Resumo

Você acabou de criar seu primeiro aplicativo de Aprendizado de Máquina do Windows, desde a criação do modelo até a execução bem-sucedida.

Recursos adicionais

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

Ferramentas de ML do Windows: saiba mais ferramentas como o Painel de ML do Windows, o WinMLRunner e o gerador de códigos mglen Windows ML.
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 das APIs de ML do Windows.

Feedback

Esta página foi útil?

Last updated on 2025-05-01

Partilhar via

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

Sobre o aplicativo de exemplo

Criar um aplicativo de área de trabalho do Windows ML (C#)

Abrir um novo projeto no Visual Studio

Explore a solução do projeto

Criar código de Aprendizado de Máquina

Inicializar aulas de aprendizado de máquina

Carregue o modelo

Definir o tensor de entrada do modelo

Vincular e avaliar o modelo

Extrair e exibir os resultados

Criar a GUI do aplicativo

Criar o controle de aplicativo

Inicie o aplicativo

Resumo

Recursos adicionais

Feedback

Recursos adicionais