Tutorial: Criar um aplicativo da Área de Trabalho do Windows Machine Learning (C++)

As APIs do Windows ML podem ser aproveitadas para interagir facilmente com modelos de machine learning em aplicativos win32 (área de trabalho) do C++. Usando as três etapas de carregamento, associação e avaliação, seu aplicativo pode se beneficiar do poder do aprendizado de máquina.

Criaremos uma versão um pouco simplificada do exemplo de Detecção de Objetos SqueezeNet, que está disponível no GitHub. Você pode baixar o exemplo completo se quiser ver como será quando terminar.

Usaremos C++/WinRT para acessar as APIs WinML. Consulte C++/WinRT para obter mais informações.

Neste tutorial, você aprenderá a:

Pré-requisitos

• Visual Studio 2019 (ou Visual Studio 2017, versão 15.7.4 ou posterior)
• Windows 10, versão 1809 ou posterior
• SDK do Windows, build 17763 ou posterior
• Extensão do Visual Studio para C++/WinRT
  1. No Visual Studio, selecione Extensões e Atualizações das Ferramentas>.
  2. Selecione Online no painel esquerdo e pesquise "WinRT" usando a caixa de pesquisa à direita.
  3. Selecione C++/WinRT, clique em Baixar e feche o Visual Studio.
  4. Siga as instruções de instalação e, em seguida, abra novamente o Visual Studio.
• Repositório Github do WindowsMachine-Learning (você pode baixá-lo como um arquivo ZIP ou clonar em seu computador)

Criar o projeto

Primeiro, criaremos o projeto no Visual Studio:

1. Selecione Arquivo > Novo > Projeto para abrir a janela Novo Projeto.
2. No painel esquerdo, selecione Instalado > Visual C++ > Windows Desktop e, no meio, selecione Aplicativo do Console do Windows (C++/WinRT).
3. Dê um nome e um local ao projeto e clique em OK.
4. Na janela Novo Projeto da Plataforma Universal do Windows, defina a versão de Destino e a versão Mínima ambas para 17763 ou posterior e clique em OK.
5. Verifique se os menus suspensos na barra de ferramentas superior estão definidos como Depurar e x64 ou x86, dependendo da arquitetura do seu computador.
6. Pressione Ctrl+F5 para executar o programa sem depuração. Um terminal deve ser aberto com um texto "Olá, mundo". Pressione qualquer tecla para fechá-la.

Carregar o modelo

Em seguida, carregaremos o modelo ONNX em nosso programa usando LearningModel.LoadFromFilePath:

1. No pch.h (na pasta Arquivos de Cabeçalho ), adicione as instruções a seguir include (elas nos dão acesso a todas as APIs que precisaremos):

   #include <winrt/Windows.AI.MachineLearning.h>
   #include <winrt/Windows.Foundation.Collections.h>
   #include <winrt/Windows.Graphics.Imaging.h>
   #include <winrt/Windows.Media.h>
   #include <winrt/Windows.Storage.h>
   
   #include <string>
   #include <fstream>
   
   #include <Windows.h>
   

2. Em main.cpp (na pasta Arquivos de Origem ), adicione as seguintes using instruções:

   using namespace Windows::AI::MachineLearning;
   using namespace Windows::Foundation::Collections;
   using namespace Windows::Graphics::Imaging;
   using namespace Windows::Media;
   using namespace Windows::Storage;
   
   using namespace std;
   

3. Adicione as seguintes declarações de variável após as using instruções:

   // Global variables
   hstring modelPath;
   string deviceName = "default";
   hstring imagePath;
   LearningModel model = nullptr;
   LearningModelDeviceKind deviceKind = LearningModelDeviceKind::Default;
   LearningModelSession session = nullptr;
   LearningModelBinding binding = nullptr;
   VideoFrame imageFrame = nullptr;
   string labelsFilePath;
   vector<string> labels;
   

4. Adicione as seguintes declarações de encaminhamento após suas variáveis globais:

   // Forward declarations
   void LoadModel();
   VideoFrame LoadImageFile(hstring filePath);
   void BindModel();
   void EvaluateModel();
   void PrintResults(IVectorView<float> results);
   void LoadLabels();
   

5. Em main.cpp, remova o código "Olá, mundo" (tudo da função main após init_apartment).

6. Localize o arquivo SqueezeNet.onnx no clone local do repositório Windows-Machine-Learning . Ele deve estar localizado em \Windows-Machine-Learning\SharedContent\models.

7. Copie o caminho do arquivo e atribua-o à variável modelPath em que o definimos na parte superior. Lembre-se de prefixar a cadeia de caracteres com um L para torná-la uma cadeia de caracteres larga que funcione corretamente com hstring e para o escape das barras invertidas (\) com uma barra invertida extra. Por exemplo:

   hstring modelPath = L"C:\\Repos\\Windows-Machine-Learning\\SharedContent\\models\\SqueezeNet.onnx";
   

8. Primeiro, implementaremos o LoadModel método. Adicione o método a seguir após o main método. Esse método carrega o modelo e gera quanto tempo levou:

   void LoadModel()
   {
        // load the model
        printf("Loading modelfile '%ws' on the '%s' device\n", modelPath.c_str(), deviceName.c_str());
        DWORD ticks = GetTickCount();
        model = LearningModel::LoadFromFilePath(modelPath);
        ticks = GetTickCount() - ticks;
        printf("model file loaded in %d ticks\n", ticks);
   }
   

9. Por fim, chame esse método no método main:

   LoadModel();
   

10. Execute o programa sem depuração. Você verá que o modelo foi carregado com êxito!

Carregar a imagem

Em seguida, carregaremos o arquivo de imagem em nosso programa:

1. Adicione o método a seguir. Esse método carregará a imagem do caminho fornecido e criará um VideoFrame a partir dele:

   VideoFrame LoadImageFile(hstring filePath)
   {
       printf("Loading the image...\n");
       DWORD ticks = GetTickCount();
       VideoFrame inputImage = nullptr;
   
       try
       {
           // open the file
           StorageFile file = StorageFile::GetFileFromPathAsync(filePath).get();
           // get a stream on it
           auto stream = file.OpenAsync(FileAccessMode::Read).get();
           // Create the decoder from the stream
           BitmapDecoder decoder = BitmapDecoder::CreateAsync(stream).get();
           // get the bitmap
           SoftwareBitmap softwareBitmap = decoder.GetSoftwareBitmapAsync().get();
           // load a videoframe from it
           inputImage = VideoFrame::CreateWithSoftwareBitmap(softwareBitmap);
       }
       catch (...)
       {
           printf("failed to load the image file, make sure you are using fully qualified paths\r\n");
           exit(EXIT_FAILURE);
       }
   
       ticks = GetTickCount() - ticks;
       printf("image file loaded in %d ticks\n", ticks);
       // all done
       return inputImage;
   }
   

2. Adicione uma chamada a esse método no main método:

   imageFrame = LoadImageFile(imagePath);
   

3. Localize a pasta de mídia no clone local do repositório Windows-Machine-Learning . Ele deve estar localizado em \Windows-Machine-Learning\SharedContent\media.

4. Escolha uma das imagens nessa pasta e atribua seu caminho de arquivo à imagePath variável em que a definimos na parte superior. Lembre-se de prefixá-la com um L para torná-la uma cadeia de caracteres larga e fazer o escape das barras invertidas com outra barra invertida. Por exemplo:

   hstring imagePath = L"C:\\Repos\\Windows-Machine-Learning\\SharedContent\\media\\kitten_224.png";
   

5. Execute o programa sem depuração. Você deve ver a imagem carregada com êxito!

Associar a entrada e a saída

Em seguida, criaremos uma sessão com base no modelo e associaremos a entrada e a saída da sessão usando LearningModelBinding.Bind. Para obter mais informações sobre associação, consulte Associar um modelo.

1. Implemente o método BindModel. Isso cria uma sessão com base no modelo e no dispositivo e uma associação com base nessa sessão. Em seguida, associamos as entradas e saídas a variáveis que criamos usando seus nomes. Sabemos antecipadamente que o recurso de entrada é chamado de "data_0" e o recurso de saída é chamado de "softmaxout_1". Você pode ver essas propriedades para qualquer modelo abrindo-as no Netron, uma ferramenta de visualização de modelo online.

   void BindModel()
   {
       printf("Binding the model...\n");
       DWORD ticks = GetTickCount();
   
       // now create a session and binding
       session = LearningModelSession{ model, LearningModelDevice(deviceKind) };
       binding = LearningModelBinding{ session };
       // bind the intput image
       binding.Bind(L"data_0", ImageFeatureValue::CreateFromVideoFrame(imageFrame));
       // bind the output
       vector<int64_t> shape({ 1, 1000, 1, 1 });
       binding.Bind(L"softmaxout_1", TensorFloat::Create(shape));
   
       ticks = GetTickCount() - ticks;
       printf("Model bound in %d ticks\n", ticks);
   }
   

2. Adicione uma chamada para BindModel no método main:

   BindModel();
   

3. Execute o programa sem depuração. As entradas e saídas do modelo devem ser associadas com êxito. Estamos quase lá!

Avaliar o modelo

Agora estamos na última etapa do diagrama no início deste tutorial, Avaliar. Avaliaremos o modelo usando LearningModelSession.Evaluate:

1. Implemente o método EvaluateModel. Esse método usa nossa sessão e a avalia usando nossa associação e uma ID de correlação. A ID de correlação é algo que poderíamos usar posteriormente para corresponder a uma chamada de avaliação específica aos resultados de saída. Mais uma vez, sabemos antecipadamente que o nome da saída é "softmaxout_1".

   void EvaluateModel()
   {
       // now run the model
       printf("Running the model...\n");
       DWORD ticks = GetTickCount();
   
       auto results = session.Evaluate(binding, L"RunId");
   
       ticks = GetTickCount() - ticks;
       printf("model run took %d ticks\n", ticks);
   
       // get the output
       auto resultTensor = results.Outputs().Lookup(L"softmaxout_1").as<TensorFloat>();
       auto resultVector = resultTensor.GetAsVectorView();
       PrintResults(resultVector);
   }
   

2. Agora vamos implementar PrintResults. Esse método obtém as três principais probabilidades de qual objeto poderia estar na imagem e as imprime:

   void PrintResults(IVectorView<float> results)
   {
       // load the labels
       LoadLabels();
       // Find the top 3 probabilities
       vector<float> topProbabilities(3);
       vector<int> topProbabilityLabelIndexes(3);
       // SqueezeNet returns a list of 1000 options, with probabilities for each, loop through all
       for (uint32_t i = 0; i < results.Size(); i++)
       {
           // is it one of the top 3?
           for (int j = 0; j < 3; j++)
           {
               if (results.GetAt(i) > topProbabilities[j])
               {
                   topProbabilityLabelIndexes[j] = i;
                   topProbabilities[j] = results.GetAt(i);
                   break;
               }
           }
       }
       // Display the result
       for (int i = 0; i < 3; i++)
       {
           printf("%s with confidence of %f\n", labels[topProbabilityLabelIndexes[i]].c_str(), topProbabilities[i]);
       }
   }
   

3. Também precisamos implementar LoadLabels. Esse método abre o arquivo de rótulos que contém todos os diferentes objetos que o modelo pode reconhecer e o analisa:

   void LoadLabels()
   {
       // Parse labels from labels file.  We know the file's entries are already sorted in order.
       ifstream labelFile{ labelsFilePath, ifstream::in };
       if (labelFile.fail())
       {
           printf("failed to load the %s file.  Make sure it exists in the same folder as the app\r\n", labelsFilePath.c_str());
           exit(EXIT_FAILURE);
       }
   
       std::string s;
       while (std::getline(labelFile, s, ','))
       {
           int labelValue = atoi(s.c_str());
           if (labelValue >= labels.size())
           {
               labels.resize(labelValue + 1);
           }
           std::getline(labelFile, s);
           labels[labelValue] = s;
       }
   }
   

4. Localize o arquivo Labels.txt em seu clone local do repositório Windows-Machine-Learning . Ele deve estar em \Windows-Machine-Learning\Samples\SqueezeNetObjectDetection\Desktop\cpp.

5. Atribua esse caminho de arquivo à labelsFilePath variável em que o definimos na parte superior. Faça o escape das barras invertidas com outra barra invertida. Por exemplo:

   string labelsFilePath = "C:\\Repos\\Windows-Machine-Learning\\Samples\\SqueezeNetObjectDetection\\Desktop\\cpp\\Labels.txt";
   

6. Adicione uma chamada ao EvaluateModel no método main:

   EvaluateModel();
   

7. Execute o programa sem depuração. Agora ele deve reconhecer corretamente o que está na imagem! Aqui está um exemplo do que ele pode gerar:

   Loading modelfile 'C:\Repos\Windows-Machine-Learning\SharedContent\models\SqueezeNet.onnx' on the 'default' device
   model file loaded in 250 ticks
   Loading the image...
   image file loaded in 78 ticks
   Binding the model...Model bound in 15 ticks
   Running the model...
   model run took 16 ticks
   tabby, tabby cat with confidence of 0.931461
   Egyptian cat with confidence of 0.065307
   Persian cat with confidence of 0.000193
   

Próximas etapas

Parabéns, você fez a detecção de objetos funcionar em um aplicativo da área de trabalho C++! Em seguida, você pode tentar usar argumentos de linha de comando para inserir os arquivos de modelo e imagem em vez de codificar, semelhante ao que o exemplo no GitHub faz. Você também pode tentar executar a avaliação em um dispositivo diferente, como a GPU, para ver como o desempenho difere.

Jogue com os outros exemplos no GitHub e estenda-os como quiser!

Consulte também

• Exemplos do Windows ML (GitHub)
• Windows.AI.MachineLearning Namespace
• Windows ML