Compartilhar via

Introdução à imagem de IA no SDK do Aplicativo Windows

  • Artigo

Importante

Disponível na versão de lançamento mais recente do canal experimental do SDK do Aplicativo do Windows.

O canal experimental do SDK do Aplicativo do Windows inclui APIs e recursos em estágios iniciais de desenvolvimento. Todas as APIs no canal experimental estão sujeitas a extensas revisões e alterações interruptivas, podendo ser removidas de versões subsequentes a qualquer momento. Não há suporte para recursos experimentais para uso em ambientes de produção e aplicativos que os usam não podem ser publicados na Microsoft Store.

  • Os recursos de Descrição da Imagem não estão disponíveis na China continental.
  • Não há suporte para aplicativos autônomos.

Os recursos de imagem são fornecidos pelo SDK de Aplicativos do Windows por meio de um conjunto de APIs, com suporte de IA (inteligência artificial), que dão suporte aos seguintes recursos:

  • Super-Resolução de Imagem: ampliação e nitidez de imagens
  • Descrição da Imagem: produzindo texto que descreve a imagem
  • Segmentação de Imagem: identificando objetos em uma imagem

para detalhes da API, consulte Referência de API para recursos de criação de imagens de IA no SDK do Aplicativo Windows.

Para obter detalhes de moderação de conteúdo, consulte Segurança de conteúdo com APIs de IA generativa.

Dica

Forneça feedback sobre essas APIs e suas funcionalidades criando um novo problema no repositório GitHub do SDK do Aplicativo Windows (inclua Criação de Imagens no título) ou respondendo a um problema existente.

Pré-requisitos

O que posso fazer com a Super Resolução de Imagem?

As APIs de super resolução de imagem no SDK do aplicativo do Windows habilitam a nitidez e o dimensionamento da imagem.

O dimensionamento é limitado a um fator máximo de 8x. Fatores de escala mais alta podem introduzir artefatos e comprometer a precisão da imagem. Se a largura ou altura final for maior que 8x seus valores originais, uma exceção será lançada.

O exemplo a seguir mostra como alterar a escala (targetWidth, targetHeight) de uma imagem de bitmap de software existente (softwareBitmap) e melhorar a nitidez da imagem (para melhorar a nitidez sem dimensionar a imagem, basta especificar a largura e a altura da imagem existentes) usando um objeto ImageScaler.

  1. Verifique se o modelo de Super Resolução de Imagem está disponível chamando o método ImageScaler.IsAvailable e aguardando que o método ImageScaler.MakeAvailableAsync retorne com êxito.

  2. Depois que o modelo de Super Resolução de Imagem estiver disponível, crie um objeto ImageScaler para referenciá-lo.

  3. Obtenha uma versão afiada e dimensionada da imagem existente passando a imagem existente e a largura e a altura desejadas para o modelo usando o método ScaleSoftwareBitmap.

using Microsoft.Graphics.Imaging;
using Microsoft.Windows.Management.Deployment;
using Windows.Graphics.Imaging;

if (!ImageScaler.IsAvailable())
{
    var result = await ImageScaler.MakeAvailableAsync();
    if (result.Status != PackageDeploymentStatus.CompletedSuccess)
    {
        throw result.ExtendedError;
    }
}
ImageScaler imageScaler = await ImageScaler.CreateAsync();
SoftwareBitmap finalImage = imageScaler.ScaleSoftwareBitmap(softwareBitmap, targetWidth, targetHeight);

#include <winrt/Microsoft.Graphics.Imaging.h>
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Graphics.Imaging.h>

using namespace winrt::Microsoft::Graphics::Imaging;
using namespace winrt::Windows::Foundation; 
using namespace winrt::Windows::Graphics::Imaging; 

 
if (!ImageScaler::IsAvailable()) 
{ 
    winrt::PackageDeploymentResult result = ImageScaler::MakeAvailableAsync().get(); 
    if (result.Status() != PackageDeploymentStatus::CompletedSuccess)
    {
       throw result.ExtendedError();
    }
}

ImageScaler imageScaler = ImageScaler::CreateAsync().get(); 
SoftwareBitmap finalImage = imageScaler.ScaleSoftwareBitmap(softwareBitmap, targetWidth, targetHeight);

O que posso fazer com a Descrição da Imagem?

Importante

A Descrição da Imagem está atualmente indisponível na China continental.

As APIs de Descrição da Imagem no SDK do Aplicativo do Windows fornecem a capacidade de gerar vários tipos de descrições de texto para uma imagem.

Há suporte para os seguintes tipos de descrições de texto:

  • Acessibilidade: oferece uma longa descrição com detalhes destinados a usuários com necessidades de acessibilidade.
  • Legenda – Fornece uma breve descrição adequada para uma legenda de imagem. O padrão se nenhum valor for especificado.
  • DetailedNarration – Fornece uma descrição longa.
  • OfficeCharts – Fornece uma descrição adequada para gráficos e diagramas.

Como essas APIs usam modelos de ML (Machine Learning), erros ocasionais podem ocorrer em que o texto não descreve a imagem corretamente. Portanto, não recomendamos o uso dessas APIs para imagens nos seguintes cenários:

  • Onde as imagens contêm conteúdo potencialmente confidencial e descrições imprecisas podem ser controversas, como sinalizadores, mapas, globos, símbolos culturais ou símbolos religiosos.
  • Quando descrições precisas são críticas, como para orientação médica ou diagnóstico, conteúdo legal ou documentos financeiros.

Obter a descrição do texto de uma imagem

A API de Descrição da Imagem usa uma imagem, o tipo de descrição de texto desejado (opcional) e o nível de moderação de conteúdo que você deseja empregar (opcional) para proteger contra uso prejudicial.

O exemplo a seguir mostra como obter uma descrição de texto para uma imagem.

Observação

A imagem deve ser um objeto ImageBuffer, pois não há suporte para SoftwareBitmap no momento. Este exemplo demonstra como converter SoftwareBitmap em ImageBuffer.

  1. Verifique se o modelo de Super Resolução de Imagem está disponível chamando o método ImageDescriptionGenerator.IsAvailable e aguardando que o método ImageDescriptionGenerator.MakeAvailableAsync retorne com êxito.

  2. Depois que o modelo de Super Resolução de Imagem estiver disponível, crie um objeto ImageDescriptionGenerator para referenciá-lo.

  3. (Opcional) Crie um objeto ContentFilterOptions e especifique seus valores preferenciais. Se você optar por usar valores padrão, poderá passar um objeto nulo.

  4. Obtenha a descrição da imagem (LanguageModelResponse.Response) chamando o método ImageDescriptionGenerator.DescribeAsync com a imagem original, uma enumeração para o tipo de descrição preferencial (opcional) e o objeto ContentFilterOptions (opcional).

using Microsoft.Graphics.Imaging;
using Microsoft.Windows.Management.Deployment;  
using Microsoft.Windows.AI.Generative;
using Microsoft.Windows.AI.ContentModeration;
using Windows.Storage.StorageFile;  
using Windows.Storage.Streams;  
using Windows.Graphics.Imaging;

if (!ImageDescriptionGenerator.IsAvailable())
{
    var result = await ImageDescriptionGenerator.MakeAvailableAsync();
    if (result.Status != PackageDeploymentStatus.CompletedSuccess)
    {
        throw result.ExtendedError;
    }
}

ImageDescriptionGenerator imageDescriptionGenerator = await ImageDescriptionGenerator.CreateAsync();

// Convert already available softwareBitmap to ImageBuffer.
ImageBuffer inputImage = ImageBuffer.CreateCopyFromBitmap(softwareBitmap);  

// Create content moderation thresholds object.
ContentFilterOptions filterOptions = new ContentFilterOptions();
filterOptions.PromptMinSeverityLevelToBlock.ViolentContentSeverity = SeverityLevel.Medium;
filterOptions.ResponseMinSeverityLevelToBlock.ViolentContentSeverity = SeverityLevel.Medium;

// Get text description.
LanguageModelResponse languageModelResponse = await imageDescriptionGenerator.DescribeAsync(inputImage, ImageDescriptionScenario.Caption, filterOptions);
string response = languageModelResponse.Response;


#include <winrt/Microsoft.Graphics.Imaging.h>
#include <winrt/Microsoft.Windows.AI.ContentModeration.h>
#include <winrt/Microsoft.Windows.AI.Generative.h>
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Graphics.Imaging.h> 
#include <winrt/Windows.Storage.Streams.h>
#include <winrt/Windows.Storage.StorageFile.h>
using namespace winrt::Microsoft::Graphics::Imaging; 
using namespace winrt::Microsoft::Windows::AI::ContentModeration; 
using namespace winrt::Microsoft::Windows::AI::Generative; 
using namespace winrt::Windows::Foundation; 
using namespace winrt::Windows::Graphics::Imaging;
using namespace winrt::Windows::Storage::Streams;
using namespace winrt::Windows::Storage::StorageFile;

if (!ImageDescriptionGenerator::IsAvailable()) 
{ 
    winrt::PackageDeploymentResult result = ImageDescriptionGenerator::MakeAvailableAsync().get(); 
    if (result.Status() != PackageDeploymentStatus::CompletedSuccess)
    {
       throw result.ExtendedError();
    }
}

ImageDescriptionGenerator imageDescriptionGenerator = ImageDescriptionGenerator::CreateAsync().get(); 
// Convert already available softwareBitmap to ImageBuffer.
auto inputBuffer = ImageBuffer::CreateCopyFromBitmap(softwareBitmap); 

// Create content moderation thresholds object.
 ContentFilterOptions contentFilter{};
 contentFilter.PromptMinSeverityLevelToBlock().ViolentContentSeverity(SeverityLevel::Medium);
 contentFilter.ResponseMinSeverityLevelToBlock().ViolentContentSeverity(SeverityLevel::Medium);


// Get text description.
LanguageModelResponse languageModelResponse = imageDescriptionGenerator.DescribeAsync(inputImage, ImageDescriptionScenario::Caption, contentFilter).get();
string text = languageModelResponse.Response();

O que posso fazer com a Segmentação de Imagem?

A segmentação de imagem pode ser usada para identificar objetos específicos em uma imagem. O modelo utiliza tanto uma imagem quanto um objeto de "dicas" e retorna uma máscara do objeto identificado.

As dicas podem ser fornecidas por meio de qualquer combinação dos seguintes:

  • Coordenadas para pontos que pertencem ao que você está identificando.
  • Coordenadas para pontos que não pertencem ao que você está identificando.
  • Um retângulo de coordenadas que inclui o que você está identificando.

Quanto mais dicas você fornecer, mais preciso o modelo pode ser. Siga estas diretrizes de dica para minimizar resultados ou erros imprecisos.

  • Evite usar vários retângulos em uma dica, pois eles podem produzir uma máscara imprecisa.
  • Evite usar pontos de exclusão exclusivamente sem pontos de inclusão ou um retângulo.
  • Não especifique mais do que o máximo permitido de 32 coordenadas (1 para um ponto, 2 para um retângulo), pois isso retornará um erro.

A máscara retornada está no formato de escala de cinza 8 com os pixels da máscara para o objeto identificado com um valor de 255 (todas as outras com um valor de 0).

Identificar um objeto em uma imagem

Os exemplos a seguir mostram maneiras de identificar um objeto dentro de uma imagem. Os exemplos pressupõem que você já tenha um objeto bitmap de software (softwareBitmap) para a entrada.

  1. Verifique se o modelo de Segmentação de Imagem está disponível chamando o método IsAvailable e aguardando que o método MakeAvailableAsync retorne com êxito.

  2. Depois que o modelo de Segmentação de Imagem estiver disponível, crie um objeto ImageObjectExtractor para referenciá-lo.

  3. Passe a imagem para ImageObjectExtractor.CreateWithSoftwareBitmapAsync.

  4. Crie um objeto ImageObjectExtractorHint. Outras maneiras de criar um objeto de dica com entradas diferentes são demonstradas posteriormente.

  5. Envie a dica para o modelo usando o método GetSoftwareBitmapObjectMask, que retorna o resultado final.

using Microsoft.Graphics.Imaging;
using Microsoft.Windows.Management.Deployment;
using Windows.Graphics.Imaging;

if (!ImageObjectExtractor.IsAvailable())
{
    var result = await ImageObjectExtractor.MakeAvailableAsync();
    if (result.Status != PackageDeploymentStatus.CompletedSuccess)
    {
        throw result.ExtendedError;
    }
}

ImageObjectExtractor imageObjectExtractor = await ImageObjectExtractor.CreateWithSoftwareBitmapAsync(softwareBitmap);

ImageObjectExtractorHint hint = new ImageObjectExtractorHint{
    includeRects: null, 
    includePoints:
        new List<PointInt32> { new PointInt32(306, 212),
                               new PointInt32(216, 336)},
    excludePoints: null};
    SoftwareBitmap finalImage = imageObjectExtractor.GetSoftwareBitmapObjectMask(hint);

#include <winrt/Microsoft.Graphics.Imaging.h> 
#include <winrt/Windows.Graphics.Imaging.h>
#include <winrt/Windows.Foundation.h>
using namespace winrt::Microsoft::Graphics::Imaging; 
using namespace winrt::Windows::Graphics::Imaging; 
using namespace winrt::Windows::Foundation; 


if (!ImageObjectExtractor::IsAvailable()) 
{ 
    winrt::PackageDeploymentResult result = ImageObjectExtractor::MakeAvailableAsync().get(); 
    if (result.Status() != PackageDeploymentStatus::CompletedSuccess)
    {
       throw result.ExtendedError();
    }
}

ImageObjectExtractor imageObjectExtractor =  ImageObjectExtractor::CreateWithSoftwareBitmapAsync(softwareBitmap).get();

ImageObjectExtractorHint hint(
    {}, 
    { 
        PointInt32{306, 212}, 
        PointInt32{216, 336} 
    },
    {}
);

SoftwareBitmap finalImage = imageObjectExtractor.GetSoftwareBitmapObjectMask(hint);

Especificar dicas com pontos incluídos e excluídos

Este snippet de código demonstra como usar pontos incluídos e excluídos como dicas.

ImageObjectExtractorHint hint(
    includeRects: null,
    includePoints: 
        new List<PointInt32> { new PointInt32(150, 90), 
                               new PointInt32(216, 336), 
                               new PointInt32(550, 330)},
    excludePoints: 
        new List<PointInt32> { new PointInt32(306, 212) });

ImageObjectExtractorHint hint(
    {}, 
    { 
        PointInt32{150, 90}, 
        PointInt32{216, 336}, 
        PointInt32{550, 330}
    },
    { 
        PointInt32{306, 212}
    }
);

Especificar dicas com retângulo

Este snippet de código demonstra como usar um retângulo (RectInt32 é X, Y, Width, Height) como uma dica.

ImageObjectExtractorHint hint(
    includeRects: 
        new List<RectInt32> {new RectInt32(370, 278, 285, 126)},
    includePoints: null,
    excludePoints: null ); 

ImageObjectExtractorHint hint(
    { 
        RectInt32{370, 278, 285, 126}
    }, 
    {},
    {}
);

IA responsável

Essas APIs de imagem fornecem aos desenvolvedores modelos poderosos e confiáveis para criar aplicativos com experiências seguras de IA seguras. Usamos uma combinação das etapas a seguir para garantir que essas APIs de imagem sejam confiáveis, seguras e criadas com responsabilidade. Recomendamos revisar as práticas recomendadas específicas descritas em Desenvolvimento responsável de IA Generativa no Windows ao implementar recursos de IA em seu aplicativo.

  • Teste completo e avaliação da qualidade do modelo para identificar e mitigar possíveis riscos.
  • Distribuição incremental de versões experimentais da API de imagens. Após a versão experimental final, a distribuição será expandida para aplicativos assinados para garantir que verificações de malware tenham sido aplicadas a aplicativos com recursos de modelo local.
  • Forneça um modelo de IA local para moderação de conteúdo que identifica e filtra conteúdo prejudicial na entrada e na saída gerada por IA de todas as APIs que usam modelos de IA generativos. Esse modelo de moderação de conteúdo local baseia-se no modelo de Segurança de Conteúdo de IA do Azure para moderação de texto e fornece desempenho semelhante.

Importante

Nenhum sistema de segurança de conteúdo é infalível e erros ocasionais podem ocorrer, portanto, recomendamos a integração de ferramentas e práticas complementares de IA Responsável (RAI). Para mais detalhes, consulte Desenvolvimento responsável de IA generativa no Windows.

Conteúdo relacionado