Introducción a la creación de imágenes de IA en el SDK de Aplicaciones para Windows

Importante

Disponible en la versión más reciente del canal experimental del SDK de aplicaciones de Windows.

El canal experimental del SDK de aplicaciones de Windows incluye API y características en las primeras fases de desarrollo. Todas las API del canal experimental están sujetas a revisiones exhaustivas y cambios importantes y se pueden eliminar de versiones posteriores en cualquier momento. Las características experimentales no se admiten para su uso en entornos de producción y las aplicaciones que las usan no se pueden publicar en Microsoft Store.

• Las características de descripción de imágenes no están disponibles en China continental.
• No se admiten aplicaciones independientes.

Las características de creación de imágenes las proporciona Windows App SDK a través de un conjunto de API, respaldadas por inteligencia artificial (IA), que admiten las siguientes funcionalidades:

• Superresolución de imágenes: escalado y mejora de la nitidez de las imágenes
• descripción de la imagen: generar texto que describa la imagen
• segmentación de imágenes: identificación de objetos dentro de una imagen

Para obtener detalles de la API, consulte la referencia de API para las funciones de imágenes de IA en el Windows App SDK.

Para obtener detalles sobre la moderación de contenido, consulte la seguridad de contenido con APIs de IA generativa.

Sugerencia

Proporcione comentarios sobre estas API y su funcionalidad creando una nueva incidencia en el repositorio de GitHub de Windows App SDK (incluya Creación de imágenes en el título) o respondiendo a una incidencia existente.

Requisitos previos

• Un Copilot+ PC de Qualcomm, Intel o AMD.
  • Los equipos Copilot+ basados en AMD no admiten actualmente la Super Resolución de Imágenes.
  • Arm64EC (compatible con emulación) no está soportado actualmente.
• Windows 11 Insider Preview Build 26120.3073 (canales de desarrollo y beta) o posterior debe estar instalado en el dispositivo.

¿Qué puedo hacer con la super resolución de imágenes?

Las API de super resolución de imágenes del SDK de aplicaciones de Windows habilitan el ajuste y el escalado de imágenes.

El escalado se limita a un factor máximo de 8x. Los factores de escala más altos pueden introducir artefactos y poner en peligro la precisión de la imagen. Si el ancho final o alto es mayor que 8 veces sus valores originales, se producirá una excepción.

En el ejemplo siguiente se muestra cómo cambiar la escala (targetWidth, targetHeight) de una imagen de mapa de bits de software existente (softwareBitmap) y mejorar la nitidez de la imagen (para mejorar la nitidez sin escalar la imagen, simplemente especificar el ancho y el alto de la imagen existentes) mediante un objeto ImageScaler.

1. Asegúrese de que el modelo de super resolución de imágenes está disponible llamando al método ImageScaler.IsAvailable y, a continuación, esperando a que el método ImageScaler.MakeAvailableAsync se devuelva correctamente.

2. Una vez disponible el modelo de super resolución de imágenes, cree un objeto ImageScaler para hacer referencia a él.

3. Obtenga una versión afilada y escalada de la imagen existente pasando la imagen existente y el ancho y alto deseados al modelo mediante el 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);

¿Qué puedo hacer con la descripción de la imagen?

Importante

La descripción de la imagen no está disponible actualmente en China continental.

Las API de descripción de imágenes del SDK de aplicaciones de Windows proporcionan la capacidad de generar varios tipos de descripciones de texto para una imagen.

Se admiten los siguientes tipos de descripciones de texto:

• Accesibilidad: proporciona una descripción detallada y extensa destinada a usuarios con necesidades de accesibilidad.
• Subtítulo: proporciona una breve descripción adecuada para un título de imagen. Valor predeterminado si no se especifica ningún valor.
• Narración Detallada: proporciona una descripción larga.
• OfficeCharts - proporciona una descripción adecuada para gráficos y diagramas.

Dado que estas API usan modelos de Machine Learning (ML), pueden producirse errores ocasionales en los que el texto no describe correctamente la imagen. Por lo tanto, no se recomienda usar estas API para imágenes en los escenarios siguientes:

• Donde las imágenes contienen contenido potencialmente confidencial y descripciones inexactas podrían ser controvertidas, como banderas, mapas, globos, símbolos culturales o símbolos religiosos.
• Cuando las descripciones precisas son críticas, como para asesoramiento médico o diagnóstico, contenido legal o documentos financieros.

Obtener la descripción del texto de una imagen

Image Description API toma una imagen, el tipo de descripción de texto deseado (opcional) y el nivel de moderación de contenido que desea emplear (opcional) para protegerse contra el uso perjudicial.

En el ejemplo siguiente se muestra cómo obtener una descripción de texto para una imagen.

Nota:

La imagen debe ser un objeto ImageBuffer, ya que no se admite actualmente SoftwareBitmap. En este ejemplo se muestra cómo convertir SoftwareBitmap en ImageBuffer.

1. Asegúrese de que el modelo de super resolución de imágenes está disponible llamando al método ImageDescriptionGenerator.IsAvailable y, a continuación, esperando a que el método ImageDescriptionGenerator.MakeAvailableAsync se devuelva correctamente.

2. Una vez disponible el modelo de super resolución de imágenes, cree un objeto ImageDescriptionGenerator para hacer referencia a él.

3. (Opcional) Cree un objeto ContentFilterOptions y especifique los valores preferidos. Si decide usar valores predeterminados, puede pasar un objeto NULL.

4. Obtenga la descripción de la imagen (LanguageModelResponse.Response) llamando al método ImageDescriptionGenerator.DescribeAsync con la imagen original, una enumeración para el tipo de descripción preferido (opcional) y el 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();

¿Qué puedo hacer con la segmentación de imágenes?

La segmentación de imágenes se puede usar para identificar objetos específicos en una imagen. El modelo toma tanto una imagen como un objeto de "pistas" y devuelve una máscara del objeto identificado.

Las sugerencias se pueden proporcionar a través de cualquier combinación de lo siguiente:

• Coordenadas para los puntos que pertenecen a lo que está identificando.
• Coordenadas para los puntos que no pertenecen a lo que está identificando.
• Rectángulo de coordenadas que incluye lo que está identificando.

Cuantos más sugerencias proporcione, más precisa puede ser el modelo. Siga estas instrucciones de sugerencia para minimizar los resultados o errores inexactos.

• Evite usar varios rectángulos en una sugerencia, ya que pueden producir una máscara inexacta.
• Evite usar puntos de exclusión exclusivamente sin incluir puntos ni un rectángulo.
• No especifique más que el máximo admitido de 32 coordenadas (1 para un punto, 2 para un rectángulo), ya que devolverá un error.

La máscara devuelta está en formato de escala gris-8 con los píxeles de la máscara para el objeto identificado que tiene un valor de 255 (todos los demás tienen un valor de 0).

Identificación de un objeto dentro de una imagen

En los ejemplos siguientes se muestran formas de identificar un objeto dentro de una imagen. En los ejemplos se asume que ya dispones de un objeto de mapa de bits de software (softwareBitmap) para la entrada.

1. Asegúrese de que el modelo de segmentación de imágenes está disponible llamando al método IsAvailable y esperando a que el método MakeAvailableAsync se devuelva correctamente.

2. Una vez disponible el modelo de segmentación de imágenes, cree un objeto ImageObjectExtractor para hacer referencia a él.

3. Pase la imagen a ImageObjectExtractor.CreateWithSoftwareBitmapAsync.

4. Cree un objeto ImageObjectExtractorHint. Otras formas de crear un objeto de sugerencia con entradas diferentes se muestran más adelante.

5. Envíe la sugerencia al modelo mediante el método GetSoftwareBitmapObjectMask, que devuelve el 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 sugerencias con puntos incluidos y excluidos

Este fragmento de código muestra cómo usar puntos incluidos y excluidos como sugerencias.

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 sugerencias con rectángulo

Este fragmento de código muestra cómo usar un rectángulo (RectInt32 es X, Y, Width, Height) como sugerencia.

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

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

Inteligencia artificial responsable

Estas API de creación de imágenes proporcionan a los desarrolladores modelos eficaces y de confianza para crear aplicaciones con experiencias de inteligencia artificial seguras y seguras. Hemos usado una combinación de los pasos siguientes para asegurarse de que estas API de creación de imágenes son confiables, seguras y creadas de forma responsable. Se recomienda revisar los procedimientos recomendados descritos en Desarrollo de IA Generativa Responsable en Windows al implementar características de inteligencia artificial en su aplicación.

• Pruebas exhaustivas y evaluación de la calidad del modelo para identificar y mitigar los posibles riesgos.
• Implementación incremental de versiones experimentales de API de procesamiento de imágenes. Después de la versión experimental final, la implementación se expandirá a las aplicaciones firmadas para asegurarse de que los exámenes de malware se han aplicado a las aplicaciones con funcionalidades del modelo local.
• Proporcione un modelo de inteligencia artificial local para la moderación de contenido que identifique y filtre el contenido dañino tanto en la entrada como en la salida generada por ia de cualquier API que usen modelos de IA generativas. Este modelo de moderación de contenido local se basa en el modelo de seguridad de contenido de Azure AI para la moderación de texto y proporciona un rendimiento similar.

Importante

Ningún sistema de seguridad de contenido es infalible y pueden ocurrir errores ocasionales, por lo que recomendamos integrar herramientas y prácticas complementarias de inteligencia artificial responsable (RAI). Para obtener más información, consulte Desarrollo de IA Generativa Responsable en Windows.

Contenido relacionado

• Desarrollar Características y Aplicaciones Responsables de IA Generativa en Windows
• Referencia API para funciones de imagen respaldadas por IA en SDK para aplicaciones de Windows
• SDK para aplicaciones de Windows
• Notas de la versión más reciente para el SDK de Aplicaciones para Windows