Implantar seu modelo em um aplicativo do Windows com as APIs do Windows Machine Learning

Na parte anterior deste tutorial, você aprendeu a criar e exportar um modelo no formato ONNX. Agora que você tem esse modelo, pode inserê-lo em um aplicativo do Windows e executá-lo localmente em um dispositivo chamando APIs WinML.

Quando terminarmos, você terá um aplicativo UWP (WinML) classificador de imagem funcional.

Sobre o aplicativo de amostra

Usando nosso modelo, criaremos um aplicativo que pode classificar imagens de alimentos. Ele permite que você selecione uma imagem do seu dispositivo local e processe-a por um modelo ONNX de classificação armazenado localmente criado e treinado na parte anterior. As marcas retornadas são exibidas ao lado da imagem, bem como a probabilidade de confiança da classificação.

Se você estiver seguindo este tutorial até agora, já deverá ter os pré-requisitos necessários para o desenvolvimento de aplicativos preparados. Se você precisar de um atualizador, consulte a primeira parte deste tutorial.

Observação

Se você preferir baixar o código de exemplo completo, poderá clonar o arquivo de solução. Clone o repositório, navegue até este exemplo e abra o arquivo ImageClassifierAppUWP.sln com o Visual Studio. Em seguida, você pode pular para a etapa [Iniciar o aplicativo](#Iniciar-o-aplicativo).

Crie um aplicativo UWP com WinML (C#)

Abaixo, mostraremos como criar seu aplicativo e código WinML do zero. Você aprenderá a:

Carregar um modelo de machine learning.
Carregue uma imagem no formato necessário.
Associe as entradas e saídas do modelo.
Avaliar o modelo e exibir os resultados significativos.

Você também usará XAML básico para criar uma GUI simples, para que você possa testar o classificador de imagem.

Criar o aplicativo

Abra o Visual Studio e escolha create a new project.

Criar um novo projeto do Visual Studio

Na barra de pesquisa, digite UWP e selecione Blank APP (Universal Windows). Isso abre um novo projeto em C# para um aplicativo UWP (Plataforma Universal do Windows) de página única que não tem controles ou layout predefinidos. Selecione Next para abrir uma janela de configuração para o projeto.

Criar um novo aplicativo UWP

Na janela de configuração:

Escolha um nome para seu projeto. Aqui, usamos ImageClassifierAppUWP.
Escolha o local do projeto.
Se você estiver usando o VS 2019, certifique-se de que Place solution and project in the same directory está desmarcado.
Se você estiver usando o VS 2017, certifique-se de que Create directory for solution está marcado.

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 o Windows 10 build 17763 ou posterior.

Para criar um aplicativo e implantar um modelo com um aplicativo WinML, você precisará do seguinte:

Depois que o projeto foi criado, navegue até a pasta do projeto, abra a pasta de ativos [....\ImageClassifierAppUWP\Assets] e copie o modelo para esse local.
Altere o nome do modelo de model.onnx para classifier.onnx. Isso torna as coisas um pouco mais claras e a alinha ao formato do tutorial.

Explorar seu modelo

Vamos nos familiarizar com a estrutura do arquivo modelo.

Abra o classifier.onnx arquivo de modelo usando o Netron.
Pressione Data para abrir as propriedades do modelo.

Propriedades do modelo

Como você pode ver, o modelo requer um objeto de ponto flutuante tensor de 32 bits (matriz multidimensional) como entrada e retorna duas saídas: o primeiro, chamado classLabel, é um tensor de cadeias de caracteres e o segundo, chamado loss, é uma sequência de mapas de cadeia de caracteres para ponto flutuante que descrevem a probabilidade de cada classificação rotulada. Você precisará dessas informações para exibir com êxito a saída do modelo em seu aplicativo do Windows.

Explorar a solução do 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, esses arquivos devem ser muito familiares.

Criar a GUI do aplicativo

Primeiro, vamos criar uma GUI simples para o aplicativo.

Clique duas vezes no MainPage.xaml arquivo. No aplicativo em branco, o modelo XAML da GUI do aplicativo está vazio, de modo que precisaremos adicionar alguns recursos da interface do usuário.
Adicione o código abaixo ao corpo principal de MainPage.xaml.

<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">

        <StackPanel Margin="1,0,-1,0">
            <TextBlock x:Name="Menu" 
                       FontWeight="Bold" 
                       TextWrapping="Wrap"
                       Margin="10,0,0,0"
                       Text="Image Classification"/>
            <TextBlock Name="space" />
            <Button Name="recognizeButton"
                    Content="Pick Image"
                    Click="OpenFileButton_Click" 
                    Width="110"
                    Height="40"
                    IsEnabled="True" 
                    HorizontalAlignment="Left"/>
            <TextBlock Name="space3" />
            <Button Name="Output"
                    Content="Result is:"
                    Width="110"
                    Height="40"
                    IsEnabled="True" 
                    HorizontalAlignment="Left" 
                    VerticalAlignment="Top">
            </Button>
            <!--Display the Result-->
            <TextBlock Name="displayOutput" 
                       FontWeight="Bold" 
                       TextWrapping="Wrap"
                       Margin="30,0,0,0"
                       Text="" Width="1471" />
            <Button Name="ProbabilityResult"
                    Content="Probability is:"
                    Width="110"
                    Height="40"
                    IsEnabled="True" 
                    HorizontalAlignment="Left"/>
            <!--Display the Result-->
            <TextBlock Name="displayProbability" 
                       FontWeight="Bold" 
                       TextWrapping="Wrap"
                       Margin="30,0,0,0"
                       Text="" Width="1471" />
            <TextBlock Name="space2" />
            <!--Image preview -->
            <Image Name="UIPreviewImage" Stretch="Uniform" MaxWidth="300" MaxHeight="300"/>
        </StackPanel>
    </Grid>

Gerador de código do Windows Machine Learning

O Gerador de Código do Windows Machine Learning, ou mlgen, é uma extensão do Visual Studio para ajudá-lo a começar a usar APIs WinML em aplicativos UWP. Ele gera código de modelo quando você adiciona um arquivo ONNX treinado ao projeto UWP.

O gerador de código do Windows Machine Learning, mlgen, cria uma interface (para C#, C++/WinRT e C++/CX) com classes wrapper que chamam a API do Windows ML para você. Assim, você pode carregar, associar e avaliar facilmente um modelo em seu projeto. Vamos usá-lo neste tutorial para lidar com muitas dessas funções para nós.

O gerador de código está disponível para o Visual Studio 2017 e posterior. Observe que, no Windows 10 versão 1903 e posterior, o mlgen não está mais incluído no SDK do Windows 10, de modo que você precisa baixar e instalar a extensão. Se você estiver acompanhando este tutorial a partir da introdução, já terá lidado com isso, mas caso contrário, deverá baixar para o VS 2019 ou para o VS 2017.

Observação

Para saber mais sobre mlgen, confira a documentação do mlgen

Se ainda não fez isso, instale o mlgen.
Clique com o botão direito do mouse na pasta Assets no Gerenciador de Soluções no Visual Studio e selecione Add > Existing Item.
Navegue até a pasta de ativos dentro de ImageClassifierAppUWP [….\ImageClassifierAppUWP\Assets], localize o modelo ONNX que você copiou nela e selecione add.
Depois de adicionar um modelo ONNX (nome: "classificador") à pasta de ativos no gerenciador de soluções no VS, o projeto agora deve ter dois novos arquivos:

classifier.onnx – o modelo no formato ONNX.
classifier.cs – arquivo de código WinML gerado automaticamente.

Estrutura do projeto com o modelo ONNX adicionado

Para que o modelo seja criado quando você compilar o aplicativo, selecione o arquivo classifier.onnx e escolha Properties. Para Build Action, selecione Content.

Agora, vamos explorar o código recém-gerado no arquivo classifier.cs.

O código gerado inclui três classes:

classifierModel: essa classe inclui dois métodos para instanciação de modelo e avaliação de modelo. Ele nos ajudará a criar a representação do modelo de machine learning, criar uma sessão no dispositivo padrão do sistema, associar as entradas e saídas específicas ao modelo e avaliar o modelo de maneira assíncrona.
classifierInput: essa classe inicializa os tipos de entrada que o modelo espera. A entrada de modelo depende dos requisitos de modelo para dados de entrada. Em nosso caso, a entrada espera um ImageFeatureValue, uma classe que descreve as propriedades da imagem usada para passar para um modelo.
classifierOutput: essa classe inicializa os tipos que o modelo terá como saída. A saída do modelo depende de como ela é definida pelo modelo. Em nosso caso, a saída será uma sequência de mapas (dicionários) do tipo String e TensorFloat (Float32), denominada perda.

Agora você usará essas classes para carregar, associar e avaliar o modelo em nosso projeto.

Carregar o modelo e as entradas

Carregar o modelo

Clique duas vezes no MainPage.xaml.cs arquivo de código para abrir o código do aplicativo.
Substitua as instruções "using" pelo indicado a seguir para ter acesso a todas as APIs que serão necessárias.

// Specify all the using statements which give us the access to all the APIs that you'll need
using System;
using System.Threading.Tasks;
using Windows.AI.MachineLearning;
using Windows.Graphics.Imaging;
using Windows.Media;
using Windows.Storage;
using Windows.Storage.Pickers;
using Windows.Storage.Streams;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Media.Imaging;

Adicione as declarações de variável a seguir após as instruções using dentro da classe MainPage no namespace ImageClassifierAppUWP.

        // All the required variable declaration
        private classifierModel modelGen;
        private classifierInput input = new classifierModelInput();
        private classifierOutput output;
        private StorageFile selectedStorageFile;
        private string result = "";
        private float resultProbability = 0;

O resultado será exibido da seguinte maneira.

// Specify all the using statements which give us the access to all the APIs that we'll need
using System;
using System.Threading.Tasks;
using Windows.AI.MachineLearning;
using Windows.Graphics.Imaging;
using Windows.Media;
using Windows.Storage;
using Windows.Storage.Pickers;
using Windows.Storage.Streams;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Media.Imaging;

namespace ImageClassifierAppUWP
{
    public sealed partial class MainPage : Page
    {
        // All the required fields declaration
        private classifierModel modelGen;
        private classifierInput input = new classifierInput();
        private classifierOutput output;
        private StorageFile selectedStorageFile;
        private string result = "";
        private float resultProbability = 0;

Agora, você vai implementar o método LoadModel. O método acessará o modelo ONNX e o armazenará na memória. Em seguida, você usará o método CreateFromStreamAsync para criar uma instância do modelo como um objeto LearningModel. A classe LearningModel representa um modelo de machine learning treinado. Uma vez instanciado, o LearningModel é o objeto inicial usado para interagir com o Windows ML.

Para carregar o modelo, você pode usar vários métodos estáticos na classe LearningModel. Nesse caso, você usará o método CreateFromStreamAsync.

O método CreateFromStreamAsync foi criado automaticamente com mlgen, portanto, você não precisa implementá-lo. Você pode examiná-lo clicando duas vezes no arquivo classifier.cs gerado por mlgen.

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

Adicione um loadModel método ao MainPage.xaml.cs arquivo de código dentro da MainPage classe.

        private async Task loadModel()
        {
            // Get an access the ONNX model and save it in memory.
            StorageFile modelFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri($"ms-appx:///Assets/classifier.onnx"));
            // Instantiate the model. 
            modelGen = await classifierModel.CreateFromStreamAsync(modelFile);
        }

Agora, adicione uma chamada ao novo método ao construtor da classe.

        // The main page to initialize and execute the model.
        public MainPage()
        {
            this.InitializeComponent();
            loadModel();
        }

O resultado será exibido da seguinte maneira.

        // The main page to initialize and execute the model.
        public MainPage()
        {
            this.InitializeComponent();
            loadModel();
        }

        // A method to load a machine learning model.
        private async Task loadModel()
        {
            // Get an access the ONNX model and save it in memory.  
            StorageFile modelFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri($"ms-appx:///Assets/classifier.onnx"));
            // Instantiate the model. 
            modelGen = await classifierModel.CreateFromStreamAsync(modelFile);
        }

Carregar a imagem

Precisamos definir um evento de clique para iniciar a sequência de quatro chamadas de método para execução do modelo: conversão, associação e avaliação, extração de saída e exibição de resultados. Adicione o método a seguir ao seu arquivo de código MainPage.xaml.cs dentro da classe MainPage.

        // Waiting for a click event to select a file 
        private async void OpenFileButton_Click(object sender, RoutedEventArgs e)
        {
            if (!await getImage())
            {
                return;
            }
            // After the click event happened and an input selected, begin the model execution. 
            // Bind the model input
            await imageBind();
            // Model evaluation
            await evaluate();
            // Extract the results
            extractResult();
            // Display the results  
            await displayResult();
        }

Agora, você vai implementar o método getImage(). Esse método vai selecionar um arquivo de imagem de entrada e salvá-lo na memória. Adicione o método a seguir ao seu arquivo de código MainPage.xaml.cs dentro da classe MainPage.

        // A method to select an input image file
        private async Task<bool> getImage()
        {
            try
            {
                // Trigger file picker to select an image file
                FileOpenPicker fileOpenPicker = new FileOpenPicker();
                fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
                fileOpenPicker.FileTypeFilter.Add(".jpg");
                fileOpenPicker.FileTypeFilter.Add(".png");
                fileOpenPicker.ViewMode = PickerViewMode.Thumbnail;
                selectedStorageFile = await fileOpenPicker.PickSingleFileAsync();
                if (selectedStorageFile == null)
                {
                    return false;
                }
            }
            catch (Exception)
            {
                return false;
            }
            return true;
        }

Agora, você implementará um método de imagem Bind() para obter a representação do arquivo no formato BGRA8 do bitmap.

Adicione a implementação do método convert() ao seu arquivo de código MainPage.xaml.cs dentro da classe MainPage. O método convert nos fará uma representação do arquivo de entrada em um formato BGRA8.

// A method to convert and bind the input image.  
        private async Task imageBind()
        {
            UIPreviewImage.Source = null;
            try
            {
                SoftwareBitmap softwareBitmap;
                using (IRandomAccessStream stream = await selectedStorageFile.OpenAsync(FileAccessMode.Read))
                {
                    // Create the decoder from the stream 
                    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);
                    // Get the SoftwareBitmap representation of the file in BGRA8 format
                    softwareBitmap = await decoder.GetSoftwareBitmapAsync();
                    softwareBitmap = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                }
                // Display the image
                SoftwareBitmapSource imageSource = new SoftwareBitmapSource();
                await imageSource.SetBitmapAsync(softwareBitmap);
                UIPreviewImage.Source = imageSource;
                // Encapsulate the image within a VideoFrame to be bound and evaluated
                VideoFrame inputImage = VideoFrame.CreateWithSoftwareBitmap(softwareBitmap);
                // bind the input image
                ImageFeatureValue imageTensor = ImageFeatureValue.CreateFromVideoFrame(inputImage);
                input.data = imageTensor;
            }
            catch (Exception e)
            {
            }
        }

O resultado do trabalho feito nesta seção terá a seguinte aparência.

        // Waiting for a click event to select a file 
        private async void OpenFileButton_Click(object sender, RoutedEventArgs e)
        {
            if (!await getImage())
            {
                return;
            }
            // After the click event happened and an input selected, we begin the model execution. 
            // Bind the model input
            await imageBind();
            // Model evaluation
            await evaluate();
            // Extract the results
            extractResult();
            // Display the results  
            await displayResult();
        }

        // A method to select an input image file
        private async Task<bool> getImage()
        {
            try
            {
                // Trigger file picker to select an image file
                FileOpenPicker fileOpenPicker = new FileOpenPicker();
                fileOpenPicker.SuggestedStartLocation = PickerLocationId.PicturesLibrary;
                fileOpenPicker.FileTypeFilter.Add(".jpg");
                fileOpenPicker.FileTypeFilter.Add(".png");
                fileOpenPicker.ViewMode = PickerViewMode.Thumbnail;
                selectedStorageFile = await fileOpenPicker.PickSingleFileAsync();
                if (selectedStorageFile == null)
                {
                    return false;
                }
            }
            catch (Exception)
            {
                return false;
            }
            return true;
        }

        // A method to convert and bind the input image.  
        private async Task imageBind()
        {
            UIPreviewImage.Source = null;

            try
            {
                SoftwareBitmap softwareBitmap;
                using (IRandomAccessStream stream = await selectedStorageFile.OpenAsync(FileAccessMode.Read))
                {
                    // Create the decoder from the stream 
                    BitmapDecoder decoder = await BitmapDecoder.CreateAsync(stream);

                    // Get the SoftwareBitmap representation of the file in BGRA8 format
                    softwareBitmap = await decoder.GetSoftwareBitmapAsync();
                    softwareBitmap = SoftwareBitmap.Convert(softwareBitmap, BitmapPixelFormat.Bgra8, BitmapAlphaMode.Premultiplied);
                }
                // Display the image
                SoftwareBitmapSource imageSource = new SoftwareBitmapSource();
                await imageSource.SetBitmapAsync(softwareBitmap);
                UIPreviewImage.Source = imageSource;

                // Encapsulate the image within a VideoFrame to be bound and evaluated
                VideoFrame inputImage = VideoFrame.CreateWithSoftwareBitmap(softwareBitmap);

                // bind the input image
                ImageFeatureValue imageTensor = ImageFeatureValue.CreateFromVideoFrame(inputImage);
                input.data = imageTensor;
            }
            catch (Exception e)
            {
            }
        }

Associar e avaliar o modelo

A seguir, você criará uma sessão com base no modelo, associará a entrada e a saída da sessão e avaliará o modelo.

Criar uma sessão para associar o modelo:

Para criar uma sessão, use a classe LearningModelSession. Essa classe é usada para avaliar modelos de machine learning e associa o modelo a um dispositivo que, em seguida, executa e avalia o modelo. Você pode selecionar um dispositivo ao criar uma sessão para executar o modelo em um dispositivo específico do computador. O dispositivo padrão é a CPU.

Observação

Para saber mais sobre como escolher um dispositivo, examine a documentação Criar uma sessão .

Associar entradas e saídas do 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 ter suporte nas APIs do Windows ML. A LearningModelBinding classe é aplicada em um LearningModelSession para associar valores a recursos de entrada e saída nomeados.

A implementação da associação é gerada automaticamente pelo mlgen, portanto, você não precisa cuidar dela. A associação é implementada chamando os métodos predefinidos da classe LearningModelBinding. Em nosso caso, ela usa o método Bind para associar um valor ao tipo de recurso nomeado.

Atualmente, o Windows ML dá suporte a todos os tipos de recursos ONNX, como Tensors (matrizes multidimensionais), Sequências (vetores de valores), Mapa (pares de valores de informações) e Imagens (formatos específicos). Todas as imagens serão representadas no Windows ML em um formato tensor. Tensorização é o processo de conversão de uma imagem em um tensor e ocorre durante a vinculação.

Felizmente, você não precisa se preocupar com a conversão de tensorização. O ImageFeatureValue método usado na parte anterior cuida da conversão e da tensorização, portanto, as imagens correspondem ao formato de imagem necessário do modelo.

Observação

Para saber mais sobre como associar um LearningModel e sobre os tipos de recursos compatíveis com o WinML, examine a documentação Associando um modelo.

Avaliar o modelo:

Depois de criar uma sessão para associar o modelo e de associar valores às entradas e saídas do modelo, você pode avaliar as entradas do modelo e obter as previsões. Para executar o modelo, chame um dos métodos de avaliação predefinidos em LearningModelSession. Em nosso caso, usaremos o método EvaluateAsync.

Semelhante a CreateFromStreamAsync, o método EvaluateAsync também foi gerado automaticamente pelo Gerador de Código do WinML, portanto, você não precisa implementá-lo. Examine esse método no arquivo classifier.cs.

O método EvaluateAsync avaliará de modo assíncrono o modelo de machine learning usando os valores de recurso já associados nas associações. Ele criará uma sessão com LearningModelSession, associará a entrada e a saída com LearningModelBinding, executará a avaliação do modelo e obterá os recursos de saída do modelo usando a classe LearningModelEvaluationResult.

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.

Adicione o método a seguir ao arquivo de código MainPage.xaml.cs dentro da classe MainPage para criar uma sessão, associar e avaliar o modelo.

        // A method to evaluate the model
        private async Task evaluate()
        {
            output = await modelGen.EvaluateAsync(input);
        }

Extrair e exibir os resultados

Agora você precisará extrair a saída do modelo e exibir os resultados certos. Você fará isso implementando os métodos extractResult e displayResult.

Como você explorou anteriormente, o modelo retorna duas saídas: a primeira chamada classLabel é um tensor de strings e a segunda chamada 'loss' é uma sequência de mapas de string para float que descreve a probabilidade de cada categoria rotulada. Portanto, para exibir com êxito o resultado e a probabilidade, tudo o que precisamos é extrair a saída da saída de perda. Precisaremos encontrar a maior probabilidade para retornar o resultado correto.

Adicione o método extractResult ao seu arquivo de código MainPage.xaml.cs dentro da classe MainPage.

        private void extractResult()
        {
        // A method to extract output (result and a probability) from the "loss" output of the model 
            var collection = output.loss;
            float maxProbability = 0;
            string keyOfMax = "";

            foreach (var dictionary in collection)
            {
                foreach (var key in dictionary.Keys)
                {
                    if (dictionary[key] > maxProbability)
                    {
                        maxProbability = dictionary[key];
                        keyOfMax = key;
                    }
                }
            }
            result = keyOfMax;
            resultProbability = maxProbability;
        }

Adicione o método displayResult ao seu arquivo de código MainPage.xaml.cs dentro da classe MainPage.

        // A method to display the results
        private async Task displayResult()
        {
            displayOutput.Text = result.ToString();
            displayProbability.Text = resultProbability.ToString();
        }

O resultado das partes de Associar e avaliar e extrair e exibir os resultados do código WinML do nosso aplicativo terá a aparência seguinte.

        // A method to evaluate the model
        private async Task evaluate()
        {
            output = await modelGen.EvaluateAsync(input);
        }

        // A method to extract output (string and a probability) from the "loss" output of the model 
        private void extractResult()
        {
            var collection = output.loss;
            float maxProbability = 0;
            string keyOfMax = "";

            foreach (var dictionary in collection)
            {
                foreach (var key in dictionary.Keys)
                {
                    if (dictionary[key] > maxProbability)
                    {
                        maxProbability = dictionary[key];
                        keyOfMax = key;
                    }
                }
            }
            result = keyOfMax;
            resultProbability = maxProbability;
        }

        // A method to display the results
        private async Task displayResult()
        {
            displayOutput.Text = result.ToString();
            displayProbability.Text = resultProbability.ToString();
        }

É isso! Você criou com êxito o aplicativo de machine learning do Windows com uma GUI básica para testar nosso modelo de classificação. A próxima etapa é iniciar o aplicativo e executá-lo localmente em seu dispositivo Windows.

Iniciar o aplicativo

Depois de concluir a interface do aplicativo, adicionou o modelo e gerou o código WinML, você pode testar o aplicativo. Certifique-se de que os menus suspensos na barra de ferramentas superior estejam configurados como Debug. Altere de Solution Platform para x64 para executar o projeto em seu computador local se o dispositivo for de 64 bits, ou x86 se for de 32 bits.

Para testar nosso aplicativo, você usará a imagem abaixo de frutas. Vamos ver como o aplicativo classifica o conteúdo da imagem.

Imagem de frutas de exemplo

Salve essa imagem em seu dispositivo local para testar o aplicativo. Altere o formato de imagem para jpg, se necessário. Você também pode adicionar qualquer outra imagem relevante de seu dispositivo local em um formato adequado – formatos .jpg, .png, .bmpou .gif.
Para executar o projeto, pressione o Start Debugging botão na barra de ferramentas ou pressione F5.
Quando o aplicativo for iniciado, pressione Pick Image e selecione a imagem no dispositivo local.

Caixa de diálogo Escolher imagem

O resultado será exibido na tela imediatamente. Como você pode ver, nosso aplicativo WinML classificou com êxito a imagem como frutas ou legumes, com uma classificação de confiança de 99,9%.

Classificação de imagem bem-sucedida

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.

Comentários

Esta página foi útil?

Last updated on 2025-06-10

Compartilhar via

Implantar seu modelo em um aplicativo do Windows com as APIs do Windows Machine Learning

Sobre o aplicativo de amostra

Crie um aplicativo UWP com WinML (C#)

Criar o aplicativo

Explorar seu modelo

Explorar a solução do projeto

Criar a GUI do aplicativo

Gerador de código do Windows Machine Learning

Carregar o modelo e as entradas

Carregar o modelo

Carregar a imagem

Associar e avaliar o modelo

Criar uma sessão para associar o modelo:

Associar entradas e saídas do modelo:

Avaliar o modelo:

Extrair e exibir os resultados

Iniciar o aplicativo

Resumo

Recursos adicionais

Comentários

Recursos adicionais