Partilhar via

Introdução à criação de imagens de IA no SDK de aplicativos Windows

  • Artigo

Importante

Disponível no canal experimental mais recente versão do SDK de Aplicativos Windows.

O canal experimental do SDK de Aplicativos 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 disruptivas e podem ser removidas de versões subsequentes a qualquer momento. Os recursos experimentais não são suportados para uso em ambientes de produção e os 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 do Aplicativo Windows por meio de um conjunto de APIs, apoiadas por inteligência artificial (IA), que suportam os seguintes recursos:

  • Super-Resolução de Imagem: ampliação e nitidez das imagens
  • Descrição da imagem: produção de texto que descreve a imagem
  • Segmentação de Imagens: identificação de objetos dentro de uma imagem

Para obter detalhes da API , consulte a referência da API para funcionalidades de imagem de IA no Windows App SDK .

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

Dica

Forneça comentários sobre essas APIs e suas funcionalidades criando um novo de Problema no repositório GitHub do SDK de Aplicativo Windows (inclua Imaging 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 Superresolução de Imagem no SDK de Aplicativos Windows permitem a nitidez e o dimensionamento de imagens.

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

O exemplo a seguir mostra como alterar a escala (targetWidth, targetHeight) de uma imagem 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 existente) 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, em seguida, aguardando que o método ImageScaler.MakeAvailableAsync retorne com êxito.

  2. Quando o modelo de Super Resolução de Imagem estiver disponível, crie um objeto ImageScaler para fazer referência a ele.

  3. Obtenha uma versão nítida e dimensionada da imagem existente passando a imagem existente e a largura e 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

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

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

Os seguintes tipos de descrições de texto são suportados:

  • Accessibility - Fornece uma longa descrição com detalhes destinados a utilizadores com necessidades de acessibilidade.
  • Caption - Fornece uma breve descrição adequada para uma legenda de imagem. O padrão se nenhum valor for especificado.
  • DetailedNarration - Fornece uma longa descrição.
  • OfficeCharts - Fornece uma descrição adequada para gráficos e diagramas.

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

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

Obter descrição de texto de uma imagem

A API de descrição de 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 SoftwareBitmap não é suportado 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, em seguida, aguardando que o método ImageDescriptionGenerator.MakeAvailableAsync retorne com êxito.

  2. Quando o modelo de Super Resolução de Imagem estiver disponível, crie um objeto ImageDescriptionGenerator para fazer referência a ele.

  3. (Opcional) Crie um objeto ContentFilterOptions e especifique seus valores preferidos. 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, um enum para o tipo de descrição preferido (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 considera tanto uma imagem quanto um objeto de "sugestões" e retorna uma máscara do objeto identificado.

As dicas podem ser fornecidas através de qualquer combinação do seguinte:

  • 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 dicas para minimizar resultados imprecisos ou erros.

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

A máscara retornada está no formato escala de cinza-8 com os pixels da máscara para o objeto identificado tendo um valor de 255 (todos os outros tendo um valor de 0).

Identificar um objeto dentro de 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 de 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. Quando o modelo de segmentação de imagem estiver disponível, crie um objeto ImageObjectExtractor para fazer referência a ele.

  3. Passe a imagem para ImageObjectExtractor.CreateWithSoftwareBitmapAsync.

  4. Crie um ImageObjectExtractorHint objeto. 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 trecho 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 trecho 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 de IA seguras e protegidas. Usamos uma combinação das etapas a seguir para garantir que essas APIs de criação de imagens sejam confiáveis, seguras e criadas de forma responsável. Recomendamos rever as práticas recomendadas descritas em Desenvolvimento de IA Generativa Responsável no Windows ao implementar recursos de IA em seu aplicativo.

  • Testes e avaliação minuciosos da qualidade do modelo para identificar e mitigar riscos potenciais.
  • Lançamento incremental de versões experimentais das APIs de imagem. Após a versão experimental final, a implantação será expandida para aplicativos assinados para garantir que as 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 identifique e filtre conteúdo prejudicial na entrada e na saída gerada por IA de quaisquer APIs que usem modelos de IA generativos. Este modelo de moderação de conteúdo local baseia-se no modelo de Segurança de Conteúdo do Azure AI para moderação de texto e oferece um desempenho semelhante.

Importante

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

Conteúdo relacionado